डी-नेस्टिंग सूची

Question

इसके अंदर नेस्टेड सूचियों वाली एक सूची को देखते हुए, नेस्टेड सूचियों के आइटम को डी-नेस्टेड के साथ वापस लौटाएं।

इनपुट

सूची में, 4-गहरी नेस्टेड सूची होगी। इनपुट के भीतर सभी को शून्य स्थान के रूप में गिनें।

उत्पादन

व्यक्तिगत रूप से प्रत्येक आइटम का प्रिंट आउट लें। सूची के रूप में आउटपुट का प्रिंट आउट न लें। आप प्रत्येक आइटम को किसी भी प्रकार के व्हाट्सएप से अलग कर सकते हैं।

उदाहरण मामलों

[[1, 0], [2, 0], [2, 3]] -> 1 2 2 3
[[[4, 5, 8]], [[5, 6, 20]], [[1, 20, 500]]] -> 4 5 8 5 6 20 1 20 500
[[[1, 0], [0, 0], [0, 0]], [[1, 0], [1, 2], [2, 0]], [[2, 0], [0, 0], [0, 0]]] -> 1 1 1 2 2 2

सबसे छोटा कोड जीतता है।

Comments

आपको 4-गहरी सूची के कम से कम एक उदाहरण को शामिल करना चाहिए। अगर मैं सही तरीके से समझ पाया, तो 4-डीप कुछ ऐसा है [[[[5]]]], है ना?

— सर्गियोल

[[[[5]]]]पर काम करता है tio.run/... लेकिन नहीं पर tio.run/...

— sergiol

उस Count all 0's within the input as a null space.मतलब को पहचानना मुश्किल हैignore zeros

— l4m2

Answer 1

एपीएल (10)

0~⍨⍎⍞~'[]'

स्पष्टीकरण:

• ⍞~'[]': उपयोगकर्ता इनपुट ( ⍞) बिना ( ~) वर्ण '[]'
  यह कुछ ऐसा देता है'1,2,0,2,3'
• ⍎: इस स्ट्रिंग का मूल्यांकन करें। ऐसा होता है कि ,यह संघचालक है, इसलिए अब हमारे पास एक सूची है: 1 2 0 2 3(एपीएल सूचियाँ व्हाट्सएप द्वारा अलग-थलग हैं)
• 0~⍨: इस सूची से सभी संख्याएँ 0 निकालें। (यह संख्याओं की एक सूची है, तार के नहीं, अब तक, इसलिए संख्याओं के भीतर शून्य हटाए नहीं गए हैं।
• यह मान आउटपुट है (डिफ़ॉल्ट रूप से, क्योंकि यह पूरे प्रोग्राम का मूल्य है, गोल्फस्क्रिप्ट की तरह)। APL सूचियां व्हाट्सएप-डिफॉल्ट रूप से अलग हो जाती हैं, इसलिए यह प्रश्न में बिल्कुल वैसा ही दिखता है।

Comments

सबसे छोटा जवाब, इसलिए यह केक लेता है। सभी गैर-उत्तरों के लिए, मैंने एक + दिया है यदि आपका कोड वास्तव में छोटा या रचनात्मक है।

— beary605

Answer 2

सैड, 20 चार्ट

समाधान POSIX विस्तारित नियमित अभिव्यक्ति पर आधारित है।

s;[^0-9]+0|[],[]+;;g

आउटपुट :

bash-3.2$ sed -rf sedFile <<< "[[[4, 5, 8]], [[5, 6, 20]], [[1, 20, 500]]]" 
4 5 8 5 6 20 1 20 500

संपादित करें : POSIX बेसिक रेगुलर एक्सप्रेशन ( @clueless का समाधान), 19 वर्ण :

s/[^0-9][^1-9]*/ /g

Comments

s/[^0-9][^1-9]*/ /gभी काम करता है, और विस्तारित नियमित अभिव्यक्ति की आवश्यकता नहीं है।

— क्लूलेस

Answer 3

अजगर, ४५

W00, गोल्फ में अपवाद हैंडलिंग!

def d(x):
 try:map(d,x)
 except:print`x`*(x!=0)

Comments

प्रकारों के लिए जाँच का बहुत चतुर तरीका।

— beary605

मुझे समाधान पसंद है, हालांकि मुझे लगता है कि यह d(input())चरित्र की गिनती में एक पंक्ति को शामिल नहीं करने के लिए धोखा दे रहा है ।

— क्लूलेस

चुनौती अस्पष्ट है ... नी, विरोधाभासी, जब यह आई / ओ की बात आती है।

— बूथबीज

Answer 4

पर्ल, 20 16 13 वर्ण

perl -ple 's/\D+0?/ /g'

-lस्विच उत्पादन में अंतिम न्यू लाइन की रक्षा करने के लिए आवश्यक है।

यहां एक वैकल्पिक संस्करण है जो वास्तव में सूचियों के साथ शब्दार्थ (51 वर्णों) के साथ काम करता है।

perl -E '$,=$";sub p{map{ref$_?p(@$_):$_||""}@_}say p eval<>'

ये दोनों कार्यक्रम समस्या के समाधान का लाभ उठाते हैं कि यह "प्रत्येक वस्तु को किसी भी तरह के व्हाट्सएप से अलग कर सकता है", और शून्य को प्रतिस्थापित करता है, बजाय उन्हें एकमुश्त हटाने के।

Answer 5

के, १२

{x@?&x:,//x}

।

k){x@?&x:,//x}((1;0);(2;0);(2;3))
1 2 2 3
k){x@?&x:,//x}(((4;5;8));((5;6;20));((1;20;500)))
4 5 8 5 6 20 1 20 500
k){x@?&x:,//x}(((1;0);(0;0);(0;0));((1;0);(1;2);(2;0));((2;0);(0;0);(0;0)))
1 1 1 2 2 2

Comments

K के संस्करण के आधार पर, आप "को छोड़कर" ( x^y) का उपयोग करने में सक्षम हो सकते हैं : {(,//x)^0}या तो {,/x^0}/। Johnearnest.github.io/ok/index.html पर

— ngn

Answer 6

पर्ल 13 , 14 चार डीआईटी: pएक चार के लिए गिनती

s/\D+|\b0/ /g

उपयोग:

cat '[[1, 0], [2, 0], [2, 3]]' | perl -pe 's/\D+|\b0/ /g'

Comments

बहुत बढ़िया। यद्यपि आपकी गिनती वास्तव में 14 वर्ण है (आपको pगणना में स्विच को शामिल करने की आवश्यकता है )।

— ब्रेडबॉक्स

@breadbox: हाँ, आप सही कह रहे हैं। मैंने यह खो दिया।

— टोटो

कटौती के बजाय प्रतिध्वनि के साथ, यह काम भी करेगा - चार गिनती में तटस्थ संचालन।

— उपयोगकर्ता अज्ञात

Answer 7

रूबी, 38 अक्षर

puts eval(gets).flatten.reject &:zero?

संख्याओं को लाइन ब्रेक द्वारा अलग करके मुद्रित किया जाता है।

Answer 8

गोल्फस्क्रिप्ट 15

~{[]*}4*{},' '*

इनपुट

कमांड लाइन से चलाएं, जैसे:

echo [[[1 0] [0 0] [0 0]] [[1 0] [1 2] [2 0]] [[2 0] [0 0] [0 0]]] | ruby golfscript.rb x.gs

(मान लें कि x.gsफ़ाइल में ऊपर प्रस्तुत कोड है)।

ध्यान दें कि ,एरे को परिभाषित करते समय कोई अल्पविराम ( ) नहीं है ; यह गोल्फस्क्रिप्ट सिंटैक्स है

उत्पादन

जब इनपुट सेक्शन में वर्णित कमांड जारी की जाती है, तो आउटपुट है:

1 1 1 2 2 2

Answer 9

पायथन 3, 49 वर्ण

import re
print(*re.findall('[1-9]\d*',input()))

पायथन 2, 58 वर्ण

import re
print re.sub('\D[^1-9]*',' ',raw_input())[1:-1]

Answer 10

जाप , 5 बाइट्स

c f ¸

झसे आज़माओ

---

व्याख्या

सरणी का निहित इनपुट U। सरणी को समतल करें c। एस fको हटाने के लिए इसे छान लें 0। रिक्त स्थान का उपयोग करके इसे स्ट्रिंग में शामिल करें ¸। परिणामी स्ट्रिंग का निहित उत्पादन।

Answer 11

जावा 10, 106 बाइट्स

void c(Object i){for(var o:(Object[])i)try{System.out.print((int)o>0?o+" ":"");}catch(Exception e){c(o);}}

इनपुट के रूप में नेस्टेड Object[], आउटपुट को STDOUT में मुद्रित किया गया।

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

---

46 बाइट्स

s->s.replaceAll("[^0-9 ]","").replace(" 0","")

इनपुट और आउटपुट दोनों String।

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

Comments

@Giuseppe ओह .. यह एक बहुत बेवकूफ गलती है। अब तय होना चाहिए।

— केविन क्रूज़सेन

Answer 12

C, 45 वर्ण

for(;s=strtok(s,"[], ");s=0)atoi(s)&&puts(s);

यह मानता है कि इनपुट द्वारा बताए गए एक परिवर्तनीय स्मृति क्षेत्र में दिया गया है s।

Comments

जवाब एक कार्यक्रम, या कम से कम एक समारोह नहीं होना चाहिए? यदि संख्या के लिए विफल रहता है 01(मेरे लिए कानूनी लगता है)। और *s-49&&puts(s)छोटा है।

— ugoren

@ यूगोरन मुझे केवल कार्यक्रम / कार्यों को पूरा करने के लिए एक उत्तर को सीमित करने वाली कोई आवश्यकता नहीं मिली। क्या वहां पर कोई?

— अलेक्जेंडर बेकलिन

@ यूगोरेन ने अग्रणी शून्य के साथ संख्याओं का सामना करने के लिए फिर से लिखा। और सुझाव को छोटा करने के लिए धन्यवाद!

— अलेक्जेंडर बाकुलिन

Answer 13

अजगर, 99 111 चर

def d(l):
    if list==type(l):return[y for x in l for y in d(x)]
    return[str(l)]*(l!=0)
print" ".join(d(input()))

पिछला 99 char संस्करण - विफल रहता है जब शून्य के साथ सूची में केवल शामिल हैं:

d=lambda l:list==type(l)and[y for x in l for y in d(x)]or[str(l)]*(l!=0)
print" ".join(d(input()))

d(l)ज़ीरो को lफ़िल्टर करते हुए और संख्याओं को स्ट्रिंग्स में कनवर्ट करते हुए, पुनरावर्ती रूप से सूची को समतल करता है ।

Comments

यह तीसरे टेस्ट केस के लिए 1 [0, 0] [0, 0] 1 1 2 2 2 [0, 0] [0, 0] देता है।

— beary605

@ beary605, मैंने अभी इस एक परीक्षा को छोड़ दिया है ... मैं a and b or cसी के बजाय उपयोग करता हूं a?b:c, लेकिन यह तब विफल होता है जब यह bगलत (इस मामले में खाली सूची) का मूल्यांकन करता है।

— ugoren

Answer 14

स्काला, ४२ चार्ट

गैर-अंकों और गैर-अंकों द्वारा स्ट्रिंग को टोकन दिया गया और शून्य के बाद।

print(readLine split"\\D|\\b0"mkString" ")

Answer 15

प्रस्तावना (79)

यह सूची को एक शब्द के रूप में प्रस्तुत करता है, इसलिए आपको '' लगाने की आवश्यकता है। इनपुट में सूची के बाद।

वास्तव में सूची सपाट है।

x([H|T]):-x(H),x(T).
x(0). x([]).
x(M):-write(M),put(32).
:-read(X),x(X),halt.

Answer 16

एपीएल (डायलॉग) , 4 बाइट्स

0~⍨∊

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

0~⍨ शून्य हटा दिया गया

∊ε nlisted (चपटा) डेटा

Answer 17

स्टैक्स , 2 बाइट्स

$f

इसे चलाएं और डीबग करें

$समतल है। fफाल्सी वैल्यू को फिल्टर करके अलग-अलग लाइनों पर प्रिंट करता है।

Answer 18

स्केल 147:

वास्तविक सूचियों पर काम करना, तार पर नहीं:

def f[A](l:List[_]):List[_]=l match{
case Nil=>l
case(l:List[_])::s=>(f(l):::f(s))
case e::s=>e::f(s)}
def p(l:List[_])=f(l)filter(!=0)mkString " "

अब टेस्टडेटा:

val l1 = List (List (1, 0), List (2, 0), List (2, 3))
val l2 = List (List (List (4, 5, 8)), List (List (5, 6, 20)), List (List (1, 20, 500)))
val l3 = List (List (List (1, 0), List (0, 0), List (0, 0)), List (List (1, 0), List (1, 2), List (2, 0)), List (List (2, 0), List (0, 0), List (0, 0)))
val l4 = List (l1, l2, l3)

scala> l4.map(p)
res94: List[String] = List(1 2 2 3, 4 5 8 5 6 20 1 20 500, 1 1 1 2 2 2)

scala> p(l4)
res95: String = 1 2 2 3 4 5 8 5 6 20 1 20 500 1 1 1 2 2 2

Answer 19

bash: 29 वर्ण

l=$(echo "[[[1, 0], [0, 0], [0, 0]], [[1, 0], [1, 2], [2, 0]], [[2, 0], [0, 0], [0, 0]]]")
echo $l|tr -d '][,'|sed 's/\b0\b/ /g'
1           1   1 2 2   2          

काउंटिंग लाइन 2 केवल 'गूंज $ एल |' के साथ। 3 नमूनों के लिए परीक्षण:

  1    2    2 3
   4 5 8   5 6 20   1 20 500
   1               1    1 2  2     2            

Answer 20

Tcl , 47 बाइट्स

proc D L {concat {*}[concat {*}[concat {*}$L]]}

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

4-गहरा मान लेना कुछ ऐसा है {{{{5}}}}। जैसा कि परीक्षण मामलों पर इस तरह की कोई बात नहीं है, ऐसा कुछ हो सकता है {{{5}}}; अगर यह है तो मैं अपने कोड को छोटा कर सकता हूं!

Tcl , 66 बाइट्स

proc D L {lsearch -al -inl -not "[string map {\{ "" \} ""} $L]" 0}

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

Answer 21

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

jfT.n

परीक्षण सूट

Answer 22

आर , 29 बाइट्स

function(l)(x=unlist(l))[!!x]

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

unlistसूची को atomic vectorपुनरावर्ती में कनवर्ट करता है , इसलिए हमें केवल शून्य तत्वों को फ़िल्टर करने की आवश्यकता है।

Answer 23

जावास्क्रिप्ट (Node.js) , 53 बाइट्स

function(x){return(','+x+',').replace(/,(0,)*/g,' ')}

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

Answer 24

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

ċ∋↰|ℕ₁ẉ⊥

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

इनपुट चर के माध्यम से इनपुट लेता है और नए सिरे से अलग किए गए आउटपुट को प्रिंट करता है। आमतौर पर मैं आउटपुट प्रारूप के बारे में शिकायत करता हूं, लेकिन यह वास्तव में मुझे एक तरह से एक बाइट बचा लेता है जो मैंने अन्यथा सोचा नहीं था - ẉ⊥अंत में डालकर इसे लपेटने से कम है {}ᶠ।

ċ           If the input is a list,
 ∋          pick some element of it
  ↰         and recur with it as the input.
   |        Otherwise, if the input
    ℕ₁      is a natural number,
      ẉ     print it with a trailing newline
       ⊥    then trigger backtracking.

यदि सूची आइटम गैर-नकारात्मक पूर्णांक होने तक सीमित नहीं हैं:

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

ċ!∋↰|0!⊥|ẉ⊥

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

Answer 25

PHP , 70 बाइट्स

function($a){array_walk_recursive($a,function($a){echo$a?"$a ":'';});}

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

यह सबसे छोटा नहीं है (और न ही सबसे लंबा), लेकिन लगा कि इसे इस्तेमाल करने का मौका मिलेगा array_walk_recursive(), जिसे आज तक मैं इसके लिए इस्तेमाल करने के बारे में नहीं सोच सकता! कम से कम यह एक मनमाना स्तर गहरी नेस्टेड सूचियों को संभालने में सक्षम होना चाहिए।

Answer 26

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 37 बाइट्स

Flatten/*DeleteCases[0]/*StringRiffle

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