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))
