इनपुट

एक सरणी जिसमें एरे या पॉज़िटिव, लगातार, आरोही पूर्णांक हो सकते हैं। सरणियों के अंदर और उसके आगे, और उसके आगे किसी भी संख्या में सरणियाँ हो सकती हैं। कोई भी एरे खाली नहीं होगा।

उत्पादन

इस ऐरे ने सरलीकृत कर दिया

किसी ऐरे को कैसे सरल करें

हम सरणी का उपयोग [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]करेंगे , हमारे उदाहरण के रूप में।

सबसे पहले, हम जांचते हैं कि मूल्य कितने गहरे हैं। यहाँ उन गहराइयों पर गहराई और संख्याएँ हैं:

हम मूल सरणी में संख्याओं को लेते हुए आउटपुट एरे का निर्माण करते हैं, उन्हें जोड़कर देखते हैं कि वे कितने गहरे घोंसले में हैं, और फिर समूहों को उनके तत्वों की मूल गहराई की गहराई पर घोंसला बनाते हैं। आरोही क्रम और आरोही गहराई में संख्याओं को व्यवस्थित करें।

तो, हमारा आउटपुट है [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]

उदाहरण

[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]] -> [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]
[[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]] -> [4, [2, 5], [[1, 3, 6]], [[[7]]], [[[[8, 9]]]], [[[[[[10]]]]]]]
[1] -> [1]
[1, [2], [[3]], [[[4]]], [[[[5]]]]] -> [1, [2], [[3]], [[[4]]], [[[[5]]]]]
[1, [[[[2], 3]]] [[4]]] -> [1, [[4]], [[[3]]], [[[[2]]]]]

code-golf array-manipulation

— डैनियल
स्रोत

क्या उत्पादन लचीला है? जैसे विभिन्न रेखाओं में संख्याएँ, जहाँ प्रत्येक रेखा एक स्तर होती है; या अन्य सरणी सीमांकक / विभाजक

— लुइस मेंडो

सम्बंधित

— nimi

@LuisMendo, हाँ यह लचीला है

— डैनियल

आप 8लाइन में चारों ओर एक ब्रैकेट जोड़ी को याद कर रहे हैं So, our output is.....। हालाँकि, आपने इसे उदाहरण स्निपेट में निर्धारित किया है।

— sbisit

2

कुछ जवाब तत्वों के साथ नेस्टिंग स्तरों के लिए एक खाली लाइन आउटपुट करते हैं। क्या ऐसे मामलों में खाली सरणी वापस करना ठीक है, उदाहरण के लिए आप पहले उदाहरण के रूप में [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[]]]], [[[[[8]]]]]]?

— nimi

1

जेली , 8 बाइट्स

fFṄḟ@;/ß

आउटपुट प्रति स्तर एक स्तर है, तत्वों के बिना स्तरों के लिए खाली लाइनें। इसे ऑनलाइन आज़माएं!

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

fFṄḟ@;/ß  Main link. Argument: A (array)

 F        Flat; yield all integers (at any level) in A.
f         Filter; intersect A with the integers, yielding those at level 0.
  Ṅ       Print the filtered array and a linefeed. Yields the filtered array.
     ;/   Reduce by concatenation.
          This decreases the levels of all integers at positive levels by 1.
   ḟ@     Swapped filter-false; remove the integers at level 0 in A from the array
          with decreased levels.
       ß  Recursively call the main link on the result.
          The program stops once A is empty, since ;/ will result in an error.

— डेनिस
स्रोत

3

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

f=(a,v=b=>a.filter(a=>b^!a[0]))=>a[0]?v().concat((a=f([].concat(...v(1))),b=v())[0]?[b]:[],v(1).map(a=>[a])):[]

उदाहरण इनपुट का उपयोग करते हुए स्पष्टीकरण: vएक सहायक विधि है जो एरियर्स (पैरामीटर के साथ 1) या मान (बिना किसी पैरामीटर के) लौटाती है । हम शुरू करते हैं a = [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]], जो गैर-रिक्त है। हम सरणियों को फ़िल्टर करते हैं, दे रहे हैं [1]। हम फिर अपने आप को एक साथ एकत्रित सरणियों पर खुद को बुलाते हैं, जो [2, 3, [4], [[5, 6], 7, [[[8]]]], 9]कि परिणाम है [2, 3, 9, [4, 7], [[5, 6]], [[[[8]]]]]। हम फिर से सरणियों को फ़िल्टर करते हैं, जो हमें अपने आउटपुट का दूसरा कार्यकाल देता है [2, 3, 9], हालांकि हमें यहां खाली सरणी नहीं डालने के लिए सावधान रहना होगा। यह उन्हें सरणियों के [4, 7], [[5, 6]], [[[[8]]]]अंदर लपेटने के लिए रहता है और उन्हें आउटपुट में जोड़ देता है, जिसके परिणामस्वरूप [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]।

— नील
स्रोत

करने के लिए एक उपनाम बनाकर कुछ बाइट्स को बचाने में सक्षम हो सकता है filter। शायद के साथ शुरूF=(x,y)=>x.filter(y)

— Cyoce

@Cyoce अंत में 30 के हो गए!

— नील

आप निश्चित रूप से इस पर करने के लिए कुछ गोल्फ बाकी है। मुझे लगता है कि आप सुरक्षित रूप से जगह ले सकता है [].concat(...v(1))के साथ v(1)करने के लिए सेव 14 बाइट्स। वहाँ शायद कुछ अन्य चीजें भी हैं, लेकिन मुझे अपने सिर में नेस्टेड कोष्ठक का ध्यान रखने में मुश्किल समय आ रहा है।

— पैट्रिक रॉबर्ट्स

1

@ पैट्रिक रॉबर्ट्स [].concat(...v(1))एक बहुत अलग जानवर है v(1), अन्यथा मैं ऐसा नहीं करता! एक साधारण उदाहरण के लिए, a = [2, [3], [[4]]]तब v(1) = [[3], [[4]]]पर विचार करें [].concat(...v(1)) = [3, [4]]।

— नील

@ नील ओह, वाह मुझे वास्तव में अपना मुंह खोलने से पहले मेरे सुझाव का परीक्षण करना चाहिए था। मुझे ऐसा लगता है कि ऐसा करने का एक छोटा तरीका होना चाहिए ..

— पैट्रिक रॉबर्ट्स

2

05AB1E , 27 26 25 21 बाइट्स

D˜gFvyydi„ÿ ?}}¶?.gG«

इसे ऑनलाइन आज़माएं!(थोड़ा संशोधित के रूप .gमें अभी तक TIO पर नहीं है)

व्याख्या

D˜gF                    # flattened input length times do
    vy                  # for each y current level of list
      ydi„ÿ ?}          # if y is a digit, print with space
              }         # end v-loop
               ¶?       # print newline
                 .g     # calculate length of stack (this should be .g but I can't test)
                   G«   # length stack times, concatenate items on stack

मुख्य रणनीति नेस्टेड सरणी के प्रत्येक संभावित स्तर पर लूप करना और किसी भी अंक को एक पंक्ति में प्रिंट करना है, जबकि गैर-अंकों (सूचियों) को एक स्तर कम नेस्टेड में रखा गया है।

— Emigna
स्रोत

2

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

बस एक पुनरावर्ती उपरांत। (एक पर्ल जवाब के लिए असामान्य, मुझे पता है ..)

sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}

इसे इस तरह से कॉल करें:

$ perl -E 'sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}f(1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9])'
1
2 3 9
4 7
5 6

8

आउटपुट की प्रत्येक पंक्ति सरणी की गहराई के स्तर से मेल खाती है (इसलिए ऊपर के उदाहरण में खाली लाइन)।

इसे कुछ और बाइट्स के लिए एक पूर्ण कार्यक्रम में बदल दिया जा सकता है: इनपुट को पर्ल पर्ल में बदलने के लिए -nफ्लैग और eval( @{ }ए को इनपुट में बदलने के लिए और अरेंज में नहीं) को जोड़ें।

perl -nE 'sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}f(@{+eval})' <<< "[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]"

मेरा पिछला दृष्टिकोण थोड़ा लंबा था (65 बाइट्स), लेकिन फिर भी दिलचस्प है, इसलिए मैं इसे यहाँ बताता हूँ:

perl -nE '/\d/?push@{$;[$d-1]},$_:/]/?$d--:$d++for/\[|]|\d+/g;say"@$_"for@' <<< "[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]"

— बापू
स्रोत

2

जावास्क्रिप्ट (ईएस 6) 121 144 152

संपादित करें बहुत संशोधित, 1 बाइट ने Thx पैट्रिक रॉबर्ट्स को बचाया, और 21 और कोड की समीक्षा की

इनपुट और आउटपुट में सरणियों पर काम कर रहे पुनरावर्ती कार्य। मुझे आउटपुट एरे में एकल तत्वों के रूप में गहराई 1 पर तत्व होने का अनुरोध पसंद नहीं है (जबकि बड़े स्तर को एक तत्व के रूप में वर्गीकृत किया गया है) [l1,l1, [l2...], [[l3...]] ]:। जबकि यह अधिक प्रत्यक्ष होगा:[ [l1...], [[l2...]], [[[l3...]]] ]

f=(l,d=0,r=[])=>l.map(v=>v[0]?f(v,d+1,r):r[d]=[...r[d]||[],v])
r.reduce((r,v,d)=>d?[...r,(n=d=>d-->1?[n(d)]:v)(d)]:v,[])

पठनीयता के लिए नई लाइन जोड़ी गई।

कुछ नोट्स: प्रत्येक पुनरावर्ती कॉल पर लाइन 2 का बार-बार मूल्यांकन किया जाता है, लेकिन पुनरावृत्ति के अंत में केवल अंतिम पुनरावृत्ति उपयोगी है।
जब d==0लाइन 2 में विशेष हैंडलिंग लेवल 1 तत्वों के लिए विसंगति का ख्याल रखता है।
nपुनरावर्ती क्रिया सरणी उत्पादन में घोंसला बनने वाले हैंडल

परीक्षा

f=(l,d=0,r=[])=>l.map(v=>v[0]?f(v,d+1,r):r[d]=[...r[d]||[],v])
&&r.reduce((r,v,d)=>d?[...r,(n=d=>d-->1?[n(d)]:v)(d)]:v,[])

console.log=x=>O.textContent+=x+'\n'

test=[
 [ 
   [1, [2,3], 4], /* -> */ [1, 4, [2,3]]
 ]
,[
   [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]], 
   // ->
   [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]
 ]
,[
  [[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]],
  // ->
  [4, [2, 5], [[1, 3, 6]], [[[7]]], [[[[8, 9]]]], [[[[[[10]]]]]]] 
 ]
,[  
  [1], /* -> */ [1]
 ]
,[  
  [1, [2], [[3]], [[[4]]], [[[[5]]]]],
  // ->
  [1, [2], [[3]], [[[4]]], [[[[5]]]]]
 ]
,[  
  [1, [[[[2], 3]]], [[4]]],
  [1, [[4]], [[[3]]], [[[[2]]]]]
]]

test.forEach(t=>{
  var i=t[0], k=t[1], r=f(i),
      si=JSON.stringify(i),
      sr=JSON.stringify(r),
      sk=JSON.stringify(k)
  
  console.log((sr==sk?'OK ':'KO ')+si + " => " + sr)
})

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

1

यह देखते हुए कि केवल नेस्टेड एरेज़ और पॉजिटिव पूर्णांक हैं, और यह निर्दिष्ट है कि इनपुट में कोई भी एरे खाली नहीं है, आपके टर्नरी ऑपरेटर के लिए एक आसान परीक्षण v[0]इसके बजाय होगा v.map। 1 बाइट बचाता है।

— पैट्रिक रॉबर्ट्स

— @ पैट्रिक रॉबर्ट्स

1

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

f=a=>(s=[],b=-1,k=0,a.replace(/\d+|\[|\]/g,a=>a=='['?b++:a==']'?b--:(s[b]=s[b]||[]).push(a)),'['+s.map((a,b)=>k=a&&(k?',':'')+'['.repeat(b)+a+']'.repeat(b)).join``+']')

डेमो

— sbisit
स्रोत

1

PHP, 145 बाइट्स

<?function c($r){$n=[];foreach($r as$k=>$v)if(is_array($v)){$n=array_merge($n,$v);unset($r[$k]);}if($n)$r[]=c($n);return$r;}print_r(c($_GET[a]));

टूट - फूट

function c($r){
  #usort($r,function($x,$y){return is_array($x)<=>is_array($y)?:$x<=>$y;}); 
#no need to sort and a simple sort($r); do it sort array after scalar
  $n=[];
  foreach($r as$k=>$v)if(is_array($v)){$n=array_merge($n,$v);unset($r[$k]);} # put arrays on the same depth together
  if($n)$r[]=c($n); # recursive if an array exists
  return$r; #return changes
}
print_r(c($_GET[a])); #Output and Input

— जार्ग हुल्सरमन
स्रोत

1

पायथ, 19 16 बाइट्स

W=Qsf!&sITp+TdQk

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

अग्रणी स्थान पर ध्यान दें। पर्ल उत्तर जैसी पंक्तियों पर आउटपुट स्तर।

व्याख्या

में निहित इनपुट Q।
fİlter आइटम Tकी Qपर:
- जाँच करें कि sक्या Iउम्म पर दांता है T।
- यदि ऐसा हुआ था (यह एक नंबर था), pप्रिंट करें Tके साथ साथ एक अंतरिक्ष +... d।
- अगर यह नहीं था (यह एक सरणी था), इसे रखो।
sउम आइटम। यह प्रत्येक आइटम से सरणियों की एक परत को निकालता है। यदि कोई नहीं बचा है, तो पैदावार0 ।
=को परिणाम सौंपें Q।
Wरिजल्ट नॉन खाली है, खाली स्ट्रिंग kऔर एक नई लाइन प्रिंट करें ।

— PurkkaKoodari
स्रोत

1

हास्केल, 124 123 बाइट्स

data L=I Int|R[L]
d#R l=((d+1)#)=<<l
d#i=[(d::Int,i)]
[]!_=[]
l!1=l
l!d=[R$l!(d-1)]
h l=R$do d<-[1..];[i|(e,i)<-0#l,d==e]!d

जैसा कि हास्केल डिफ़ॉल्ट रूप से मिश्रित सूचियों (पूर्णांक और पूर्णांक की सूची) का समर्थन नहीं करता है, मैं एक कस्टम सूची प्रकार को परिभाषित करता हूं L। उपयोग उदाहरण:

*Main> h (R[I 1, R[I 2, I 3], R[ R[I 4]], R[ R[ R[I 5, I 6], I 7, R[R[R[I 8]]]], I 9]])
R [I 1,R [I 2,I 3,I 9],R [R [I 4,I 7]],R [R [R [I 5,I 6]]],R [R [R [R [R [I 8]]]]]]

नोट: इसे चलाने में कुछ समय लगता है, क्योंकि यह एक गहरे स्तर के घोंसले की तलाश के लिए सभी सकारात्मक Ints (32 या 64bit) से गुजरता है। इसके अलावा: कस्टम सूची प्रकार को डिफ़ॉल्ट रूप से मुद्रित नहीं किया जा सकता है, इसलिए यदि आप परिणाम को उपरोक्त उदाहरण में देखना चाहते हैं, तो आपको घोषणा में जोड़ना deriving Showहोगा data(->data L=I Int|R[L] deriving Show ) में । क्योंकि किसी फ़ंक्शन से L-सूची वापस करने के लिए इसकी आवश्यकता नहीं है, मैं बाइट्स की गणना नहीं करता हूं।

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

data L=I Int|R[L]               -- custom list type L, which is either an Int
                                -- (-> I Int) or a list of some L (-> R [L]) 

d#R l=((d+1)#)=<<l              -- # makes a list of (depth, I-number) pairs from
d#i=[(d::Int,i)]                -- a given L-list, e.g.
                                -- 0 # (R[I 1,R[I 2,I 3],I 4]) -> [(1,I 4),(2,I 2),(2,I 3),(1,I 4)]
                                -- the type annotation ::Int makes sure that all
                                -- depths are bounded. Without it, Haskell
                                -- would use arbitrary large numbers of type
                                -- ::Integer and the program won't finish

[]!_=[]                         -- ! wraps a list of Is with (d-1) additional
l!1=l                           --  R constructors
l!d=[R$l!(d-1)]

h l=                            -- main function, takes a L-list
      do d<-[1..]               -- for each nest level d make
        [i|(e,i)<-0#l,d==e]     -- a list of all I where the depth is d
                           !!d  -- and wrap it again with d-1 Rs         
     R$                         -- wrap with a final R

@BlackCap को संपादित करें ने बाइट >>=को doअंकन से स्विच करके बचाया । धन्यवाद!

— nimi
स्रोत

अंकन एक बाइट बचाता हैh l=R$do d<-[1..];[i|(e,i)<-0#l,d==e]!d

— BlackCap

0

जावास्क्रिप्ट (ईएस 6), 127 137 134 बाइट्स

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

f=(a,l=[],d=0,o='')=>`[${a.map(x=>x[0]?f(x,l,d+1,o+'['):l[d]=(l[d]?l[d]+',':o)+x),l.map((s,d)=>x+s+']'.repeat(d,x=','),x='').join``}]`

परीक्षण के मामलों

कोड स्निपेट दिखाएं

f=(a,l=[],d=0,o='')=>`[${a.map(x=>x[0]?f(x,l,d+1,o+'['):l[d]=(l[d]?l[d]+',':o)+x),l.map((s,d)=>x+s+']'.repeat(d,x=','),x='').join``}]`

console.log(f([1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]));
console.log(f([[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]]));
console.log(f([1]));
console.log(f([1, [2], [[3]], [[[4]]], [[[[5]]]]]));
console.log(f([1, [[[[2], 3]]], [[4]]]));

Expand snippet

— Arnauld
स्रोत

@ शेबिंग नोटिंग के लिए धन्यवाद। यह तय होना चाहिए।

— अरनुलद

मेरा मानना है कि अब अच्छा लग रहा है! :)

— केड

एक सरणी को सरल करें

इनपुट

उत्पादन

किसी ऐरे को कैसे सरल करें

उदाहरण

जेली , 8 बाइट्स

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

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

05AB1E , 27 26 25 21 बाइट्स

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

जावास्क्रिप्ट (ईएस 6) 121 144 152

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

डेमो

PHP, 145 बाइट्स

पायथ, 19 16 बाइट्स

व्याख्या

हास्केल, 124 123 बाइट्स

जावास्क्रिप्ट (ईएस 6), 127 137 134 बाइट्स

परीक्षण के मामलों