एक रगड़ सरणी सरणी

Question

रैग्ड ऐरे एक ऐसा ऐरे है जहाँ प्रत्येक एलीमेंट अज्ञात संख्या के पॉजिटिव पूर्णांकों की एक सरणी है।

उदाहरण के लिए, निम्नलिखित रैग्ड एरे हैं:

[[1,2,3],[4],[9,10]]               Shape:  3,1,2
[[1],[2],[3]]                      Shape:  1,1,1
[[1,2,3,4,5,6,8]]                  Shape:  7

निम्नलिखित रैग्ड एरे नहीं हैं :

[1]   Each element will be an array
[]    The array will contain at least 1 element
[[1,2,3],[]]  Each subarray will contain at least 1 integer

आपको एक रैग्ड सरणी इनपुट करने की आवश्यकता है, और पूर्णांक के साथ एक रैग्ड सरणी लौटाएं

• आउटपुट सरणी का इनपुट सरणी के समान आकार होना चाहिए । हम सरणी के आकार को प्रत्येक उपखंड की लंबाई के रूप में परिभाषित करते हैं ।
• प्रत्येक पूर्णांक में प्रत्येक संभावित स्थान पर प्रदर्शित होने के लिए समान रूप से संभावना होनी चाहिए।
• आप मान सकते हैं कि आपकी भाषा बिल्ट-इन यादृच्छिक है।

उदाहरण के लिए, यदि मैं इसमें पास हुआ [[4],[1,2,3],[4]], तो [[1],[4,4,2],[3]]एक मान्य आउटपुट होगा, लेकिन होगा [[4,1,3],[3],[4]]या [[4],[4],[1,2,3]]नहीं।

Comments

सम्बंधित।

— मार्टिन एंडर

क्या इनपुट हमेशा एक 2D सरणी होगा?

— डेनिस

Answer 1

जेली, जेली के कोडपेज में 3 बाइट्स

FẊṁ

स्पष्टीकरण:

FẊṁ
F    flatten list
 Ẋ   shuffle the output from the previous line
  ṁ  unflatten the list, shaping it like…

क्योंकि प्रोग्राम अधूरा है ( ṁदूसरा तर्क नहीं दिया गया है), डिफ़ॉल्ट प्रोग्राम इनपुट का उपयोग करना है; इस प्रकार ṁइनपुट के रूप में आउटपुट में समान सबलिस्ट पैटर्न होता है।

इसे ऑनलाइन आज़माएं!

Comments

वाह, अनफ्लैट एक साफ और अप्रत्याशित कमांड है।

— मैजिक ऑक्टोपस Urn

अनफ्लैटटेन सबसे अच्छा शब्द नहीं हो सकता है क्योंकि बाएं तर्क को सपाट होना नहीं है। महामारी ढालना है ।

— डेनिस

@ डेनिस: इसका मतलब यह है कि यह इस चुनौती के लिए सही ढंग से काम नहीं करेगा कि एक इनपुट रैग्ड एरे पर जिसमें पूर्णांक के बजाय तत्वों के रूप में सूचियां निहित थीं (क्योंकि यह अंदर की सूचियों को पहले ही समतल कर देगा)? यह थोड़ा निराशाजनक है, आप उम्मीद करेंगे कि यह उस प्रकार की परवाह किए बिना काम करेगा जो रैग्ड सरणी में था। (अपडेट: मैं जाँच की है, ऐसा लगता है कि दोनों Fऔर ṁसपाट ही नहीं, एक की कई परतों के लिए काम करते हैं।)

मेरा मतलब है कि बायां तर्क ṁकुछ भी हो सकता है, न कि केवल एक फ्लैट सूची। उदाहरण के लिए: tio.run/nexus/jelly#@/9wZ@P///@jow11FIxidRSijXUUTEC0qY6CWWs/…

— डेनिस

ओह, मुझे लगता है कि एक unflatten ऑपरेशन कॉल करेंगे; बाएं तर्क को एक फ्लैट सूची के रूप में माना जा रहा है (बस यह तत्वों के रूप में सूचियों को शामिल करने के लिए होता है, लेकिन उन तत्वों को अपारदर्शी के रूप में व्याख्या किया जा रहा है)। वास्तव में, मुझे संदेह है कि हम इस बात पर सहमत हैं कि किस चीज से असहमत होना है, लेकिन इस बात से असहमत हैं कि क्या है ...

Answer 2

PowerShell v2 +, 86 बाइट्स

param($n)$a=$n-split'[^\d]'-ne''|sort{random};-join($n-split'\d+'-ne''|%{$_+$a[$i++]})

स्ट्रिंग हेरफेर के माध्यम से काम करता है। इनपुट को एक स्ट्रिंग के रूप में पास किया जाता है जो सरणी का प्रतिनिधित्व करता है, आपकी भाषा के लिए जो भी प्रारूप काम करता है । ;-)

-splitगैर-अंकों पर इनपुट को बाहर निकालें, sortउन्हें randomस्क्रिप्ट ब्लॉक पर आधारित करें (जो कि प्रत्येक इनपुट के लिए एक अलग यादृच्छिक वजन असाइन करेगा), जो इसमें संग्रहीत करता है $a। हम फिर splitसे इनपुट करते हैं, इस बार अंकों पर, और प्रत्येक एक आउटपुट के लिए वर्तमान मूल्य (आमतौर पर कोष्ठक और अल्पविराम) स्ट्रिंग-कंक्रीनेट से इसी संख्या के साथ $a। यह -joinएक साथ एक स्ट्रिंग में वापस एड है, और आउटपुट निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "@(@(1,2,3),4)"
@(@(3,2,1),4)

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "@(@(1,2,3),4)"
@(@(1,2,4),3)

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[4],[1,2,3],[4]]"
[[4],[2,4,3],[1]]

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[10],[1,2,3],[5]]"
[[10],[5,2,1],[3]]

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[10],[1,2,3],[5]]"
[[5],[10,2,1],[3]]

Answer 3

पायथन 2 , 89 बाइट्स

from random import*
x=input();r=sum(x,[]);shuffle(r)
print[[r.pop()for _ in t]for t in x]

इसे ऑनलाइन आज़माएं!

Comments

मैं अजगर को अच्छी तरह से नहीं जानता, लेकिन क्या तुम नहीं कर सकते थे shuffle(r=sum(x,[]))?

— कॉनर ओ'ब्रायन

नहीं, जगह में फेरबदल करना और कोई नहीं लौटना ।

— डेनिस

Answer 4

जावास्क्रिप्ट (ईएस 6), 78 75 बाइट्स

x=>x.map(y=>y.map(z=>+s.splice(Math.random()*s.length,1)),s=eval(`[${x}]`))

यह पहली बार है जब मैं .splice()एक कोड-गोल्फ चुनौती का उपयोग कर याद कर सकता हूं ...

आप पहले से सरणी को फेरबदल करके दो बाइट को गोल्फ से बाहर कर सकते हैं:

x=>x.map(y=>y.map(z=>s.pop()),s=eval(`[${x}]`).sort(_=>Math.random()-.5))

हालाँकि, यह अंतिम पूर्णांक पहले समय का बहुमत लगाता है, इसलिए मैं यह मानने जा रहा हूं कि पूर्णांक समान रूप से वितरित नहीं हैं।

Comments

"आप मान सकते हैं कि आपकी भाषा का अंतर्निहित यादृच्छिक यादृच्छिक है।"

— कॉनर ओ'ब्रायन

@ ConorO'Brien "प्रत्येक पूर्णांक को प्रत्येक संभावित स्थान पर प्रदर्शित होने के लिए समान रूप से संभावना होनी चाहिए।"

— ETHproductions

sortअसंगत तुलना कुंजी दिए जाने पर ठीक से काम नहीं करता है। यहां तक ​​कि अगर भाषा की यादृच्छिकता यादृच्छिक है, तो इसकी तरह इस स्थिति में खराबी होगी, और यही वह पूर्वाग्रह है जो आप देख रहे हैं। जैसे, मुझे लगता है कि दूसरा समाधान गलत है।

Answer 5

रूबी, 47 बाइट्स

->a{b=a.flatten.shuffle;a.map{|x|x.map{b.pop}}}

Answer 6

ब्रेकीलॉग , 17 बाइट्स

c@~P,?:{l~l}a.cP,

इसे ऑनलाइन आज़माएं!

व्याख्या

हम मूल रूप से इनपुट के रूप में समान "आकार" वाले उपादानों की एक सूची बनाते हैं, और फिर बताते हैं कि यदि हम सब कुछ एक सूची में समेटते हैं, तो इसका परिणाम एकल सूची में इनपुट के संघटन के फेरबदल के रूप में होना चाहिए। ।

c@~P,                 Concatenate the Input into a single list. Shuffle it and call that P.
     ?:{   }a.        The Output is the result of applying this to each element of the input:
        l~l               The Output is a list of same length as the Input.    
             .cP,     P is the concatenation of the sublists of the Output.

Answer 7

पर्ल, 37 बाइट्स

कोड + -pध्वज के 36 बाइट्स ।

@n=/\d+/g;s/\d+/splice@n,rand@n,1/ge

इसे चलाने के लिए:

perl -pE '@n=/\d+/g;s/\d+/splice@n,rand@n,1/ge' <<< "[[4],[1,2,3],[4]"

स्पष्टीकरण:

@ एन = / डी + / जी # सभी पूर्णांक @ एन में स्टोर करें
s / \ d + / # के साथ प्रत्येक पूर्णांक को बदलें ...
splice @ n, rand @ n, 1 / ge # @ की यादृच्छिक स्थिति में एक तत्व (जो @n से हटा दिया गया है)

Answer 8

05AB1E , 17 बाइट्स

˜.r¹vDyg£DˆgF¦}}¯

˜                 Unflatten input
 .r               tmp = shuffle(flattened_input)
   ¹v             For each sub-array
     Dyg£         Take the first length(current_array) elements from tmp
         Dˆ       Append the result to a global array
           gF¦}   Remove the first elements from tmp
               }  End for
                ¯ Display the global array

इसे ऑनलाइन आज़माएं!

मैं 05AB1E या 2sable समाधान का इंतजार कर रहा हूं, जिसमें कुछ अप्रभावी / मोल्डिंग का उपयोग करके अंतर्निहित मैं अभी तक नहीं जानता :)।

Answer 9

एपीएल, 35 बाइट्स

मैं मुश्किल से पर्ल को भी पीट रहा हूं, मुझे याद आ रहा है।

{Z[?⍨⍴Z]⊂⍨(⍳⍴Z←∊⍵)∊⊃¨{⍵+⊃⌽⍺}\⍳¨⍴¨⍵}

उदाहरण के लिए:

      {Z[?⍨⍴Z]⊂⍨(⍳⍴Z←∊⍵)∊⊃¨{⍵+⊃⌽⍺}\⍳¨⍴¨⍵}(1 2 3)(,4)(9 10)
┌──────┬─┬───┐
│10 3 2│1│9 4│
└──────┴─┴───┘

स्पष्टीकरण:

• एक समतल सरणी में उप-सरणियों के प्रारंभ के संबंधित सूचकांकों का पता लगाएं:
  • ⍳¨⍴¨⍵: प्रत्येक उप-सरणी के लिए, सूचकांकों की एक सूची प्राप्त करें
  • {⍵+⊃⌽⍺}\: पहले उप-सरणी से शुरू करते हुए, अगले सरणी में प्रत्येक मान में अंतिम मान जोड़ें।
  • ⊃¨: सरणियों का पहला आइटम प्राप्त करें, जो शुरुआती स्थान हैं
  • (⍳⍴Z←∊⍵)∊: चपटा सरणी स्टोर में Z। एक बिट-वेक्टर उत्पन्न करें जहां लोग उन स्थानों को चिह्नित करते हैं जहां उप-सरणियां शुरू होनी चाहिए।
• चपटे सरणी को समतल करें:
  • ?⍨⍴Z: का एक यादृच्छिक क्रमांकन उत्पन्न करते हैं Z।
  • Z[... ]: परमिट Z।
• ⊂⍨: बिट-वेक्टर के अनुसार उप-सरणियों में क्रमचय को विभाजित करें।

Comments

आप इन-प्लेस प्रतिस्थापन कर सकते हैं। असाइनमेंट ने आपको चर को समतल करने की अनुमति दी:A⊣(∊A)←(∊A)[?⍨≢∊A←⎕]

— Adám

@ Adám: वाह, मुझे नहीं पता था कि आप ऐसा कर सकते हैं। क्या कोई सूची है कि कौन से कार्य यह कर सकते हैं?

— मारिनस

जी हां । और यह संशोधित असाइनमेंट के साथ भी काम करता है।

— एडमंड

Answer 10

अजगर, 15 बाइट्स

tPc.SsQ.u+NlYQ0

एक प्रोग्राम जो किसी सूची का इनपुट लेता है और परिणाम प्रिंट करता है।

परीक्षण सूट

यह काम किस प्रकार करता है

tPc.SsQ.u+NlYQ0  Program. Input: Q
       .u    Q0  (1) Reduce Q with starting value 0, returning all results:
         +        Add
          N       the current value
           lY     to the length of the next element of Q
     sQ          Flatten Q
   .S            (2) Randomly shuffle
  c              Chop (1) at every location in (2)
tP               Discard the first and last elements
                 Implicitly print

Answer 11

PHP , 105 बाइट्स

$m=array_merge(...$i=$_GET[i]);shuffle($m);foreach($i as$v)$o[]=array_splice($m,0,count($v));print_r($o);

कम से कम 105 बाइट्स के लिए धन्यवाद user59178।

मूल उत्तर:

PHP , 132 बाइट्स

$i=$_GET['i'];$m=call_user_func_array('array_merge',$i);shuffle($m);foreach($i as$v){$o[]=array_splice($m,0,count($v));}print_r($o);

Comments

$m=array_merge(...$i=$_GET[i]);25 बाइट्स से कम है $i=$_GET['i'];$m=call_user_func_array('array_merge',$i);और एक ही काम करता है। इसके अलावा आप 2 और बाइट बचाने {}के foreachलिए के बाद छोड़ सकते हैं ।

— user59178

Answer 12

दे घुमा के, 63, 58 बाइट्स

संपादन:

• अनुकूलित sed अभिव्यक्ति थोड़ा, -5 बाइट्स

ध्यान दें:

बैश वास्तव में बहुआयामी सरणियों का समर्थन नहीं करता है (वे केवल कुछ हद तक अनुकरण किया जा सकता है), इसलिए, इसके बजाय, यह कार्यक्रम एक असभ्य सरणी के "क्रमबद्ध" पाठ प्रतिनिधित्व को स्वीकार करेगा, जैसा कि कार्य विवरण में दर्शाया गया है, जैसे: [[1,2,3],[4],[9,10]]और आउटपुट प्रदान करते हैं। उसी प्रारूप में।

golfed

printf `sed 's/\w\+/%d/g'<<<$1` `grep -Po '\d+'<<<$1|shuf`

परीक्षा

>./shuffle []
[]

>./shuffle [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
[11,12,9,5,3,6,1,15,14,2,13,7,10,8,4]

>./shuffle [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
[9,15,11,10,7,6,1,14,2,3,12,5,4,13,8]

>./shuffle [[1,2,3],[4],[9,10]]
[[10,2,4],[9],[3,1]]

>./shuffle [[1,2,3],[4],[9,10]]
[[3,4,1],[10],[2,9]]

एक अच्छा बोनस यह है कि आप इसे मनमाने ढंग से गहराई से बीहड़ सरणियों को खिला सकते हैं:

./shuffle [[1,[2,[3,[99,101]]],[4],[9,10]]
[[9,[4,[1,[101,2]]],[10],[3,99]]

और यह अभी भी सही ढंग से काम करेगा।

इसे ऑनलाइन आज़माएं!

Answer 13

ऑक्टेव, 60 बाइट्स

@(a)mat2cell([a{:}](randperm(sum(s=cellfun(@numel,a)))),1,s)

Answer 14

MATLAB , 84 बाइट्स

function b=g(c);a=[c{:}];a=a(randperm(numel(a)));b=mat2cell(a,1,cellfun('length',c))

Answer 15

जावा, 368 बाइट्स

interface Z{int w(int i);default Z m(int n,int s){return i->w(i)+i>=n?s:0;}static int[][]f(int[][]r){int L=0,o=0,x,d,e=0;Z u=i->0,v=i->i;for(int[]a:r){d=a.length;L+=d;u=u.m(L,1);v=v.m(L,-d);}int[]c=new int[L];for(;e<L;)c[e++]=(int)(L*Math.random());for(int[]a:r){for(x=0;x<a.length;){d=c[x+o];e=v.w(d);d=u.w(d);L=a[x];a[x++]=r[d][e];r[d][e]=L;}o+=a.length;}return r;}}

विधि static int[][] f( int[][] r ){...}चुनौती हल करती है। आयात से बचने और उपयोग में आसानी के लिए एक डिफ़ॉल्ट विधि में जोड़ने के लिए अपने स्वयं के कार्यात्मक इंटरफ़ेस को रोल करने का निर्णय लिया

interface Z{ //define my own functional interface instead of importing

  int w(int i);

  //return a new lambda
  //where w(int i) adds the value s
  //to the result when i is greater than n
  default Z m(int n,int s){
      return i->w(i)+i>=n?s:0;
  }

  static int[][]f(int[][]r){
      int L=0,o=0,x,d,e=0;
      Z u=i->0, //lambda to convert a flattened index to the input's first dimension index
        v=i->i; //lambda to convert a flattened index to the input's second dimension index
      for(int[]a:r){
          d=a.length;
          L+=d; //running total of the lengths
          u=u.m(L,1); //increment the 1st conversion by 1 at every array length
          v=v.m(L,-d); //decrement the 2nd conversion by the array length after that length
      }
      int[]c=new int[L]; //will contain flattened index swapping positions
      for(;e<L;) //randomize the swap positions
          c[e++]=(int)(L*Math.random());
      for(int[]a:r){ //swap the elements from the input
          for(x=0;x<a.length;){
              d=c[x+o]; //flattened swap index
              e=v.w(d); //convert swap index to 2nd dimension index
              d=u.w(d); //convert swap index to 1st dimension index
              L=a[x];
              a[x++]=r[d][e];
              r[d][e]=L;
          }
          o+=a.length; //increment offset for flattened index array
      }
      return r;
  }

}

Answer 16

गणितज्ञ, 67 बाइट्स

ReplacePart[#,Thread[RandomSample@Position[#,_Integer]->Union@@#]]&

स्पष्टीकरण: यह 2D रैग्ड सरणी में सभी पूर्णांकों की स्थिति की सूची को बदल देता है। Union@@के लिए छोटा हैFlatten@

नोट: स्क्वीजी ब्रैकेट्स {}को कोष्ठक के बजाय उपयोग किया जाता है []।