xây dựng mảng danh sách
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
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]
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}
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}]
Điều này sử dụng một chức năng ẩn danh song song với ConstantArray
và Range
để 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}
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}
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 BitShiftRight
và IntegerPart
:
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)
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}]
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
Đề 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ớiQuotient
- hoạt động bit không nhanh như trong C
/@
chậm, nếu@
có thể lây lan- ...
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} *)