def array_to_trips(demand, output): ''' convert numpy array into _trips.txt input file for Matthew Steele's solver ''' row = 0 zones = int(np.max(demand[:,0])) out = ['<NUMBER OF ZONES> {}\n'.format(zones)] out.append('<TOTAL OD FLOW> {}\n'.format(np.sum(demand[:,2]))) out.append('<END OF METADATA>\n\n\n') for i in range(zones): out.append('Origin') out.append(spaces(10-digits(i+1))) out.append('{}\n'.format(i+1)) count = 0 while (row < demand.shape[0]) and (demand[row,0] == i+1): count = count + 1 d = int(demand[row,1]) out.append(spaces(5-digits(d))) out.append('{} :'.format(d)) out.append(spaces(8-digits(demand[row,2]))) out.append('{:.2f}; '.format(demand[row,2])) row = row + 1 if count % 5 == 0: out.append('\n') count = 0 out.append('\n') with open(output, "w") as text_file: text_file.write(''.join(out))
def array_to_trips(demand, output): ''' convert numpy array into _trips.txt input file for Matthew Steele's solver ''' row = 0 zones = int(np.max(demand[:, 0])) out = ['<NUMBER OF ZONES> {}\n'.format(zones)] out.append('<TOTAL OD FLOW> {}\n'.format(np.sum(demand[:, 2]))) out.append('<END OF METADATA>\n\n\n') for i in range(zones): out.append('Origin') out.append(spaces(10 - digits(i + 1))) out.append('{}\n'.format(i + 1)) count = 0 while (row < demand.shape[0]) and (demand[row, 0] == i + 1): count = count + 1 d = int(demand[row, 1]) out.append(spaces(5 - digits(d))) out.append('{} :'.format(d)) out.append(spaces(8 - digits(demand[row, 2]))) out.append('{:.2f}; '.format(demand[row, 2])) row = row + 1 if count % 5 == 0: out.append('\n') count = 0 out.append('\n') with open(output, "w") as text_file: text_file.write(''.join(out))
def do_wrong_cancelling(n, d): nd = utils.digits(n) dd = utils.digits(d) if not (nd[1] == 0 and dd[1] == 0 or nd[0] == nd[1] and dd[0] == dd[1]): if nd[0] == dd[1]: return nd[1], dd[0] elif nd[1] == dd[0]: return nd[0], dd[1] return n, d
def isCurious( n, d ): ans = reduceFraction( n, d ) ndigits = digits( n ) ddigits = digits( d ) for i, nd in enumerate( ndigits ): for j, dd in enumerate( ddigits ): if nd == dd: cn = number( ndd for ii, ndd in enumerate( ndigits ) if i != ii ) cd = number( ddd for jj, ddd in enumerate( ddigits ) if j != jj ) if ans == reduceFraction( cn, cd ): return True return False
def check( n ): if n in ends: return ends[ n ] else: ends[ n ] = check( sum( map( lambda x : x * x, digits( n ) ) ) ) return ends[ n ]
def euler33(): ret = 1 for a in range(10, 100): for b in range(a + 1, 100): f = Fraction(a, b) d_a = set(digits(a)) d_b = set(digits(b)) intersect = d_a & d_b if len(intersect) == 1 and list(intersect) != [0]: try: if Fraction(list(d_a - d_b)[0], list(d_b - d_a)[0]) == f: ret *= f except: pass return ret.denominator
def add_multiplicator(self, mult): x = self.n * mult num_digits_x = utils.num_digits(x) self.concatenation *= 10 ** num_digits_x self.concatenation += x self.num_digits += num_digits_x self.digits |= set(utils.digits(x))
def main(): s = 0 for i in xrange(3, 7 * fac(9)): digs = utils.digits(i) sum_digs = sum(map(fac, digs)) if i == sum_digs: s += i print s
def digitsUsed( *numbers ): ret = [] for number in numbers: for digit in digits( number ): if not digit: return [] else: ret.append( digit ) return ret
def euler119(): a = set() for x in range(2, 100): for y in range(2, 100): res = x ** y if sum(digits(res)) == x: a.add(res) return sorted(a)[30 - 1]
def euler80(): decimal.getcontext().prec = 105 ret = 0 for i in range(2, 101): if is_int(math.sqrt(i)): continue x = str(decimal.Decimal(i).sqrt()).replace(".", "") ret += sum(digits(x[:100])) return ret
def only_prime_rotations(n): ds = utils.digits(n, 10)[::-1] for _ in range(len(ds)): ds.append(ds.pop(0)) i = int(''.join(map(str, ds))) if not utils.isPrime(i): # print(i,"not prime",ds) return False # print(ds) return True
def isGood( num, code ): numTup = map( int, str( num ) ) numIndex = len( numTup ) for digit in reversed( digits( code ) ): while numIndex: if digit == code: numIndex -= 1 continue numIndex -= 1 else: return False else: return True
def d( n ): d = 1 while n - d * ( 10 ** d - 10 ** ( d - 1 ) ) > 0: n -= d * ( 10 ** d - 10 ** ( d - 1 ) ) d += 1 s = 10 ** ( d - 1 ) while n - d > 0: s += 1 n -= d for digit in digits( s ): n -= 1 if not n: return digit
def main(_): # Import data wild_data = utils.digits(FLAGS.wild_image) mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True) # Create the model x = tf.placeholder(tf.float32, [None, 784]) W = tf.Variable(tf.zeros([784, 10])) b = tf.Variable(tf.zeros([10])) y = tf.matmul(x, W) + b # Define loss and optimizer y_ = tf.placeholder(tf.float32, [None, 10]) # The raw formulation of cross-entropy, # # tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.nn.softmax(y)), # reduction_indices=[1])) # # can be numerically unstable. # # So here we use tf.nn.softmax_cross_entropy_with_logits on the raw # outputs of 'y', and then average across the batch. cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) sess = tf.InteractiveSession() tf.global_variables_initializer().run() # Train for _ in range(1000): batch_xs, batch_ys = mnist.train.next_batch(100) sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) #~ # Test trained model #~ correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) #~ accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) #~ print(sess.run(accuracy, feed_dict={x: mnist.test.images, #~ y_: mnist.test.labels}) #~ ) guessed_labels = tf.argmax(y, 1) y_guess = sess.run(guessed_labels, feed_dict={x: wild_data}) print(list(y_guess))
def queue_jobs(srr_list_file: Path, pool: str, subprocesses: int): data_path = create_data_path(SCRIPT_LABEL) slurm_path = create_slurm_path(SCRIPT_LABEL) with open(srr_list_file) as f: srr_ids = [line.strip() for line in f] srr_sublist_count = ceil(len(srr_ids) / SLURM_ARRAY_MAX) srr_filename_digits = digits(srr_sublist_count) for i, srr_sublist_raw in enumerate(grouper(srr_ids, SLURM_ARRAY_MAX)): srr_sublist_path = data_path / SRR_LIST_FILENAME_TEMPLATE.format( i, srr_filename_digits) print( f'{i:0{srr_filename_digits}} Saving SRR sublist to {srr_sublist_path}' ) srr_sublist = list(filter(None, srr_sublist_raw)) with open(srr_sublist_path, 'w') as f: for srr_id in srr_sublist: print(srr_id, file=f) array_index_spec = f'0-{len(srr_sublist) - 1}' script_file = slurm_path / SCRIPT_FILENAME_TEMPLATE.format( i, srr_filename_digits) print(f'{i:0{srr_filename_digits}} Saving script to {script_file}') with open(script_file, 'w') as f: script_content = script_template.format( srr_list_file=srr_sublist_path.absolute(), pool=pool, subprocesses=subprocesses, stdout_path=script_file.with_suffix('.out')) print(script_content, file=f) slurm_command = [ piece.format( array_index_spec=array_index_spec, script_filename=script_file, ) for piece in SBATCH_COMMAND_TEMPLATE ] print(f'{i:0{srr_filename_digits}} Running', ' '.join(slurm_command)) check_call(slurm_command)
def digitsSum(): for a in xrange( 100 ): for b in xrange( 100 ): yield sum( digits( a ** b ) )
def palindrom_generator(guard): for i in xrange(1, guard): if palindrom(digits(i)) and palindrom(bin(i)): yield i
def euler48(): return from_digits(digits(sum([x ** x for x in range(1, 1001)]))[-10:])
def __init__(self, n): self.n = n self.concatenation = n self.num_digits = utils.num_digits(n) self.digits = set(utils.digits(n))
def nextVal( n ): return sum( map( fact, digits( n ) ) )
def curiousGen(): for x in xrange( 10, LIMIT ): if x == sum( map( fact, digits( x ) ) ): yield x
def end(s): return s if s == 1 or s == 89 else end(sum(map(quad, digits(s))))
from utils import digits, number g = { 2 : 2, 3 : 3, 4 : 5, 5 : 7, 6 : 11, 7 : 13, 8 : 17 } numbers = frozenset( xrange( 10 ) ) fringe = [ ( 8, digits( x * 17 ), numbers - set( digits( x * 17 ) ) ) for x in xrange( 1000 / 17, 100 / 17, -1 ) if len( set( digits( x * 17 ) ) ) == 3 ] def successorFn( (d, used, unused) ): return [ ( d - 1, ( u, ) + used, unused - { u } ) for u in unused ] def goalState( ( d, _, __ ) ): return d == 1 def isGood( (d, used, _) ): return not number( used[:3] ) % g[ d ] def explore( fringe ): while fringe: node = fringe.pop() if goalState( node ): yield node; continue elif isGood( node ): fringe += successorFn( node ) print sum( number( used ) for _, used, _ in explore( fringe ) )
s = set() def digitsUsed( *numbers ): ret = [] for number in numbers: for digit in digits( number ): if not digit: return [] else: ret.append( digit ) return ret a = 2 while True: b = 2 if 0 in digits( a ): a += 1 continue if len( digitsUsed( a, b, a * b ) ) > 9: break while True: if 0 in digits( b ): b += 1 continue used = digitsUsed( a, b, a * b ) if 9 == len( used ) == len( set( used ) ): s.add( a * b ) elif len( used ) > 9:
from utils import digits cubes = {} # digits -> value i = 1 while True: cube = i** 3 key = tuple( sorted( digits( i ** 3 ) ) ) if key not in cubes: cubes[ key ] = [] cubes[ key ].append( cube ) if len( cubes[ key ] ) == 5: break i += 1 print min( cubes[ key ] )
def euler56(): ret = 0 for a in range(1, 100): for b in range(1, 100): ret = max(ret, sum(digits(a ** b))) return ret
from utils import product, digits print sum( digits( product( xrange( 1, 101 ) ) ) )
from utils import primeGen, digits from operator import add s = {} for prime in primeGen( start=1000, end=10000 ): d = tuple( sorted( digits( prime ) ) ) if d not in s: s[ d ] = () s[ d ] += ( prime, ) for d, ps in s.iteritems(): if len( ps ) >= 3: l = len( ps ) for i in xrange( l ): for j in xrange( i + 1, l ): for k in xrange( i + j, l ): p1, p2, p3 = ps[ i ], ps[ j ], ps[ k ] if p3 - p2 == p2 - p1 and p1 != 1487: print reduce( add, map( str, ( p1, p2, p3 ) ) )
def only_odds(n): for d in utils.digits(n, 10): if d > 0 and d % 2 == 0: return False return True
def rotated(n): d = utils.digits(n) result = [] for _ in xrange(len(d)): result.append(undigit(rot(d))) return result
def isGood( n ): return equals( *map( lambda x : sorted( digits( x ) ), ( n * i for i in xrange( 1, 7 ) ) ) )
def amend(self, price): offset = (price['buy']+price['sell'])/2 - (self.reg[0]['h']+self.reg[0]['l'])/2 for r in self.reg: r['h'] = digits((r['h']+offset), 6) r['l'] = digits((r['l']+offset), 6)
def euler30(): ret = 0 for i in range(2, (9 ** 5) * 5 + 1): if sum([x ** 5 for x in digits(i)]) == i: ret += i return ret
def euler20(): return sum(digits(math.factorial(100)))
# # The factorial digit sum of n is the sum of the digits of n!. import sys from math import factorial from utils import digits def digit_sum(n): if n < 0: return digit_sum(-n) elif n in range(0, 10): return n return sum(d for d in digits(n)) def factorial_digit_sum(n): return digit_sum(factorial(n)) if __name__ == '__main__': n = int(sys.argv[1].strip()) fact = factorial(n) digs = digits(fact) digit_sum_str = ' + '.join(str(d) for d in digs) fact_digit_sum = digit_sum(n) print('\n{}! = {}, digit sum = {} = {}\n'.format(n, fact, digit_sum_str, fact_digit_sum))
def digit_sum(n): if n < 0: return digit_sum(-n) elif n in range(0, 10): return n return sum(d for d in digits(n))
from utils import factorial, digits s = 0 for i in range(3, 1000000): if sum(map(factorial, digits(i))) == i: s += i print(s)
def digit_seq(): i = 1 while True: for d in utils.digits(i): yield d i += 1
def euler15(): return sum(digits(2 ** 1000))