Project Euler 项目计算机程序集
这是一个使用Mathematica 和 F# 并排编写的“Project Euler” [1] 问题的“解决方案”集合。（HP48 计算器 UserRPL 也在可能的情况下添加）
目的是证明这两种语言在解决计算问题方面可以非常相似，尽管每种语言都带有自己的口音，但在快速而优雅地解决计算问题方面非常相似。
Select[Range[1, 999], (Mod[#, 3] == 0 || Mod[#, 5] == 0) &] // Total
|
let euler_1 = List.filter (fun x -> (x % 5 = 0 || x % 3 = 0))[1 .. 999] |> List.sum
<<0 << X 3 MOD 0 == X 5 MOD 0 == or <<X +>> IFT >> 'X' 1 999 1 SEQ>>
Select[Fibonacci /@ Range[1, NestWhile[(# + 1) &, 1, Fibonacci[#] <= 4*^6 &]-1], Mod[#, 2] == 0 &] // Total
|
let fib = Seq.unfold (fun (i,j) -> Some(i, (j,i+j))) (1,1)
let euler_2 = Seq.filter (fun x -> (x%2=0)) (fib |> Seq.takeWhile (fun n -> n<= 4000000)) |> Seq.sum
FactorInteger[600851475143][[All, 1]] // Max
Another Version:
FactorInteger[600851475143][[-1]][[1]]
|
let factor_integer (n:int64) =
let rec find_factor acc (n_p:int64) num =
if num < n_p then
acc
elif num % n_p = 0L then
find_factor (n_p::acc) n_p (num/n_p)
else
find_factor acc (n_p + 1L) num
find_factor [] 2L n
let euler_3 = Seq.max (factor_integer 600851475143L)
Select[Outer[Times, Range[100, 999], Range[100, 999]] // Flatten, (Reverse[IntegerDigits[#]] == IntegerDigits[#]) &] // Max
|
A more faster version:
Max[ToExpression[Cases[Map[ToString, Union[Flatten[Table[x Table[y, {y, 100, 999}], {x, 100, 999}]]]], _?(# == StringReverse[#] &)]]]
|
let integer_digits (n:int) =
let rec intdig (n: int) =
match n with
| 0 -> []
| _ -> (n%10)::(intdig (n/10))
List.rev (intdig n)
let isPalindrome n =
(integer_digits n) = ((integer_digits n) |> List.rev)
let euler_4 = [for x in 100..999 do
for y in 100..999 do
if isPalindrome (x*y) then yield x*y] |> List.max
Let palindrome x = let digits = show x in digits == reverse digits
maximum[x*y|x<-[100..999],y<-[100..999],palindrome(x*y)]
LCM @@ Range[1, 20]
|
open System.Numerics
let lcm x y =
if x = 0I || y = 0I then 0I
else (x / (BigInteger.GreatestCommonDivisor (x,y))) * y
let euler_5 = [1I .. 20I] |> List.fold lcm 1I
Total[Range[1, 100]]^2 - Total[#^2 & /@ Range[1, 100]]
|
let euler_6 = (List.sum [1..100]|>(fun x-> x*x)) - (List.sum (List.map (fun x-> x*x) [1..100]))
Prime[10001]
|
let isPrime (n:int64) =
{ 2L..(int64 (sqrt (float n))) } |> Seq.forall (fun x -> n%x <> 0L)
let primes =
{ 2L..System.Int64.MaxValue } |> Seq.filter isPrime
let euler_7 = primes |> Seq.nth 10000
txt = "73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450";
data = StringCases[txt, DigitCharacter] // ToExpression;
Map[Times @@ # &, Partition[data, 5, 1]] // Max
|
let txt = "73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450"
let data = txt |> Seq.toList |> List.filter System.Char.IsDigit |> List.map System.Char.GetNumericValue
let rec partition_5 l =
match l with
| x1::(x2::x3::x4::x5::_ as t) -> [x1;x2;x3;x4;x5]::(partition_5 t)
| _ -> []
let euler_8 = List.map (fun x -> List.fold (*) 1.0 x) (partition_5 data) |> List.max
a*b*c /. (FindInstance[a^2 + b^2 == c^2 && a + b + c == 1000 && c > b > a > 0, {a, b, c},Integers])
|
let triples = seq {for a in 1..1000 do for b in 1..1000 do for c in 1..1000 -> (a,b,c)}
let (a,b,c) = Seq.find (fun (a,b,c) -> (a*a+b*b = c*c)&&(a+b+c=1000)) triples
let euler_9 = a*b*c
(Prime /@ Range[1, NestWhile[(# + 1) &, 1, Prime[#] < 2*^6 &] - 1]) // Total
|
let euler_10 = primes |> Seq.takeWhile (fun elem -> elem < 2000000L) |> Seq.sum
mm = {{8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8}, {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0}, {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65}, {52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91}, {22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80}, {24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50}, {32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70}, {67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21}, {24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72}, {21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95}, {78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92}, {16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57}, {86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58}, {19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40}, {4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66}, {88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69}, {4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36}, {20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16}, {20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54}, {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48}};
cord[{k_, n_}] := Module[
{boundary, temp},
boundary[{a_, b_}] := 21 > a > 0 && 21 > b > 0;
temp = {{k, n + #} & /@ {0, 1, 2, 3}, {k + #, n} & /@ {0, 1, 2,
3}, {k + #, n + #} & /@ {0, 1, 2, 3}, {{k + 3, n}, {k + 2,
n + 1}, {k + 1, n + 2}, {k, n + 3}}};
temp = Select[temp, And @@ (boundary /@ #) &];
Times @@ Extract[mm, #] & /@ temp
]
cord /@ (Outer[List, Range[1, 20], Range[1, 20]] // Flatten[#, 1] &) //
Flatten // Max
|
let text = @" 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48";
let cell = text |> String.split ['\n']|> List.map (String.split [' '] >> List.map int )
let rec findPatterns (cells : int list list) =
match cells with
| (a11::(a12::a13::a14::_ as t1))::
((a21::(a22::a23:: _::_ as t2))::
(a31::(a32::a33:: _::_ as t3))::
(a41::( _:: _::a44::_ as t4))::_ as t5) -> let h = a11*a12*a13*a14
let v = a11*a21*a31*a41
let d1 = a11*a22*a33*a44
let d2 = a41*a32*a23*a14
[h; v; d1; d2] ::
(findPatterns [t1; t2; t3; t4] @ (findPatterns t5))
| _ -> [[]]
let euler11 =
cell |> findPatterns |> List.concat |> List.max
Binomial[NestWhile[(# + 1) &, 0, ((Length@Divisors @ Binomial[# + 1, 2]) <= 500) &] + 1, 2]
|
let factor_integer_2 n =
let rec find_factor acc n_p num =
if num < n_p then
acc
elif num % n_p = 0 then
find_factor (n_p::acc) n_p (num/n_p)
else
find_factor acc (n_p + 1) num
find_factor [] 2 n
let divisor_count n =
if n = 1 then 1
else
let a = factor_integer_2 n
a |> Seq.countBy (fun x-> x) |> Seq.map (fun (a,b) -> b+1) |> Seq.reduce (*)
let triangles =
Seq.unfold (fun (c,n) -> Some(n+c, (n+c, n+1))) (0, 1)
let euler12 = Seq.find (fun x -> divisor_count x > 500) triangles
numbers = {37107287533902102798797998220837590246510135740250,
46376937677490009712648124896970078050417018260538,
74324986199524741059474233309513058123726617309629,
91942213363574161572522430563301811072406154908250,
23067588207539346171171980310421047513778063246676,
89261670696623633820136378418383684178734361726757,
28112879812849979408065481931592621691275889832738,
44274228917432520321923589422876796487670272189318,
47451445736001306439091167216856844588711603153276,
70386486105843025439939619828917593665686757934951,
62176457141856560629502157223196586755079324193331,
64906352462741904929101432445813822663347944758178,
92575867718337217661963751590579239728245598838407,
58203565325359399008402633568948830189458628227828,
80181199384826282014278194139940567587151170094390,
35398664372827112653829987240784473053190104293586,
86515506006295864861532075273371959191420517255829,
71693888707715466499115593487603532921714970056938,
54370070576826684624621495650076471787294438377604,
53282654108756828443191190634694037855217779295145,
36123272525000296071075082563815656710885258350721,
45876576172410976447339110607218265236877223636045,
17423706905851860660448207621209813287860733969412,
81142660418086830619328460811191061556940512689692,
51934325451728388641918047049293215058642563049483,
62467221648435076201727918039944693004732956340691,
15732444386908125794514089057706229429197107928209,
55037687525678773091862540744969844508330393682126,
18336384825330154686196124348767681297534375946515,
80386287592878490201521685554828717201219257766954,
78182833757993103614740356856449095527097864797581,
16726320100436897842553539920931837441497806860984,
48403098129077791799088218795327364475675590848030,
87086987551392711854517078544161852424320693150332,
59959406895756536782107074926966537676326235447210,
69793950679652694742597709739166693763042633987085,
41052684708299085211399427365734116182760315001271,
65378607361501080857009149939512557028198746004375,
35829035317434717326932123578154982629742552737307,
94953759765105305946966067683156574377167401875275,
88902802571733229619176668713819931811048770190271,
25267680276078003013678680992525463401061632866526,
36270218540497705585629946580636237993140746255962,
24074486908231174977792365466257246923322810917141,
91430288197103288597806669760892938638285025333403,
34413065578016127815921815005561868836468420090470,
23053081172816430487623791969842487255036638784583,
11487696932154902810424020138335124462181441773470,
63783299490636259666498587618221225225512486764533,
67720186971698544312419572409913959008952310058822,
95548255300263520781532296796249481641953868218774,
76085327132285723110424803456124867697064507995236,
37774242535411291684276865538926205024910326572967,
23701913275725675285653248258265463092207058596522,
29798860272258331913126375147341994889534765745501,
18495701454879288984856827726077713721403798879715,
38298203783031473527721580348144513491373226651381,
34829543829199918180278916522431027392251122869539,
40957953066405232632538044100059654939159879593635,
29746152185502371307642255121183693803580388584903,
41698116222072977186158236678424689157993532961922,
62467957194401269043877107275048102390895523597457,
23189706772547915061505504953922979530901129967519,
86188088225875314529584099251203829009407770775672,
11306739708304724483816533873502340845647058077308,
82959174767140363198008187129011875491310547126581,
97623331044818386269515456334926366572897563400500,
42846280183517070527831839425882145521227251250327,
55121603546981200581762165212827652751691296897789,
32238195734329339946437501907836945765883352399886,
75506164965184775180738168837861091527357929701337,
62177842752192623401942399639168044983993173312731,
32924185707147349566916674687634660915035914677504,
99518671430235219628894890102423325116913619626622,
73267460800591547471830798392868535206946944540724,
76841822524674417161514036427982273348055556214818,
97142617910342598647204516893989422179826088076852,
87783646182799346313767754307809363333018982642090,
10848802521674670883215120185883543223812876952786,
71329612474782464538636993009049310363619763878039,
62184073572399794223406235393808339651327408011116,
66627891981488087797941876876144230030984490851411,
60661826293682836764744779239180335110989069790714,
85786944089552990653640447425576083659976645795096,
66024396409905389607120198219976047599490197230297,
64913982680032973156037120041377903785566085089252,
16730939319872750275468906903707539413042652315011,
94809377245048795150954100921645863754710598436791,
78639167021187492431995700641917969777599028300699,
15368713711936614952811305876380278410754449733078,
40789923115535562561142322423255033685442488917353,
44889911501440648020369068063960672322193204149535,
41503128880339536053299340368006977710650566631954,
81234880673210146739058568557934581403627822703280,
82616570773948327592232845941706525094512325230608,
22918802058777319719839450180888072429661980811197,
77158542502016545090413245809786882778948721859617,
72107838435069186155435662884062257473692284509516,
20849603980134001723930671666823555245252804609722,
53503534226472524250874054075591789781264330331690};
Total[numbers] // IntegerDigits // #[[1 ;; 10]] &
|
let euler13 = List.sum [37107287533902102798797998220837590246510135740250N;
46376937677490009712648124896970078050417018260538N;
74324986199524741059474233309513058123726617309629N;
91942213363574161572522430563301811072406154908250N;
23067588207539346171171980310421047513778063246676N;
89261670696623633820136378418383684178734361726757N;
28112879812849979408065481931592621691275889832738N;
44274228917432520321923589422876796487670272189318N;
47451445736001306439091167216856844588711603153276N;
70386486105843025439939619828917593665686757934951N;
62176457141856560629502157223196586755079324193331N;
64906352462741904929101432445813822663347944758178N;
92575867718337217661963751590579239728245598838407N;
58203565325359399008402633568948830189458628227828N;
80181199384826282014278194139940567587151170094390N;
35398664372827112653829987240784473053190104293586N;
86515506006295864861532075273371959191420517255829N;
71693888707715466499115593487603532921714970056938N;
54370070576826684624621495650076471787294438377604N;
53282654108756828443191190634694037855217779295145N;
36123272525000296071075082563815656710885258350721N;
45876576172410976447339110607218265236877223636045N;
17423706905851860660448207621209813287860733969412N;
81142660418086830619328460811191061556940512689692N;
51934325451728388641918047049293215058642563049483N;
62467221648435076201727918039944693004732956340691N;
15732444386908125794514089057706229429197107928209N;
55037687525678773091862540744969844508330393682126N;
18336384825330154686196124348767681297534375946515N;
80386287592878490201521685554828717201219257766954N;
78182833757993103614740356856449095527097864797581N;
16726320100436897842553539920931837441497806860984N;
48403098129077791799088218795327364475675590848030N;
87086987551392711854517078544161852424320693150332N;
59959406895756536782107074926966537676326235447210N;
69793950679652694742597709739166693763042633987085N;
41052684708299085211399427365734116182760315001271N;
65378607361501080857009149939512557028198746004375N;
35829035317434717326932123578154982629742552737307N;
94953759765105305946966067683156574377167401875275N;
88902802571733229619176668713819931811048770190271N;
25267680276078003013678680992525463401061632866526N;
36270218540497705585629946580636237993140746255962N;
24074486908231174977792365466257246923322810917141N;
91430288197103288597806669760892938638285025333403N;
34413065578016127815921815005561868836468420090470N;
23053081172816430487623791969842487255036638784583N;
11487696932154902810424020138335124462181441773470N;
63783299490636259666498587618221225225512486764533N;
67720186971698544312419572409913959008952310058822N;
95548255300263520781532296796249481641953868218774N;
76085327132285723110424803456124867697064507995236N;
37774242535411291684276865538926205024910326572967N;
23701913275725675285653248258265463092207058596522N;
29798860272258331913126375147341994889534765745501N;
18495701454879288984856827726077713721403798879715N;
38298203783031473527721580348144513491373226651381N;
34829543829199918180278916522431027392251122869539N;
40957953066405232632538044100059654939159879593635N;
29746152185502371307642255121183693803580388584903N;
41698116222072977186158236678424689157993532961922N;
62467957194401269043877107275048102390895523597457N;
23189706772547915061505504953922979530901129967519N;
86188088225875314529584099251203829009407770775672N;
11306739708304724483816533873502340845647058077308N;
82959174767140363198008187129011875491310547126581N;
97623331044818386269515456334926366572897563400500N;
42846280183517070527831839425882145521227251250327N;
55121603546981200581762165212827652751691296897789N;
32238195734329339946437501907836945765883352399886N;
75506164965184775180738168837861091527357929701337N;
62177842752192623401942399639168044983993173312731N;
32924185707147349566916674687634660915035914677504N;
99518671430235219628894890102423325116913619626622N;
73267460800591547471830798392868535206946944540724N;
76841822524674417161514036427982273348055556214818N;
97142617910342598647204516893989422179826088076852N;
87783646182799346313767754307809363333018982642090N;
10848802521674670883215120185883543223812876952786N;
71329612474782464538636993009049310363619763878039N;
62184073572399794223406235393808339651327408011116N;
66627891981488087797941876876144230030984490851411N;
60661826293682836764744779239180335110989069790714N;
85786944089552990653640447425576083659976645795096N;
66024396409905389607120198219976047599490197230297N;
64913982680032973156037120041377903785566085089252N;
16730939319872750275468906903707539413042652315011N;
94809377245048795150954100921645863754710598436791N;
78639167021187492431995700641917969777599028300699N;
15368713711936614952811305876380278410754449733078N;
40789923115535562561142322423255033685442488917353N;
44889911501440648020369068063960672322193204149535N;
41503128880339536053299340368006977710650566631954N;
81234880673210146739058568557934581403627822703280N;
82616570773948327592232845941706525094512325230608N;
22918802058777319719839450180888072429661980811197N;
77158542502016545090413245809786882778948721859617N;
72107838435069186155435662884062257473692284509516N;
20849603980134001723930671666823555245252804609722N;
53503534226472524250874054075591789781264330331690N;]
hailstoneLength[1] = 1;
hailstoneLength[2] = 2;
hailstoneLength[n_?EvenQ]:= hailstoneLength[n] = hailstoneLength[n/2] + 1;
hailstoneLength[n_?OddQ]:= hailstoneLength[n] = hailstoneLength[3 n + 1] + 1;
Sort[{#, hailstoneLength[#]}& /@ Range[1, 10^6], #1[[2]] > #2[[2]] &][[1]]
|
let rec hailstone_length (n:int64) =
match n with
| 1L -> 1L
| 2L -> 2L
| _ when n%2L=0L -> 1L + hailstone_length (n/2L)
| _ -> 1L + hailstone_length (3L*n+1L)
let euler14 = List.map (fun x -> (x,hailstone_length x)) [2L .. 1000000L] |> List.maxBy (fun x -> snd x)
Binomial[40, 20]
|
let binomial (n:bigint) (k:bigint) =
(List.reduce (*) [1I..n])/(List.reduce (*) [1I..k])/(List.reduce (*) [1I..(n-k)])
let euler15 = binomial 40I 20I
IntegerDigits[2^1000] // Total
|
let euler16 =
let a = BigInteger.Pow (2I, 1000)
a.ToString() |> Seq.toList |> List.map System.Char.GetNumericValue |> List.sum
dict1 = StringLength[{"one", "two", "three", "four", "five", "six",
"seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen",
"fourteen", "fifteen", "sixteen", "seventeen", "eighteen",
"nineteen", "twenty"}];
dict2 = StringLength[{"twenty", "thirty", "forty", "fifty", "sixty",
"seventy", "eighty", "ninety"}];
countNumber[n_] := Module[{},
Which[20 >= n >= 1, dict1[[n]],
100 > n > 20, dict2[[Quotient[n, 10] - 1]] + countNumber[Mod[n, 10]],
1000 > n >= 100, dict1[[Quotient[n, 100]]] +
If[Mod[n, 100] == 0, StringLength["hundred"],
StringLength["hundredand"] + countNumber[Mod[n, 100]]],
n == 1000, StringLength["onethousand"],
n == 0, 0,
True, "out of range"]]
countNumber /@ Range[1, 1000] // Total
|
let dict1 = Array.map String.length [|"one"; "two"; "three"; "four"; "five"; "six"; "seven"; "eight"; "nine"; "ten"; "eleven"; "twelve"; "thirteen";
"fourteen"; "fifteen"; "sixteen"; "seventeen"; "eighteen"; "nineteen"; "twenty"|]
let dict2 = Array.map String.length [|"twenty"; "thirty"; "forty"; "fifty"; "sixty"; "seventy"; "eighty"; "ninety"|]
let rec count_number n =
if 20>=n && n>=1 then dict1.[n-1]
else if 100>n && n>20 then dict2.[(n/10)-2]+ (count_number (n%10))
else if 1000>n && n>=100 then dict1.[n/100-1]+
if (n%100=0) then String.length "hundred"
else String.length "hundredand" + (count_number (n%100))
else if n=1000 then String.length "onethousand"
else if n=0 then 0
else 0
let euler17 = List.map count_number [1..1000] |> List.sum
c = Reverse[{{75}, {95, 64}, {17, 47, 82}, {18, 35, 87, 10}, {20, 4, 82, 47, 65}, {19, 1, 23, 75, 3, 34}, {88, 2, 77, 73, 7, 63, 67},
{99, 65, 4, 28, 6, 16, 70, 92}, {41, 41, 26, 56, 83, 40, 80, 70, 33}, {41, 48, 72, 33, 47, 32, 37, 16, 94, 29}, {53, 71, 44,
65, 25, 43, 91, 52, 97, 51, 14}, {70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57},
{91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48}, {63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31},
{4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23}}];
Fold[ Max /@ (Partition[#1, 2, 1] + #2) &, c[[1]], c[[2 ;;]]]
|
let tw= [[75];
[95; 64];
[17; 47; 82];
[18; 35; 87; 10];
[20; 04; 82; 47; 65];
[19; 01; 23; 75; 03; 34];
[88; 02; 77; 73; 07; 63; 67];
[99; 65; 04; 28; 06; 16; 70; 92];
[41; 41; 26; 56; 83; 40; 80; 70; 33];
[41; 48; 72; 33; 47; 32; 37; 16; 94; 29];
[53; 71; 44; 65; 25; 43; 91; 52; 97; 51; 14];
[70; 11; 33; 28; 77; 73; 17; 78; 39; 68; 17; 57];
[91; 71; 52; 38; 17; 14; 91; 43; 58; 50; 27; 29; 48];
[63; 66; 04; 68; 89; 53; 67; 30; 73; 16; 69; 87; 40; 31];
[04; 62; 98; 27; 23; 09; 70; 98; 73; 93; 38; 53; 60; 04; 23]]
let tw2 = List.rev tw
let crunch (a:int list) (b: int list) =
let rec partition_2_1 x =
match x with
| (a::b::c) -> (max a b)::(partition_2_1 (b::c))
| _ -> []
let temp = partition_2_1 a
List.zip b temp |> List.map (fun (a,b) -> a+b)
let euler18 = List.fold crunch tw2.Head tw2.Tail
<< Calendar`
DayOfWeek /@ (Outer[List, Range[1901, 2000], Range[1, 12], {1}] // Flatten[#, 2] &) // Cases[#, Sunday] & // Length
|
open System
let startDate = new DateTime(1901, 1, 1)
let euler19 = startDate
|> Seq.unfold (fun (x : DateTime) -> Some(x, x.AddMonths(1)))
|> Seq.takeWhile (fun (x : DateTime) -> x.Year < 2001)
|> Seq.filter (fun (x : DateTime) -> x.DayOfWeek = DayOfWeek.Sunday)
|> Seq.length
IntegerDigits[100!] // Total
|
open System.Numerics
let kk = List.reduce (*) [1I..100I]
let integer_digits_2 (n:bigint) =
let rec intdiv (n:bigint) =
match BigInteger.DivRem(n,10I) with
| (a,b) when a=0I -> [b]
| (a,b) -> b::(intdiv a)
List.rev (intdiv n)
let euler20 = integer_digits_2 kk |> List.reduce (+)
amicable[n_] := Module[{ds},
ds[k_] := DivisorSigma[1, k] - k;
ds[ds[n]] == n && ds[n] != n]
Select[Range[2, 10000], amicable] // Total
|
let divisors n =
let rec find_factor acc n_p num =
if num <= n_p then
acc
elif num % n_p = 0 then
find_factor (n_p::acc) (n_p+1) num
else
find_factor acc (n_p + 1) num
find_factor [] 1 n
let divisor_sum n =
List.sum (divisors n)
let amicable n =
let k = divisor_sum n
(divisor_sum k)=n && (k <> n)
let euler21 = List.filter amicable [2..10000] |> List.sum
SetDirectory[NotebookDirectory[]]
data = Import["names.txt", "CSV"] // Flatten;
MapIndexed[First[#2]* Total[(ToCharacterCode[#1] - ToCharacterCode["A"][[1]] + 1)] &, Sort[data]] // Total
|
open System.IO
let euler22 =
let names = File.ReadAllText(@"C:\names.txt").Split([|','|]) |> Array.sort
let char_val (x:char) = 1 + (int x)-(int 'A')
let score (i, (x:string)) =
let t = x.Replace("\"","")
i * (Array.map char_val (t.ToCharArray()) |> Array.sum)
Array.zip [|1..names.Length|] names |> Array.map score |> Array.sum
abundant[x_] := DivisorSigma[1, x] > 2 x
abList = Select[Range[1, 28123], abundant];
isSum[checkList_, x_] :=
If[checkList == {}, False,
If[First[checkList] > x, False,
If[MemberQ[abList, x - First[checkList]], True,
isSum[Rest[checkList], x]]]]
f[sum_, x_] := If[isSum[abList, x], sum, x + sum]
Block[{$IterationLimit = 30000},
Fold[f, 0, Range[1, 28123]]] // Timing
|
let divisors n =
let rec find_factor acc n_p num =
if num <= n_p then
acc
elif num % n_p = 0 then
find_factor (n_p::acc) (n_p+1) num
else
find_factor acc (n_p + 1) num
find_factor [] 1 n
let abundant x =
let sum = Seq.fold (+) 0 (divisors x)
(sum > x)
let euler23 =
let abNumberLookup = [| for i in 0..28123 -> abundant i|]
let abdList = List.filter abundant [1 .. 28123]
let rec isPairOfAb (h::t) x =
if h >= x then false
elif abNumberLookup.[x - h] then true
else isPairOfAb t x
let nonPairOfAb = List.filter (fun i -> not (isPairOfAb abdList i)) [1 .. 28123]
List.reduce (+) nonPairOfAb
Permutations[Range[0, 9]][[1000000]]
|
let factorial n = List.reduce (*) [1..n]
let divrem n r = (n/r,n%r)
let rec perm (n:int) (s:string) =
if s.Length = 1 then s
else
let (q, r) = divrem n (factorial (s.Length - 1))
s.[q].ToString() + perm r (s.[..(q-1)]+s.[(q+1)..])
let euler24 = perm 999999 "0123456789"
NestWhile[(# + 1) &, 0, Length[IntegerDigits[Fibonacci[#]]] < 1000 &]
|
open System.Numerics
let euler25 = ((1I,1I)|> Seq.unfold (fun (a,b) -> if(a > BigInteger.Pow(10I, 999I)) then None else Some(a+b, (b,a+b))) |> Seq.length)+1
lst = Table[Length@First@Flatten[RealDigits[1/i], 1], {i, 1, 999}];
Position[lst, Max@lst]
|