xây dựng mảng danh sách

Jan 16 2021

Tôi muốn tạo danh sách ix={1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4}

tôi có thể làm

L=4;
ix = ConstantArray[0, Length[L]^2]
k = 0;
For[i = 1, i <= Length[ix], i++, If[Mod[i, L] == 1, k = k + 1, k]; ix[[i]] = k;]

ix
(* output *)
{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}

Nhưng tôi không thích nó. Có cách nào khác "Mathematica" để làm điều đó không?

Trả lời

20 SimonWoods Jan 16 2021 at 19:23

Như bạn thấy từ các nhận xét và câu trả lời, cách tự nhiên để làm điều đó trong Mathematica là tạo một mảng 2D và sau đó làm phẳng nó. Một vài ví dụ khác về cách tiếp cận đó:

Flatten[Table[i, {i, 4}, 4]]

Flatten[Array[# &, {4, 4}]]

Đối với trường hợp cụ thể này, bạn cũng có thể làm điều gì đó như:

Ceiling[Range[16]/4]
13 bills Jan 17 2021 at 01:23

Bạn cũng có thể hiểu đây là một sản phẩm bên ngoài:

Outer[Times, Range[4], ConstantArray[1, 4]] // Flatten
{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}
12 kglr Jan 16 2021 at 22:29

Bạn cũng có thể sử dụng dạng 4 đối số của Array:

Array[# &, {4, 4}, 1, Flatten @* List]
{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}
Array[Range @ 4 &, 4, 1, Sort @* Join]
{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}
Array[{1, 0, 0, 0} &, 4, 1, Accumulate @* Join]
{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}

Và một số phương pháp bổ sung:

Round[1/2 + 6 Range[16]/25]

Sort @ Mod[Range @ 16, 4, 1]

Join @@ Table @@@ Table[{i, 4}, {i, 4}]

1 + ⌊Most @ Subdivide[4, 16]⌋

Join @@ Accumulate @ Table[1, 4, 4]

Accumulate @ Upsample[{1, 1, 1, 1}, 4] (*thanks: Simon Woods *)

⌈ArrayResample[Range@4, 16, {"Bin", 1}]⌉

Internal`RepetitionFromMultiplicity @ Thread[{Range @ 4, 4}]
10 CATrevillian Jan 16 2021 at 18:44

Điều này sử dụng một chức năng ẩn danh song song với ConstantArrayRangeđể làm những gì bạn muốn:

ConstantArray[#,4]&/@Range@4//Flatten

{1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4}

7 wuyudi Jan 17 2021 at 13:53

Cách khác:

Quotient[Range@16, 4, -3]

{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}

7 user1066 Jan 16 2021 at 22:12

Riffle / Nest

Range[4]//Nest[Riffle[#,#]&,#,2]& 

Ngoài ra:

Range[4]//Riffle[#,#]&//Riffle[#,#]&

{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}

BitShiftRight

Sau Ceiling phương pháp gọn gàng của Simon Woods:

1+Table[BitShiftRight[n,2], {n, 0, 15}]

Ngoài ra:

1+BitShiftRight[#,2]&@Range[0,15]

IntegerPart

Từ tài liệu cho BitShiftRight-> Chi tiết và mối quan hệ giữa BitShiftRightIntegerPart:

1+IntegerPart@Table[n/4, {n, 0, 15}]

Ngoài ra:

1+IntegerPart[Range[0,15]/4]

Các trường hợp

Cases[Range[4], x_:> Splice@{x,x,x,x}]

(Nguyên văn một bình luận)

6 wxffles Jan 18 2021 at 04:00
CoefficientList[Series[x^4/((1 - x) (1 - x^4)), {x, 0, 19}], x][[5 ;;]]

.

LinearRecurrence[{1, 0, 0, 1, -1}, {1, 1, 1, 1, 2}, 16]

.

Table[Length@IntegerPartitions[k - 1, All, {1, 4}], {k, 16}]
5 MichaelE2 Jan 18 2021 at 05:28

Một vài điều nữa:

PadRight[{Range@4}\[Transpose], {4, 4}, "Fixed"] // Flatten
Outer[# &, #, #] &@Range@4 // Flatten

Cập nhật - Những cái bổ sung:

Range[4] SparseArray[{}, {4, 4}, 1] // Flatten
With[{p = ConstantArray[1, 4]},
  SparseArray[{Band[p] -> 1}, Length[p] p]@"NonzeroPositions" // Flatten
  ]
TensorProduct[Range@4, ConstantArray[1, {4}]] // Flatten
3 SneezeFor16Min Jan 29 2021 at 02:34

Đề xuất:

Quotient[Range[4, 19], 4] (* ~1.759μs *)

Điểm chuẩn

Quotient[Range@16, 4, -3] (* ~2.554μs *)
Outer[Times, Range[4], ConstantArray[1, 4]] // Flatten (* ~2.573μs *)

Internal`RepetitionFromMultiplicity @ Thread[{Range @ 4, 4}] (* ~3.498μs *)
Flatten@Transpose@ConstantArray[Range@4, 4] (* ~3.527μs *)
Flatten[ConstantArray[Range[4], 4], {2, 1}] (* ~3.701μs *)
Flatten[Table[i, {i, 4}, 4]] (* ~3.919μs *)
Range[4]//Riffle[#,#]&//Riffle[#,#]& (* ~3.928μs *)

1+BitShiftRight[#,2]&@Range[0,15] (* ~4.191μs *)
Range[4]//Nest[Riffle[#,#]&,#,2]& (* ~4.411μs *)
Array[{1, 0, 0, 0} &, 4, 1, Accumulate @* Join] (* ~4.747μs *)

Sort@Mod[Range@16, 4, 1] (* ~5.506μs *)
Array[Range @ 4 &, 4, 1, Sort @* Join] (* ~5.655μs *)
Range[4] SparseArray[{}, {4, 4}, 1] // Flatten (* ~5.853μs *)
Outer[# &, #, #] &@Range@4 // Flatten (* ~5.974μs *)

Join @@ Accumulate @ Table[1, 4, 4] (* ~6.300μs *)
Flatten[Array[# &, {4, 4}]] (* ~6.833μs *)

PadRight[{Range@4}\[Transpose], {4, 4}, "Fixed"] // Flatten (* ~7.013μs *)
Join @@ Table @@@ Table[{i, 4}, {i, 4}] (* ~7.589μs *)

Cases[Range[4], x_:> Splice@{x,x,x,x}] (* ~8.041μs *)
Array[# &, {4, 4}, 1, Flatten @* List] (* ~8.519μs *)

1+Table[BitShiftRight[n,2], {n, 0, 15}] (* ~9.554μs *)

ConstantArray[#,4]&/@Range@4//Flatten (* ~10.058μs *)
Ceiling[Range[16]/4] (* ~11.210μs *)
1 + ⌊Most @ Subdivide[4, 16]⌋ (* ~13.635μs *)
1+IntegerPart@Table[n/4, {n, 0, 15}] (* ~18.513μs *)
TensorProduct[Range@4, ConstantArray[1, {4}]] // Flatten (* ~18.924μs *)
Round[1/2 + 6 Range[16]/25] (* ~22.859μs *)
Table[Length@IntegerPartitions[k - 1, All, {1, 4}], {k, 16}] (* ~58.000μs *)

Accumulate @ Upsample[{1, 1, 1, 1}, 4] (* ~194.7μs with 6k runs *)
LinearRecurrence[{1, 0, 0, 1, -1}, {1, 1, 1, 1, 2}, 16] (* ~336.2μs with 5k runs *)
CoefficientList[Series[x^4/((1 - x) (1 - x^4)), {x, 0, 19}], x][[5 ;;]] (* ~529.7μs with 18k runs *)

⌈ArrayResample[Range@4, 16, {"Bin", 1}]⌉ (* ~1620μs with 1k runs *)

Mỗi lần lặp lại 30k lần trừ khi có quy định khác. Người ta có thể kết luận rằng, trong Mathematica ,

  • đại số đơn giản thường hoạt động nhanh hơn
  • nhiều đối số được chỉ định $\neq$ nhanh hơn
  • / sự phân chia kéo, so với Quotient
  • hoạt động bit không nhanh như trong C
  • /@chậm, nếu @có thể lây lan
  • ...
1 Roman Jan 19 2021 at 00:29
f[x_] = InterpolatingPolynomial[{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}, x] // Expand
(*    8256 - x*536645091/20020 + x^2*1798275487/48510 -
      x^3*128580216461/4365900 + x^4*25293360053/1663200 -
      x^5*8745144029/1603800 + x^6*768388933/544320 -
      x^7*315030731/1166400 + x^8*92080313/2381400 -
      x^9*237559139/57153600 + x^10*30277/90720 -
      x^11*50569/2566080 + x^12*12427/14968800 -
      x^13*27557/1167566400 + x^14*17/41912640 - x^15/314344800    *)

Array[f, 16]
(*    {1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}    *)