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  5895 

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 may 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 31 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) dec  0.19% (12) long  0.19% (12) prime  0.19% (12) nth  0.19% (12) next  0.17% (11) where  0.17% (11) new  0.17% (11) ever  0.17% (11) ending  0.17% (11) {i,j}  0.17% (11) >  0.17% (11) just  0.17% (11) then  0.17% (11) currpermutation  0.17% (11) say  0.17% (11) lexicographic  0.17% (11) was  0.17% (11) cyclelen  0.17% (11) real  0.17% (11) need  0.17% (11) look  0.17% (11) filed  0.16% (10) other  0.16% (10) may  0.16% (10) factor  0.16% (10) set  0.16% (10) grid  0.16% (10) when  0.16% (10) mod  0.16% (10) suffix  0.16% (10) their  0.16% (10) does  0.16% (10) remainder  0.16% (10) mucheru  0.16% (10) able  0.16% (10) but  0.16% (10) comment  0.16% (10) could  0.16% (10) odd  0.14% (9) see  0.14% (9) integers  0.14% (9) abundant_nums  0.14% (9) is,  0.14% (9) column  0.14% (9) what  0.14% (9) million  0.14% (9) make  0.14% (9) out.  0.14% (9) since  0.14% (9) –  0.14% (9) tell  0.14% (9) ask  0.14% (9) paths  0.14% (9) recur  0.14% (9) power  0.14% (9) count  0.14% (9) put  0.13% (8) 10:  0.13% (8) 12:  0.13% (8) 11:  0.13% (8) script#  0.13% (8) 0):  0.13% (8) proper  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) at the  0.43% (27) in the  0.36% (23) that the  0.36% (23) the number  0.36% (23) to the  0.33% (21) sum of  0.33% (21) can be  0.33% (21) the first  0.3% (19) 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) is the  0.19% (12) that can  0.19% (12) be created  0.19% (12) for the  0.19% (12) it can  0.19% (12) two numbers  0.17% (11) is out  0.17% (11) here are  0.17% (11) two abundant  0.17% (11) numbers that  0.17% (11) by mucheru  0.16% (10) all the  0.16% (10) mucheru   0.16% (10) such that  0.16% (10) first student  0.16% (10) filed under  0.16% (10) 1: def  0.16% (10) there are  0.16% (10) cannot be  0.16% (10) from the  0.14% (9) of digits  0.14% (9) need to  0.14% (9) happy numbers  0.14% (9) n): 2:  0.14% (9) know that  0.14% (9) numbers in  0.13% (8) out. it  0.13% (8) determine the  0.13% (8) is out.  0.13% (8) a number  0.13% (8) the product  0.13% (8) the problem  0.13% (8) ending at  0.13% (8) and the  0.13% (8) with the  0.13% (8) to find  0.11% (7) of paths  0.11% (7) {i,j} such  0.11% (7) second student  0.11% (7) the numbers  0.11% (7) find the  0.11% (7) greater than  0.11% (7) be written  0.11% (7) presence africaine  0.11% (7) you can  0.11% (7) starting with  0.11% (7) the digits  0.11% (7) written as  0.11% (7) pairs {i,j}  0.09% (6) we know  0.09% (6) less than  0.09% (6) equivalence class  0.09% (6) off on  0.09% (6)  comments  0.09% (6) that cannot  0.09% (6) == 0):  0.09% (6) the only  0.09% (6) with a  0.09% (6) comments off  0.09% (6) set of  0.09% (6) on the  0.09% (6) permutation of  0.09% (6) the real  0.09% (6) if the  0.09% (6) any one  0.08% (5) under hisabati,  0.08% (5) in range(0,  0.08% (5) proper divisors  0.08% (5) length of  0.08% (5) the longest  0.08% (5) in range(1,  0.08% (5) determining the  0.08% (5) lexicographic permutation  0.08% (5) space is  0.08% (5) , there  0.08% (5) 10 million  0.08% (5) euler by  0.08% (5) hisabati, project  0.08% (5) does not  0.08% (5) the second  0.08% (5) to determine  0.08% (5) the same  0.08% (5) digits in  0.08% (5) looking at  0.08% (5) are the  0.08% (5) all pairs  0.08% (5) has the  0.08% (5) student has  0.08% (5) into the  0.08% (5) project euler:  0.08% (5) chief justice  0.08% (5) that i+j  0.08% (5) we have  0.06% (4) permutations starting  0.06% (4) of factoring  0.06% (4) have a  0.06% (4) the two  0.06% (4) squares of  0.06% (4) this approach  0.06% (4) we are  0.06% (4) the set  0.06% (4) student says:  0.06% (4) and has  0.06% (4) number is  0.06% (4) corner of  0.06% (4) the top  0.06% (4) from project  0.06% (4) euler asks  0.06% (4) of squares  0.06% (4) for example,  0.06% (4) even number  0.06% (4) n into  0.06% (4) we need  0.06% (4) with 10  0.06% (4) will be  0.06% (4) cyclelen =  0.06% (4) that are  0.06% (4) the fraction  0.06% (4) power of  0.06% (4) that we  0.06% (4) the reality  0.06% (4) theoretical space  0.06% (4) that is  0.06% (4) longest cycle  0.06% (4) the next  0.06% (4) size of  0.06% (4) by the  0.06% (4) left corner  0.06% (4) i knew  0.06% (4) their sum  0.06% (4) nerdy tshirts  0.06% (4) a sequence  0.06% (4) a permutation  0.06% (4) permutations of  0.06% (4) know the  0.06% (4) of permutations  0.06% (4) is that  0.06% (4) where the  0.06% (4) then the  0.06% (4) factoring n  0.06% (4) knew that  0.06% (4) paths ending  0.06% (4) abundant numbers.  0.06% (4) 4: for  0.06% (4) in range.  0.06% (4) a path  0.06% (4) than 14  0.06% (4) right corner  0.06% (4) the grid  0.06% (4) expressed as  0.06% (4) equal to  0.06% (4) the pairs  0.06% (4) one node  0.06% (4) value of  0.05% (3) through the  0.05% (3) means that  0.05% (3) class is  0.05% (3) given the  0.05% (3) each equivalence  0.05% (3) only way  0.05% (3) nth lexicographic  0.05% (3) each class  0.05% (3) that second  0.05% (3) could not  0.05% (3) are pretty  0.05% (3) have to  0.05% (3) is not  0.05% (3) out because  0.05% (3) only one  0.05% (3) end at  0.05% (3) as well  0.05% (3) equivalence class.  0.05% (3) > jan  0.05% (3) is less  0.05% (3) the lower  0.05% (3) the decimal  0.05% (3) by adding  0.05% (3) do not  0.05% (3) evenly divide  0.05% (3) student could  0.05% (3) all even  0.05% (3) that he  0.05% (3) coprime with  0.05% (3) an experience  0.05% (3) 10 has  0.05% (3) 3 dimensional  0.05% (3) one of  0.05% (3) numbers greater  0.05% (3) reality of  0.05% (3) the order  0.05% (3) there is  0.05% (3) through a  0.05% (3) the cycle  0.05% (3) for which  0.05% (3) the abundant  0.05% (3) the max  0.05% (3) the journal  0.05% (3) a cycle  0.05% (3) decimal representation  0.05% (3) in which  0.05% (3) be expressed  0.05% (3) the length  0.05% (3) 89, we  0.05% (3) the size  0.05% (3) the series  0.05% (3) starting at  0.05% (3) a grid  0.05% (3) end up  0.05% (3) he has  0.05% (3) under 10  0.05% (3) multiple ways  0.05% (3) cycle is  0.05% (3) would be  0.05% (3) that have  0.05% (3) do this,  0.05% (3) evaluate a  0.05% (3) that you  0.05% (3) number for  0.05% (3) justice selection  0.05% (3) two in  0.05% (3) kenya’s chief  0.05% (3) what is  0.05% (3) are in  0.05% (3) all integer  0.05% (3) with an  0.05% (3) 5: for  0.05% (3) since we  0.05% (3) from 1  0.05% (3) all numbers  0.05% (3) ends in  0.05% (3) lookup table  0.05% (3) you would  0.05% (3) of this  0.05% (3) with 2  0.05% (3) for our  0.05% (3) in 89.  0.05% (3) 274240th permutation  0.05% (3) start with  0.05% (3) 5: return  0.05% (3) the value  0.05% (3) when the  0.05% (3) nonhappy numbers  0.05% (3) product n  0.05% (3) is prime  0.05% (3) that is,  0.05% (3) the digits.  0.05% (3) able to  0.05% (3) abundant_nums_filter[a] =  0.05% (3) a comment  0.03% (2) on line  0.03% (2) return abundant  0.03% (2) the end  0.03% (2) way to  0.03% (2)  leave  0.03% (2) of cycles  0.03% (2) 12: return  0.03% (2) the other  0.03% (2) divisors of  0.03% (2) a remainder  0.03% (2) routine that  0.03% (2) curr_num =  0.03% (2) 11: break  0.03% (2) if(r ==  0.03% (2) in unit  0.03% (2) representations of  0.03% (2) in range(0,n)]  0.03% (2) in divisors):  0.03% (2) recurring cycle.  0.03% (2) odd number  0.03% (2) to solve  0.03% (2) two numbers.  0.03% (2) each iteration  0.03% (2) cycles in  0.03% (2) if(a %  0.03% (2) the main  0.03% (2) 8: else:  0.03% (2) will help  0.03% (2) 0) and  0.03% (2) bottom right  0.03% (2) top left  0.03% (2) asked to  0.03% (2) for any  0.03% (2) negative binomial  0.03% (2) nodes in  0.03% (2) nodes that  0.03% (2) paths in  0.03% (2) euler: determining  0.03% (2) permutation from  0.03% (2) the 274240th  0.03% (2) with 0  0.03% (2) 10 digits,  0.03% (2) with any  0.03% (2) > dec  0.03% (2) one digit  0.03% (2) can lead  0.03% (2) into it  0.03% (2) leads to  0.03% (2) c. this  0.03% (2) pass through  0.03% (2) numrowcells +  0.03% (2) binomial distribution  0.03% (2) 1): 6:  0.03% (2) numcolumncells +  0.03% (2) geometric distribution  0.03% (2) to get  0.03% (2) node immediately  0.03% (2) 0 (the  0.03% (2) (the node  0.03% (2) use this  0.03% (2) calculate the  0.03% (2) as shown  0.03% (2) at any  0.03% (2) digits will  0.03% (2) the sequences  0.03% (2) while (n  0.03% (2) the algorithm  0.03% (2) is coprime  0.03% (2) 15: return  0.03% (2) currlen =  0.03% (2) maxcyclelengenerator =  0.03% (2) maxcyclelen =  0.03% (2) 10d mod  0.03% (2) we start  0.03% (2) n evenly  0.03% (2) the loop  0.03% (2) iteration of  0.03% (2) divides a  0.03% (2) and only  0.03% (2) of 10.  0.03% (2) = 2ax5b  0.03% (2) break 12:  0.03% (2) the permutations  0.03% (2) we could  0.03% (2) prevvalue =  0.03% (2) in suffix  0.03% (2) the nth  0.03% (2) of them  0.03% (2) millionth permutation  0.03% (2) comes to  0.03% (2) return currpermutation  0.03% (2) 6: if(i  0.03% (2) in lexicographic  0.03% (2) lexicographic order.  0.03% (2) projects a  0.03% (2) digits. the  0.03% (2) 6: for  0.03% (2) = digits[maxindex]  0.03% (2) in each  0.03% (2) that was  0.03% (2) he tries  0.03% (2) may be  0.03% (2) in 89,  0.03% (2) gets the  0.03% (2) that end  0.03% (2) and check  0.03% (2) in our  0.03% (2) each number  0.03% (2) we evaluate  0.03% (2) ending in  0.03% (2) two integers  0.03% (2) could be  0.03% (2) arrive at  0.03% (2) a match  0.03% (2) series starting  0.03% (2) a series  0.03% (2) at 145  0.03% (2) up looking  0.03% (2) our lookup  0.03% (2) table to  0.03% (2) to account  0.03% (2) account for  0.03% (2) by creating  0.03% (2) such a  0.03% (2) the title  0.03% (2) same digits  0.03% (2) contain the  0.03% (2) figure out  0.03% (2) count of  0.03% (2) than 14.  0.03% (2) this means  0.03% (2) thinking of  0.03% (2) digits function  0.03% (2) only need  0.03% (2) brute force  0.03% (2) determine that  0.03% (2) of each  0.03% (2) first:  0.03% (2) how many  0.03% (2) new number  0.03% (2) two primes.  0.03% (2) we also  0.03% (2) us that  0.03% (2) derivation is  0.03% (2) as follows:  0.03% (2) one way  0.03% (2) numbers are  0.03% (2) “i knew  0.03% (2) this tells  0.03% (2) adding two  0.03% (2) the sum.  0.03% (2) pairs, he  0.03% (2) the sum,  0.03% (2) since he  0.03% (2) sure that  0.03% (2) integer that  0.03% (2) in other  0.03% (2) pair {i,j}  0.03% (2) because the  0.03% (2) only {i,j}  0.03% (2) products of  0.03% (2) consider the  0.03% (2) otherwise, if  0.03% (2) eliminate all  0.03% (2) he cannot  0.03% (2) adding the  0.03% (2) determined all  0.03% (2) we determine  0.03% (2) are both  0.03% (2) there was  0.03% (2) that for  0.03% (2) for sure  0.03% (2) says: “i  0.03% (2) up with  0.03% (2) way of  0.03% (2) the final  0.03% (2) 14. this  0.03% (2) know their  0.03% (2) nondecreasing sequence  0.03% (2) your ajax  0.03% (2) on two  0.03% (2) used in  0.03% (2) ajax applications  0.03% (2) just as  0.03% (2) as with  0.03% (2) meaning that  0.03% (2) the javascript  0.03% (2) as you  0.03% (2) you need  0.03% (2) in this  0.03% (2) them to  0.03% (2) its own  0.03% (2) microsoft does  0.03% (2) this leads  0.03% (2) of slides  0.03% (2) zoom in  0.03% (2) list of  0.03% (2) base libraries  0.03% (2) the .net  0.03% (2) all integers  0.03% (2) number that  0.03% (2) the smallest  0.03% (2) of all  0.03% (2) can determine  0.03% (2) reading the  0.03% (2) than 48  0.03% (2) the judges  0.03% (2) than the  0.03% (2) number whose  0.03% (2) and it  0.03% (2) product from  0.03% (2) from microsoft  0.03% (2) are some  0.03% (2) a judge  0.03% (2) of its  0.03% (2) a perfect  0.03% (2) back to  0.03% (2) european space  0.03% (2) to this  0.03% (2) end of  0.03% (2) the following  0.03% (2) a very  0.03% (2) is thinking  0.03% (2) we may  0.03% (2) to that  0.03% (2) western space.  0.03% (2) call the  0.03% (2) the front  0.03% (2) the caption  0.03% (2) solve the  0.03% (2) with these  0.03% (2) from each  0.03% (2) that there  0.03% (2) gotten to  0.03% (2) first: i  0.03% (2) then there  0.03% (2) a permutations  0.03% (2) the idea  0.03% (2) of study  0.03% (2) that an  0.03% (2) the fact  0.03% (2) model some  0.03% (2) well as  0.03% (2) field of  0.03% (2) theoretical spaces  0.03% (2) mudimbe makes  0.03% (2) idea of  0.03% (2) seems to  0.03% (2) intellectual space  0.03% (2) a space  0.03% (2) a theoretical  0.03% (2) as african  0.03% (2) claims to  0.03% (2) and human  0.03% (2) intellectual movement  0.03% (2) in doing  0.03% (2) in range(1,n):  0.03% (2)  the sum of  0.27% (17) sum of two  0.19% (12) be created by  0.19% (12) of two abundant  0.17% (11) the number of  0.17% (11) can be created  0.16% (10) two abundant numbers  0.16% (10) by mucheru   0.16% (10) as the sum  0.13% (8) the first student  0.13% (8) is out. it  0.13% (8) be written as  0.11% (7) {i,j} such that  0.11% (7) number of paths  0.11% (7) that cannot be  0.09% (6) we know that  0.09% (6) of the digits  0.09% (6) mucheru  comments  0.09% (6) comments off on  0.09% (6)  comments off  0.09% (6) pairs {i,j} such  0.08% (5) hisabati, project euler  0.08% (5) written as the  0.08% (5) project euler by  0.08% (5) under hisabati, project  0.08% (5) euler by mucheru  0.08% (5) filed under hisabati,  0.08% (5) permutations starting with  0.06% (4) two abundant numbers.  0.06% (4) to determine the  0.06% (4) from project euler  0.06% (4) that can be  0.06% (4) project euler asks  0.06% (4) we need to  0.06% (4) sequence of digits  0.06% (4) the longest cycle  0.06% (4) numbers that cannot  0.06% (4) sum of squares  0.06% (4) squares of digits  0.06% (4) numbers in range.  0.06% (4) the numbers that  0.06% (4) a path ending  0.06% (4) factoring n into  0.06% (4) that the first  0.06% (4) such that i+j  0.06% (4) of factoring n  0.06% (4) paths ending at  0.06% (4) of paths ending  0.06% (4) the length of  0.05% (3) is equal to  0.05% (3) kenya’s chief justice  0.05% (3) first student says  0.05% (3) order of 10  0.05% (3) that second student  0.05% (3) the decimal representation  0.05% (3) the order of  0.05% (3) student has the  0.05% (3) is less than  0.05% (3) all even numbers  0.05% (3) abundant numbers in  0.05% (3) be expressed as  0.05% (3) can be written  0.05% (3) us to find  0.05% (3) need to determine  0.05% (3) chief justice selection  0.05% (3) the size of  0.05% (3) left corner of  0.05% (3) asks us to  0.05% (3) and j are  0.05% (3) into two in  0.05% (3) lexicographic permutation of  0.05% (3) to do this,  0.05% (3) there is no  0.05% (3) digits in a  0.05% (3) of permutations starting  0.05% (3) of cycles in  0.03% (2) from the set  0.03% (2) way to get  0.03% (2) the 274240th permutation  0.03% (2) == 0): 7:  0.03% (2) ending at b  0.03% (2) permutation from the  0.03% (2)  leave a  0.03% (2) even numbers greater  0.03% (2) set of permutations  0.03% (2) starting with 2  0.03% (2) ending at c  0.03% (2) any one digit  0.03% (2) greater than 48  0.03% (2) the top left  0.03% (2) project euler: determining  0.03% (2) leads to the  0.03% (2) corner of a  0.03% (2) cannot pass through  0.03% (2) bottom right corner  0.03% (2) with any one  0.03% (2) numrowcells + 1  0.03% (2) not in divisors):  0.03% (2) also know that  0.03% (2) each iteration of  0.03% (2) 10d mod n  0.03% (2) corner of the  0.03% (2) 10 in the  0.03% (2) paths in a  0.03% (2) any one node  0.03% (2) length of the  0.03% (2) cycle is equal  0.03% (2) leave a comment  0.03% (2) (the node immediately  0.03% (2) in the grid.  0.03% (2) while (n %  0.03% (2) to the order  0.03% (2) the bottom right  0.03% (2) the lower right  0.03% (2) on line 5  0.03% (2) of a cycle  0.03% (2) that can lead  0.03% (2) cycle will be  0.03% (2) looking at the  0.03% (2) evenly divides a  0.03% (2) power of 10.  0.03% (2) as the first  0.03% (2) only way to  0.03% (2) a power of  0.03% (2) n evenly divides  0.03% (2) 11: break 12:  0.03% (2) product from microsoft  0.03% (2) out because the  0.03% (2) student says: “i  0.03% (2) knew that the  0.03% (2) because the only  0.03% (2) is as follows:  0.03% (2) we also know  0.03% (2) adding two primes.  0.03% (2) this tells us  0.03% (2) has the product  0.03% (2) n and has  0.03% (2) euler: happy numbers  0.03% (2) find the number  0.03% (2) of nonhappy numbers  0.03% (2) this is the  0.03% (2) less than 14.  0.03% (2) determined all pairs  0.03% (2) add up to  0.03% (2) by adding two  0.03% (2) cannot be created  0.03% (2) multiple ways of  0.03% (2) to find all  0.03% (2) product n and  0.03% (2) say that the  0.03% (2) do not know  0.03% (2) that the judges  0.03% (2) is thinking of  0.03% (2) first: i  0.03% (2) has determined all  0.03% (2) way of factoring  0.03% (2) is no pair  0.03% (2) first student could  0.03% (2) an integer that  0.03% (2) list of pairs  0.03% (2) since he has  0.03% (2) second student says:  0.03% (2) “i knew that  0.03% (2) up looking at  0.03% (2) in the series  0.03% (2) going back to  0.03% (2) in the .net  0.03% (2) written as a  0.03% (2) this leads to  0.03% (2) in doing so  0.03% (2) the idea of  0.03% (2) is a theoretical  0.03% (2) reality of a  0.03% (2) a perfect number  0.03% (2) a number whose  0.03% (2) abundant numbers is  0.03% (2) numbers in the  0.03% (2) we can determine  0.03% (2) expressed as the  0.03% (2) number that can  0.03% (2) number is called  0.03% (2) number whose proper  0.03% (2) though it is  0.03% (2) on the front  0.03% (2) in a number  0.03% (2) for each number  0.03% (2) in 89. the  0.03% (2) sum of the  0.03% (2) ends in 89,  0.03% (2) end up looking  0.03% (2) the series starting  0.03% (2) this means that  0.03% (2) contain the same  0.03% (2) from each equivalence  0.03% (2) there are the  0.03% (2) the value of  0.03% (2) figure out how  0.03% (2) the digits. the  0.03% (2) determine the size  0.03% (2) size of the  0.03% (2) all the numbers  0.03% (2) 