def inversecalc(l): n = len(l[0]) a = [[0 for temp in range(2 * n)] for temp1 in range(n)] for i in range(n): for j in range(n): a[i][j] = f(l[i][j]) for i in range(n): for j in range(n): if i == j: a[i][j + n] = f(1, 1) else: a[i][j + n] = f(0, 1) for i in range(n): for j in range(n): if i != j: r = f(a[j][i]) / f(a[i][i]) for k in range(2 * n): a[j][k] = a[j][k] - r * a[i][k] for i in range(n): d = a[i][i] for j in range(2 * n): a[i][j] = a[i][j] / d inversematrix = [[] for temp2 in range(n)] for i in range(n): for j in range(n, 2 * n): inversematrix[i].append(a[i][j]) return inversematrix
def my_solution(marbles, step): from fractions import Fraction as f sequences = [ [{ marbles: f(1, 1) }], ] for i in xrange(step): curr_step = [] for seq in sequences[i]: k, v = seq.keys()[0], seq.values()[0] if 'w' in k: new_seq = k.replace('w', 'b', 1) curr_step.append({new_seq: f(k.count('w'), len(k)) * v}) if 'b' in k and i < step - 1: # Ignore black pearls in last iteration new_seq = k.replace('b', 'w', 1) curr_step.append({new_seq: f(k.count('b'), len(k)) * v}) sequences.append(curr_step) return round(float(sum(s.values()[0] for s in sequences[-1])), 2)
def main(): # basic numeric data types in python print(type(6)) print(type(6.5)) print(type(6 + 7j)) num = 6 + 7j print(isinstance(num, complex)) #operations using binary, octal, hexadecimal print(0b100010010) print(0b100010010 + 0o15) print(0b100010010 + 0xFB) #python casting print(int(63.7)) print(float(63)) print(float('63.26')) #using Decimal module to get more precise values print(0.1) print(d(0.1)) print(d(202.5624) * d(1235.984316)) #using fractions module print(f('1.1') + f(12, 10)) print(f(-3, 5) > 0) #using math module print(math.pi) print(math.cos(math.pi)) print(math.factorial(26)) print(math.cos(math.pi) + math.sin(math.pi))
def __init__(self,max_numb,max_depth,grouping,depth = 0): """Recursively build an arithematic equation, using only the operations given in OPS. Note that the expression is given by fractional numbers, and expects a fractional response. However, currently there is an 80% chance of any given fractional number being an integer.""" if (depth < max_depth and random.randint(0,max_depth) > depth): self.left = Expression(max_numb,max_depth, grouping,depth + 1) else: p = random.random() if p < .4: den = 1 else: den = random.randint(1,max_numb) self.left = f(random.randint(1,max_numb),den) if (depth < max_depth and random.randint(0,max_depth) > depth): self.right = Expression(max_numb, max_depth,grouping,depth + 1) else: p = random.random() if p < .8: d = 1 else: d = random.randint(1,max_numb) self.right = f(random.randint(1,max_numb),d) self.grouped = random.random() < grouping self.operator = random.choice(Expression.OPS)
def compute_probabilies(m): res = [f(0, 1)] * len(m) terminal_states = [] for i, row in enumerate(m): if sum(row) == 0: # It is a terminal state terminal_states.append(i) continue total = sum(row) p_past = [] for j, element in enumerate(row): res[j] = f(element, total) if i == 0: continue if j < i and m[j][i]: p_past.append(f(m[j][i], (1 - res[j] * m[j][i]))) continue last = 0 ii = 0 while ii < i: last += f(m[ii][j], (1 - (res[ii] * m[ii][ii + 1]))) ii += 1 res[j] = (res[j] * sum(p_past)) + last print('partial res {}: '.format(res[:])) m[i] = res[:] print(terminal_states) return [e for i, e in enumerate(res) if i in terminal_states]
def prob(n, k): if k == 0: return f(1, n + 1) elif n == k: return f(1, factorial(n + 1)) else: return prob(n - 1, k) * f(n, n + 1) + prob(n - 1, k - 1) * f(1, n + 1)
def calculaX(self, mA, x, j, k): if (j == k): k -= 1 if (k < 0): return 0 if (k < j): return 0 return f(mA[j][k]) * f(x[k]) + self.calculaX(mA, x, j, k - 1)
def calculaX(self, mA,x,j,k): if (j == k): k -= 1 if (k < 0): return 0 if (k < j): return 0 return f(mA[j][k])*f(x[k]) + self.calculaX(mA,x,j,k-1)
def _bin2interval(self, enc): a = f(0) b = f(1) for bit in enc: if bit == '0': b = (a + b) / 2 else: a = (a + b) / 2 return a, b
def Upper_Triangle_Solver(U, b, n): x = np.zeros((n, 1), dtype=int) x = x + f() for i in range(n - 1, -1, -1): rhs = f(b[i], U[i][i]) for j in range(n - 1, i, -1): rhs -= U[i][j] * x[j] / U[i][i] x[i] = rhs return x
def pre_compute(array): d = {1: '1 2', 2: '1 4'} tmp = f(1, 4) for i in range(2, 25): if i % 2 == 0: # new R tmp += f(1, pow(2, i + 1)) else: # new L tmp -= f(1, pow(2, i + 1)) d[i + 1] = ' '.join([str(tmp.numerator), str(tmp.denominator)]) return d
def main(a=15499, b=94744): fy = lambda n: prod([prime(i) for i in range(1, n + 1)]) fx = lambda n: prod([prime(i) - 1 for i in range(1, n + 1)]) n = 1 while True: if f(fy(n), fx(n)) > f(b, a): break n = n + 1 k = int(a / (a * fy(n) - b * fx(n))) + 1 return k * fy(n)
def sqrtconvergents(n): a0,period = sqrtperiod(n) p = len(period) yield f(a0,1) if p==0: return for terms in count(): frac = f(1,period[terms%p]) for t in range(terms-1,-1,-1): frac = f(1,period[t%p]+frac) yield a0 + frac
def _decode_len(self, enc, length): a, b = self._bin2interval(enc) decoded = "" u = f(0) v = f(1) for _ in range(length): u, v, c = self._interval2char(u, v, a, b) decoded += c return decoded
def calculaXMetodoEliminacao(self): self.matrizIncognitas = self.defineMatrizIcognitas() c = 0 k = self.ordem-1 while c < self.ordem: termo = self.calculaX(self.matrizFinal,self.matrizIncognitas[0],k-c,k) if (f(self.matrizFinal[k-c][k-c]) == 0): self.setErro(1) break else: self.matrizIncognitas[0][k-c] = (f(self.matrizIndependentesFinal[0][k-c]) - f(termo))/f(self.matrizFinal[k-c][k-c]) c += 1
def _decode_eof(self, enc): a, b = self._bin2interval(enc) decoded = "" u = f(0) v = f(1) c = None while c != '.': u, v, c = self._interval2char(u, v, a, b) decoded += c return decoded
def decode(self, enc): a, b = self._bin2interval(enc) center = (a + b) / 2 decoded = "" u = f(0) v = f(1) c = None while c != '.': u, v, c = self._interval2char(u, v, center) decoded += c return decoded
def is_unique(nominator, denominator): common_digit = digits(nominator) & digits(denominator) #print common_digit if common_digit: common_digit = list(common_digit)[0] if common_digit > 0: new_nominator = eliminate_digit(nominator, common_digit) new_denominator = eliminate_digit(denominator, common_digit) if new_denominator and f(nominator, denominator) == f(new_nominator, new_denominator): #print f(nominator, denominator) return True return False
def compute(i, exp): num_1 = "" x = i - 2 # puts together first number while (exp[x] in string.digits or exp[x] == "-") and x >= 0: num_1 += exp[x] x -= 1 first_ins = x + 1 num_1 = int(num_1[::-1]) if exp[x] == "/": numer = "" x -= 1 while (exp[x] in string.digits or exp[x] == "-") and x >= 0: numer += exp[x] x -= 1 first_ins = x + 1 numer = numer[::-1] num_1 = f(int(numer), int(num_1)) f_possible = 1 num_2 = "" x = i + 2 # puts together second number while (exp[x] in string.digits or exp[x] == "-") and x < len(exp): num_2 += exp[x] if x + 1 < len(exp): x += 1 else: f_possible = 0 break last_ins = x - 1 if not f_possible: last_ins += 1 num_2 = int(num_2) if exp[x] == "/" and f_possible == 1: denom = "" x += 1 while x < len(exp) and (exp[x] in string.digits or exp[x] == "-"): denom += exp[x] x += 1 last_ins = x - 1 num_2 = f(int(num_2), int(denom)) a = exp[first_ins:last_ins + 1] b = str(calc(num_1, exp[i], num_2)) exp = exp.replace(a, b) return (exp)
def calculaXMetodoEliminacao(self): self.matrizIncognitas = self.defineMatrizIcognitas() c = 0 k = self.ordem - 1 while c < self.ordem: termo = self.calculaX(self.matrizFinal, self.matrizIncognitas[0], k - c, k) if (f(self.matrizFinal[k - c][k - c]) == 0): self.setErro(1) break else: self.matrizIncognitas[0][ k - c] = (f(self.matrizIndependentesFinal[0][k - c]) - f(termo)) / f(self.matrizFinal[k - c][k - c]) c += 1
def _f4(self): from random import randint as r # 直接导入randint函数,更名为r from random import uniform as ru # 直接导入uniform函数,更名为ru,用于生成指定范围内的随机浮点数 from fractions import Fraction as f # 直接导入fractions函数,更名为f ops = ['+', '-', '*', '/'] # 存储操作符 kuohao = ['(', '', ')'] # 存储括号,下标为0,1,2 left1 = r(0, 1) left2 = r(0, 1) left3 = r(0, 1) right1 = r(1, 2) right2 = r(1, 2) right3 = r(1, 2) if left1 == 0: left2 = 1 left3 = 1 if right1 == 2: right2 = 1 right3 = 1 else: right2 = 2 right3 = 1 else: if left2 == 0: left3 = 1 right1 = 1 if right2 == 2: right3 = 1 else: right3 = 2 else: left3 = 0 right1 = 1 right2 = 1 right3 = 2 add_1 = ru(0, 1) add_1 = f(add_1).limit_denominator(10) # 限制最大分母值,小数变分数 add_2 = ru(0, 1) add_2 = f(add_2).limit_denominator(10) add_3 = r(1, 10) add_4 = r(1, 10) ops1 = r(0, 2) ops2 = r(0, 3) ops3 = r(0, 3) # 由上述操作,随机生成表达式 eq = kuohao[left1] + str(add_1) + ops[ops1] + kuohao[left2] + str(add_2) + kuohao[right1] + ops[ops2] + kuohao[ left3] + str(add_3) + kuohao[right2] + ops[ops3] + str(add_4) + kuohao[right3] return (eq)
def t_NUMBER(t): r'-?[0-9]+/[0-9]+|-?[0-9]+' parts = re.split('/',t.value) if len(parts) == 1: parts.append(1) t.value = f(*map(int,parts)) return t
def invOfMat(mat): t = transpose(mat) inverseOfMatrix = [] for i in range(len(t)): list1 = [f(int(i == j), 1) for j in range(len(mat))] inverseOfMatrix.append(GE(t, list1)) return inverseOfMatrix
def transform(arr): listOfSums = list(map(sum, arr)) booleanIndices = list(map(lambda x: x == 0, listOfSums)) indices = set([i for i, x in enumerate(booleanIndices) if x]) currentMatrix = [] for i in range(len(arr)): currentMatrix.append( list( map( lambda x: f(0, 1) if (listOfSums[i] == 0) else reduce(x, listOfSums[i]), arr[i]))) replaceMatrix = [] replaceZeros = [] for i in range(len(currentMatrix)): if i not in indices: replaceMatrix.append(currentMatrix[i]) else: replaceZeros.append(currentMatrix[i]) replaceMatrix.extend(replaceZeros) t = [] for i in range(len(replaceMatrix)): t.append([]) copyMatrix = [] for j in range(len(replaceMatrix)): if j not in indices: t[i].append(replaceMatrix[i][j]) else: copyMatrix.append(replaceMatrix[i][j]) t[i].extend(copyMatrix) return [t, len(replaceZeros)]
def retMatrix(mat): cmat = [] for i in range(len(mat)): cmat.append([]) for j in range(len(mat[i])): cmat[i].append(f(mat[i][j].numerator, mat[i][j].denominator)) return cmat
def lerMatrix(m): file_obj = open("matrix" + m + ".txt") matrix = [] ordem = 0 matrix_append = matrix.append for line in file_obj: ordem = ordem + 1 matrix_append([f(x) for x in line.split() if x]) file_obj = open("matrixIndependente" + m + ".txt") data = [] data_append = data.append for line in file_obj: data_append([f(x) for x in line.split() if x]) return [matrix, data, ordem]
def _qr(self, symbol): q = f(0) for a, p in self.e.tuples(): if a == symbol: r = q + p break q += p return q, r
def answer(m): probabilities = compute_probabilies(m) print(probabilities) denominator = reduce(gcd, probabilities) print(denominator) return [ (f(p, denominator)).numerator for p in probabilities ] + [denominator.denominator]
def e033(): alist = [] for y in range(1,10): for z in range(y,10): x=float(9)*y*z/(10*y-z) if int(x) == x and y/z < 1 and x<10: #print(x, y, z, str(10*y+x)+'/'+str(z+10*x), str(y)+'/'+str(z)) alist+=[f(y,z)] return str(reduce(mul,alist)).split('/')[1]
def calculate_entropy(self, freqs): entropy = 0 total_freq = sum(freqs) p = [f(x, total_freq) for x in freqs] for i in range(len(p)): if p[i] > 0: entropy = entropy - p[i]*log2(p[i]) return entropy
def multiplyMatrices(arr1, arr2): answer = [] for x in range(len(arr1)): answer.append([]) for y in range(len(arr2[0])): answer[x].append(f(0, 1)) for z in range(len(arr1[0])): answer[x][y] += arr1[x][z] * arr2[z][y] return answer
def solve(): s, sg, fg, d, t = map(int, input().split()) actual = s + f(d * 50 * 60 * 60, t * 1000) asg = abs(sg - actual) afg = abs(fg - actual) return 'SEBI' if asg < afg else 'FATHER' if asg > afg else 'DRAW'
def can_simplify( fr ): a = str( fr[ 0 ] ) b = str( fr[ 1 ] ) if '0' in a and '0' in b: return False for i in a: if b.find( i ) > -1: if len( a.replace( i, '' ) ) == 0 \ or len( b.replace( i, '' ) ) == 0: continue newa = int( a.replace( i, '' ) ) newb = int( b.replace( i, '' ) ) if newb == 0: continue if f( newa, newb ) == f( fr[ 0 ], fr[ 1 ] ): return True return False
def dfs(): probability = f(1) visited = [False for i in range(len(l[0]))] util(0, visited, probability, recur, realprob) #main cauclation starter visited = [False for i in range(len(l[0]))] for i in range(len(l[0])): visited = [False for j in range(len(l[0]))] dfs2(i, i, visited)
def util(start, visited, probability, recur, realprob): visited[start] = True realprob[start] += probability for i in range(len(l[start])): if visited[i] == False and l[start][i] != 0: recur, realprob = util( i, visited, probability * (f(l[start][i], sumofrow[start])), recur, realprob) elif visited[i] == True and l[start][i] != 0: if terminalstate[i]: realprob[i] += probability * f(l[start][i], sumofrow[start]) else: recur[i] += probability * f(l[start][i], sumofrow[start]) #print(probability, start) #print(recur, realprob) return recur, realprob
def main(): lst = [0] * 1000 lst[0] = f(1, 1) num = 0 for i in range(1, 1000): lst[i] = 1 + 1 / (1 + lst[i - 1]) n_digits = int(log10(lst[i].numerator)) + 1 d_digits = int(log10(lst[i].denominator)) + 1 if n_digits > d_digits: num += 1 return num
def validate(answer,sol): """Validate the users answer (answer) against the solution stored in the datastore. Note that since fractional types are not allowed in the datastore, it is necessary to parse both the user answer and the stored solution. Further, sets are used since order of roots (in the case of algebraic expressions) may be arbitrary.""" solution = set() answers = set() for s,ans in zip(answer.split(),sol): ans = map(int,ans.split('/')) s = map(int,s.split('/')) if len(s) == 1: solution.add(f(s[0],1)) else: solution.add(f(*s)) if len(ans) == 1: answers.add(f(ans[0],1)) else: answers.add(f(*ans)) return solution == answers
def get_values(params): ''' >>> for i in range(100): ... params = get_random(); ... length = f(int(params["nBeats"]),int(params["beat"])); ... values = get_values(params); ... length2 = sum([f(i[0],i[1]) for i in zip(values["nums"],values["dens"])]); ... assert(length2 == length); >>> ''' length = f(int(params["nBeats"]),int(params["beat"])) unevenness = int(params["unevenness"]) velocity = int(params["velocity"]) nNotes = int(round(length/min_value*velocity*0.01)) nBars = int(nNotes/8.)+1 for i in range(nBars,0,-1): if length.numerator % i == 0: break nBars = i barLength = length/nBars k = round(unevenness*0.04)+1 res = [] bar_1 = get_bar_values(barLength,unevenness,velocity) if k == 1: for i in range(nBars): res.extend(bar_1) elif k == 2: bar_2 = alter_values(bar_1) for i in range(nBars): if i % 2: res.extend(bar_1) else: res.extend(bar_2) elif k == 3: res.extend(bar_1) for i in range(nBars-1): res.extend(alter_values(bar_1)) elif k == 4: bar_2 = get_bar_values(barLength,unevenness,velocity) for i in range(nBars): if i % 2: res.extend(bar_1) else: res.extend(bar_2) else: res.extend(bar_1) for i in range(nBars-1): res.extend(get_bar_values(barLength,unevenness,velocity)) rhythm = {} rhythm["nums"],rhythm["dens"] = zip(*[(i.numerator,i.denominator) for i in res]) return rhythm
def get_solution(self,p = .75): """Build the solution set. p represents the probability of a random root being an integer. Currently the probability breakdown of a Linear (L), Quadratic (Q) and Cubic (C) equation is given by -L : 20% -Q : 70% -C : 10% """ x = random.random() if x < .2: num_roots = 1 elif .2 < x < .9: num_roots = 2 else: num_roots = 3 roots = set() for _ in range(num_roots): if random.random() < p: den = 1 else: den = random.randint(1,self.number_range[1]) roots.add(f(random.randint(*self.number_range),den)) return roots
def calculaMatrizMetodoEliminacao(self): self.matrizFinal = self.defineMatrizFinal() self.matrizIndependentesFinal = self.defineMatrizAuxiliar() self.matrizIndependentesFinal[0][0] = self.matrizIndependentesFinal[0][0] k = self.ordem lista = [] nI = 0 while k > 0: i = self.ordem - k den = f(self.matrizFinal[self.ordem-k][self.ordem-k]) #Verifica elemento e permuta a linha if (den == 0): if (i == 0): self.setErro(1) break else: lista = self.matrizFinal[i+1] self.matrizFinal[i+1] = self.matrizFinal[i] self.matrizFinal[i] = lista nI = self.matrizIndependentesFinal[0][i+1] self.matrizIndependentesFinal[0][i+1] = self.matrizIndependentesFinal[0][i] self.matrizIndependentesFinal[0][i] = nI den = f(self.matrizFinal[self.ordem-k][self.ordem-k]) if (den == 0): self.setErro(1) break while i+1 < self.ordem: contador = 0 j = self.ordem - k + 1 num = f(self.matrizFinal[i+1][self.ordem-k]) divisor = num/den while contador < self.ordem: if (j > self.ordem): break self.matrizFinal[i+1][j-1] = f(self.matrizFinal[i+1][j-1]) - f(self.matrizFinal[self.ordem-k][j-1]) * divisor j += 1 contador += 1 self.matrizIndependentesFinal[0][i+1] = f(self.matrizIndependentesFinal[0][i+1]) - f(self.matrizIndependentesFinal[0][self.ordem-k]) * divisor i += 1 k -= 1 else: self.calculaXMetodoEliminacao()
from fractions import Fraction as f import fileinput ans = [ f() ] for i in range( 1, 34 ): ans += [ ans[ -1 ] + f( 1, i ) ] ans = [ i * ans[ i ] for i in range( len( ans ) ) ] def proc( n ): if int( n ) == n: print( n ) else: i, n, d = str( int( n ) ), str( n.numerator % n.denominator ), str( n.denominator ) print( ' ' * len( i ) + ' ' + n ) print( str( i ) + ' ' + '-' * len( d ) ) print( ' ' * len( i ) + ' ' + d ) for i in fileinput.input(): proc( ans[ int( i ) ] )
def calculaX(mA,x,j,k): if (j == k): k -= 1 if (k < 0): return 0 return f(mA[j][k])*f(x[k]) + calculaX(mA,x,j,k-1)
from fractions import Fraction as f import sys # strange patterns by looking at pythagorean triples def sqr(x): return x*x def greenq(x,y,x2,y2): return 2*(x2-x)*(y2-y) def redq(x,y,x2,y2): return sqr(x2-x)-sqr(y2-y) def blueq(x,y,x2,y2): return sqr(x2-x)+sqr(y2-y) blueqlimit=1000000 xs,ys=[],[] for m in range(-20,20): for n in range(-20,20): if (m*m-n*n==0): continue if (m == 0 or n == 0): continue x = f(redq(0,0,m,n),m+blueq(0,0,m,n)) y = f(greenq(0,0,m,n),n+blueq(0,0,m,n)) xs += [x] ys += [y] max=max(xs+ys) for i in range(0,len(xs)): xs[i] = f( xs[i], max ) ys[i] = f( ys[i], max ) print len(xs), 'points' import numpy as np import matplotlib.pylab as plt fig,ax = plt.subplots(figsize=(8,8))
def test(top=12): res = 0 for x in range(1,top): if x == getnumer(f(x,top)): res+=1 return res/(top-1)
from fractions import Fraction as f from fractions import gcd ans = 0 os = f( 1, 2 ) ot = f( 1, 3 ) for d in xrange( 1, 12001 ): for n in xrange( d / 3, d ): if f( n, d ) >= os: break if f( n, d ) <= ot: continue if gcd( n, d ) == 1: ans += 1 print ans
p2 = [cursor.position[0],cursor.position[1]] cursor.turnleft() cursor.forward(rabbits[-1]) p3 = [cursor.position[0],cursor.position[1]] xs += [p1[0]] ys += [p1[1]] xs += [p2[0]] ys += [p2[1]] xs += [p3[0]] ys += [p3[1]] xs += [p1[0]] ys += [p1[1]] rabbits+=[rabbits[-1]+rabbits[-2]] max=max(xs+ys) for i in range(0,len(xs)): xs[i] = f(xs[i], max ) ys[i] = f(ys[i], max ) print len(xs), 'points' import numpy as np import matplotlib.pylab as plt fig,ax = plt.subplots(figsize=(8,8)) ax.set_ylim([-1.2,1.2]) ax.set_xlim([-1.2,1.2]) #ax.scatter(xs,ys) ax.plot(xs,ys) plt.show()
return new_i def is_unique(nominator, denominator): common_digit = digits(nominator) & digits(denominator) #print common_digit if common_digit: common_digit = list(common_digit)[0] if common_digit > 0: new_nominator = eliminate_digit(nominator, common_digit) new_denominator = eliminate_digit(denominator, common_digit) if new_denominator and f(nominator, denominator) == f(new_nominator, new_denominator): #print f(nominator, denominator) return True return False #print is_unique(49, 98) prod = 1 for i in xrange(10, 100): for j in xrange(i+1, 100): if is_unique(i, j): prod *= f(i, j) print prod.denominator
#!/usr/bin/python # # problem 57: http://projecteuler.net/problem=57 # from fractions import Fraction as f iter = lambda x: f(1,2 + x) counter = 0 loop_counter = 1 whole = f(1) frac = f(1,2) while loop_counter < 10**3: loop_counter += 1 frac = iter(frac) num = whole + frac if len(str(num.numerator)) > len(str(num.denominator)): counter += 1 print '\nAnswer:', counter
# note - blue, red, and green quadrance are from Norman Wildberger's # Chromogeometry def sqr(x): return x*x def greenq(x,y,x2,y2): return 2*(x2-x)*(y2-y) def redq(x,y,x2,y2): return sqr(x2-x)-sqr(y2-y) def blueq(x,y,x2,y2): return sqr(x2-x)+sqr(y2-y) xs,ys=[],[] xs2,ys2=[],[] r=24 for m in range(-r,r): for n in range(-r,r): if blueq(0,0,m,n)==0: continue if blueq(0,0,m,n)+m+n==0: continue x = m*f(redq(0,0,m,n),blueq(0,0,m,n)) y = m*f(greenq(0,0,m,n),blueq(0,0,m,n)) xs += [x] ys += [y] max=max(xs+ys) for i in range(0,len(xs)): xs[i] = f(xs[i], max ) ys[i] = f(ys[i], max ) print len(xs), 'points' import numpy as np import matplotlib.pylab as plt fig,ax = plt.subplots(figsize=(8,8)) ax.set_ylim([-1.2,1.2])
from fractions import Fraction as f import sys # strange patterns by looking at pythagorean triples def sqr(x): return x*x def greenq(x,y,x2,y2): return 2*(x2-x)*(y2-y) def redq(x,y,x2,y2): return sqr(x2-x)-sqr(y2-y) def blueq(x,y,x2,y2): return sqr(x2-x)+sqr(y2-y) blueqlimit=1000000 xs,ys=[],[] for m in range(-20,20): for n in range(-20,20): if (m*m-n*n==0): continue if (m == 0 or n == 0): continue x = f(redq(0,0,m,n),blueq(0,0,m,n)/m) y = f(greenq(0,0,m,n),blueq(0,0,m,n)/m) xs += [x] ys += [y] max=max(xs+ys) for i in range(0,len(xs)): xs[i] = f( xs[i], max ) ys[i] = f( ys[i], max ) print len(xs), 'points' import numpy as np import matplotlib.pylab as plt fig,ax = plt.subplots(figsize=(8,8))
# -*- coding: utf-8 -*- #!/bin/python """ P=VI I=P/V I=V/R RI=V R=V/I R=V/(P/V) R=V**2/P """ from fractions import Fraction as f import sys if __name__ == '__main__': p = f(sys.argv[1]) print "%.0fW:" % p for vin in range(3, 13): i = p/vin r = vin/i assert r == vin/(p/vin) == (vin**2)/p print u"%dV %.2fA %.1fΩ" % (vin, i, r)
def sqr(x): return x*x def greenq(x,y,x2,y2): return 2*(x2-x)*(y2-y) def redq(x,y,x2,y2): return sqr(x2-x)-sqr(y2-y) def blueq(x,y,x2,y2): return sqr(x2-x)+sqr(y2-y) xs,ys=[],[] xs2,ys2=[],[] depth=15 layers=[[]] for j in range(0,depth): layer=layers[j] layers+=[[]] for i in range(2*j): num = i denom = 2*j layers[j] += [f(num,denom)] layers[j+1]+=[f(1,1)] #for i in layers: # print i,'\n' for layer in layers: for t in layer: if blueq(0,0,1,t)==0: continue x = len(layer)*f(redq(0,0,1,t),blueq(0,0,1,t)) y = len(layer)*f(greenq(0,0,1,t),blueq(0,0,1,t)) xs += [x] ys += [y] xs += [-x] ys += [y] xs += [-x]
from fractions import Fraction as f from pe_utils import sieve max_cycle = 1 max_d = 0 primes = sieve(1000) for d in primes: for c in xrange(1, 1000): x = f(1, d) y = x * (10 ** c) - x z = x * (10 ** c) if z.denominator == 1: # no cycle break if y.denominator == 1: # got cycle if c > max_cycle: max_cycle = c max_d = d break print max_d, max_cycle
from fractions import Fraction as f if __name__ == '__main__': for _ in xrange(input()): n, m = map(int, raw_input().split()) num = f(m, n) * f(1, 4) den = f(n - m, n) * f(2, 9) ans = num / (num + den) print '%d/%d' % (ans.numerator, ans.denominator)
def p_expression_binop(p): '''expression : expression PLUS expression | expression MINUS expression | expression TIMES expression''' if p[2] == '+': p[0] = p[1] + p[3] elif p[2] == '-': p[0] = p[1] - p[3] elif p[2] == '*': p[0] = p[1] * p[3] def p_expression_group(p): 'expression : LPAREN expression RPAREN' p[0] = p[2] parser = yacc.yacc(debug = 0, optimize = 1, write_tables = 0) if __name__ == "__main__": assert parser.parse("9 - 3/7 + 3/7 + 1") == 10 assert parser.parse("7 + 3/2 - 3/2") == 7 assert parser.parse("4 + 4") == 8 assert parser.parse("3/4 + 4/4") == f(7,4) assert parser.parse("2 - 3") == -1 assert parser.parse("2 * 4") == 8 assert parser.parse("2 + 4 * 7") == 30 assert parser.parse("(2 + 3) * 5") == 25 assert parser.parse("3/4 - 1/4") == f(1,2) assert parser.parse("0/4 * 9") == 0
def sqr(x): return x*x def greenq(x,y,x2,y2): return 2*(x2-x)*(y2-y) def redq(x,y,x2,y2): return sqr(x2-x)-sqr(y2-y) def blueq(x,y,x2,y2): return sqr(x2-x)+sqr(y2-y) xs,ys=[],[] xs2,ys2=[],[] depth=30 layers=[[]] for j in range(0,depth): layer=layers[j] layers+=[[]] for i in range(j): num = i denom = j layers[j] += [f(num,denom)] # layers[j+1]+=[f(1,1)] for i in layers: print i,'\n' for layer in layers: for t in layer: if greenq(0,0,1,t)==0: continue if redq(0,0,1,t)==0: continue x = len(layer)*f(greenq(0,0,1,t),redq(0,0,1,t)) y = len(layer)*f(redq(0,0,1,t),greenq(0,0,1,t)) xs += [x] ys += [y] max=max(xs+ys)
#!/usr/bin/env python from fractions import Fraction as f ls = list() for i in range(0,101): if i % 3 == 0: ls.append(i/3*2) else: ls.append(1) ls[1] = 2 ls1 = ls[1:] x = f(ls1.pop()) print ls1, len(ls1) for i in range(0, len(ls1)): x = ls1.pop() + 1 / x print x n = x.numerator print sum(map(int, str(n)))