1. सीधा संस्करण
स्क्रिप्ट नीचे यादृच्छिक पर कार्य का उत्पादन करेगा, + , - , × और ÷ । आप एक अधिकतम संख्या निर्धारित कर सकते हैं जिसे स्क्रिप्ट उपयोग कर सकती है, साथ ही असाइनमेंट के बीच समय अंतराल भी।
असाइनमेंट
असाइनमेंट को ज़ेनिटी एंट्री विंडो में प्रस्तुत किया जाता है:
यदि उत्तर गलत है:
यदि उत्तर सही है:
लिपी
#!/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()
कैसे इस्तेमाल करे
- स्क्रिप्ट को एक खाली फ़ाइल में कॉपी करें, इसे इस रूप में सहेजें
mindpractice.py
तर्क के रूप में असाइनमेंट के बीच अधिकतम अनुमत संख्या और अंतराल समय (सेकंड में) के साथ इसे चलाएं:
python3 /path/to/mindpractice.py <max_number> <interval>
जैसे
python3 /path/to/mindpractice.py 1000 300
1000असाइनमेंट के बीच में 5 मिनट के ब्रेक के साथ, के आंकड़ों की गणना करना।
यदि सभी ठीक काम करते हैं, तो आप इसे सामान्य तरीके से स्टार्टअप एप्लिकेशन में जोड़ सकते हैं, या टॉगल करने के लिए एक लांचर बनाया जा सकता है, जिसे मैं बाद में हटा सकता हूं :)
ध्यान दें
- विभाजन कुछ स्पष्टीकरण की आवश्यकता हो सकती। आप शायद झांकियों में गणना करना पसंद नहीं करेंगे। इसलिए, यदि असाइनमेंट एक विभाजन है, तो स्क्रिप्ट उन संख्याओं को देखती है जिन्हें वह विभाजित कर सकता है, और एक (यादृच्छिक पर) चुनता है। यदि (मुख्य) संख्या एक प्रमुख संख्या हो जाती है, तो असाइनमेंट को दूसरे प्रकार में बदल दिया जाता है।
2. अधिक विकल्प
एक बार जब आप की गणना शुरू करते हैं, आपको पता चल जाएगा कि विभाजित के आंकड़े से ऊपर (मान लीजिए) 100 की तुलना में काफी आसान है गुणा 100 के आंकड़े।
नीचे दी गई स्क्रिप्ट के साथ आप प्रति अभ्यास प्रकार के अनुसार अधिकतम संख्या निर्धारित कर सकते हैं (स्क्रिप्ट के नीचे निर्देश देखें)।
लिपी
#!/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()
कैसे इस्तेमाल करे
स्क्रिप्ट को पहले वाले की तरह सेट करें, लेकिन इसे तर्कों के साथ चलाएं (किसी भी क्रम में, स्क्रिप्ट सही तर्कों को सही आइटम से जोड़ेगी):
p: विराम दें (असाइनमेंट्स के बीच विराम दें, सेकंड में)s: घटाना (अधिकतम संख्या की गणना)a: जोड़ें (अधिकतम संख्या)m: गुणा (अधिकतम संख्या)d: विभाजन (अधिकतम संख्या)
उदाहरण के लिए:
python3 '/home/jacob/Desktop/num.py' a:10 d:100 s:10 m:10 p:300
हर पांच मिनट में एक व्यायाम दिखाने के लिए 10 तक की संख्या, 100 को विभाजित करने के लिए छोड़कर ।
3. चलो थोड़ा दूर किया
कुछ आंकड़ों को देखने में सक्षम होने के नाते
नीचे दिए गए संस्करण आपको प्रत्येक 10 अभ्यासों के बाद के आंकड़े दिखाते हैं:
इसके अतिरिक्त (बच्चों के लिए उपयोग किए जाने पर उपयोगी हो सकता है), आप देख सकते हैं कि पिछले 100 गलत उत्तर वाले अभ्यासों में क्या गलत हुआ। एक छिपी हुई फ़ाइल में, असाइनमेंट और उनके (गलत) दोनों उत्तर लिखे गए हैं:
यह लॉगफाइल स्थित है:
~/.calculog
लिपी
#!/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 = []
कैसे इस्तेमाल करे
उपयोग बहुत हद तक विकल्प 2 की तरह है, लेकिन आपके पास लॉगफ़ाइल उपलब्ध होगा और हर 10 असाइनमेंट के बाद स्कोर होगा।
4. अंतिम संस्करण
नीचे दिया गया संस्करण विकल्प 3 की तरह है (लॉग फ़ाइल और रिपोर्ट सहित), लेकिन कुछ अतिरिक्त विशेषताएं हैं:
वर्गमूल की गणना जोड़ता है
संख्याओं की एक श्रृंखला का उपयोग करके जोड़ता है , इसके बजाय बस एक अधिकतम सेट करें
- केवल विशिष्ट गणना प्रकार चलाने के लिए विकल्प जोड़ता है (उदाहरण के लिए केवल विभाजित और गुणा करें)।
उन तर्कों को याद करता है जो पिछली बार के साथ चलाए गए थे, जब तर्कों के बिना चलाया जाता है (केवल पहली बार, तर्क सेट किए जाने चाहिए )। यदि पहले रन पर कोई तर्क नहीं दिया गया था, तो स्क्रिप्ट एक संदेश भेजती है:
लिपी
#!/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 = []
कैसे इस्तेमाल करे
स्क्रिप्ट को एक खाली फ़ाइल में कॉपी करें, इसे (फिर से) के रूप में सहेजें mindpractice.py। इसे निम्न विकल्पों के साथ चलाएँ (उदाहरण के लिए)
सेट होना चाहिए:
p:300 to set the interval between assignments to 5 minutes
वैकल्पिक (एक चयन करें):
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
उदाहरण आदेश:
python3 '/path/to/mindpractice.py' p:300 d:10-100 s:10-30 r:300-600
स्थापित करना:
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
जोड़ने और गुणा करते समय उपयोग नहीं किया जाता है।
फिर अगली बार, यदि स्क्रिप्ट के साथ चलाया जाता है:
python3 '/path/to/mindpractice.py'
यह अंतिम प्रयुक्त तर्कों को याद रखेगा
उस संस्करण का उपयोग करें जो आपकी आवश्यकताओं को पूरा करता है ...
