Д>Пинайте сколько угодно, приемлю любую критику.

let rec dig (v, i) = if i = 0 then v % 10 else dig(v/10, i-1)

let isPoly x =
    let rec count (v, n) =
        if v < 10 then n
        else count (v/10, n+1)
    let c = count (x, 0)
    Seq.for_all (fun i -> dig(x, i) = dig(x, c-i)) { 0 .. c / 2 }

let problem4 min max =
    seq { for i in max .. -1 .. min do
          for j in i .. -1 .. min do 
          yield (i * j) }
    |> Seq.filter isPoly
    |> Seq.max

Д>>Пинайте сколько угодно, приемлю любую критику.

isPoli n = fs == reverse fs
    where fs = show n

solution n = maximum [i*j | i <- [1..n], j <- [i..n], isPoli i*j]

main = print $ solution 999

>./ (#~ (-:|.&.":)"0) , */~ i.999

>./ (#~ (-:|.&.":)"0) , */~ i.999

|/x@&x=0$|:'$x:,/x*/:x:!1000

Q>|/x@&x=0$|:'$x:,/x*/:x:!1000
Q>

>./(#~(-:|.&.":)"0),*/~i.999

Д>>>Пинайте сколько угодно, приемлю любую критику.

А>isPoli n = fs == reverse fs
А>    where fs = show n

А>solution n = maximum [i*j | i <- [1..n], j <- [i..n], isPoli i*j]

А>main = print $ solution 999
А>

let filter s = List.rev (Seq.to_list s) = (Seq.to_list s)
printfn "%d" ((seq { for i in [100 * 100..999 * 999] do if filter (i.ToString()) then yield i }) |> Seq.fold(max) 0)

let naturalNumbersBelow limit = {1..limit-1}
let naturalMultiplesOf3Or5Below limit = naturalNumbersBelow limit |> Seq.filter(fun v -> v % 3 = 0 || v % 5 = 0)
let sumOfAllTheMultiplesOf3Or5Below limit = naturalMultiplesOf3Or5Below limit |> Seq.fold (fun a b -> a + b) 0
let sumOfAllTheMultiplesOf3Or5Below1000 = sumOfAllTheMultiplesOf3Or5Below 1000
print_any sumOfAllTheMultiplesOf3Or5Below1000

printfn "%d" ([1 .. 3 .. 999] @ [1 .. 5 .. 999]  |> Seq.fold (+) 0 )

Y>Человек же сказал, что только учился F# (я тоже этим сейчас занят )

>./,(0:`([*])@.((-:|.)@:":@*))"0/~ (+(i.@(1000&-))) 100

>./ , (* (-:|.)@":)@*/~ 100+i.900

Y>let filter s = List.rev (Seq.to_list s) = (Seq.to_list s)
Y>printfn "%d" ((seq { for i in [100 * 100..999 * 999] do if filter (i.ToString()) then yield i }) |> Seq.fold(max) 0)
Y>

printfn "%A" <| Seq.max (seq{
        for i in 10 .. 999 do
            for j in i .. 999 do
                let ps = (i*j).ToString().ToCharArray()
                if Array.forall2 (=) ps (Array.rev ps) then yield i*j }

maximum [p | i <- [100..999], j <- [i..999], let (p,ps) = (i*j,show p), ps == reverse ps]

Y>>printfn "%d" ([1 .. 3 .. 999] @ [1 .. 5 .. 999]  |> Seq.fold (+) 0 )
Y>>

S>Можно-то можно. Ответ совпал?

printfn "%d" ([0 .. 3 .. 999] @ [0 .. 5 .. 999]  |> Seq.fold (+) ([0 .. 15 .. 999] |> Seq.fold (-) 0))

printfn "%d" (([0 .. 3 .. 999] @ [0 .. 5 .. 999]  |> Seq.sum) -  ([0 .. 15 .. 999] |> Seq.sum))

>>./(#~(-:|.&.":)"0),*/~i.999
А>

>./(*(-:|.)@":"0),*/~i.1e3

>>>./(#~(-:|.&.":)"0),*/~i.999
А>>

>./,(*(-:|.)@":)@*/~i.1e3

A contributor to the J forum recently made the point that for J aficionados, J phrases can become a more natural medium for expressing ideas than any natural language equivalent.

Д>Пинайте сколько угодно, приемлю любую критику.

let powerValue = 5I
 
let answer =
    let maxValue d = (pow 10I d) - 1I
    let maxDigits =
        {for d in 1I..10I -> (d, maxValue d, d * pow 9I powerValue)} |>
        Seq.first (fun (d, value, sum) ->
            if value > sum then Some(d) else None) |> Option.get
    {10I .. maxValue maxDigits} |> Seq.filter (fun v ->
        v = (v.ToString() |>
             Seq.map (fun d -> int(d)-int('0')) |>
             Seq.map (fun d -> pow (bigint.FromInt32(d)) powerValue) |>
             Seq.fold (+) 0I)) |>
    Seq.fold (+) 0I
    
print_any answer

let solve n =
    let pows = [| for i in 0 .. 9 -> pown i n |]
    let list = new ResizeArray<int>()
    
    let rec test i x s =
        let rec loop j =
            if j < pows.Length then test (i+1) (10*x+j) (s+pows.[j]); loop (j+1)
        if i <= n then loop 0
        elif x = s && s > 1 then list.Add(s);
    
    test 0 0 0; list |> Seq.sum

printfn "problem30 = %d" (solve 5)

let digits =
    let rec digs l = function 0 -> list | x -> digs (x % 10::l) (x/10)
    digs List.empty   

let test y n  =
    let sum = digits n |> List.map (fun x -> pown x y) |> List.sum
    n = sum

seq { 2..1000000 } |> Seq.filter (test 5) |> Seq.sum |> printfn "%d"

П>let solve n =
П>    let pows = [| for i in 0 .. 9 -> pown i n |]
П>    let list = new ResizeArray<int>()
    
П>    let rec test i x s =
П>        let rec loop j =
П>            if j < pows.Length then test (i+1) (10*x+j) (s+pows.[j]); loop (j+1)
П>        if i <= n then loop 0
П>        elif x = s && s > 1 then list.Add(s);
    
П>    test 0 0 0; list |> Seq.sum
П>

let solve2 p =
    let digits = [0..9]
    let pows = [| for i in 0 .. 9 -> pown i p |]
    
    let rec loop n c ds sum =
        if c > p then 
            if n = ds then 
                printfn "%d" n
                sum + n 
            else sum
        else
            digits |> List.fold (fun s d -> loop (n*10 + d) (c+1) (ds + pows.[d]) s) sum
    loop 0 0 0 -1

• Скорее всего, выложенный ProjectEuler.sln не будет открываться с установленной VS Integration для Nemerle, так как я с ним работал больше года назад. Но код самих решений должен компилироваться.
  
• Каждое решение находится в отдельном файле с именем вида "TaskXXX.n", где XXX — номер задачи. Также собственно код решения всегда находится в методе класса-наследника TaskBase — мне так было удобней их потом запускать.
  
• Иногда в коде используется класс Oyster.Math.IntX — это мой класс для работы с целыми неограниченной точности, скачать можно тут: http://intx.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=10694.
  
• Подсветки кода нет, потому что Google Code не хочет подсвечивать файлы с расширением *.n и я не знаю, можно ли его настроить так, чтобы он подсвечивал код так же, как код C# (файлы *.cs).