F＃：文件解析

这是我在这个网站上的第一篇文章:-)我正在学习F＃。为此，我尝试解决欧拉问题（http://projecteuler.net/）。在第11题（http://projecteuler.net/problem=11），完成第一个任务就是解析包含该20×20个网格中的文件：F＃：文件解析

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

我写了这个代码解析的文件，我试图做一个“功能“ 办法。它的工作原理，但我觉得它有点复杂相比，我可以写在C＃：

open System 
open System.IO 

let readLines = 
    seq { 
     use sr = new StreamReader("Input.txt") 
     while not sr.EndOfStream do 
      yield sr.ReadLine() 
    } |> Seq.zip (Seq.ofList [0..19]) 

let parseLine tupleLine = 
    let (index:int, line:string) = tupleLine 
    line.Split([| ' ' |]) 
    |> Array.map(fun s -> Int32.Parse(s)) 
    |> Seq.zip [| 0 .. 19 |] 
    |> Seq.map (fun tl -> (index, fst tl, snd tl)) 

let tabNumbers = Array.create 400 0 

let fillArray tupleNumber = 
    let (line, column, number) = tupleNumber 
    tabNumbers.[20 * line + column] <- number 

readLines 
|> Seq.map parseLine 
|> ignore

有没有一种简单的方法来实现这一点？提前谢谢！

PS：对不起我的英文不好...

来源

2011-11-01 schglurps

也许你不应该这样做基于行，而是分裂每个空白字符。 – 2011-11-01 11:59:21

你的英语不错。（La seule'faute'c'est de mettre des espaces avant les'：？！'）PS。 as-tu vu http://french.stackexchange.com？ – Benjol

这是你的代码的相应版本：

let readLines = 
    "Input.txt" 
    |> File.ReadAllLines 
    |> Array.mapi (fun i line -> (i, line)) 

let parseLine (i, line) = 
    line.Split([|' '|]) 
    |> Array.mapi (fun j s -> i, j, Int32.Parse(s))

或者你可以结合他们有一个更简洁的版本：

let readAll = 
    "Input.txt" 
    |> File.ReadAllLines 
    |> Array.mapi (fun i line -> line.Split([|' '|]) 
           |> Array.mapi (fun j s -> i, j, Int32.Parse(s)))

来源

2011-11-01 12:21:44 pad

感谢您的回答，并感谢Array.mapi功能！你的解决方案比我的更干净清晰！编辑：我想说你的答案是有用的，但我没有enoiugh声望做到这一点... – schglurps

这样做了，我投了你的答案！ :-) – schglurps

F＃：文件解析

回答

相关问题