2016-07-26 64 views
2

是否有构造二维数组的简写方法?是否有构造二维数组的简写方法?

我真的不希望做到以下几点:

let board = array2D [| 
         [| 0;0 |] 
         [| 0;1 |] 
         [| 0;2 |] 
         [| 0;3 |] 
         [| 0;4 |] 
         [| 0;5 |] 
         [| 0;6 |] 
         [| 0;7 |] 
         [| 1;0 |] 
         [| 1;1 |] 
         [| 1;2 |] 
         ... 
         [| 7;7 |] 
        |] 

我想我可以做这样的事情:

let board = array2D [| 
         [| 0;0 |]..[|7;7|] 
        |] 

或者这样:

let board = array2D [| 
         [| 0.., 0..7 |] 
        |] 

任何指导意见?

+1

是不是有你想要的东西之间的错误和你写的是什么?这里的板子是一个有64个“行”和2个“列”的2D数组;也许你希望它是一个8x8的网格呢? – Sehnsucht

+1

@Sehnsucht:我想这也是大多数人想要的,因此我的答案。但是,他可能需要64x2网格(提供了正确的答案)。 –

回答

6

也许你需要的是理解:

array2D [for i in 0..7 do for j in 0..7 do yield [|i;j|] ] 

这将返回似乎是你想要的顺序你想要的:

val it : int [,] = [[0; 0] 
        [0; 1] 
        [0; 2] 
        [0; 3] 
        [0; 4] 
        [0; 5] 
        [0; 6] 
        [0; 7] 
        [1; 0] 
        [1; 1] 
        [1; 2] 
        [1; 3] 
        [1; 4] 
        [1; 5] 
        [1; 6] 
        [1; 7] 
        [2; 0] 
        [2; 1] 
        [2; 2] 
        [2; 3] 
        [2; 4] 
        [2; 5] 
        [2; 6] 
        [2; 7] 
        [3; 0] 
        [3; 1] 
        [3; 2] 
        [3; 3] 
        [3; 4] 
        [3; 5] 
        [3; 6] 
        [3; 7] 
        [4; 0] 
        [4; 1] 
        [4; 2] 
        [4; 3] 
        [4; 4] 
        [4; 5] 
        [4; 6] 
        [4; 7] 
        [5; 0] 
        [5; 1] 
        [5; 2] 
        [5; 3] 
        [5; 4] 
        [5; 5] 
        [5; 6] 
        [5; 7] 
        [6; 0] 
        [6; 1] 
        [6; 2] 
        [6; 3] 
        [6; 4] 
        [6; 5] 
        [6; 6] 
        [6; 7] 
        [7; 0] 
        [7; 1] 
        [7; 2] 
        [7; 3] 
        [7; 4] 
        [7; 5] 
        [7; 6] 
        [7; 7]] 
6

Ringil的答案是更正确的(对于你问的)。但是,如果你是一个稍微不同的阵列状寻找另一种方式,你可以做到以下几点:

您可以使用Array2D.init

> let board = Array2D.init 8 8 (fun x y -> (x,y));; 

val board : (int * int) [,] = 
    [[(0, 0); (0, 1); (0, 2); (0, 3); (0, 4); (0, 5); (0, 6); (0, 7)] 
    [(1, 0); (1, 1); (1, 2); (1, 3); (1, 4); (1, 5); (1, 6); (1, 7)] 
    [(2, 0); (2, 1); (2, 2); (2, 3); (2, 4); (2, 5); (2, 6); (2, 7)] 
    [(3, 0); (3, 1); (3, 2); (3, 3); (3, 4); (3, 5); (3, 6); (3, 7)] 
    [(4, 0); (4, 1); (4, 2); (4, 3); (4, 4); (4, 5); (4, 6); (4, 7)] 
    [(5, 0); (5, 1); (5, 2); (5, 3); (5, 4); (5, 5); (5, 6); (5, 7)] 
    [(6, 0); (6, 1); (6, 2); (6, 3); (6, 4); (6, 5); (6, 6); (6, 7)] 
    [(7, 0); (7, 1); (7, 2); (7, 3); (7, 4); (7, 5); (7, 6); (7, 7)]] 

我会在这里的情况下,任何人离开这个发现它有用,因为我认为这种数据形状在许多情况下是有意义的。