Periyodik olarak zihinsel aritmetik egzersizleri yapmama izin veren bir yazılım var mı?

Tembel doğamın farkındayım ve zaman zaman kendimi bazı temel zihinsel aritmetik yapmaya itmem gerekiyor. Bu nedenle, periyodik olarak kısa bir zihinsel aritmetik egzersizi yapmamı isteyen bir yazılım arıyorum (artı, eksi, çarpma, bölme).

Kriter:

• Aralık süresini özelleştirmeme izin vermeli
• Ubuntu Masaüstüne entegre olmalı, yani arka planda gizlenmeli ve sadece egzersiz süresi boyunca görünmelidir (pop-up)

1. Basit sürüm

Aşağıdaki komut dosyası rastgele, + , - , × ve ÷ şeklinde atamalar üretecektir . Komut dosyasının kullanabileceği maksimum sayıyı ve atamalar arasındaki zaman aralığını ayarlayabilirsiniz (ve yapmalısınız).

Ödevler

Ödevler bir Zenity giriş penceresinde sunulur:

cevap yanlışsa:

Cevap doğruysa:

Senaryo

#!/usr/bin/env python3
from random import randint
import sys
import subprocess
import time

# maximum number & interval
max_n = int(sys.argv[1]); pause = int(sys.argv[2])

def fix_float(n):
    """
    if the assignment is a division, the script divides the random number by a
    number (integer) it can be divided by. it looks up those numbers, and picks
    one of them (at random). if the number is a prime number the assignment is
    changed into another type
    """
    try:
        divs = [i for i in range(2, n) if n%i == 0]
        pick = randint(1, len(divs))
        div_by = divs[pick-1]
        return [str(n)+" : "+str(div_by), int(n/div_by)]
    except (ValueError, IndexError):
        pass

def get_assignment():
    """
    get a random number within the user defined range, make the assignment and
    the textual presentation
    """
    n1 = randint(2, max_n); n2 = randint(2, max_n)
    assignments = [
        [str(n1)+" + "+str(n2), n1+n2],
        [str(n1)+" - "+str(n2), n1-n2],
        [str(n1)+" x "+str(n2), n1*n2],
        fix_float(n1),
        ]
    # pick an assignment (type) at random
    assignment = assignments[randint(0, 3)]
    # if the random number is a prime number and the assignment a division...
    assignment = assignment if assignment != None else assignments[1]
    # run the interface job
    try:
        answer = int(subprocess.check_output(["/bin/bash", "-c",
            'zenity --entry --title="Think hard:" --text='+'"'+assignment[0]+'"'
            ]).decode("utf-8"))
        if answer == assignment[1]:
            subprocess.Popen(["notify-send", "Coolcool"])
        else:
            subprocess.Popen([
                "notify-send", "Oooops, "+assignment[0]+\
                " = "+str(assignment[1])])
    except (subprocess.CalledProcessError, ValueError):
        pass

while True:
    time.sleep(pause)
    get_assignment()

Nasıl kullanılır

1. Komut dosyasını boş bir dosyaya kopyalayın, mindpractice.py

2. Bağımsız değişken olarak atamalar arasındaki izin verilen maksimum sayı ve aralık (saniye olarak) ile çalıştırın:

   python3 /path/to/mindpractice.py <max_number> <interval>

   Örneğin

   python3 /path/to/mindpractice.py 1000 300

   1000ödevler arasında 5 dakikalık bir ara ile rakamlara kadar hesaplamalar yapmak .

3. Tüm cezası çalışıyorsa, o uygulamalar olağan şekilde başlangıç ekleyebileceğiniz, ya geçiş için bir başlatıcısı daha sonra eklemek olabilir yapılabilir :)

Not

• Bölme bir açıklama gerekebilir. Muhtemelen şamandıralarda hesaplamak istemezsiniz. Bu nedenle, atama bir bölümse, komut dosyası bölünebileceği sayıları arar ve birini (rastgele) seçer. (Ana) sayı asal sayı ise, atama başka bir türe dönüştürülür.

2. Diğer seçenekler

Hesaplamaya başladığınızda, 100'e kadar rakamlara bölmenin (diyelim ki) 100'e kadar rakamları çarpmaktan çok daha kolay olduğunu göreceksiniz .

Aşağıdaki komut dosyasıyla, egzersiz türü başına maksimum sayı belirleyebilirsiniz (ve komut dosyasının altındaki talimatlara bakın).

Senaryo

#!/usr/bin/env python3
from random import randint
import sys
import subprocess
import time

levels = sys.argv[1:]
pause = [int(arg.replace("p:", "")) for arg in levels if "p:" in arg][0]

def fix_float(n):
    """
    if the assignment is a division, the script divides the random number by a
    number (integer) it can be divided by. it looks up those numbers, and picks
    one of them (at random). if the number is a prime number the assignment is
    changed into another type
    """
    try:
        divs = [i for i in range(2, n) if n%i == 0]
        pick = randint(1, len(divs))
        div_by = divs[pick-1]
        return [str(n)+" : "+str(div_by), int(n/div_by)]
    except (ValueError, IndexError):
        pass

def get_assignment():
    """
    get a random number within the user defined range, make the assignment and
    the textual presentation
    """
    # pick an assignment (type) at random
    track = randint(0, 3)
    arg = ["a:", "s:", "m:", "d:"][track]
    max_n = [int(item.replace(arg, "")) for item in levels if arg in item][0]

    n1 = randint(2, max_n); n2 = randint(2, max_n)
    assignments = [
        [str(n1)+" + "+str(n2), n1+n2],
        [str(n1)+" - "+str(n2), n1-n2],
        [str(n1)+" x "+str(n2), n1*n2],
        fix_float(n1),
        ]
    assignment = assignments[track]     
    # if the random number is a prime number and the assignment a division...
    assignment = assignment if assignment != None else assignments[1]
    # run the interface job
    try:
        answer = int(subprocess.check_output(["/bin/bash", "-c",
            'zenity --entry --title="Think hard:" --text='+'"'+assignment[0]+'"'
            ]).decode("utf-8"))
        if answer == assignment[1]:
            subprocess.Popen(["notify-send", "Coolcool"])
        else:
            subprocess.Popen([
                "notify-send", "Oooops, "+assignment[0]+\
                " = "+str(assignment[1])])
    except (subprocess.CalledProcessError, ValueError):
        pass

while True:
    time.sleep(pause)
    get_assignment()

Nasıl kullanılır

• Komut dosyasını birincisi gibi kurun, ancak bağımsız değişkenlerle çalıştırın (herhangi bir sırayla, komut dosyası doğru bağımsız değişkenleri doğru öğeye bağlar):

  • p: duraklatma (ödevler arasında saniye cinsinden ara)
  • s: çıkart (hesaplanacak maksimum sayı)
  • a: ekle (maksimum sayı)
  • m: çarp (maksimum sayı)
  • d: böl (maksimum sayı)

  Örneğin:

  python3 '/home/jacob/Desktop/num.py' a:10 d:100 s:10 m:10 p:300

  her 100 dakikada bir egzersiz göstermek, şekil 100'e bölünmek dışında 10'a kadar sayılar .

3. Hadi biraz uzaklaşalım

Bazı istatistikleri görebilmek

Aşağıdaki sürüm, her 10 alıştırmadan sonra istatistikleri gösterir:

Ek olarak (çocuklar için kullanıldığında yararlı olabilir), yanlış cevaplanan son 100 alıştırmada neyin yanlış gittiğini görebilirsiniz. Gizli bir dosyada hem ödevler hem de (yanlış) cevapları yazılır:

Bu günlük dosyası bulunur:

~/.calculog

Senaryo

#!/usr/bin/env python3
from random import randint
import sys
import subprocess
import time
import os

log = os.environ["HOME"]+"/.calculog"

levels = sys.argv[1:]
pause = [int(arg.replace("p:", "")) for arg in levels if "p:" in arg][0]

def fix_float(n):
    """
    if the assignment is a division, the script divides the random number by a
    number (integer) it can be divided by. it looks up those numbers, and picks
    one of them (at random). if the number is a prime number the assignment is
    changed into another type
    """
    try:
        divs = [i for i in range(2, n) if n%i == 0]
        pick = randint(1, len(divs))
        div_by = divs[pick-1]
        return [str(n)+" : "+str(div_by), int(n/div_by)]
    except (ValueError, IndexError):
        pass

def get_assignment():
    """
    get a random number within the user defined range, make the assignment and
    the textual presentation
    """
    # pick an assignment (type) at random
    track = randint(0, 3)
    arg = ["a:", "s:", "m:", "d:"][track]
    max_n = [int(item.replace(arg, "")) for item in levels if arg in item][0]

    n1 = randint(2, max_n); n2 = randint(2, max_n)
    assignments = [
        [str(n1)+" + "+str(n2), n1+n2],
        [str(n1)+" - "+str(n2), n1-n2],
        [str(n1)+" x "+str(n2), n1*n2],
        fix_float(n1),
        ]
    assignment = assignments[track]     
    # if the random number is a prime number and the assignment a division...
    assignment = assignment if assignment != None else assignments[1]
    # run the interface job
    try:
        answer = int(subprocess.check_output(["/bin/bash", "-c",
            'zenity --entry --title="Think hard:" --text='+'"'+assignment[0]+'"'
            ]).decode("utf-8"))
        if answer == assignment[1]:
            subprocess.Popen(["notify-send", "Coolcool"])
            return "ok"
        else:
            subprocess.Popen([
                "notify-send", "Oooops, "+assignment[0]+\
                " = "+str(assignment[1])])
            open(log, "+a").write(assignment[0]+"\t\t"+str(answer)+"\n")
            try:
                history = open(log).read().splitlines()
                open(log, "wt").write(("\n").join(history[-100:])+"\n")     
            except FileNotFoundError:
                pass 
            return "mistake"
    except (subprocess.CalledProcessError, ValueError):
        return None

results = []
while True:
    time.sleep(pause)
    results.append(get_assignment())
    if len(results) >= 10:
        score = results.count("ok")
        subprocess.call([
            "zenity", "--info",
            '--title=Latest scores',
            '--text='+str(score)+' out of 10',
            '--width=160',
            ])
        results = []

Nasıl kullanılır

Kullanımı neredeyse seçenek 2'ye benzer, ancak her 10 atamadan sonra günlük dosyasına ve puanlara sahip olacaksınız.

4. Mükemmel sürüm

Aşağıdaki sürüm, seçenek 3'e (günlük dosyası ve raporlar dahil) benzer, ancak bazı ek özelliklere sahiptir:

• karekök hesaplamayı ekler

  

• yalnızca bir maksimum sayı ayarlamak yerine, bir sayı aralığı kullanarak

• yalnızca belirli hesaplama türlerini çalıştırma seçeneğini ekler (örneğin yalnızca böl ve çarp).

• Geçen zamanla çalıştırıldı argümanları hatırlar, değişkenler olmadan çalıştırdığınızda (yalnızca ilk kez, argümanlar gerekir seti olun). İlk çalıştırmada herhangi bir bağımsız değişken ayarlanmadıysa, komut dosyası bir ileti gönderir:

  

Senaryo

#!/usr/bin/env python3
from random import randint
import sys
import subprocess
import time
import os

"""
Use this script to practice head count. Some explanation might be needed:
The script can be used for the following types of calculating:

Type          argument example      explanation
-------------------------------------------------------------------------------
add           a:30-100              to add in numbers from 30-100
subtract      s:10-100              to subtract in numbers from 10-100
multiply      m:10-20               to multiply in numbers from 10-20
divide        d:200-400             to divide in numbers from 200-400
square root   r:1-1000              to find square root in numbers from 1-1000

N.B.
-------------------------------------------------------------------------------
- The argument p: (pause in seconds; break between the assignments) *must* be
  set, for example: p:300 to launch an assignment every 5 minutes
- A calculation type will only run *if* the argument is set for the
  corresponding type. An example: python3 /path/to/script p:60 s:30-60
  will run a subtract- assignment every minute.

Miscellaneous information:
-------------------------------------------------------------------------------
- On first run, arguments *must* be set. After first run, when no arguments
  are used the last set arguments will run, until the script is run with a new
  set of arguments.
- A log file of the last 100 incorrectly answered questions is kept in
  ~/.calculog
- After 10 assignments, the score of the last 10 pops up.
"""

log = os.environ["HOME"]+"/.calculog"
prefs = os.environ["HOME"]+"/.calcuprefs"
levels = sys.argv[1:]

if levels:
    open(prefs, "wt").write(str(levels))
else:
    try:
        levels = eval(open(prefs).read())
    except FileNotFoundError:
        subprocess.call([
            "zenity", "--info",
            '--title=Missing arguments',
            '--text=On first run, the script needs to be run with arguments\n'
            ])

def fix_float(n):
    """
    if the assignment is a division, the script divides the random number by a
    number (integer) it can be divided by. it looks up those numbers, and picks
    one of them (at random). if the number is a prime number the assignment is
    changed into another type
    """
    try:
        divs = [i for i in range(2, n) if n%i == 0]
        pick = randint(1, len(divs))
        div_by = divs[pick-1]
        return [str(n)+" : "+str(div_by), int(n/div_by)]
    except (ValueError, IndexError):
        pass

def fix_sqr(f1, f2):
    """
    If the assignment is calculating a square root, this function finds the sets
    of numbers (integers) that make a couple, within the given range.
    """
    q = f1; r = q**(.5); sets = []
    while q < f2:
        r = q**(.5)
        if r == int(r):
            sets.append([int(r), int(q)])
        q = q+1
    if sets:
        pick = sets[randint(0, len(sets)-1)]
        return ["√"+str(pick[1]), pick[0]]

def get_assignment():
    """
    get a random number within the user defined range, make the assignment and
    the textual presentation
    """ 
    args = ["a:", "s:", "m:", "d:", "r:"]
    indc = []
    for i, item in enumerate(args):
        if item in str(levels):
            indc.append(i)

    index = indc[randint(0, len(indc)-1)]
    name = args[index]

    minmax = [
        [int(n) for n in item.replace(name, "").split("-")] \
        for item in levels if name in item][0]

    assignment = None
    # if the random number is a prime number *and* the assignment a division 
    # or a square root...
    while assignment == None:
        n1 = randint(minmax[0], minmax[1]); n2 = randint(minmax[0], minmax[1])
        assignment = [
            [str(n1)+" + "+str(n2), n1+n2],
            [str(n1)+" - "+str(n2), n1-n2],
            [str(n1)+" x "+str(n2), n1*n2],
            fix_float(n1),
            fix_sqr(minmax[0], minmax[1]),
            ][index]
    # run the interface job
    try:
        answer = int(subprocess.check_output(["/bin/bash", "-c",
            'zenity --entry --title="Think hard:" --text='+'"'+assignment[0]+'"'
            ]).decode("utf-8"))
        if answer == assignment[1]:
            subprocess.Popen(["notify-send", "Coolcool"])
            return "ok"
        else:
            subprocess.Popen([
                "notify-send", "Oooops, "+assignment[0]+\
                " = "+str(assignment[1])])
            open(log, "+a").write(assignment[0]+"\t\t"+str(answer)+"\n")
            try:
                history = open(log).read().splitlines()
                open(log, "wt").write(("\n").join(history[-100:])+"\n")     
            except FileNotFoundError:
                pass 
            return "mistake"
    except (subprocess.CalledProcessError, ValueError):
        return None

if levels:
    pause = [int(arg.replace("p:", "")) for arg in levels if "p:" in arg][0]
    [levels.remove(item) for item in levels if "p:" in item]
    results = []
    while True:
        time.sleep(pause)
        results.append(get_assignment())
        if len(results) >= 10:
            score = results.count("ok")
            subprocess.call([
                "zenity", "--info",
                '--title=Latest scores',
                '--text='+str(score)+' out of 10',
                '--width=160',
                ])
            results = []

Nasıl kullanılır

• Komut dosyasını boş bir dosyaya kopyalayın, (tekrar) olarak kaydedin mindpractice.py. Aşağıdaki seçeneklerle çalıştırın (örnek olarak)

  Ayarlanmalı:

  p:300                to set the interval between assignments to 5 minutes

  İsteğe bağlı (seçim yapın):

  a:30-100             to add in numbers from 30-100 (optional)
  s:10-100             to subtract in numbers from 10-100
  m:10-20              to multiply in numbers from 10-20
  d:200-400            to divide in numbers from 200-400
  r:1-1000             to find square root in numbers from 1-1000

• Örnek komut:

  python3 '/path/to/mindpractice.py' p:300 d:10-100 s:10-30  r:300-600

  kurmak:

  p:300                to set the interval between assignments to 5 minutes
  d:10-100             to divide in numbers from 10-100
  s:10-30              to subtract in numbers from 10-30
  r:300-600            to calculate square roots from 300-600

  iken ekleyerek ve çoğaltan kullanılmaz.

Sonra bir dahaki sefere, komut dosyası ile çalıştırılırsa:

python3 '/path/to/mindpractice.py'

Son kullanılan argümanları hatırlayacak

İhtiyaçlarınıza en uygun sürümü kullanın ...

Giriş:

Aşağıdaki uygulama, kullanıcı tarafından değerlendirilmek üzere rasgele tamsayı ifadeleri üretir. Rastgele oluşturulan ifadelerin aralığı, ana açılır pencerede kullanıcının ayarlarına bağlıdır. Lets BeginDüğmeye tıklandığında , kullanıcı İptal düğmesine basana kadar oturum süresiz olarak başlar.

Kaynak kodu:

#!/usr/bin/env python

# Author: Serg Kolo
# Date: Jan 30,2016
# Purpose: A graphical utility for practicing
#          random arithmetic operations
# Written for: http://askubuntu.com/q/725287/295286

#    Copyright: Serg Kolo , 2016
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.

import sys
import time
import random
from PyQt4 import QtGui


class mathApp(QtGui.QWidget):
   def __init__(self):
       super(mathApp,self).__init__()
       self.mainMenu()

   def mainMenu(self):
      self.setGeometry(300, 300, 400, 200)

      self.btn = QtGui.QPushButton("Let's begin",self)
      self.btn.move(20,150)
      self.btn.clicked.connect(self.askQuestions)

      self.lbl1 = QtGui.QLabel(self)
      self.lbl1.move(20,25)
      self.lbl1.setText("Numbers From")


      self.lbl2 = QtGui.QLabel(self)
      self.lbl2.move(20,55)
      self.lbl2.setText("Numbers To")

      self.lbl2 = QtGui.QLabel(self)
      self.lbl2.move(20,85)
      self.lbl2.setText("Repeat (seconds)")

      self.le1 = QtGui.QLineEdit(self)
      self.le1.move(150,20)

      self.le2 = QtGui.QLineEdit(self)
      self.le2.move(150,50)

      self.le3 = QtGui.QLineEdit(self)
      self.le3.move(150,80)

      self.lbl3 = QtGui.QLabel(self)
      self.lbl3.move(20,105)

      self.setWindowTitle('Random Integer Arithmetic')

      self.show()

   def askQuestions(self):
       rangeStart = int(self.le1.text())
       rangeEnd = int(self.le2.text())
       sleepTime = int(self.le3.text())
       done=False
       while not done:
          self.show()
          expression = self.generateOperation(rangeStart,rangeEnd)
          correctAnswer = eval(expression)

          prompt = QtGui.QInputDialog() 
          text,ok = prompt.getText(self,"Don't think too hard",expression) 
          if ok:
             if int(text) == correctAnswer:                
                self.showAnswer("CORRECT,YOU ROCK !")
             else :
                self.showAnswer("Nope");
          else:
              done=True

          if done==True:
              self.close()
          time.sleep(sleepTime)


   def generateOperation(self,start,end):
      a = random.randint(start,end)
      b = random.randint(start,end)
      oplist = ['+','-','/','*']
      op = oplist[random.randint(0,3)]
      expr = str(a) + op + str(b) + ''
      return expr

   def showAnswer(self,result):
       popup = QtGui.QMessageBox()
       popup.setText(result)
       popup.exec_()


def main():
   root = QtGui.QApplication(sys.argv)
   app = mathApp()
   sys.exit(root.exec_())

if __name__ == '__main__':
   main()