सूची-सरणी निर्माण

Jan 16 2021

मैं सूची बनाना चाहता हूं ix={1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4}

मैं कर सकता हूँ

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}

लेकिन मुझे यह पसंद नहीं है। क्या ऐसा करने के लिए एक और "मैथमेटिका" है?

जवाब

20 SimonWoods Jan 16 2021 at 19:23

जैसा कि आप टिप्पणियों और उत्तरों से देखते हैं, गणितज्ञों में इसे करने का स्वाभाविक तरीका एक 2D सरणी बनाना और फिर उसे समतल करना है। उस दृष्टिकोण के कुछ और उदाहरण:

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

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

इस विशिष्ट मामले के लिए आप कुछ ऐसा भी कर सकते हैं:

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

आप इसे बाहरी उत्पाद के रूप में भी व्याख्या कर सकते हैं:

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

आप 4-तर्क फॉर्म का भी उपयोग कर सकते हैं 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}

और कुछ अतिरिक्त तरीके:

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

इस के साथ मिलकर एक अनाम फ़ंक्शन का उपयोग करता है ConstantArrayऔर Rangeवह करना चाहता है जो आप चाहते हैं:

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

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

7 wuyudi Jan 17 2021 at 13:53

एक और तरीका:

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

राइफल / नेस्ट

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

वैकल्पिक रूप से:

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

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

बिटशिफ्टर

साइमन वुड्स द्वारा साफ Ceiling तरीके के बाद :

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

वैकल्पिक रूप से:

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

इंटेगरपार्ट

के लिए दस्तावेज़ से BitShiftRight-> विवरण , और के बीच संबंधों को BitShiftRightऔर IntegerPart:

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

वैकल्पिक रूप से:

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

मामलों

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

(मूल रूप से एक टिप्पणी)

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

कुछ और:

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

अद्यतन - अतिरिक्त वाले:

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

सिफारिश:

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

बेंचमार्क

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 *)

प्रत्येक 30k बार दोहराया जब तक अन्यथा नहीं कहा गया। कोई यह निष्कर्ष निकाल सकता है कि, गणितज्ञ में ,

  • साधारण बीजगणित आम तौर पर तेजी से काम करता है
  • अधिक तर्क निर्दिष्ट $\neq$ और तेज
  • / की तुलना में विभाजन drags Quotient
  • बिट ऑपरेशंस उतने तेज़ नहीं हैं जितने कि वे C में हैं
  • /@धीमा है, अगर @फैल सकता है
  • ...
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}    *)