Title  tafakuri Length: 9, Words: 1 

Description  pusty
Length: 0, Words: 0 
Keywords  pusty 
Robots  follow, all 
Charset  UTF8 
Og Meta  Title  pusty 
Og Meta  Description  pusty 
Og Meta  Site name  pusty 
Words/Characters  5896 

Text/HTML  38.47 % 
Headings  H1 10
H2 3 H3 10 H4 10 H5 0 H6 0 
H1  kenya’s chief justice selection


H2  recent posts

H3  may

H4  30 20 6 23 21 16 2 27 16 
H5  
H6 
strong  1


b  1

i  
em  1 1 89 89 
Bolds  strong 4 b 4 i 0 em 4 

twitter:title  pusty 

twitter:description  pusty 
google+ itemprop=name  pusty 
Pliki zewnętrzne  2 
Pliki CSS  0 
Pliki javascript  2 
Linki  103 

Linki wewnętrzne  1 
Linki zewnętrzne  102 
Linki bez atrybutu Title  88 
Linki z atrybutem NOFOLLOW  0 
logout  wplogin.php?action=logout 

tafakuri  http://tafakuri.net/ 

home  http://tafakuri.net 
kenya’s chief justice selection  http://tafakuri.net/?p=79 
two numbers  http://tafakuri.net/?p=78 
project euler: happy numbers  http://tafakuri.net/?p=77 
nerdy tshirts  http://tafakuri.net/?p=76 
presence africaine  http://tafakuri.net/?p=74 
elimu  http://tafakuri.net/?cat=2 
fasihi  http://tafakuri.net/?cat=3 
filosofia  http://tafakuri.net/?cat=5 
hisabati  http://tafakuri.net/?cat=13 
mashairi  http://tafakuri.net/?cat=10 
maswali  http://tafakuri.net/?cat=7 
project euler  http://tafakuri.net/?cat=14 
sayansi  http://tafakuri.net/?cat=9 
siasa  http://tafakuri.net/?cat=6 
soyinka  http://tafakuri.net/?cat=4 
tarakirishi  http://tafakuri.net/?cat=12 
teknolojia  http://tafakuri.net/?cat=8 
uchumi  http://tafakuri.net/?cat=11 
uncategorized  http://tafakuri.net/?cat=1 
a pdf library manager  http://tafakuri.net/?page_id=15 
a simple chatbot  http://tafakuri.net/?page_id=34 
a finite field calculator  http://tafakuri.net/?page_id=17 
a permutations calculator  http://tafakuri.net/?page_id=18 
binomial  http://tafakuri.net/?page_id=26 
negative binomial  http://tafakuri.net/?page_id=28 
geometric  http://tafakuri.net/?page_id=29 
hypergeometric  http://tafakuri.net/?page_id=30 
poisson  http://tafakuri.net/?page_id=31 
single walk  http://tafakuri.net/?page_id=32 
multiple walks  http://tafakuri.net/?page_id=33 
« may  http://tafakuri.net/?m=201105 
kenya’s chief justice selection  http://tafakuri.net/?p=79 
siasa  http://tafakuri.net/?cat=6 
mucheru  http://tafakuri.net/?author=2 
two numbers  http://tafakuri.net/?p=78 
hisabati  http://tafakuri.net/?cat=13 
mucheru  http://tafakuri.net/?author=2 
project euler: happy numbers  http://tafakuri.net/?p=77 
hisabati  http://tafakuri.net/?cat=13 
project euler  http://tafakuri.net/?cat=14 
mucheru  http://tafakuri.net/?author=2 
1 comment  http://tafakuri.net/?p=77#comments 
equivalence classes  http://en.wikipedia.org/wiki/equivalence_class 
http://www.andrews.edu/~calkins/math/webtexts/prod02.htm  http://www.andrews.edu/~calkins/math/webtexts/prod02.htm 
nerdy tshirts  http://tafakuri.net/?p=76 
sayansi  http://tafakuri.net/?cat=9 
tarakirishi  http://tafakuri.net/?cat=12 
mucheru  http://tafakuri.net/?author=2 
xkcd  http://xkcd.com 
my code is compiling  http://xkcd.com/303/ 
sudo make me a sandwich  http://xkcd.com/149/ 
airspeed velocity of an unladen swallow  http://www.youtube.com/watch?v=pws8mgjwsg&feature=related 
i^{2}  http://en.wikipedia.org/wiki/imaginary_number 
real  http://en.wikipedia.org/wiki/real_number 
presence africaine  http://tafakuri.net/?p=74 
filosofia  http://tafakuri.net/?cat=5 
mucheru  http://tafakuri.net/?author=2 
  http://books.google.com/books?id=c8ykxigrm1gc&printsec=frontcover 
the surreptitious speech: présence africaine and the politics of otherness  http://books.google.com/books?id=c8ykxigrm1gc&printsec=frontcover 
a roundup of fun toys and tools  http://tafakuri.net/?p=72 
teknolojia  http://tafakuri.net/?cat=8 
mucheru  http://tafakuri.net/?author=2 
2 comments  http://tafakuri.net/?p=72#comments 
http://www.officelabs.com/projects/pptplex/pages/default.aspx  http://www.officelabs.com/projects/pptplex/pages/default.aspx 
http://projects.nikhilk.net/scriptsharp  http://projects.nikhilk.net/scriptsharp 
extjs  http://www.extjs.com/ 
ext#  http://code.google.com/p/extsharp/ 
http://photosynth.net/  http://photosynth.net/ 
http://research.microsoft.com/enus/um/redmond/projects/songsmith/index.html  http://research.microsoft.com/enus/um/redmond/projects/songsmith/index.html 
this  http://arstechnica.com/reviews/apps/microsoftsongsmithreview.ars 
summing numbers that cannot be written as a sum of two abundant numbers  http://tafakuri.net/?p=71 
hisabati  http://tafakuri.net/?cat=13 
project euler  http://tafakuri.net/?cat=14 
mucheru  http://tafakuri.net/?author=2 
here  http://projecteuclid.org/dpubs?verb=display&version=1.0&service=ui&handle=euclid.prims/1195193227&page=record 
here  http://projecteuclid.org/dpubs?verb=display&version=1.0&service=ui&handle=euclid.prims/1195193227&page=record 
length of cycles in unit fractions  http://tafakuri.net/?p=69 
hisabati  http://tafakuri.net/?cat=13 
project euler  http://tafakuri.net/?cat=14 
mucheru  http://tafakuri.net/?author=2 
leave a comment  http://tafakuri.net/?p=69#respond 
long division  http://en.wikipedia.org/wiki/long_division 
coprime  http://en.wikipedia.org/wiki/coprime 
order  http://en.wikipedia.org/wiki/order_(group_theory) 
the multiplicative group of integers modulo n  http://en.wikipedia.org/wiki/multiplicative_group_of_integers_modulo_n 
project euler: nth lexicographic permutation  http://tafakuri.net/?p=68 
hisabati  http://tafakuri.net/?cat=13 
project euler  http://tafakuri.net/?cat=14 
mucheru  http://tafakuri.net/?author=2 
leave a comment  http://tafakuri.net/?p=68#respond 
here  http://en.wikipedia.org/wiki/factorial 
project euler: determining the number of paths in a grid  http://tafakuri.net/?p=66 
hisabati  http://tafakuri.net/?cat=13 
project euler  http://tafakuri.net/?cat=14 
mucheru  http://tafakuri.net/?author=2 
next page →  http://tafakuri.net/?paged=2 
tafakuri  http://tafakuri.net/ 
wordpress  http://www.wordpress.org 
blue zinfandel  http://www.briangardner.com/themes/bluezinfandelwordpresstheme.htm 
brian gardner  http://www.briangardner.com 
Zdjęcia  2 

Zdjęcia bez atrybutu ALT  1 
Zdjęcia bez atrybutu TITLE  1 
http://projecteuler.net/project/images/p_015.gif
http://projecteuler.net/project/images/p_015.gif
tafakuri fikira nzito kuhusu jambo fulani; mazingatio; taamuli home logout a permutations calculator about binomial distribution geometric distribution hypergeometric distribution managing pdf libraries multiple walk data negative binomial distribution poisson distribution said the bot, v.1 simple calculations in finite fields single random walk > recent posts kenya’s chief justice selection two numbers project euler: happy numbers nerdy tshirts presence africaine categories elimu fasihi filosofia hisabati mashairi maswali project euler sayansi siasa soyinka tarakirishi teknolojia uchumi uncategorized projects a pdf library manager a simple chatbot a finite field calculator a permutations calculator discrete distributions binomial negative binomial geometric hypergeometric poisson random walks single walk multiple walks june 2017 m t w t f s s « may 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 may 9 kenya’s chief justice selection filed under siasa by mucheru  comments off on kenya’s chief justice selection kenya is going through the process of selecting the next chief justice. candidates for the post are being interviewed by a panel of prominent lawyers in a public hearing. this is a new selection process – previously the chief justice was appointed by the president and did not need to be accountable to anyone else. you can tell that the lawyers are enjoying digging into the (often illprepared) judges. ahmednasir, the former law society of kenya chairman had this question for lady justice ang’awa: your judgments consist of one line or one paragraph rulings, skeleton in nature and lacks depth. it is evident you have a problem writing in prose. do you think writing in poetry will help or capture the essence of justice? reading the coverage of the hearings is quite entertaining and also illuminating. the interviewers are bringing up particular cases that the judges handled and putting them to task for decisions handed suspiciously in favor of connected politicians or businessmen. the best part of this is that the judges never thought they would have to explain their decisions and some are still indignant when asked to. going back to ang’awa – how does a judge of the high court make a career of issuing oneline rulings? sure, it looks good for her statistics that she clears many cases. at this level, though, the goal of a judge is not simply to adjudicate conflicts – they interpret the law, provide guidance to lower courts and establish precedent which will guide future courts. how is one to infer a legal doctrine from oneline rulings? my advice for the justice is to branch out. try some verses as ahmednasir suggested. maybe combine the love for brevity with poetic skills and write some haiku. > aug 30 two numbers filed under hisabati by mucheru  comments off on two numbers here is an interesting puzzle that was posted to one of the discussion groups at work. a teacher tells two students that he is thinking of two natural numbers greater than 1. he tells the first student the product of the two numbers and the second one their sum. the students then have the following dialog: first: i do not know their sum. second: i knew that. their sum is less than 14. first: i knew that, and now i know the numbers. second: so do i. what were the numbers and how did they figure them out? solution let’s say that the two numbers that the teacher is thinking of are a and b. lets say that the product a*b = n and the sum a+b = m. when the first student gets the product n, it is fair to assume that he tries to factor n to find out the two numbers. there may be multiple ways of factoring n into two integers greater than 1 so we can assume he finds all such pairs. when the second student gets the sum m, he tries to find all integer pairs {i,j} such that i+j = m. both students have their lists of candidate pairs before they start their conversation. we can now step through their statements. first student says: ” i do not know their sum” remember that the first student has the product n and has determined all pairs {i,j} such that i*j=n. if he cannot find the sum, this implies that there are multiple ways of factoring n into two integers. otherwise, if there was only one way of factoring n into two, he would have a single pair {i,j} and would be able to determine the sum. if n cannot be factored uniquely into two numbers, then the target numbers a and b cannot both be prime (maybe one or zero of them is prime). otherwise, if a and b were both prime, then there would only be one way of factoring n into two. second student says: “i knew that the first student could not know the sum” recall that second student has the sum m and has enumerated all pairs {i,j} such that i+j = m. since he has these pairs, he can calculate all the possible products of i*j and this will help him know what kind of info the first student has. when the first student says that he cannot uniquely determine the sum, it confirms what second knew. in second student’s list of pairs {i,j} , there is no pair such that, given the product, you can uniquely identify the sum. the only way that second student could have known for sure that the first student could not determine the sum is if on the list of pairs that second student has, there is no pair {i,j} such that both i and j are prime. in other words, m is an integer that cannot be created by adding two primes. second student says: the sum is less than 14 this tells us that 1 < m < 14. from the previous section , we also know that m cannot be created by adding two primes. this tells us that m = 11. the derivation is as follows: m is in the set {2,3,4,5,6,7,8,9,10,11,12,13} 2 is out because the only {i,j} such that i+j = 2 is {1,1} and we know that both candidate numbers are greater than 1. 3 is out because the only {i,j} s.t. i+j=3 is {1,2} 4 is out because it can be created by 2+2 where 2 is prime 5 is out. it can be created by 2+3 6 is out. it can be created by 3+3 7 is out. it can be created by 2+5 8 is out. it can be created by 3+5 9 is out. it can be created by 2+7 10 is out. it can be created by 3+7 12 is out. it can be created by 5+7 13 is out. it can be created by 2+11 first student says: “i knew that the sum m < 14” remember that the first student has the product n and has determined all pairs {i,j} such that i*j=n. since he has the pairs, he has also summed them and he knows for sure that for all {i,j}, i+j <14. in other words, n is an integer that can be factored into two in multiple ways but however you do it, the two numbers you end up with always add up to less than 14. this is the final piece. the final derivation is as follows: we know that i and j are both numbers in {2,3,4,5,6,7,8,9,10,11,12,13} (i.e. neither i nor j can be greater than 14) we can enumerate all pairs {i,j} such that i+j < 14 {22,3,4,5,6,7,8,9,10,11} {33,4,5,6,7,8,9,10} {44,5,6,7,8,9} {55,6,7,8} {66,7} where the notation {xy,z} is shorthand for the pairs “the pairs where the smaller number is x and the larger is either y or z” (i.e. {x,y} and {x,z}) we can then eliminate all pairs where i and j are both prime. this leaves. {24,6,8,9,10} {34,6,8,9,10} {44,5,6,7,8,9} {56,8} {66,7} consider the products of pairs i*j 4 5 6 7 8 9 10 2 8 12 16 18 20 3 12 18 24 27 30 4 16 20 24 28 32 36 5 30 40 6 36 42 eliminate all products that can be created by multiplying numbers that add up to >=14. this eliminates 24, 28, 30, 32, 36, 40 and 42 because : 36 = 18*2, and 18+2>14 30 = 15*2, and 15+2 > 14 24 = 12*2, and 12+2 = 14 28 = 14*2 42=21*2 32=16*2 40=20*2 this gives us the grid: 4 5 6 8 9 10 2 8 12 16 18 20 3 12 18 27 4 16 20 which gives the pairs {24,6,8,9,10} {34,6,9} {44,5} we already know that i+j = 11. looking at our pairs, we determine that the answer is {2,9} > sep 20 project euler: happy numbers filed under hisabati, project euler by mucheru  1 comment problem 92 from project euler asks us to find the number of nonhappy numbers under 10 million: a number chain is created by continuously adding the square of the digits in a number to form a new number until it has been seen before. for example, 44 > 32 > 13 > 10 > 1 > 1 85 > 89 > 145 > 42 > 20 > 4 > 16 > 37 > 58 > 89 therefore any chain that arrives at 1 or 89 will become stuck in an endless loop. what is most amazing is that every starting number will eventually arrive at 1 or 89. how many starting numbers below ten million will arrive at 89? the numbers that have a sequence ending in 1 are called the ‘happy’ numbers (making the rest nonhappy). as with most project euler problems, this could be solved by brute force. following the definition of the sequences, we can run through all numbers from 1 to 10 million. for each number, split it into its constituent digits, square each digit and sum them all. if the sum of squares of digits is 89, we’ve found a match. otherwise, test the new number for a match (split digits, square etc). the problem with this approach is that you will have to evaluate at lest 10 million numbers. in a naive implementation, you would actually end up looking at some numbers multiple times. for example, in the series starting at 85 above, you would end up looking at 145 and you may look at it again when you consider the series starting at 145. clearly, this approach does not scale. the first optimization we can make is ensure we evaluate a number only once. to do this, we can store a lookup table with all the numbers that have a series ending in 89. if we evaluate a series that ends in 89, we know that any numbers in the series ends in 89 (i.e. 85,145,20 etc from above). the second optimization comes when we notice that the largest possible sum of the squares of digits in a number for our test is (92)x7 = 567 (from the number 9999999). this reduces the number of sequence evaluations we have to make. we can construct our lookup table showing numbers between 0 and 567 that end in 89. then for each number in our test range from 0 to 10 million, we simply calculate the sum of squares of digits and check our lookup table to see if the value would terminate in 89. the third optimization is based on the realization that the sum of squares of digits function does not change if you reorder the digits. that is, the sum of squares for 123 is the same as for 213, 312, 321 etc. so if the sequence starting at 123 ends at 89, we know that 312, 213 etc will end at 89 as well. formally, this means that the sumofsquaresofdigits function partitions the set of integers into equivalence classes such that a~b if a and b contain the same digits. using this optimization,we only need to check sequences for 11,440 numbers – almost 1000 times smaller than the 10 million checks that the brute force approach would have us make. however, to use this approach, we need to determine the size of each equivalence class. that way, if we determine that that a particular number ends in 89, then we can update our count of matching numbers by adding the full size of the numbers equivalence class. we turn to combinatorics to determine the size of each class. for any one number, its equivalence class is constructed by creating permutations of the digits. the size of the class is therefore given by the number of unique permutations of digits in a sequence. we need to account for repetitions of indistinguishable objects: that is, given the sequence 100335, we need to account for that the the 3s and 0s can be interchanged in permutations without resulting in different integers. the formula and reasoning for such a count is explained at http://www.andrews.edu/~calkins/math/webtexts/prod02.htm under the title “permutations with repeated elements”. the eventual formula is; npr1 r2…rk = n! /( r1!r2!…rk!) where we are arranging n elements where the first element occurs r1 times, the second r2 times … we still need to figure out how to make sure we pick one (and only one) element from each equivalence class for our sequence calculations. each class is composed of numbers that contain the same digits in some order. we can represent each class by creating a string with the nondecreasing sequence of digits that define the class. generating all strings of of length 7 with nondecreasing sequence of digits will give us exactly one representative from each equivalence class. with these optimizations, we solve the problem in 0.5 seconds using python. we can also count all the nonhappy numbers under 10^100 in under a minute. we can further reduce our computations by noticing that there are much fewer happy numbers than unhappy numbers – there are 20 happy numbers under 100. since all numbers are either happy or nonhappy, we can determine the number of nonhappy numbers by counting happy numbers and subtracting from the count of numbers in range. > sep 6 nerdy tshirts filed under sayansi, tarakirishi by mucheru  comments off on nerdy tshirts working at a software company, i’ve gotten to see a fair share of nerdy tshirts. there are the those celebrating various video games, software launches etc. then there are the programming references (“wanna grab a byte?”). probably nobody does programming humor better than xkcd – their “my code is compiling” and “sudo make me a sandwich” shirts are pretty common. this week, i saw two shirts that are in contention for the title of “most awesome tshirt ever”. the first had a decidedly complicated looking equation on the front, giving the value of vs. the caption read “airspeed velocity of an unladen swallow“. priceless. i was tempted to ask if the swallow was african or european. the second had a big bold “i2” on the front with the caption “keeping it real“. that made my day! > mar 23 presence africaine filed under filosofia by mucheru  comments off on presence africaine i recently finished reading “the surreptitious speech: présence africaine and the politics of otherness “ , a compilation of essays edited by valentine mudimbe. the collection celebrates 40 years of the journal presence africaine. mudimbe writes a very engaging summary at the end of the compendium, in which he lays the tone of the compilation and gives his opinion on presence. in the span of forty years, the journal and publishing house presence africaine succeeded in organizing a new literary and intellectual space for “a surreptitious speech.” this space is not the other side of what we may call the western space. in fact, it belongs to that space, though it is true that from the beginning presence defined itself on the margin of this center it challenged. there was a political reason for this. andré gide made it explicit in the first issue of the journal: why should presence speak according to the expectations of a culture that was violating what presence wanted to promote? the idea of constructing space struck me as a very algebraic operation (we construct spaces in algebra all the time) and that got me excited. theoretical spaces are a powerful tool for reasoning in mathematics and in many sciences. how would this tool be useful in such a “concrete” field of study as african studies? mudimbe makes it clear that the space created by presence is a theoretical space, much like the mathematical one. a space is always a construct. it is a theoretical articulation that claims to render and represent operations or, put simply, the reality of a place, that is, a primary experience. a space is, to say the least, a secondorder plane reflecting upon a firstorder practice of life and human experience. in algebra, we use spaces to help us model some aspect of reality that is the subject of study. for instance, we may model the forces acting on an object as vectors in a 3 dimensional plane. in doing so we ignore some of the complexities of the real world and escape into the clean world of 3 dimensional vector spaces. a notable difference between intellectual movement theoretical space and the mathematical modeling space is that the intellectual space influences the reality it models. it seems to be an active space where the mathematical space is passive (the fact that we model some scenario as vectors acting in a 3 dimensional space does not actually mean that it happens that way). in a schrödingeresque manner, the fact that an intellectual movement space studies a certain society changes the reality of that society. this seconddegree organization, by its very being, considerably alters and transforms the primary logic in which it claims to root itself. to that extent, its narratives as well as its postulations invent “what is really out there’ in the field of everyday place. methods of faithfully expressing the place, at least in social and human sciences, undergo regular transformations in order to reflect better the reality of an experience and its complexity. the idea of using spaces as a metaphor comes together wonderfully in the next paragraph. mudimbe makes explicit the contending cultural theoretical spaces and shows how herculean presence’s task was. indeed, after reading the contributions to this volume, one could deduce that, until the founding of presence africaine, african cultures and their designations were submitted to a european space that actualized them as figures of its own past, precisely as anterior to the rupture that radically separated prehistory from history. the memory of the european space would appear thus, diachronically and synchronically, as the paradigm of human experience and, at the same time, as that which historically has muted all other human differences by reducing them to the project of an evolutionary becoming. in this perspective, presence africaine could appear to signify the unthinkable: an otherness spatializing itself from a nowhere that could not but be a utopian project. in effect, its surreptitious voice faces western culture in the name of an absolute alterity; yet this very alterity seems to spring from the western space. > jan 21 a roundup of fun toys and tools filed under teknolojia by mucheru  2 comments microsoft does a poor job of advertising new products, especially those in beta. often this leads to the impression that microsoft does not innovate. here are some new products i’ve been playing with/using that are pretty cool. powerpoint plex (pptplex) from office labs (http://www.officelabs.com/projects/pptplex/pages/default.aspx).if you’ve ever wished your slideshow could be something more than a linear series of slides, this is for you. you can can arrange your slides on a canvas, zoom in and out of slides and set your path for navigating through the slides. this means that you can have long code samples in your presentations and zoom into the sections you need as you need them. i can’t imagine going back to linear slides. an earlier version of plex was used in this demo of touch wall. script# (http://projects.nikhilk.net/scriptsharp)this is the result of an independent project by nikhil kothari, an software architect in the .net developer platform. using the script# compiler, you can compile c# code into javascript (it does with c# what google web toolkit does for java). here’s a blurb from nikhil’s site. script# brings productivity to ajax and javascript development. script# is a free tool that enables developers to author c# source code and subsequently compile it into regular script that works across all modern browsers, and in doing so, leverage the productivity and power of existing .net tools as well as the visual studio ide. script# empowers you with a development methodology and approach that brings software engineering, long term maintainability and scalable development approaches for your ajax applications, components and frameworks. with script#, you can design your ajax applications just as you would .net applications – complete with object inheritance, namespaces, interfaces, event receivers, private methods etc. the javascript produced is browser independent, meaning that you get insulated from all the little browser quirks. you also get a lot of code reuse, just as with regular oop. script# provides its own base libraries for ajax development, mirroring the libraries provided in the .net platform. alternatively, you can use base libraries from asp.net ajax, or third party platforms like extjs(via ext#). script# produces a dll with the javascript at compilation so your dlls can be used in future projects as reference assemblies. photosynth(http://photosynth.net/)this product from microsoft live labs takes set of photos and constructs a 3d model. the effects are pretty astounding. songsmith(http://research.microsoft.com/enus/um/redmond/projects/songsmith/index.html)this falls neatly into the toy category. this product from microsoft research allows you to hum or sing a tune and it generates an accompaniment. arstechnica had a really good article on this. there are some youtube videos providing songsmith rearrangements of classic tunes. my favorite is the remake of roxanne by the police. > jan 16 summing numbers that cannot be written as a sum of two abundant numbers filed under hisabati, project euler by mucheru  comments off on summing numbers that cannot be written as a sum of two abundant numbers problem 23 from project euler asks for the sum of numbers that cannot be written as the sum of two abundant numbers: a perfect number is a number for which the sum of its proper divisors is exactly equal to the number. for example, the sum of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number. a number whose proper divisors are less than the number is called deficient and a number whose proper divisors exceed the number is called abundant. as 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest number that can be written as the sum of two abundant numbers is 24. by mathematical analysis, it can be shown that all integers greater than 28123 can be written as the sum of two abundant numbers. however, this upper limit cannot be reduced any further by analysis even though it is known that the greatest number that cannot be expressed as the sum of two abundant numbers is less than this limit. find the sum of all the positive integers which cannot be written as the sum of two abundant numbers. when i read the problem, the requirements seemed to be pretty straightforward. we need to find all the abundant numbers in the range so that we can determine all the numbers that are the sum of two abundant numbers. my first(naive) approach to this was terribly inefficient – it ran for hours and didn’t give the right answer. we cannot get around the need to determine the abundant numbers in range. however, we can reduce the search space when determining the numbers that are expressed as sums of two abundant numbers. to do this, we take advantage of some known properties: the upper bound for numbers that cannot be expressed as the sum of two numbers is actually 20161 not 28123 (as shown here). all even numbers greater than 48 can be written as the sum of two abundant numbers (also shown in the article here). with these facts in mind, we are ready for the implementation. the first routine determines the abundant numbers in range. 1: def abundant_nums_in_range(n): 2: abundant=[] 3: min_abundant_not_multiple_of_2_or_3 = 5391411025 4: for i in range(1,n): 5: if(i < min_abundant_not_multiple_of_2_or_3): 6: if(i % 2 != 0) and (i%3 != 0): 7: continue 8: divisors = proper_divisors(i) 9: divisors_sum = 0 10: for d in divisors: 11: divisors_sum += d 12: if(divisors_sum > i): 13: abundant.append(i) 14: return abundant 15: the routine that determines proper divisors of a number tests divisors from 1 to the squareroot of the number and extracts all divisors in pairs. 1: def proper_divisors(n): 2: divisors =[] 3: maxvalue = int(sqrt(n))+1 4: for i in range(1,maxvalue): 5: if(n % i == 0): 6: if(i not in divisors): 7: divisors.append(i) 8: quotient = n/i 9: if(quotient == n): continue 10: if(quotient not in divisors): 11: divisors.append(quotient) 12: return divisors 13: the main routine for the solution is the method that determines all numbers in range that can be expressed as sum of two numbers. since we know that all even numbers greater than 48 are in our target set, we only need to determine odd numbers in range. the only way to get an odd number by summing two numbers is to sum an even number with an odd. 1: def abundant_pair_sums_in_range(n): 2: abundant_nums = abundant_nums_in_range(n) 3: even_abundants = [] 4: odd_abundants = [] 5: for a in abundant_nums: 6: if(a %2 == 0): 7: even_abundants.append(a) 8: else: 9: odd_abundants.append(a) 10: abundant_sum_nums = [] 11: num_even_abundants = len(even_abundants) 12: num_odd_abundants = len(odd_abundants) 13: curr_num = 0 14: abundant_nums_filter = [0 for x in range(0,n)] 15: # all even numbers >48 are the sum of two abundants 16: for a in range(0,n): 17: if(a % 2 ==0): 18: if(a > 48): 19: abundant_nums_filter[a] = 1 20: elif a in [24,30,32,36,38,40,42,44,48]: 21: abundant_nums_filter[a] = 1 22: for i in range(0, num_even_abundants): 23: for j in range(0, num_odd_abundants): 24: curr_num = even_abundants[i] + odd_abundants[j] 25: if(curr_num < n): 26: abundant_nums_filter[curr_num] = 1 27: for a in range(1,n): 28: if abundant_nums_filter[a] == 1 : 29: abundant_sum_nums.append(a) 30: return abundant_sum_nums 31: the last routine ties all operations together. 1: def get_non_abundant_sums(n): 2: abundant_sums = abundant_pair_sums_in_range(n) 3: sum_all = sum([x for x in range(0,n)]) 4: sum_abundants = sum(abundant_sums) 5: return (sum_all  sum_abundants) 6: > jan 2 length of cycles in unit fractions filed under hisabati, project euler by mucheru  leave a comment problem 26 of project euler asks us to find the length of cycles in unit fractions: a unit fraction contains 1 in the numerator. the decimal representation of the unit fractions with denominators 2 to 10 are given: 1/2 = 0.5 1/3 = 0.(3) 1/4 = 0.25 1/5 = 0.2 1/6 = 0.1(6) 1/7 = 0.(142857) 1/8 = 0.125 1/9 = 0.(1) 1/10 = 0.1 where 0.1(6) means 0.166666…, and has a 1digit recurring cycle. it can be seen that 1/7 has a 6digit recurring cycle. find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part. the decimal representations of the fractions and therefore cycles can be discovered using long division. a python implementation of this would be: 1: def unit_fraction_decimal_rep(n): 2: numerator, denominator = 1, n 3: fraction = [] 4: remainders = {} 5: while true: 6: numerator *= 10 7: r = numerator % denominator 8: q = (numerator  r)/denominator 9: if(r == 0): 10: fraction.append(q) 11: break 12: if(r in remainders.values()): 13: foundcycle = false 14: for key,value in remainders.items(): 15: if(r == value) and (q == int(fraction[key])): 16: # mark the cycle with parenthesis 17: fraction.insert(key,"(") 18: fraction.append(")") 19: foundcycle = true 20: break 21: if foundcycle: 22: break 23: remainders[len(fraction)] = r 24: fraction.append(str(q)) 25: numerator = r 26: return "0."+"".join(fraction) to solve the problem posed, we could generate fractional representations of all integers from 1000 down and check for the longest cycles. however, looking at the algorithm above we can figure out how long a cycle will be without actually having to calculate it. the terms in the decimal representation are determined by the remainder in each iteration of the loop starting on line 5 above. if one of the remainders is 0, then the fraction terminates. on the other hand, if we see a remainder that we have seen previously, then we have gotten to the end of a cycle. the maximum length of a cycle is n1 since there are only n1 possibilities for the remainder. in each iteration of the loop on line 5, we multiply the numerator by 10. this establishes a relationship between 10 and n. we use a little algebra to explore the relationship. if the fraction terminates, then at some point we get a remainder of 0 meaning that n evenly divides a power of 10. since 10 has only two divisors, 2 and 5, n evenly divides a power of 10 if and only if n = 2ax5b where a,b are nonnegative integers (a or b may be 0 in which case n is either only divisible by 2 or by 5). the fraction will recur if n does not evenly divide any power of 10. if n is has no factors in common with 10 (abbreviated as n is coprime with 10), the length of the recurring cycle is equal to the order of 10 in the group zn (the multiplicative group of integers modulo n). if 10 has order d then 10d mod n = 1 and 1 becomes the first remainder repeated (since we start with numerator 1). if n is not coprime with 10, there is no d for which 10d mod n = 1. in such cases n= 2ax5bxm where m is coprime with 10. so 1/n = 1/(2ax5b) x 1/m . the component 1/(2ax5b) will terminate so the cycle that results in 1/n is contributed by 1/m and the length of the cycle is equal to the order of 10 in zm. applying this, we come up with the algorithm below: 1: def recurring_cycle_length(n): 2: cyclelen = 0 3: # remove powers of 2 and 5 in n 4: while (n % 2 == 0): 5: n /= 2 6: while (n % 5 == 0): 7: n /= 5 8: if n > 1: 9: a = 10 % n 10: cyclelen = 1 11: while a != 1: 12: a *= 10 13: a %= n 14: cyclelen += 1 15: return cyclelen the longest cycle will be generated when 10 has a high order in zn or zm. so when searching for the longest cycle we start with the maximum value of n in the range and move down. if n is prime, the order of 10 in the zn is either n1 or a divisor of n1. if we find a max value for the period which is equal to n1, we have found the longest cycle. 1: def max_len_recurring_cycle_in_range(n): 2: # iterate from the max num down 3: maxcyclelen = 0 4: maxcyclelengenerator = n 5: for i in range(n, 1, 1): 6: currlen = recurring_cycle_length(i) 7: if(currlen > maxcyclelen): 8: maxcyclelen = currlen 9: maxcyclelengenerator = i 10: if(currlen == i1): 11: break 12: return maxcyclelengenerator, maxcyclelen > dec 27 project euler: nth lexicographic permutation filed under hisabati, project euler by mucheru  leave a comment problem 24 from project euler asks us to find the nth lexicographic permutation of a sequence of digits: a permutation is an ordered arrangement of objects. for example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. if all of the permutations are listed numerically or alphabetically, we call it lexicographic order. the lexicographic permutations of 0, 1 and 2 are: 012 021 102 120 201 210 what is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9? my first instinct was to write a routine that would enumerate permutations of a sequence of digits in lexicographic order. this would involve two functions: the first would take a permutation and return the next lexicographic permutation of the digits. the next function would call the first 999999 times, starting with the first sequence (0123456789) and passing intermediate values as it went along. the main function is below. 1: def next_lexicographic_permutation(currpermutation): 2: digits = [int(x) for x in str(currpermutation)] 3: maxindex = len(digits)1 4: prevvalue = digits[maxindex] 5: currvalue = digits[maxindex] 6: for i in range(maxindex, 1,1): 7: currvalue = digits[i] 8: if (i == 0) and (currvalue == max(digits)): 9: return currpermutation 10: if(currvalue < prevvalue): 11: prefix = digits[:i] 12: suffix = digits[i:] 13: nextstart = min([x for x in suffix if x > currvalue]) 14: suffix.remove(nextstart) 15: suffix.sort() 16: nextpermutation = "".join([str(x) for x in prefix]) +str(nextstart)+ "".join([str(x) for x in suffix]) 17: return nextpermutation 18: else: 19: prevvalue = currvalue 20: return currpermutation 21: while this approach worked, the operation took 30 seconds. after looking at the problem for a while longer and consulting my muse, i realized that we could directly determine the nth permutation. it is an established fact that given a set of m elements, the number of permutations possible is given by m!( read as “m factorial”, defined here). so for our set of 10 digits, there are 10! possible permutations. of these permutations, 1/10 of them have 0 as the first digit, 1/10 have 1 as the first etc. this comes to 9! = 362,880 permutations starting with any one digit. since sequences are presented in lexicographic order, we know that the millionth permutation has to start with 2 ( the sequences starting with 0 end at 9! and those starting with1 end at 2*9!). the millionth permutation of 10 digits will be the 274240th permutation from the set of permutations starting with 2 (i.e. 1000,000 – 2*9!, accounting for the permutations that started with 0 and 1). the problem of determining the 274240th permutation from the set of permutations starting with 2 is equivalent to the problem we’ve just solved for 10 digits, except that this time we are determining the 274240th permutation of the digits 013456789. to solve it,we apply the same algorithm as we did previously giving a rather neat recursive solution to the general problem. 1: def nth_lexicographic_permutation(initialpermutation, n): 2: currpermutation=str(initialpermutation) 3: if len(currpermutation) == 1: return initialpermutation 4: residue = n 5: # number of permutations starting with any one digit 6: numsuffixpermutations = factorial(len(currpermutation)  1) 7: outputdigitindex = 0 8: if(numsuffixpermutations < residue): 9: outputdigitindex = residue / numsuffixpermutations 10: if(residue % numsuffixpermutations == 0): 11: outputdigitindex = 1 12: residue = (outputdigitindex * numsuffixpermutations) 13: indexdigit = currpermutation[outputdigitindex] 14: currpermutation = currpermutation.replace(indexdigit,'') 15: return indexdigit + nth_lexicographic_permutation(currpermutation, residue) 16: this second solution runs in less than a second! > dec 16 project euler: determining the number of paths in a grid filed under hisabati, project euler by mucheru  comments off on project euler: determining the number of paths in a grid for problem 15 from project euler, we are asked to find the number of paths leading from the top left corner of a grid to the bottom right corner that do not involve backtracking. starting in the top left corner of a 2 by 2 grid, there are 6 routes (without backtracking) to the bottom right corner. how many routes are there through a 20 by 20 grid? given the way the problem is set up, for any one node there are at most two nodes that can lead directly to the node. if we assign coordinates to the grid with (0,0) being the topleft corner, the only nodes that have direct outgoing paths to (1,1) are (0,1) and (1,0). trivially, each of the nodes in row 0 (the top row) has only one node that can lead into it (the node immediately to its left). similarly, nodes in column 0 (the leftmost column) each have one node leading into them (the node immediately above them). we can use this information to calculate the number of paths ending at any one node in the grid. to do this, consider nodes a, b and c that form the lower right triangle of an arbitrary square in the grid. we label the nodes such that a is the lower left corner of the square, b is the lower right corner while c is the upper right corner of the square. as shown before, the only way to get a path ending at b is to take a path ending at either a or c and add one step to it. we also know that a path ending at a cannot pass through c (since we don’t allow backtracking) and similarly a path ending at c cannot pass through a. therefore, the number of paths ending at b = number of paths ending at a + number of paths ending at c. this leads to the following rather short algorithm: 1: def num_paths_to_grid_bottom(numrowcells, numcolumncells): 2: currrow = [1 for x in range(numcolumncells + 1)] 3: # the number of nodes to consider = numrowcells + 1 4: for numrow in range(1, numrowcells + 1): 5: for numcolumn in range(1, numcolumncells + 1): 6: currrow[numcolumn] += currrow[numcolumn  1] 7: return currrow[numcolumncells] > next page → copyright © 2007 tafakuri • powered by wordpress • using blue zinfandel theme by brian gardner
One word  Two words phrases  Three words phrases 
the  7.46% (472) num  2.5% (158) that  2.01% (127) and  1.76% (111) number  1.71% (108) for  1.55% (98) her  1.22% (77) can  1.15% (73) all  1.08% (68) numbers  1.04% (66) are  1.03% (65) his  1.01% (64) sum  1.01% (64) permutation  0.85% (54) this  0.84% (53) abundant  0.82% (52) its  0.74% (47) digit  0.73% (46) with  0.65% (41) here  0.63% (40) not  0.63% (40) end  0.6% (38) out  0.59% (37) ran  0.57% (36) you  0.55% (35) two  0.55% (35) cycle  0.54% (34) digits  0.51% (32) term  0.47% (30) one  0.46% (29) from  0.46% (29) range  0.46% (29) space  0.43% (27) first  0.41% (26) our  0.41% (26) project  0.4% (25) pair  0.36% (23) there  0.36% (23) start  0.35% (22) permutations  0.35% (22) divisor  0.35% (22) how  0.33% (21) divisors  0.33% (21) now  0.33% (21) has  0.33% (21) value  0.32% (20) student  0.32% (20) second  0.32% (20) have  0.3% (19) “  0.3% (19) fraction  0.3% (19) max  0.3% (19) than  0.28% (18) pairs  0.28% (18) know  0.28% (18) determine  0.28% (18) them  0.27% (17) only  0.27% (17) would  0.27% (17) euler  0.27% (17) even  0.27% (17) into  0.25% (16) sing  0.25% (16) cannot  0.25% (16) problem  0.25% (16) def  0.25% (16) under  0.25% (16) fact  0.24% (15) use  0.24% (15) ten  0.24% (15) product  0.24% (15) any  0.24% (15) n):  0.24% (15) turn  0.24% (15) each  0.24% (15) abundants  0.24% (15) sequence  0.24% (15) will  0.22% (14) starting  0.22% (14) order  0.22% (14) some  0.22% (14) created  0.22% (14) path  0.22% (14) script  0.22% (14) node  0.22% (14) return  0.22% (14) ”  0.22% (14) such  0.22% (14) call  0.21% (13) presence  0.21% (13) way  0.21% (13) happy  0.21% (13) square  0.21% (13) main  0.21% (13) row  0.21% (13) get  0.21% (13) integer  0.19% (12) which  0.19% (12) form  0.19% (12) give  0.19% (12) much  0.19% (12) class  0.19% (12) find  0.19% (12) own  0.19% (12) nth  0.19% (12) long  0.19% (12) prime  0.19% (12) dec  0.19% (12) ever  0.17% (11) say  0.17% (11) next  0.17% (11) just  0.17% (11) new  0.17% (11) where  0.17% (11) lexicographic  0.17% (11) ending  0.17% (11) need  0.17% (11) was  0.17% (11) cyclelen  0.17% (11) currpermutation  0.17% (11) >  0.17% (11) {i,j}  0.17% (11) real  0.17% (11) look  0.17% (11) then  0.17% (11) other  0.16% (10) comment  0.16% (10) their  0.16% (10) mucheru  0.16% (10) filed  0.16% (10) set  0.16% (10) able  0.16% (10) could  0.16% (10) factor  0.16% (10) mod  0.16% (10) grid  0.16% (10) but  0.16% (10) when  0.16% (10) remainder  0.16% (10) suffix  0.16% (10) does  0.16% (10) see  0.14% (9) column  0.14% (9) is,  0.14% (9) odd  0.14% (9) what  0.14% (9) abundant_nums  0.14% (9) integers  0.14% (9) million  0.14% (9) tell  0.14% (9) –  0.14% (9) since  0.14% (9) make  0.14% (9) recur  0.14% (9) paths  0.14% (9) out.  0.14% (9) count  0.14% (9) power  0.14% (9) may  0.14% (9) ask  0.14% (9) put  0.13% (8) script#  0.13% (8) proper  0.13% (8) 10:  0.13% (8) 0):  0.13% (8) 12:  0.13% (8) 11:  0.13% (8) read  0.13% (8) off  0.13% (8) africaine  0.13% (8) justice  0.13% (8) numerator  0.13% (8) your  0.13% (8) approach  0.13% (8) length  0.13% (8) corner  0.13% (8) time  0.13% (8) less  0.13% (8) numbers.  0.13% (8) multiple  0.13% (8) did  0.11% (7) through  0.11% (7) maxcyclelen  0.11% (7) line  0.11% (7) numcolumn  0.11% (7) also  0.11% (7) etc  0.11% (7) mean  0.11% (7) written  0.11% (7) hisabati  0.11% (7) add  0.11% (7) .net  0.11% (7) represent  0.11% (7) comments  0.11% (7) nodes  0.11% (7) given  0.11% (7) hum  0.11% (7) using  0.11% (7) spaces  0.11% (7) recurring  0.11% (7) while  0.11% (7) greater  0.11% (7) i+j  0.11% (7) both  0.11% (7) 13:  0.11% (7) side  0.11% (7) right  0.11% (7) left  0.09% (6) odd_abundants  0.09% (6) lead  0.09% (6) either  0.09% (6) equivalence  0.09% (6) construct  0.09% (6) model  0.09% (6) looking  0.09% (6) slides  0.09% (6) tool  0.09% (6) fun  0.09% (6) most  0.09% (6) 14:  0.09% (6) even_abundants  0.09% (6) plex  0.09% (6) very  0.09% (6) (the  0.09% (6) part  0.09% (6) distribution  0.09% (6) mar  0.09% (6) 15:  0.09% (6) says  0.09% (6) sums  0.09% (6) found  0.09% (6) series  0.09% (6) come  0.09% (6) shirts  0.09% (6) squares  0.09% (6) residue  0.09% (6) currvalue  0.09% (6) consider  0.08% (5) solve  0.08% (5) nonhappy  0.08% (5) test  0.08% (5) code  0.08% (5) element  0.08% (5) class.  0.08% (5) optimization  0.08% (5) reality  0.08% (5) same  0.08% (5) theoretical  0.08% (5) function  0.08% (5) 89.  0.08% (5) tshirt  0.08% (5) table  0.08% (5) hisabati,  0.08% (5) 123  0.08% (5) times  0.08% (5) ways  0.08% (5) remainders  0.08% (5) she  0.08% (5) judge  0.08% (5) back  0.08% (5) above  0.08% (5) 0.1  0.08% (5) decimal  0.08% (5) knew  0.08% (5) abundant_nums_filter  0.08% (5) range(0,  0.08% (5) unit  0.08% (5) n1  0.08% (5) move  0.08% (5) chief  0.08% (5) walk  0.08% (5) range(1,  0.08% (5) 1):  0.08% (5) top  0.08% (5) euler:  0.08% (5) kenya  0.08% (5) projects  0.08% (5) numsuffixpermutations  0.08% (5) outputdigitindex  0.08% (5) 14.  0.08% (5) longest  0.08% (5) products  0.08% (5) determining  0.08% (5) sure  0.08% (5) ajax  0.08% (5) microsoft  0.08% (5) however  0.08% (5) routine  0.08% (5) possible  0.08% (5) means  0.06% (4) development  0.06% (4) size  0.06% (4) javascript  0.06% (4) mudimbe  0.06% (4) algebra  0.06% (4) curr_num  0.06% (4) unique  0.06% (4) 10,  0.06% (4) intellectual  0.06% (4) currlen  0.06% (4) maxindex  0.06% (4) mathematical  0.06% (4) pass  0.06% (4) experience  0.06% (4) numrow  0.06% (4) human  0.06% (4) contain  0.06% (4) numcolumncells  0.06% (4) currrow  0.06% (4) sequences  0.06% (4) however,  0.06% (4) allow  0.06% (4) quotient  0.06% (4) 1000  0.06% (4) case  0.06% (4) 2ax5b  0.06% (4) object  0.06% (4) cycle.  0.06% (4) software  0.06% (4) search  0.06% (4) range.  0.06% (4) though  0.06% (4) pretty  0.06% (4) take  0.06% (4) cycles  0.06% (4) fractions  0.06% (4) 16:  0.06% (4) representation  0.06% (4) denominator  0.06% (4) expressed  0.06% (4) method  0.06% (4) it.  0.06% (4) …  0.06% (4) 10.  0.06% (4) account  0.06% (4) equal  0.06% (4) algorithm  0.06% (4) if(r  0.06% (4) shown  0.06% (4) break  0.06% (4) operation  0.06% (4) ties  0.06% (4) reduce  0.06% (4) law  0.06% (4) post  0.06% (4) going  0.06% (4) had  0.06% (4) (i.e.  0.06% (4) because  0.06% (4) it,  0.06% (4) field  0.06% (4) asks  0.06% (4) nerdy  0.06% (4) selection  0.06% (4) digits,  0.06% (4) tshirts  0.06% (4) therefore  0.06% (4) example,  0.06% (4) 145  0.06% (4) they  0.06% (4) previous  0.06% (4) solution  0.06% (4) factoring  0.06% (4) says:  0.06% (4) figure  0.06% (4) were  0.06% (4)  0.06% (4) sum.  0.06% (4) tells  0.06% (4) these  0.06% (4) many  0.06% (4) adding  0.06% (4) list  0.06% (4) lower  0.06% (4) calculate  0.06% (4) i*j  0.06% (4) 89,  0.06% (4) think  0.06% (4) check  0.06% (4) 567  0.06% (4) libraries  0.06% (4) terminate  0.06% (4) actually  0.06% (4) this,  0.06% (4) comes  0.06% (4) binomial  0.06% (4) geometric  0.06% (4) digits.  0.06% (4) ends  0.06% (4) etc.  0.06% (4) generate  0.05% (3) down  0.05% (3) loop  0.05% (3) compile  0.05% (3) base  0.05% (3) value)  0.05% (3) browser  0.05% (3) applications  0.05% (3) lookup  0.05% (3) nikhil  0.05% (3) calculator  0.05% (3) event  0.05% (3) foundcycle  0.05% (3) court  0.05% (3) point  0.05% (3) european  0.05% (3) reading  0.05% (3) jan  0.05% (3) enumerate  0.05% (3) regular  0.05% (3) society  0.05% (3) well  0.05% (3) help  0.05% (3) coprime  0.05% (3) divide  0.05% (3) evenly  0.05% (3) implementation  0.05% (3) presentations  0.05% (3) arrange  0.05% (3) without  0.05% (3) cases  0.05% (3) judges  0.05% (3) labs  0.05% (3) result  0.05% (3) simply  0.05% (3) force  0.05% (3) students  0.05% (3) 21:  0.05% (3) candidate  0.05% (3) before  0.05% (3) if(i  0.05% (3) currrow[numcolumn  0.05% (3) divisors_sum  0.05% (3) 20:  0.05% (3) abundant_nums_filter[a]  0.05% (3) following  0.05% (3) if(a  0.05% (3) abundant_sum_nums  0.05% (3) that,  0.05% (3) change  0.05% (3) 19:  0.05% (3) 18:  0.05% (3) 17:  0.05% (3) abundant_sums  0.05% (3) determines  0.05% (3) summing  0.05% (3) establish  0.05% (3) between  0.05% (3) songsmith  0.05% (3) provide  0.05% (3) known  0.05% (3) full  0.05% (3) maxcyclelengenerator  0.05% (3) pairs,  0.05% (3) 1/10  0.05% (3) write  0.05% (3) determined  0.05% (3) here).  0.05% (3) otherwise,  0.05% (3) uniquely  0.05% (3) “i  0.05% (3) upper  0.05% (3) leave  0.05% (3) photos  0.05% (3) group  0.05% (3) 274240th  0.05% (3) “m  0.05% (3) 1):  0.05% (3) western  0.05% (3) seen  0.05% (3) journal  0.05% (3) order.  0.05% (3) lest  0.05% (3) itself  0.05% (3) reason  0.05% (3) gives  0.05% (3) elements  0.05% (3) clear  0.05% (3) got  0.05% (3) sep  0.05% (3) culture  0.05% (3) nextstart  0.05% (3) compilation  0.05% (3) arrive  0.05% (3) those  0.05% (3) bottom  0.05% (3) kenya’s  0.05% (3) define  0.05% (3) single  0.05% (3) match  0.05% (3) direct  0.05% (3) number,  0.05% (3) negative  0.05% (3) below  0.05% (3) surreptitious  0.05% (3) initialpermutation  0.05% (3) african  0.05% (3) called  0.05% (3) evaluate  0.05% (3) indexdigit  0.05% (3) prevvalue  0.05% (3) true  0.05% (3) acting  0.05% (3) millionth  0.05% (3) dimensional  0.05% (3) eliminate  0.05% (3) vector  0.05% (3) previously  0.05% (3) numrowcells  0.05% (3) being  0.05% (3) or,  0.05% (3) residue)  0.03% (2) abundant_pair_sums_in_range(n)  0.03% (2) walks  0.03% (2) sum_all  0.03% (2) if(currlen  0.03% (2) similarly  0.03% (2) first:  0.03% (2) 26:  0.03% (2) leading  0.03% (2) sum_abundants  0.03% (2) 25:  0.03% (2) filosofia  0.03% (2) lawyers  0.03% (2) ahmednasir  0.03% (2) contains  0.03% (2) try  0.03% (2) siasa  0.03% (2) sayansi  0.03% (2) remove  0.03% (2) teacher  0.03% (2) component  0.03% (2) maybe  0.03% (2) zm.  0.03% (2) 24:  0.03% (2) thinking  0.03% (2) calculations  0.03% (2) digits[maxindex]  0.03% (2) finite  0.03% (2) immediately  0.03% (2) •  0.03% (2) grid.  0.03% (2) hypergeometric  0.03% (2) range(0,n)]  0.03% (2) simple  0.03% (2) page  0.03% (2) relationship  0.03% (2) powers  0.03% (2) 23:  0.03% (2) recent  0.03% (2) 1/m  0.03% (2) 22:  0.03% (2) writing  0.03% (2) paragraph  0.03% (2) random  0.03% (2) backtracking)  0.03% (2) routes  0.03% (2) decisions  0.03% (2) 1/(2ax5b)  0.03% (2) "".join([str(x)  0.03% (2) high  0.03% (2) ang’awa  0.03% (2) (currvalue  0.03% (2) directly  0.03% (2) common  0.03% (2) rulings?  0.03% (2) oneline  0.03% (2) permutation.  0.03% (2) arrangement  0.03% (2) nextpermutation  0.03% (2) involve  0.03% (2) iteration  0.03% (2) prefix  0.03% (2) maximum  0.03% (2) task  0.03% (2) teknolojia  0.03% (2) explain  0.03% (2) 999999  0.03% (2) values  0.03% (2) asked  0.03% (2) still  0.03% (2) good  0.03% (2) poisson  0.03% (2) len(currpermutation)  0.03% (2) multiply  0.03% (2) neat  0.03% (2) rather  0.03% (2) 1/n  0.03% (2) divides  0.03% (2) favor  0.03% (2) 0.2  0.03% (2) 0.1(6)  0.03% (2) 1/7  0.03% (2) 1).  0.03% (2) (since  0.03% (2) representations  0.03% (2) digit,  0.03% (2) python  0.03% (2) process  0.03% (2) pdf  0.03% (2) 10d  0.03% (2) short  0.03% (2) apply  0.03% (2) particular  0.03% (2) tarakirishi  0.03% (2) future  0.03% (2) smallest  0.03% (2) 36,  0.03% (2) like  0.03% (2) makes  0.03% (2) study  0.03% (2) claims  0.03% (2) operations  0.03% (2) place,  0.03% (2) 30,  0.03% (2) 32,  0.03% (2) answer  0.03% (2) chain  0.03% (2) space,  0.03% (2) space.  0.03% (2) been  0.03% (2) until  0.03% (2) defined  0.03% (2) idea  0.03% (2) explicit  0.03% (2) this.  0.03% (2) primary  0.03% (2) experience.  0.03% (2) {66,7}  0.03% (2) “the  0.03% (2) smaller  0.03% (2) studies  0.03% (2) root  0.03% (2) least  0.03% (2) methods  0.03% (2) really  0.03% (2) seems  0.03% (2) movement  0.03% (2) 24,  0.03% (2) 28,  0.03% (2) plane  0.03% (2) {24,6,8,9,10}  0.03% (2) vectors  0.03% (2) difference  0.03% (2) world  0.03% (2) doing  0.03% (2) “a  0.03% (2) become  0.03% (2) we’ve  0.03% (2) nondecreasing  0.03% (2) string  0.03% (2) times,  0.03% (2) exactly  0.03% (2) 0.5  0.03% (2) tafakuri  0.03% (2) further  0.03% (2) seconds  0.03% (2) naive  0.03% (2) eventual  0.03% (2) make.  0.03% (2) third  0.03% (2) 312,  0.03% (2) creating  0.03% (2) formula  0.03% (2) repeated  0.03% (2) title  0.03% (2) reasoning  0.03% (2) all.  0.03% (2) counting  0.03% (2) swallow  0.03% (2) rest  0.03% (2) caption  0.03% (2) front  0.03% (2) made  0.03% (2) every  0.03% (2) years  0.03% (2) otherness  0.03% (2) giving  0.03% (2) solved  0.03% (2) gotten  0.03% (2) i’ve  0.03% (2) split  0.03% (2) video  0.03% (2) programming  0.03% (2) brute  0.03% (2) run  0.03% (2) better  0.03% (2) {44,5,6,7,8,9}  0.03% (2) reflect  0.03% (2) prime,  0.03% (2) analysis  0.03% (2) limit  0.03% (2) 28123  0.03% (2) target  0.03% (2) integers.  0.03% (2) ready  0.03% (2) i*j=n.  0.03% (2) sum,  0.03% (2) 213  0.03% (2) abundant.  0.03% (2) tune  0.03% (2) research  0.03% (2) toy  0.03% (2) article  0.03% (2) info  0.03% (2) whose  0.03% (2) number.  0.03% (2) perfect  0.03% (2) remember  0.03% (2) sum”  0.03% (2) if(quotient  0.03% (2) fair  0.03% (2) divisors):  0.03% (2) gets  0.03% (2) abundant_nums_in_range(n)  0.03% (2) num_even_abundants  0.03% (2) else:  0.03% (2) second:  0.03% (2) if(n  0.03% (2) maxvalue  0.03% (2) continue  0.03% (2) range(1,n):  0.03% (2) min_abundant_not_multiple_of_2_or_3  0.03% (2) step  0.03% (2) pairs.  0.03% (2) =[]  0.03% (2) assume  0.03% (2) tries  0.03% (2) reference  0.03% (2) dll  0.03% (2) office  0.03% (2) always  0.03% (2) leads  0.03% (2) often  0.03% (2) linear  0.03% (2) factored  0.03% (2) slides.  0.03% (2) words,  0.03% (2) zoom  0.03% (2) final  0.03% (2) tools  0.03% (2) nor  0.03% (2) after  0.03% (2) together  0.03% (2) appear  0.03% (2) and,  0.03% (2) alterity  0.03% (2) name  0.03% (2) faces  0.03% (2) 2+2  0.03% (2) used  0.03% (2) primes.  0.03% (2) section  0.03% (2) works  0.03% (2) design  0.03% (2) meaning  0.03% (2) oop.  0.03% (2) little  0.03% (2) prime.  0.03% (2) 11.  0.03% (2) derivation  0.03% (2) developer  0.03% (2) {2,3,4,5,6,7,8,9,10,11,12,13}  0.03% (2) independent  0.03% (2) platform.  0.03% (2) follows:  0.03% (2) productivity  0.03% (2) brings  0.03% (2) web  0.03% (2) num_odd_abundants  0.03% (2)  of the  0.59% (37) the sum  0.46% (29) that the  0.36% (23) the number  0.36% (23) in the  0.36% (23) can be  0.33% (21) sum of  0.33% (21) to the  0.33% (21) the first  0.3% (19) we can  0.28% (18) in range  0.28% (18) project euler  0.27% (17) as the  0.25% (16) that a  0.24% (15) number of  0.22% (14) of two  0.22% (14) created by  0.22% (14) abundant numbers  0.21% (13) it can  0.19% (12) is the  0.19% (12) for the  0.19% (12) be created  0.19% (12) that can  0.19% (12) two numbers  0.17% (11) numbers that  0.17% (11) two abundant  0.17% (11) is out  0.17% (11) all the  0.16% (10) by mucheru  0.16% (10) there are  0.16% (10) filed under  0.16% (10) such that  0.16% (10) cannot be  0.16% (10) mucheru   0.16% (10) first student  0.16% (10) 1: def  0.16% (10) from the  0.14% (9) need to  0.14% (9) of digits  0.14% (9) know that  0.14% (9) happy numbers  0.14% (9) out. it  0.13% (8) determine the  0.13% (8) the product  0.13% (8) a number  0.13% (8) the problem  0.13% (8) and the  0.13% (8) is out.  0.13% (8) with the  0.13% (8) ending at  0.13% (8) numbers in  0.13% (8) to find  0.11% (7) than 1  0.11% (7) greater than  0.11% (7) you can  0.11% (7) the numbers  0.11% (7) find the  0.11% (7) the digits  0.11% (7) presence africaine  0.11% (7) second student  0.11% (7) starting with  0.11% (7) be written  0.11% (7) {i,j} such  0.11% (7) of paths  0.11% (7) written as  0.11% (7) numbers a  0.09% (6) set of  0.09% (6) comments off  0.09% (6) pairs {i,j}  0.09% (6) into two  0.09% (6) less than  0.09% (6) if the  0.09% (6) on the  0.09% (6) under hisabati  0.09% (6)  comments  0.09% (6) off on  0.09% (6) that cannot  0.09% (6) == 0):  0.09% (6) equivalence class  0.09% (6) the only  0.09% (6) permutation of  0.09% (6) we know  0.09% (6) under hisabati,  0.08% (5) has the  0.08% (5) into the  0.08% (5) looking at  0.08% (5) the same  0.08% (5) student says  0.08% (5) the square  0.08% (5) 10 million  0.08% (5) space is  0.08% (5) digits in  0.08% (5) does not  0.08% (5) all pairs  0.08% (5) euler by  0.08% (5) hisabati, project  0.08% (5) length of  0.08% (5) proper divisors  0.08% (5) the second  0.08% (5) lexicographic permutation  0.08% (5) project euler:  0.08% (5) chief justice  0.08% (5) this is  0.08% (5) any one  0.08% (5) determining the  0.08% (5) the longest  0.08% (5) to determine  0.08% (5) student has  0.08% (5) that i+j  0.08% (5) will be  0.06% (4) from project  0.06% (4) permutations starting  0.06% (4) that we  0.06% (4) this approach  0.06% (4) squares of  0.06% (4) by the  0.06% (4) a sequence  0.06% (4) of permutations  0.06% (4) the top  0.06% (4) from a  0.06% (4) one node  0.06% (4) path ending  0.06% (4) paths ending  0.06% (4) corner of  0.06% (4) right corner  0.06% (4) power of  0.06% (4) left corner  0.06% (4) that are  0.06% (4) cyclelen =  0.06% (4) the fraction  0.06% (4) size of  0.06% (4) 4: for  0.06% (4) not in  0.06% (4) abundant numbers.  0.06% (4) permutations of  0.06% (4) we need  0.06% (4) sequence of  0.06% (4) expressed as  0.06% (4) we are  0.06% (4) the sequence  0.06% (4) number is  0.06% (4) then the  0.06% (4) have a  0.06% (4) we have  0.06% (4) the reality  0.06% (4) recurring cycle  0.06% (4) the next  0.06% (4) of squares  0.06% (4) numbers is  0.06% (4) unit fraction  0.06% (4) is that  0.06% (4) in range.  0.06% (4) n into  0.06% (4) of factoring  0.06% (4) the two  0.06% (4) nerdy tshirts  0.06% (4) student says:  0.06% (4) that m  0.06% (4) knew that  0.06% (4) and has  0.06% (4) i knew  0.06% (4) where the  0.06% (4) factoring n  0.06% (4) here is  0.06% (4) the set  0.06% (4) start with  0.05% (3) value of  0.05% (3) are in  0.05% (3) coprime with  0.05% (3) the journal  0.05% (3) numbers greater  0.05% (3) is not  0.05% (3) the cycle  0.05% (3) find a  0.05% (3) of this  0.05% (3) what is  0.05% (3) that second  0.05% (3) the digits.  0.05% (3) only way  0.05% (3) currvalue =  0.05% (3) class is  0.05% (3) each equivalence  0.05% (3) numbers filed  0.05% (3) take a  0.05% (3) the millionth  0.05% (3) and in  0.05% (3) there is  0.05% (3) of pairs  0.05% (3) of numbers  0.05% (3) each class  0.05% (3) given the  0.05% (3) for our  0.05% (3) all numbers  0.05% (3) he has  0.05% (3) decimal representation  0.05% (3) the length  0.05% (3) the value  0.05% (3) for which  0.05% (3) that you  0.05% (3) not know  0.05% (3) sum is  0.05% (3) unit fractions  0.05% (3) 0): 7:  0.05% (3) that he  0.05% (3) even numbers  0.05% (3) the abundant  0.05% (3) abundant_nums_filter[a] =  0.05% (3) be expressed  0.05% (3) the decimal  0.05% (3) the remainder  0.05% (3) a power  0.05% (3) 3 dimensional  0.05% (3) could not  0.05% (3) he can  0.05% (3) is equal  0.05% (3) the mathematical  0.05% (3) student could  0.05% (3) fact that  0.05% (3) a cycle  0.05% (3) one of  0.05% (3) numbers and  0.05% (3) as well  0.05% (3) reality of  0.05% (3) in which  0.05% (3) order of  0.05% (3) are pretty  0.05% (3) ends in  0.05% (3) evaluate a  0.05% (3) numbers under  0.05% (3) in 89.  0.05% (3) end up  0.05% (3) asks us  0.05% (3) would have  0.05% (3) number for  0.05% (3) a grid  0.05% (3) comment problem  0.05% (3) this, we  0.05% (3) the lower  0.05% (3) out because  0.05% (3) with 2  0.05% (3) justice selection  0.05% (3) that have  0.05% (3) have to  0.05% (3) you would  0.05% (3) through the  0.05% (3) starting at  0.05% (3) the series  0.05% (3) kenya’s chief  0.05% (3) lookup table  0.05% (3) 89, we  0.05% (3) is either  0.05% (3) end at  0.05% (3) 10 digits  0.05% (3) 274240th permutation  0.05% (3) 5: for  0.05% (3) means that  0.05% (3) by adding  0.05% (3) solve the  0.03% (2) we could  0.03% (2) student gets  0.03% (2) foundcycle =  0.03% (2) break 12:  0.03% (2) the grid.  0.03% (2) their sum.  0.03% (2) this would  0.03% (2) if(r ==  0.03% (2) representations of  0.03% (2) =[] 3:  0.03% (2) nodes in  0.03% (2) in each  0.03% (2) iteration of  0.03% (2) the loop  0.03% (2) to calculate  0.03% (2) cycle will  0.03% (2) 7: return  0.03% (2) quotient =  0.03% (2) (the node  0.03% (2) all integers  0.03% (2) the algorithm  0.03% (2) 6: if(i  0.03% (2) lower right  0.03% (2) cannot pass  0.03% (2) cycles in  0.03% (2) negative binomial  0.03% (2) to get  0.03% (2) binomial distribution  0.03% (2) first: i  0.03% (2) geometric distribution  0.03% (2) odd_abundants =  0.03% (2) say that  0.03% (2) curr_num =  0.03% (2) an odd  0.03% (2) we only  0.03% (2) leave a  0.03% (2) second:  0.03% (2) in unit  0.03% (2) as sum  0.03% (2) recurring cycle.  0.03% (2) even_abundants =  0.03% (2) this leads  0.03% (2) of cycles  0.03% (2) line 5  0.03% (2) way to  0.03% (2) in our  0.03% (2) 48 are  0.03% (2) is thinking  0.03% (2) can lead  0.03% (2) outputdigitindex =  0.03% (2) possible permutation  0.03% (2) numsuffixpermutations =  0.03% (2) going back  0.03% (2) oneline rulings?  0.03% (2) does a  0.03% (2) this second  0.03% (2) the nth  0.03% (2) 12: return  0.03% (2) 11: break  0.03% (2) > dec  0.03% (2) tries to  0.03% (2) paths in  0.03% (2) my first  0.03% (2) lexicographic order.  0.03% (2) 10 digits,  0.03% (2) with 0  0.03% (2) is one  0.03% (2) with any  0.03% (2) in lexicographic  0.03% (2) "".join([str(x) for  0.03% (2) at this  0.03% (2) permutation from  0.03% (2) thinking of  0.03% (2) the 274240th  0.03% (2) call the  0.03% (2) prevvalue =  0.03% (2) maxcyclelengenerator =  0.03% (2) maxcyclelen =  0.03% (2) the nodes  0.03% (2) 0 (the  0.03% (2) nodes that  0.03% (2) how many  0.03% (2) top left  0.03% (2) evenly divides  0.03% (2) the numerator  0.03% (2) each iteration  0.03% (2) have the  0.03% (2) first:  0.03% (2) end of  0.03% (2) the maximum  0.03% (2) node immediately  0.03% (2) of 10.  0.03% (2) has only  0.03% (2) them to  0.03% (2) writing in  0.03% (2) euler: determining  0.03% (2) while (n  0.03% (2) prime, the  0.03% (2) (since we  0.03% (2) and did  0.03% (2) projects a  0.03% (2) n does  0.03% (2) is coprime  0.03% (2) the bottom  0.03% (2) 10d mod  0.03% (2) to its  0.03% (2) this product  0.03% (2) we determine  0.03% (2) use this  0.03% (2) that both  0.03% (2) in 89,  0.03% (2) then we  0.03% (2) for any  0.03% (2) adding the  0.03% (2) numbers by  0.03% (2) than the  0.03% (2) numbers –  0.03% (2) if you  0.03% (2) tells us  0.03% (2) that 1  0.03% (2) two primes.  0.03% (2) of integers  0.03% (2) an integer  0.03% (2) contain the  0.03% (2) digits. the  0.03% (2) the class  0.03% (2) a permutations  0.03% (2) can determine  0.03% (2) digits will  0.03% (2) the title  0.03% (2) the caption  0.03% (2) the end  0.03% (2) products of  0.03% (2) on presence  0.03% (2) no pair  0.03% (2) from each  0.03% (2) to account  0.03% (2) for sure  0.03% (2) given by  0.03% (2) account for  0.03% (2) out how  0.03% (2) sure we  0.03% (2) to make  0.03% (2) 89. the  0.03% (2) to see  0.03% (2) starting number  0.03% (2) sure that  0.03% (2) other words,  0.03% (2) arrive at  0.03% (2) pairs, he  0.03% (2) as with  0.03% (2) ending in  0.03% (2) since he  0.03% (2) be factored  0.03% (2) of nonhappy  0.03% (2) determine that  0.03% (2) the final  0.03% (2) eliminate all  0.03% (2) > sep  0.03% (2) euler: happy  0.03% (2) add up  0.03% (2) than 14.  0.03% (2) for each  0.03% (2) it into  0.03% (2) adding two  0.03% (2) we evaluate  0.03% (2) series starting  0.03% (2) also know  0.03% (2) our test  0.03% (2) calculate the  0.03% (2) our lookup  0.03% (2) consider the  0.03% (2) because the  0.03% (2) new number  0.03% (2) “i knew  0.03% (2) digits, square  0.03% (2) than 1.  0.03% (2) only {i,j}  0.03% (2) at some  0.03% (2) up looking  0.03% (2) intellectual space  0.03% (2) the other  0.03% (2) pair {i,j}  0.03% (2) product from  0.03% (2) used in  0.03% (2) pairs where  0.03% (2) from microsoft  0.03% (2) perfect number  0.03% (2) one way  0.03% (2) summing numbers  0.03% (2) the sum.  0.03% (2) base libraries  0.03% (2) your ajax  0.03% (2) well as  0.03% (2) of them  0.03% (2) as you  0.03% (2) etc. the  0.03% (2) can use  0.03% (2) just as  0.03% (2) divisors of  0.03% (2) whose proper  0.03% (2) the upper  0.03% (2) integers greater  0.03% (2) the range  0.03% (2) ways of  0.03% (2) two numbers.  0.03% (2) divisors =  0.03% (2) 0) and  0.03% (2) out the  0.03% (2) find all  0.03% (2) remember that  0.03% (2) that there  0.03% (2) the smallest  0.03% (2) is called  0.03% (2) that all  0.03% (2) the sum,  0.03% (2) has determined  0.03% (2) that i*j=n.  0.03% (2) the .net  0.03% (2) in this  0.03% (2) we use  0.03% (2) a space  0.03% (2) always a  0.03% (2) model some  0.03% (2) as vectors  0.03% (2) the idea  0.03% (2) experience and  0.03% (2) doing so  0.03% (2) mudimbe makes  0.03% (2) field of  0.03% (2) though it  0.03% (2) the western  0.03% (2) what we  0.03% (2) idea of  0.03% (2) in algebra  0.03% (2) in such  0.03% (2) theoretical spaces  0.03% (2) says: “i  0.03% (2) reading the  0.03% (2) could be  0.03% (2) otherwise, if  0.03% (2) new products  0.03% (2) than a  0.03% (2) your slides  0.03% (2) you need  0.03% (2) this means  0.03% (2) are some  0.03% (2) leads to  0.03% (2) way of  0.03% (2) european space  0.03% (2) of its  0.03% (2) human experience  0.03% (2) be one  0.03% (2) seems to  0.03% (2) then there  0.03% (2) that determines  0.03% (2)  the sum of  0.27% (17) be created by  0.19% (12) sum of two  0.19% (12) of two abundant  0.17% (11) the number of  0.17% (11) it can be  0.17% (11) by mucheru   0.16% (10) can be created  0.16% (10) two abundant numbers  0.16% (10) out. it can  0.13% (8) as the sum  0.13% (8) the first student  0.13% (8) number of paths  0.11% (7) be written as  0.11% (7) {i,j} such that  0.11% (7)  comments off  0.09% (6) comments off on  0.09% (6) of the digits  0.09% (6) mucheru  comments  0.09% (6) that cannot be  0.09% (6) pairs {i,j} such  0.08% (5) project euler by  0.08% (5) under hisabati, project  0.08% (5) hisabati, project euler  0.08% (5) filed under hisabati,  0.08% (5) euler by mucheru  0.08% (5) written as the  0.08% (5) numbers in range  0.08% (5) that can be  0.06% (4) two abundant numbers.  0.06% (4) path ending at  0.06% (4) numbers in range.  0.06% (4) sum of squares  0.06% (4) paths ending at  0.06% (4) project euler asks  0.06% (4) the two numbers  0.06% (4) to determine the  0.06% (4) cannot be written  0.06% (4) of paths ending  0.06% (4) from project euler  0.06% (4) a path ending  0.06% (4) to find the  0.06% (4) n into two  0.06% (4) factoring n into  0.06% (4) that i+j =  0.06% (4) of factoring n  0.06% (4) all pairs {i,j}  0.06% (4) that the first  0.06% (4) permutation of the  0.06% (4) permutations starting with  0.06% (4) such that i+j  0.06% (4) the numbers that  0.06% (4) the set of  0.05% (3) need to determine  0.05% (3) ending at a  0.05% (3) of squares of  0.05% (3) euler asks us  0.05% (3) the size of  0.05% (3) to do this,  0.05% (3) of digits in  0.05% (3) nth lexicographic permutation  0.05% (3) order of 10  0.05% (3) all even numbers  0.05% (3) the length of  0.05% (3) the only way  0.05% (3) numbers greater than  0.05% (3) of permutations starting  0.05% (3) equal to the  0.05% (3) the decimal representation  0.05% (3) power of 10  0.05% (3) there is no  0.05% (3) is equal to  0.05% (3) the abundant numbers  0.05% (3) know that a  0.05% (3) the reality of  0.05% (3) the order of  0.05% (3) happy numbers under  0.05% (3) determine the sum  0.05% (3) is out because  0.05% (3) and j are  0.05% (3) that the sum  0.05% (3) first student has  0.05% (3) the product n  0.05% (3) less than 14  0.05% (3) the sum m  0.05% (3) not know the  0.05% (3) , there is  0.05% (3) numbers filed under  0.05% (3) us to find  0.05% (3) chief justice selection  0.05% (3) one of the  0.05% (3) n and has  0.03% (2) power of 10.  0.03% (2) length of the  0.03% (2) n does not  0.03% (2) we start with  0.03% (2) n is either  0.03% (2) 10d mod n  0.03% (2) that there are  0.03% (2) is coprime with  0.03% (2) determined all pairs  0.03% (2) multiple ways of  0.03% (2) figure out how  0.03% (2) cycles in unit  0.03% (2) leave a comment  0.03% (2) second student has  0.03% (2) we only need  0.03% (2) when the first  0.03% (2) expressed as sum  0.03% (2) first student could  0.03% (2) knew that the  0.03% (2) divides a power  0.03% (2) evenly divides a  0.03% (2) iteration of the  0.03% (2) while (n %  0.03% (2) the value of  0.03% (2) for the longest  0.03% (2) student says: “i  0.03% (2) mucheru  leave  0.03% (2) top left corner  0.03% (2) to the bottom  0.03% (2) the top left  0.03% (2) in a grid  0.03% (2) not know their  0.03% (2) starting with any  0.03% (2) euler: determining the  0.03% (2) corner of a  0.03% (2) that can lead  0.03% (2) going back to  0.03% (2) is that the  0.03% (2) on two numbers  0.03% (2) way to get  0.03% (2) in the grid.  0.03% (2) corner of the  0.03% (2) 274240th permutation from  0.03% (2) less than 14.  0.03% (2) a comment problem  0.03% (2) ways of factoring  0.03% (2) not in divisors):  0.03% (2) integers greater than  0.03% (2) has the product  0.03% (2) first student says:  0.03% (2) he tries to  0.03% (2) of a sequence  0.03% (2) the 274240th permutation  0.03% (2) from the set  0.03% (2) first: i  0.03% (2) number of permutations  0.03% (2) say that the  0.03% (2) "".join([str(x) for x  0.03% (2) == 0): 7:  0.03% (2) of two numbers  0.03% (2) size of each  0.03% (2) need to account  0.03% (2) from each equivalence  0.03% (2) each equivalence class.  0.03% (2) and has determined  0.03% (2) only need to  0.03% (2) since he has  0.03% (2) of numbers that  0.03% (2) contain the same  0.03% (2) of the journal  0.03% (2) the end of  0.03% (2) says: “i knew  0.03% (2) remember that the  0.03% (2) nondecreasing sequence of  0.03% (2) we can determine  0.03% (2) in other words,  0.03% (2) 89, we know  0.03% (2) the series starting  0.03% (2) up looking at  0.03% (2) we determine that  0.03% (2) from 1 to  0.03% (2) in a number  0.03% (2) numbers that have  0.03% (2) series starting at  0.03% (2) we evaluate a  0.03% (2) derivation is as  0.03% (2) integer that can  0.03% (2) our lookup table  0.03% (2) a number for  0.03% (2) numbers in the  0.03% (2) j are both  0.03% (2) the fact that  0.03% (2) because the only  0.03% (2) is no pair  0.03% (2) find the sum  0.03% (2) cannot be expressed  0.03% (2) though it is  0.03% (2) second student says:  0.03% (2) adding two primes.  0.03% (2) to find all  0.03% (2) in the range  0.03% (2) even numbers greater  0.03% (2) proper divisors of  0.03% (2) nonhappy numbers under  0.03% (2) do this, we  0.03% (2) student could not  0.03% (2) are the sum  0.03% (2) abundant numbers is  0.03% (2) the sum is  0.03% (2) this means that  0.03% (2) summing numbers that  0.03% (2) here are some  0.03% (2) leads to the  0.03% (2) an experience and  0.03% (2) the western space.  0.03% (2) greater than 1.  0.03% (2) the only {i,j}  0.03% (2) number whose proper  0.03% (2) whose proper divisors  0.03% (2) this tells us  0.03% (2) also know that  0.03% (2) tells us that  0.03% (2) created by adding  0.03% (2) of the number  0.03% (2) 