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.48 % 
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 february 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 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.47% (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) sum  1.01% (64) his  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) not  0.63% (40) here  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) divisor  0.35% (22) permutations  0.35% (22) divisors  0.33% (21) now  0.33% (21) how  0.33% (21) has  0.33% (21) second  0.32% (20) value  0.32% (20) student  0.32% (20) fraction  0.3% (19) max  0.3% (19) “  0.3% (19) have  0.3% (19) know  0.28% (18) than  0.28% (18) pairs  0.28% (18) determine  0.28% (18) even  0.27% (17) only  0.27% (17) would  0.27% (17) them  0.27% (17) euler  0.27% (17) sing  0.25% (16) into  0.25% (16) problem  0.25% (16) cannot  0.25% (16) under  0.25% (16) def  0.25% (16) any  0.24% (15) product  0.24% (15) sequence  0.24% (15) ten  0.24% (15) each  0.24% (15) abundants  0.24% (15) fact  0.24% (15) turn  0.24% (15) use  0.24% (15) n):  0.24% (15) some  0.22% (14) will  0.22% (14) created  0.22% (14) return  0.22% (14) node  0.22% (14) order  0.22% (14) starting  0.22% (14) ”  0.22% (14) path  0.22% (14) such  0.22% (14) script  0.22% (14) get  0.21% (13) presence  0.21% (13) way  0.21% (13) row  0.21% (13) happy  0.21% (13) call  0.21% (13) square  0.21% (13) main  0.21% (13) own  0.19% (12) which  0.19% (12) find  0.19% (12) integer  0.19% (12) prime  0.19% (12) long  0.19% (12) much  0.19% (12) form  0.19% (12) class  0.19% (12) dec  0.19% (12) nth  0.19% (12) give  0.19% (12) lexicographic  0.17% (11) {i,j}  0.17% (11) cyclelen  0.17% (11) >  0.17% (11) next  0.17% (11) real  0.17% (11) just  0.17% (11) ever  0.17% (11) then  0.17% (11) new  0.17% (11) currpermutation  0.17% (11) need  0.17% (11) ending  0.17% (11) was  0.17% (11) where  0.17% (11) say  0.17% (11) look  0.17% (11) comment  0.16% (10) mod  0.16% (10) factor  0.16% (10) when  0.16% (10) other  0.16% (10) grid  0.16% (10) mucheru  0.16% (10) filed  0.16% (10) but  0.16% (10) able  0.16% (10) remainder  0.16% (10) does  0.16% (10) set  0.16% (10) suffix  0.16% (10) their  0.16% (10) could  0.16% (10) what  0.14% (9) since  0.14% (9) count  0.14% (9) odd  0.14% (9) ask  0.14% (9) power  0.14% (9) integers  0.14% (9) see  0.14% (9) is,  0.14% (9) recur  0.14% (9) abundant_nums  0.14% (9) million  0.14% (9) paths  0.14% (9) tell  0.14% (9) column  0.14% (9) make  0.14% (9) out.  0.14% (9) –  0.14% (9) may  0.14% (9) your  0.13% (8) read  0.13% (8) justice  0.13% (8) off  0.13% (8) 0):  0.13% (8) numerator  0.13% (8) multiple  0.13% (8) put  0.13% (8) approach  0.13% (8) 10:  0.13% (8) script#  0.13% (8) 12:  0.13% (8) time  0.13% (8) corner  0.13% (8) proper  0.13% (8) africaine  0.13% (8) length  0.13% (8) numbers.  0.13% (8) less  0.13% (8) 11:  0.13% (8) written  0.11% (7) maxcyclelen  0.11% (7) did  0.11% (7) add  0.11% (7) hum  0.11% (7) given  0.11% (7) while  0.11% (7) line  0.11% (7) mean  0.11% (7) numcolumn  0.11% (7) .net  0.11% (7) also  0.11% (7) represent  0.11% (7) comments  0.11% (7) nodes  0.11% (7) side  0.11% (7) recurring  0.11% (7) using  0.11% (7) hisabati  0.11% (7) i+j  0.11% (7) both  0.11% (7) greater  0.11% (7) right  0.11% (7) spaces  0.11% (7) through  0.11% (7) etc  0.11% (7) 13:  0.11% (7) lead  0.09% (6) looking  0.09% (6) shirts  0.09% (6) tool  0.09% (6) currvalue  0.09% (6) 15:  0.09% (6) part  0.09% (6) model  0.09% (6) come  0.09% (6) most  0.09% (6) (the  0.09% (6) left  0.09% (6) equivalence  0.09% (6) plex  0.09% (6) series  0.09% (6) sums  0.09% (6) construct  0.09% (6) 14:  0.09% (6) squares  0.09% (6) mar  0.09% (6) distribution  0.09% (6) found  0.09% (6) even_abundants  0.09% (6) very  0.09% (6) either  0.09% (6) fun  0.09% (6) odd_abundants  0.09% (6) residue  0.09% (6) says  0.09% (6) slides  0.09% (6) ajax  0.08% (5) move  0.08% (5) 123  0.08% (5) unit  0.08% (5) times  0.08% (5) hisabati,  0.08% (5) same  0.08% (5) nonhappy  0.08% (5) element  0.08% (5) table  0.08% (5) optimization  0.08% (5) abundant_nums_filter  0.08% (5) kenya  0.08% (5) chief  0.08% (5) class.  0.08% (5) microsoft  0.08% (5) test  0.08% (5) euler:  0.08% (5) 89.  0.08% (5) 14.  0.08% (5) consider  0.08% (5) remainders  0.08% (5) code  0.08% (5) top  0.08% (5) sure  0.08% (5) tshirt  0.08% (5) decimal  0.08% (5) possible  0.08% (5) she  0.08% (5) reality  0.08% (5) outputdigitindex  0.08% (5) judge  0.08% (5) numsuffixpermutations  0.08% (5) determining  0.08% (5) ways  0.08% (5) 0.1  0.08% (5) routine  0.08% (5) theoretical  0.08% (5) longest  0.08% (5) knew  0.08% (5) walk  0.08% (5) products  0.08% (5) function  0.08% (5) range(1,  0.08% (5) range(0,  0.08% (5) projects  0.08% (5) 1):  0.08% (5) solve  0.08% (5) however  0.08% (5) back  0.08% (5) above  0.08% (5) n1  0.08% (5) algebra  0.06% (4) digits.  0.06% (4) tshirts  0.06% (4) selection  0.06% (4) mathematical  0.06% (4) sequences  0.06% (4) intellectual  0.06% (4) denominator  0.06% (4) reduce  0.06% (4) contain  0.06% (4) 10.  0.06% (4) means  0.06% (4) mudimbe  0.06% (4) though  0.06% (4) experience  0.06% (4) currrow  0.06% (4) etc.  0.06% (4) 1000  0.06% (4) case  0.06% (4) field  0.06% (4) ties  0.06% (4) account  0.06% (4) object  0.06% (4) unique  0.06% (4) algorithm  0.06% (4) it.  0.06% (4) software  0.06% (4) pretty  0.06% (4) nerdy  0.06% (4) range.  0.06% (4) human  0.06% (4) …  0.06% (4) fractions  0.06% (4) pass  0.06% (4) break  0.06% (4) size  0.06% (4) going  0.06% (4) representation  0.06% (4) however,  0.06% (4) if(r  0.06% (4) cycles  0.06% (4) 2ax5b  0.06% (4) allow  0.06% (4) cycle.  0.06% (4) terminate  0.06% (4) maxindex  0.06% (4) calculate  0.06% (4) i*j  0.06% (4) list  0.06% (4) quotient  0.06% (4) adding  0.06% (4) previous  0.06% (4) method  0.06% (4) libraries  0.06% (4) because  0.06% (4) numcolumncells  0.06% (4) it,  0.06% (4) (i.e.  0.06% (4) post  0.06% (4) currlen  0.06% (4) development  0.06% (4) these  0.06% (4) many  0.06% (4) javascript  0.06% (4) take  0.06% (4) were  0.06% (4) figure  0.06% (4) solution  0.06% (4) sum.  0.06% (4)  0.06% (4) factoring  0.06% (4) tells  0.06% (4) lower  0.06% (4) search  0.06% (4) binomial  0.06% (4) expressed  0.06% (4) says:  0.06% (4) shown  0.06% (4) geometric  0.06% (4) equal  0.06% (4) numrow  0.06% (4) they  0.06% (4) asks  0.06% (4) 145  0.06% (4) 89,  0.06% (4) 16:  0.06% (4) 10,  0.06% (4) operation  0.06% (4) law  0.06% (4) had  0.06% (4) actually  0.06% (4) this,  0.06% (4) curr_num  0.06% (4) therefore  0.06% (4) comes  0.06% (4) ends  0.06% (4) digits,  0.06% (4) 567  0.06% (4) check  0.06% (4) think  0.06% (4) example,  0.06% (4) 17:  0.05% (3) got  0.05% (3) 18:  0.05% (3) 21:  0.05% (3) upper  0.05% (3) 20:  0.05% (3) divisors_sum  0.05% (3) or,  0.05% (3) abundant_nums_filter[a]  0.05% (3) 19:  0.05% (3) here).  0.05% (3) calculator  0.05% (3) jan  0.05% (3) determines  0.05% (3) 1/10  0.05% (3) european  0.05% (3) clear  0.05% (3) labs  0.05% (3) regular  0.05% (3) event  0.05% (3) abundant_sum_nums  0.05% (3) if(a  0.05% (3) vector  0.05% (3) nikhil  0.05% (3) single  0.05% (3) result  0.05% (3) applications  0.05% (3) leave  0.05% (3) dimensional  0.05% (3) well  0.05% (3) browser  0.05% (3) currrow[numcolumn  0.05% (3) abundant_sums  0.05% (3) negative  0.05% (3) presentations  0.05% (3) acting  0.05% (3) base  0.05% (3) numrowcells  0.05% (3) photos  0.05% (3) kenya’s  0.05% (3) compile  0.05% (3) songsmith  0.05% (3) summing  0.05% (3) arrange  0.05% (3) if(i  0.05% (3) culture  0.05% (3) establish  0.05% (3) society  0.05% (3) uniquely  0.05% (3) called  0.05% (3) simply  0.05% (3) provide  0.05% (3) number,  0.05% (3) previously  0.05% (3) match  0.05% (3) arrive  0.05% (3) evaluate  0.05% (3) lest  0.05% (3) lookup  0.05% (3) between  0.05% (3) being  0.05% (3) otherwise,  0.05% (3) change  0.05% (3) coprime  0.05% (3) below  0.05% (3) reason  0.05% (3) determined  0.05% (3) maxcyclelengenerator  0.05% (3) millionth  0.05% (3) bottom  0.05% (3) court  0.05% (3) enumerate  0.05% (3) 1):  0.05% (3) known  0.05% (3) eliminate  0.05% (3) judges  0.05% (3) seen  0.05% (3) cases  0.05% (3) gives  0.05% (3) pairs,  0.05% (3) sep  0.05% (3) reading  0.05% (3) help  0.05% (3) “i  0.05% (3) direct  0.05% (3) nextstart  0.05% (3) group  0.05% (3) force  0.05% (3) african  0.05% (3) students  0.05% (3) those  0.05% (3) divide  0.05% (3) generate  0.05% (3) value)  0.05% (3) initialpermutation  0.05% (3) foundcycle  0.05% (3) following  0.05% (3) write  0.05% (3) surreptitious  0.05% (3) compilation  0.05% (3) journal  0.05% (3) 274240th  0.05% (3) western  0.05% (3) implementation  0.05% (3) true  0.05% (3) itself  0.05% (3) loop  0.05% (3) down  0.05% (3) define  0.05% (3) point  0.05% (3) indexdigit  0.05% (3) full  0.05% (3) without  0.05% (3) that,  0.05% (3) evenly  0.05% (3) prevvalue  0.05% (3) elements  0.05% (3) “m  0.05% (3) before  0.05% (3) order.  0.05% (3) candidate  0.05% (3) rather  0.03% (2) "".join([str(x)  0.03% (2) digits[maxindex]  0.03% (2) continue  0.03% (2) nextpermutation  0.03% (2) neat  0.03% (2) (currvalue  0.03% (2) if(quotient  0.03% (2) digit,  0.03% (2) len(currpermutation)  0.03% (2) apply  0.03% (2) page  0.03% (2) prefix  0.03% (2) values  0.03% (2) leading  0.03% (2) maxvalue  0.03% (2) divisors):  0.03% (2) if(n  0.03% (2) permutation.  0.03% (2) residue)  0.03% (2) =[]  0.03% (2) directly  0.03% (2) component  0.03% (2) 999999  0.03% (2) maximum  0.03% (2) 25:  0.03% (2) 26:  0.03% (2) abundant_pair_sums_in_range(n)  0.03% (2) sum_all  0.03% (2) sum_abundants  0.03% (2) relationship  0.03% (2) multiply  0.03% (2) grid.  0.03% (2) iteration  0.03% (2) 24:  0.03% (2) contains  0.03% (2) 0.2  0.03% (2) 0.1(6)  0.03% (2) 1/7  0.03% (2) similarly  0.03% (2) short  0.03% (2) python  0.03% (2) representations  0.03% (2) common  0.03% (2) 23:  0.03% (2) involve  0.03% (2) num_even_abundants  0.03% (2) arrangement  0.03% (2) routes  0.03% (2) abundant_nums_in_range(n)  0.03% (2) if(currlen  0.03% (2) backtracking)  0.03% (2) else:  0.03% (2) powers  0.03% (2) remove  0.03% (2) num_odd_abundants  0.03% (2) 22:  0.03% (2) zm.  0.03% (2) range(0,n)]  0.03% (2) 1/m  0.03% (2) 1/(2ax5b)  0.03% (2) 1/n  0.03% (2) 1).  0.03% (2) (since  0.03% (2) 10d  0.03% (2) immediately  0.03% (2) divides  0.03% (2) tafakuri  0.03% (2) range(1,n):  0.03% (2) {2,3,4,5,6,7,8,9,10,11,12,13}  0.03% (2) “the  0.03% (2) {66,7}  0.03% (2) {44,5,6,7,8,9}  0.03% (2) nor  0.03% (2) final  0.03% (2) always  0.03% (2) factored  0.03% (2) words,  0.03% (2) 2+2  0.03% (2) follows:  0.03% (2) {24,6,8,9,10}  0.03% (2) derivation  0.03% (2) 11.  0.03% (2) section  0.03% (2) primes.  0.03% (2) prime.  0.03% (2) info  0.03% (2) prime,  0.03% (2) target  0.03% (2) integers.  0.03% (2) smaller  0.03% (2) 24,  0.03% (2) i*j=n.  0.03% (2) solved  0.03% (2) 213  0.03% (2) 312,  0.03% (2) third  0.03% (2) naive  0.03% (2) we’ve  0.03% (2) all.  0.03% (2) split  0.03% (2) run  0.03% (2) brute  0.03% (2) rest  0.03% (2) 28,  0.03% (2) every  0.03% (2) become  0.03% (2) been  0.03% (2) until  0.03% (2) chain  0.03% (2) answer  0.03% (2) 36,  0.03% (2) 32,  0.03% (2) 30,  0.03% (2) sum,  0.03% (2) remember  0.03% (2) creating  0.03% (2) siasa  0.03% (2) task  0.03% (2) particular  0.03% (2) writing  0.03% (2) paragraph  0.03% (2) lawyers  0.03% (2) process  0.03% (2) walks  0.03% (2) teknolojia  0.03% (2) tarakirishi  0.03% (2) sayansi  0.03% (2) favor  0.03% (2) filosofia  0.03% (2) recent  0.03% (2) random  0.03% (2) finite  0.03% (2) calculations  0.03% (2) simple  0.03% (2) poisson  0.03% (2) pdf  0.03% (2) hypergeometric  0.03% (2) decisions  0.03% (2) explain  0.03% (2) sum”  0.03% (2) teacher  0.03% (2) step  0.03% (2) pairs.  0.03% (2) tries  0.03% (2) assume  0.03% (2) fair  0.03% (2) gets  0.03% (2) second:  0.03% (2) first:  0.03% (2) thinking  0.03% (2) maybe  0.03% (2) still  0.03% (2) ahmednasir  0.03% (2) try  0.03% (2) future  0.03% (2) good  0.03% (2) rulings?  0.03% (2) oneline  0.03% (2) high  0.03% (2) ang’awa  0.03% (2) asked  0.03% (2) make.  0.03% (2) formula  0.03% (2) min_abundant_not_multiple_of_2_or_3  0.03% (2) tools  0.03% (2) developer  0.03% (2) independent  0.03% (2) used  0.03% (2) slides.  0.03% (2) zoom  0.03% (2) linear  0.03% (2) office  0.03% (2) leads  0.03% (2) often  0.03% (2) alterity  0.03% (2) web  0.03% (2) name  0.03% (2) faces  0.03% (2) and,  0.03% (2) appear  0.03% (2) after  0.03% (2) together  0.03% (2) reflect  0.03% (2) least  0.03% (2) methods  0.03% (2) platform.  0.03% (2) brings  0.03% (2) root  0.03% (2) article  0.03% (2) ready  0.03% (2) analysis  0.03% (2) limit  0.03% (2) 28123  0.03% (2) smallest  0.03% (2) abundant.  0.03% (2) whose  0.03% (2) number.  0.03% (2) perfect  0.03% (2) tune  0.03% (2) productivity  0.03% (2) research  0.03% (2) toy  0.03% (2) reference  0.03% (2) dll  0.03% (2) oop.  0.03% (2) little  0.03% (2) meaning  0.03% (2) design  0.03% (2) works  0.03% (2) really  0.03% (2) studies  0.03% (2) reasoning  0.03% (2) counting  0.03% (2) front  0.03% (2) swallow  0.03% (2) caption  0.03% (2) giving  0.03% (2) better  0.03% (2) programming  0.03% (2) video  0.03% (2) gotten  0.03% (2) i’ve  0.03% (2) further  0.03% (2) otherness  0.03% (2) seconds  0.03% (2) 0.5  0.03% (2) exactly  0.03% (2) nondecreasing  0.03% (2) string  0.03% (2) times,  0.03% (2) eventual  0.03% (2) repeated  0.03% (2) title  0.03% (2) made  0.03% (2) years  0.03% (2) seems  0.03% (2) operations  0.03% (2) movement  0.03% (2) difference  0.03% (2) world  0.03% (2) doing  0.03% (2) vectors  0.03% (2) plane  0.03% (2) experience.  0.03% (2) primary  0.03% (2) place,  0.03% (2) claims  0.03% (2) “a  0.03% (2) like  0.03% (2) makes  0.03% (2) study  0.03% (2) idea  0.03% (2) explicit  0.03% (2) this.  0.03% (2) defined  0.03% (2) space,  0.03% (2) space.  0.03% (2) •  0.03% (2)  of the  0.59% (37) the sum  0.46% (29) in the  0.36% (23) the number  0.36% (23) that the  0.36% (23) can be  0.33% (21) to the  0.33% (21) sum of  0.33% (21) the first  0.3% (19) in range  0.28% (18) we can  0.28% (18) project euler  0.27% (17) as the  0.25% (16) that a  0.24% (15) created by  0.22% (14) number of  0.22% (14) of two  0.22% (14) abundant numbers  0.21% (13) it can  0.19% (12) that can  0.19% (12) be created  0.19% (12) is the  0.19% (12) for the  0.19% (12) is out  0.17% (11) two numbers  0.17% (11) two abundant  0.17% (11) numbers that  0.17% (11) 1: def  0.16% (10) by mucheru  0.16% (10) first student  0.16% (10) such that  0.16% (10) there are  0.16% (10) all the  0.16% (10) mucheru   0.16% (10) filed under  0.16% (10) cannot be  0.16% (10) need to  0.14% (9) happy numbers  0.14% (9) from the  0.14% (9) know that  0.14% (9) of digits  0.14% (9) the product  0.13% (8) is out.  0.13% (8) with the  0.13% (8) determine the  0.13% (8) ending at  0.13% (8) out. it  0.13% (8) and the  0.13% (8) numbers in  0.13% (8) the problem  0.13% (8) a number  0.13% (8) starting with  0.11% (7) second student  0.11% (7) the digits  0.11% (7) of paths  0.11% (7) to find  0.11% (7) {i,j} such  0.11% (7) than 1  0.11% (7) the numbers  0.11% (7) written as  0.11% (7) greater than  0.11% (7) be written  0.11% (7) find the  0.11% (7) presence africaine  0.11% (7) you can  0.11% (7) set of  0.09% (6)  comments  0.09% (6) numbers a  0.09% (6) if the  0.09% (6) equivalence class  0.09% (6) comments off  0.09% (6) off on  0.09% (6) that cannot  0.09% (6) permutation of  0.09% (6) we know  0.09% (6) the only  0.09% (6) on the  0.09% (6) into two  0.09% (6) pairs {i,j}  0.09% (6) under hisabati  0.09% (6) less than  0.09% (6) == 0):  0.09% (6) space is  0.08% (5) euler by  0.08% (5) this is  0.08% (5) hisabati, project  0.08% (5) determining the  0.08% (5) lexicographic permutation  0.08% (5) student says  0.08% (5) the square  0.08% (5) length of  0.08% (5) into the  0.08% (5) chief justice  0.08% (5) under hisabati,  0.08% (5) the second  0.08% (5) the longest  0.08% (5) digits in  0.08% (5) has the  0.08% (5) proper divisors  0.08% (5) the same  0.08% (5) that i+j  0.08% (5) looking at  0.08% (5) student has  0.08% (5) all pairs  0.08% (5) to determine  0.08% (5) 10 million  0.08% (5) project euler:  0.08% (5) does not  0.08% (5) any one  0.08% (5) we have  0.06% (4) then the  0.06% (4) have a  0.06% (4) abundant numbers.  0.06% (4) student says:  0.06% (4) of squares  0.06% (4) path ending  0.06% (4) the sequence  0.06% (4) a sequence  0.06% (4) in range.  0.06% (4) numbers is  0.06% (4) the fraction  0.06% (4) we need  0.06% (4) where the  0.06% (4) sequence of  0.06% (4) number is  0.06% (4) permutations of  0.06% (4) size of  0.06% (4) is that  0.06% (4) this approach  0.06% (4) cyclelen =  0.06% (4) paths ending  0.06% (4) squares of  0.06% (4) we are  0.06% (4) nerdy tshirts  0.06% (4) from a  0.06% (4) recurring cycle  0.06% (4) by the  0.06% (4) expressed as  0.06% (4) power of  0.06% (4) i knew  0.06% (4) will be  0.06% (4) the next  0.06% (4) the reality  0.06% (4) of factoring  0.06% (4) n into  0.06% (4) the top  0.06% (4) the two  0.06% (4) and has  0.06% (4) corner of  0.06% (4) one node  0.06% (4) knew that  0.06% (4) 4: for  0.06% (4) from project  0.06% (4) here is  0.06% (4) unit fraction  0.06% (4) right corner  0.06% (4) that we  0.06% (4) of permutations  0.06% (4) the set  0.06% (4) permutations starting  0.06% (4) that are  0.06% (4) that m  0.06% (4) factoring n  0.06% (4) not in  0.06% (4) left corner  0.06% (4) abundant_nums_filter[a] =  0.05% (3) means that  0.05% (3) that you  0.05% (3) lookup table  0.05% (3) is equal  0.05% (3) a power  0.05% (3) order of  0.05% (3) number for  0.05% (3) a cycle  0.05% (3) be expressed  0.05% (3) as well  0.05% (3) each equivalence  0.05% (3) fact that  0.05% (3) in which  0.05% (3) of numbers  0.05% (3) is not  0.05% (3) the journal  0.05% (3) value of  0.05% (3) are in  0.05% (3) all numbers  0.05% (3) for which  0.05% (3) the abundant  0.05% (3) the value  0.05% (3) of this  0.05% (3) decimal representation  0.05% (3) each class  0.05% (3) reality of  0.05% (3) for our  0.05% (3) and in  0.05% (3) the length  0.05% (3) the mathematical  0.05% (3) the decimal  0.05% (3) unit fractions  0.05% (3) the remainder  0.05% (3) even numbers  0.05% (3) class is  0.05% (3) 0): 7:  0.05% (3) one of  0.05% (3) 3 dimensional  0.05% (3) are pretty  0.05% (3) 89, we  0.05% (3) ends in  0.05% (3) given the  0.05% (3) only way  0.05% (3) that second  0.05% (3) could not  0.05% (3) 10 digits  0.05% (3) end at  0.05% (3) with 2  0.05% (3) of pairs  0.05% (3) out because  0.05% (3) currvalue =  0.05% (3) the digits.  0.05% (3) end up  0.05% (3) take a  0.05% (3) the millionth  0.05% (3) there is  0.05% (3) he can  0.05% (3) what is  0.05% (3) numbers filed  0.05% (3) 5: for  0.05% (3) kenya’s chief  0.05% (3) justice selection  0.05% (3) through the  0.05% (3) would have  0.05% (3) the lower  0.05% (3) numbers greater  0.05% (3) he has  0.05% (3) numbers and  0.05% (3) not know  0.05% (3) sum is  0.05% (3) that he  0.05% (3) a grid  0.05% (3) 274240th permutation  0.05% (3) student could  0.05% (3) is either  0.05% (3) by adding  0.05% (3) comment problem  0.05% (3) find a  0.05% (3) evaluate a  0.05% (3) in 89.  0.05% (3) this, we  0.05% (3) start with  0.05% (3) starting at  0.05% (3) the series  0.05% (3) coprime with  0.05% (3) the cycle  0.05% (3) you would  0.05% (3) have to  0.05% (3) that have  0.05% (3) numbers under  0.05% (3) asks us  0.05% (3) quotient =  0.03% (2) that determines  0.03% (2) node immediately  0.03% (2) =[] 3:  0.03% (2) 0 (the  0.03% (2) 6: if(i  0.03% (2) the nodes  0.03% (2) can lead  0.03% (2) representations of  0.03% (2) divisors =  0.03% (2) as sum  0.03% (2) > dec  0.03% (2) 48 are  0.03% (2) in our  0.03% (2) we only  0.03% (2) to get  0.03% (2) how many  0.03% (2) top left  0.03% (2) an odd  0.03% (2) nodes that  0.03% (2) possible permutation  0.03% (2) euler: determining  0.03% (2) way to  0.03% (2) cycle will  0.03% (2) this leads  0.03% (2) is coprime  0.03% (2) the algorithm  0.03% (2) n does  0.03% (2) cannot pass  0.03% (2) the range  0.03% (2) has only  0.03% (2) the nth  0.03% (2) 0) and  0.03% (2) lower right  0.03% (2) the grid.  0.03% (2) the upper  0.03% (2) 10d mod  0.03% (2) (the node  0.03% (2) of 10.  0.03% (2) (since we  0.03% (2) nodes in  0.03% (2) to its  0.03% (2) the bottom  0.03% (2) odd_abundants =  0.03% (2) even_abundants =  0.03% (2) "".join([str(x) for  0.03% (2) maxcyclelengenerator =  0.03% (2) with 0  0.03% (2) recurring cycle.  0.03% (2) 11: break  0.03% (2) in lexicographic  0.03% (2) with any  0.03% (2) 10 digits,  0.03% (2) line 5  0.03% (2) this would  0.03% (2) in unit  0.03% (2) the loop  0.03% (2) if(r ==  0.03% (2) prevvalue =  0.03% (2) break 12:  0.03% (2) foundcycle =  0.03% (2) call the  0.03% (2) solve the  0.03% (2) iteration of  0.03% (2) we could  0.03% (2) maxcyclelen =  0.03% (2) of cycles  0.03% (2) 12: return  0.03% (2) the numerator  0.03% (2) evenly divides  0.03% (2) curr_num =  0.03% (2) paths in  0.03% (2) this second  0.03% (2) outputdigitindex =  0.03% (2) to calculate  0.03% (2) in each  0.03% (2) all integers  0.03% (2) my first  0.03% (2) end of  0.03% (2) permutation from  0.03% (2) cycles in  0.03% (2) each iteration  0.03% (2) lexicographic order.  0.03% (2) the 274240th  0.03% (2) while (n  0.03% (2) prime, the  0.03% (2) leave a  0.03% (2) the maximum  0.03% (2) numsuffixpermutations =  0.03% (2) a permutations  0.03% (2) that all  0.03% (2) only {i,j}  0.03% (2) be factored  0.03% (2) other words,  0.03% (2) sure that  0.03% (2) pairs, he  0.03% (2) since he  0.03% (2) “i knew  0.03% (2) than 1.  0.03% (2) because the  0.03% (2) than 14.  0.03% (2) adding two  0.03% (2) also know  0.03% (2) that 1  0.03% (2) tells us  0.03% (2) two primes.  0.03% (2) an integer  0.03% (2) that both  0.03% (2) for sure  0.03% (2) add up  0.03% (2) the final  0.03% (2) products of  0.03% (2) for each  0.03% (2) series starting  0.03% (2) consider the  0.03% (2) at some  0.03% (2) up looking  0.03% (2) new number  0.03% (2) digits, square  0.03% (2) it into  0.03% (2) as with  0.03% (2) pairs where  0.03% (2) ending in  0.03% (2) arrive at  0.03% (2) starting number  0.03% (2) of nonhappy  0.03% (2) euler: happy  0.03% (2) > sep  0.03% (2) determine that  0.03% (2) eliminate all  0.03% (2) no pair  0.03% (2) says: “i  0.03% (2) our test  0.03% (2) at this  0.03% (2) first: i  0.03% (2) second:  0.03% (2) their sum.  0.03% (2) first:  0.03% (2) have the  0.03% (2) thinking of  0.03% (2) is one  0.03% (2) oneline rulings?  0.03% (2) is thinking  0.03% (2) does a  0.03% (2) going back  0.03% (2) them to  0.03% (2) writing in  0.03% (2) and did  0.03% (2) projects a  0.03% (2) negative binomial  0.03% (2) geometric distribution  0.03% (2) say that  0.03% (2) student gets  0.03% (2) way of  0.03% (2) that there  0.03% (2) be one  0.03% (2) then there  0.03% (2) otherwise, if  0.03% (2) of them  0.03% (2) the sum.  0.03% (2) pair {i,j}  0.03% (2) one way  0.03% (2) the sum,  0.03% (2) tries to  0.03% (2) that i*j=n.  0.03% (2) has determined  0.03% (2) remember that  0.03% (2) find all  0.03% (2) integers greater  0.03% (2) ways of  0.03% (2) two numbers.  0.03% (2) out the  0.03% (2) we evaluate  0.03% (2) our lookup  0.03% (2) the smallest  0.03% (2) european space  0.03% (2) than a  0.03% (2) could be  0.03% (2) new products  0.03% (2) are some  0.03% (2) leads to  0.03% (2) seems to  0.03% (2) human experience  0.03% (2) of its  0.03% (2) this means  0.03% (2) reading the  0.03% (2) the idea  0.03% (2) experience and  0.03% (2) doing so  0.03% (2) as vectors  0.03% (2) model some  0.03% (2) we use  0.03% (2) a space  0.03% (2) your slides  0.03% (2) you need  0.03% (2) mudimbe makes  0.03% (2) product from  0.03% (2) is called  0.03% (2) whose proper  0.03% (2) divisors of  0.03% (2) perfect number  0.03% (2) summing numbers  0.03% (2) from microsoft  0.03% (2) this product  0.03% (2) used in  0.03% (2) in this  0.03% (2) base libraries  0.03% (2) can use  0.03% (2) just as  0.03% (2) etc. the  0.03% (2) as you  0.03% (2) your ajax  0.03% (2) well as  0.03% (2) the .net  0.03% (2) always a  0.03% (2) field of  0.03% (2) calculate the  0.03% (2) in 89,  0.03% (2) given by  0.03% (2) the class  0.03% (2) digits. the  0.03% (2) for any  0.03% (2) adding the  0.03% (2) numbers by  0.03% (2) then we  0.03% (2) we determine  0.03% (2) account for  0.03% (2) use this  0.03% (2) than the  0.03% (2) numbers –  0.03% (2) contain the  0.03% (2) of integers  0.03% (2) if you  0.03% (2) 89. the  0.03% (2) to see  0.03% (2) to account  0.03% (2) out how  0.03% (2) in such  0.03% (2) intellectual space  0.03% (2) theoretical spaces  0.03% (2) in algebra  0.03% (2) idea of  0.03% (2) though it  0.03% (2) the western  0.03% (2) what we  0.03% (2) the other  0.03% (2) the end  0.03% (2) to make  0.03% (2) on presence  0.03% (2) the caption  0.03% (2) the title  0.03% (2) binomial distribution  0.03% (2) can determine  0.03% (2) digits will  0.03% (2) from each  0.03% (2) sure we  0.03% (2) 7: return  0.03% (2)  the sum of  0.27% (17) be created by  0.19% (12) sum of two  0.19% (12) the number of  0.17% (11) of two abundant  0.17% (11) by mucheru   0.16% (10) two abundant numbers  0.16% (10) can be created  0.16% (10) as the sum  0.13% (8) the first student  0.13% (8) is out. it  0.13% (8) number of paths  0.11% (7) {i,j} such that  0.11% (7) be written as  0.11% (7)  comments off  0.09% (6) we know that  0.09% (6) of the digits  0.09% (6) that cannot be  0.09% (6) mucheru  comments  0.09% (6) comments off on  0.09% (6) hisabati, project euler  0.08% (5) euler by mucheru  0.08% (5) filed under hisabati,  0.08% (5) under hisabati, project  0.08% (5) written as the  0.08% (5) pairs {i,j} such  0.08% (5) project euler by  0.08% (5) numbers that cannot  0.06% (4) a path ending  0.06% (4) to determine the  0.06% (4) sum of squares  0.06% (4) permutations starting with  0.06% (4) of paths ending  0.06% (4) we need to  0.06% (4) that the first  0.06% (4) the numbers that  0.06% (4) of factoring n  0.06% (4) that can be  0.06% (4) the longest cycle  0.06% (4) sequence of digits  0.06% (4) project euler asks  0.06% (4) from project euler  0.06% (4) numbers in range.  0.06% (4) two abundant numbers.  0.06% (4) factoring n into  0.06% (4) such that i+j  0.06% (4) paths ending at  0.06% (4) squares of digits  0.06% (4) digits in a  0.05% (3) us to find  0.05% (3) can be written  0.05% (3) the order of  0.05% (3) order of 10  0.05% (3) to do this,  0.05% (3) the size of  0.05% (3) all even numbers  0.05% (3) is equal to  0.05% (3) the length of  0.05% (3) the decimal representation  0.05% (3) need to determine  0.05% (3) be expressed as  0.05% (3) chief justice selection  0.05% (3) lexicographic permutation of  0.05% (3) asks us to  0.05% (3) left corner of  0.05% (3) kenya’s chief justice  0.05% (3) is less than  0.05% (3) student has the  0.05% (3) that second student  0.05% (3) first student says  0.05% (3) there is no  0.05% (3) and j are  0.05% (3) abundant numbers in  0.05% (3) into two in  0.05% (3) of permutations starting  0.05% (3) even numbers greater  0.03% (2) of cycles in  0.03% (2) that can lead  0.03% (2) (the node immediately  0.03% (2) leave a comment  0.03% (2) set of permutations  0.03% (2) in the grid.  0.03% (2) == 0): 7:  0.03% (2) way to get  0.03% (2) corner of the  0.03% (2) only way to  0.03% (2) the lower right  0.03% (2) starting with 2  0.03% (2) ending at b  0.03% (2) also know that  0.03% (2) not in divisors):  0.03% (2) ending at c  0.03% (2) permutation from the  0.03% (2) greater than 48  0.03% (2) cannot pass through  0.03% (2) leads to the  0.03% (2) with any one  0.03% (2) any one node  0.03% (2)  leave a  0.03% (2) while (n %  0.03% (2) bottom right corner  0.03% (2) to the order  0.03% (2) any one digit  0.03% (2) cycle is equal  0.03% (2) length of the  0.03% (2) 10d mod n  0.03% (2) project euler: determining  0.03% (2) 10 in the  0.03% (2) paths in a  0.03% (2) the top left  0.03% (2) corner of a  0.03% (2) from the set  0.03% (2) 11: break 12:  0.03% (2) a power of  0.03% (2) the bottom right  0.03% (2) n evenly divides  0.03% (2) power of 10.  0.03% (2) evenly divides a  0.03% (2) of a cycle  0.03% (2) on line 5  0.03% (2) as the first  0.03% (2) the 274240th permutation  0.03% (2) cycle will be  0.03% (2) looking at the  0.03% (2) each iteration of  0.03% (2) product from microsoft  0.03% (2) all the numbers  0.03% (2) student says: “i  0.03% (2) we also know  0.03% (2) adding two primes.  0.03% (2) this tells us  0.03% (2) is as follows:  0.03% (2) because the only  0.03% (2) out because the  0.03% (2) knew that the  0.03% (2) cannot be created  0.03% (2) has the product  0.03% (2) n and has  0.03% (2) determined all pairs  0.03% (2) add up to  0.03% (2) less than 14.  0.03% (2) this is the  0.03% (2) euler: happy numbers  0.03% (2) by adding two  0.03% (2) an integer that  0.03% (2) of nonhappy numbers  0.03% (2) to find all  0.03% (2) that the judges  0.03% (2) is thinking of  0.03% (2) first: i  0.03% (2) do not know  0.03% (2) say that the  0.03% (2) multiple ways of  0.03% (2) product n and  0.03% (2) first student could  0.03% (2) has determined all  0.03% (2) way of factoring  0.03% (2) second student says:  0.03% (2) “i knew that  0.03% (2) since he has  0.03% (2) list of pairs  0.03% (2) is no pair  0.03% (2) find the number  0.03% (2) up looking at  0.03% (2) we can determine  0.03% (2) written as a  0.03% (2) is a theoretical  0.03% (2) reality of a  0.03% (2) in doing so  0.03% (2) this leads to  0.03% (2) going back to  0.03% (2) in the .net  0.03% (2) a perfect number  0.03% (2) though it is  0.03% (2) a number whose  0.03% (2) number is called  0.03% (2) number whose proper  0.03% (2) number that can  0.03% (2) expressed as the  0.03% (2) abundant numbers is  0.03% (2) numbers in the  0.03% (2) the idea of  0.03% (2) on the front  0.03% (2) in the series  0.03% (2) in 89. the  0.03% (2) end up looking  0.03% (2) the series starting  0.03% (2) ends in 89,  0.03% (2) sum of the  0.03% (2) in a number  0.03% (2) for each number  0.03% (2) this means that  0.03% (2) the value of  0.03% (2) contain the same  0.03% (2) determine the size  0.03% (2) size of the  0.03% (2) the digits. the  0.03% (2) figure out how  0.03% (2) from each equivalence  0.03% (2) there are the  0.03% (2) numrowcells + 1  0.03% (2) 