आपको एक नेस्टेड ऐरे दिया जाएगा। आपके कार्यक्रम की व्यूह रचना करनी है।

पर कैसे?

उदाहरण के लिए, मान लें कि हमारे पास एक नेस्टेड सरणी है, जैसे [["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]।

इस नेस्टेड सरणी की कल्पना की जा सकती है:

->1
->2
-->1
-->2
->3
>4
---->5
>6

उदाहरण

Input 1:
["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]
Output 1:
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

Input 2:
[["1","2"],["3","4"]]
Output 2:
->1
->2
->3
->4

नियम

आप इनपुट के रूप में स्ट्रिंग (या अन्य प्रकार जो नेस्टेड सरणी की तरह काम करते हैं) का उपयोग कर सकते हैं।
"परतों" का अधिकतम स्तर 2 ^ 32-1 है।

code-golf printable-ascii

— मैथ्यू रो
स्रोत

क्या यह सटीक दृश्य होना चाहिए?

— पेनालॉसा

@mnbvc हाँ, जब तक मैं इसे करने के लिए मजबूर नहीं करता हूं लोग I / O को बहुत अधिक मोड़ना शुरू कर देते हैं। मेरा विश्वास करो, मैंने कोशिश की।

— मैथ्यू रो

मुझे ऐसा लग रहा है कि रेटिना इसे जीतेगी।

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

1

क्या तार में कोई भी चरित्र दिखाई दे सकता है, इस पर कोई प्रतिबंध है?

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

अतिरिक्त संबंधित प्रश्न 1 , 2

— AdmBorkBork

12

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

{1=≡⍺:⎕←⍺,⍨⍵↑1↓⍵/'->'⋄⍺∇¨⍵+1}∘0

परीक्षा:

      r
┌────┬─────────────────────────────────────────────────────────────────────────────────────────┐
│Atom│┌──────┬──────────────────────────────┬───────┬────────────────────────────────┬────────┐│
│    ││Proton│┌────────┬────────┬──────────┐│Neutron│┌────────┬──────────┬──────────┐│Electron││
│    ││      ││Up Quark│Up Quark│Down Quark││       ││Up Quark│Down Quark│Down Quark││        ││
│    ││      │└────────┴────────┴──────────┘│       │└────────┴──────────┴──────────┘│        ││
│    │└──────┴──────────────────────────────┴───────┴────────────────────────────────┴────────┘│
└────┴─────────────────────────────────────────────────────────────────────────────────────────┘
      {1=≡⍺:⎕←⍺,⍨⍵↑1↓⍵/'->'⋄⍺∇¨⍵+1}∘0 ⊢ r 
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

स्पष्टीकरण:

{... }∘0: निम्नलिखित फंक्शन को 0बाध्य करें ⍵:
- 1=≡⍺:: यदि इनपुट में गहराई 1 है (यानी ऐसा सरणी जिसमें अन्य सरणियाँ नहीं हैं):
  - ⍵/'->': ⍵ -s और ⍵ >s युक्त स्ट्रिंग बनाएँ ,
  - 1↓: पहला तत्व छोड़ें,
  - ⍵↑: और पहले ⍵तत्वों को ले लो । इसके परिणामस्वरूप एक स्ट्रिंग होती है जिसमें ⍵-1डैश और एक होता है >।
  - ⍺,⍨: इसके लिए इनपुट संलग्न करें,
  - ⎕←: और आउटपुट स्क्रीन के लिए
- ⋄: अन्यथा,
  - ⍺∇¨⍵+1: ⍵प्रत्येक नेस्टेड सरणी में 1 जोड़ें और फंक्शन लागू करें

— मारीनस
स्रोत

5

रुको, क्या यह उस आस्की-कला के रूप में इनपुट लेता है?

— R

4

@ रिकर: नहीं, यह एक सामान्य नेस्टेड सरणी लेता है, हालांकि यह है कि डायलाग एपीएल नेस्टेड एरे को कैसे प्रदर्शित करता है, और (मुझे लगा) यह स्पष्ट करता है कि क्या चल रहा है। आप इसे लिखकर निर्माण कर सकते हैं ('Atom' ('Proton' ('Up Quark' 'Up Quark' 'Down Quark') 'Neutron' ('Up Quark' 'Down Quark' 'Down Quark') 'Electron'))।

— मारिनस

9

आह ठीक है। जो इसे साफ करता है। कुछ हद तक अब

— असंतुष्ट

1

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

— अदम

7

गणितज्ञ, 58 57 56 बाइट्स

1 बाइट बचाने के लिए ग्रेग मार्टिन को धन्यवाद।

1 बाइट बचाने के लिए ngenisis के लिए धन्यवाद।

MapIndexed[Print[Table["-",Tr[1^#2]-1]<>">",#]&,#,{-1}]&

— मार्टिन एंडर
स्रोत

47

PPCG में आपका स्वागत है! आपको पता होना चाहिए कि ऐसे उत्तर जो बहुत कम या कोई स्पष्टीकरण प्रदान करते हैं, सिस्टम द्वारा स्वचालित रूप से ध्वजांकित हो जाते हैं और कम गुणवत्ता की समीक्षा कतार में समाप्त हो जाते हैं । हो सकता है कि आपका उत्तर हटा दिया जाए। ध्यान दें कि यदि आपके पास कई हटाए गए उत्तर हैं, तो आपको अस्थायी निलंबन मिल सकता है। बस थोड़ा सा सिर!

— स्टीवी ग्रिफिन

20

@StewieGriffin गर्मजोशी से स्वागत के लिए धन्यवाद, मैं इसे ध्यान में रखूंगा!

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

6

@StewieGriffin क्या आप साइटमैप का स्वागत कर रहे हैं? यहाँ क्या हो रहा है? क्या यह अंदरूनी मजाक है? यदि आप उत्तर में हैं तो आप लोगों के लिए #confused और अच्छा वसंत।

— माइंडविन

4

@ मिंडविन: स्टैक एक्सचेंज के पास उत्तर को पकड़ने के लिए एक फ़िल्टर है जो सहायक होने की संभावना नहीं है। इस तरह की पोस्ट (शीर्षक + शॉर्ट कोड सैंपल, नो कमेंट्री) इस पर झूठी सकारात्मकता पैदा करने की अत्यधिक संभावना है, क्योंकि यह कंप्यूटर के लिए एक कम प्रयास पोस्ट की तरह दिखता है (और स्टिव ग्रिफिन की टिप्पणी में स्क्रीनशॉट के लिए एक लिंक है जो इंगित करता है। वास्तव में एक गलत सकारात्मक घटना हुई; यह स्थिति का मजाक उड़ा रही है)। यहां एक और पोस्ट का उदाहरण दिया गया है जो फ़िल्टर में पकड़ा गया है।

8

@ टिट्स मैं एक जोड़ना पसंद करूंगा लेकिन मैं स्टीवी की टिप्पणी को अमान्य नहीं करना चाहता। :(

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

6

जावा 7, 153 141 114 बाइट्स

String r="";<T,S>S c(S s,T o){for(T x:(T[])o)if(x instanceof Object[])c("-"+s,x);else r+=s+">"+x+"\n";return(S)r;}

-39 बाइट्स @ बारटेक्स 2 एक्स के लिए धन्यवाद

स्पष्टीकरण:

String r="";                         // Result String outside the method / on class-level
<T,S> S c(S s, T o){                 // Recursive Method with generic String and Object parameters and String return-type
  for(T x : (T[])o)                  //  Loop over the input-array
    if(x instanceof Object[])        //   If the current item is an array itself:
      c("-"+s, x);                   //    Recursive method-call with this array
    else                             //   Else:
      r += s+">"+x+"\n";             //    Append return-String with stripes String-input, ">", current item, and a new-line
                                     //  End of loop (implicit / single-line body)
  return (S)r;                       //  Return the result-String
}                                    // End of method

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  String r="";<T,S>S c(S s,T o){for(T x:(T[])o)if(x instanceof Object[])c("-"+s,x);else r+=s+">"+x+"\n";return(S)r;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c("", new Object[]{new Object[]{1,2},new Object[]{new Object[]{1,2},3},4,new Object[]{new Object[]{new Object[]{new Object[]{5}}}},6}));
    m.r = "";
    System.out.println(m.c("", new Object[]{"Atom",new Object[]{"Proton",new Object[]{"Up Quark","Up Quark","Down Quark"}},new Object[]{"Neutron",new Object[]{"Up Quark","Up Quark","Down Quark"}},"Electron"}));
  }
}

आउटपुट:

->1
->2
-->1
-->2
->3
>4
---->5
>6

>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Up Quark
-->Down Quark
>Electron

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

1

आप टर्नरी ऑपरेटर का उपयोग करके इसे थोड़ा छोटा (143 या 142) भी प्राप्त कर सकते for(int j=i;j-->0;r+="-");हैं कि अगली पंक्ति क्या करती है, और ऑब्जेक्ट के बजाय जेनेरिक तर्क का उपयोग कर रही है]:

String r="";<T>String c(int i,T[] o){for(T x:o)if(x instanceof Object[])c(i+1,(T[])x);else for(int j=i;j-->=0;r+=j<0?">"+x+"\n":"-");return r;}

और यहां तक कि 1 वर्ण कम हो सकता है यदि 0 को 1 के बजाय 1 के रूप में पारित किया जाए। तर्क ठीक है।

— barteks2x

मुझे सामान्य तर्क से [] को हटाकर इसे और भी छोटा बनाने का एक तरीका मिल गया, यह अतिरिक्त 2 पात्रों को बचाता है (लेकिन टिप्पणी को 5 मिनट बाद संपादित नहीं कर सकता है)

— barteks2x

@ Barteks2x धन्यवाद! -12 बाइट्स थैंक यू। :) Btw, []1 अतिरिक्त बाइट को बचाने के लिए पैरामीटर से हटाकर एक त्रुटि देता है। रनिंग के बाद यहां डिबग में त्रुटि देखें ।

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

String r="";<T>String c(int i,T a){for(T x:(T[])a)if(x instanceof Object[])c(i+1,x);else for(int j=i;j-->0;r+=j<1?">"+x+"\n":"-");return r;}

यह काम। इसके अलावा आप अतिरिक्त बाइट को बचाने के लिए स्ट्रिंग के साथ समान जेनेरिक ट्रिक कर सकते हैं, लेकिन इसे प्रिंट करने से पहले वेरिएबल में रिजल्ट को स्टोर करने की आवश्यकता है, या एक स्पष्ट कास्ट (अस्पष्ट विधि कॉल):

String r="";<T,S>S c(int i,T a){for(T x:(T[])a)if(x instanceof Object[])c(i+1,x);else for(int j=i;j-->0;r+=j<1?">"+x+"\n":"-");return(S)r;}

— barteks2x

1

मुझे यकीन नहीं है कि अगर इसकी अनुमति दी जाती है, लेकिन यहां 114 बाइट्स, शून्य के बजाय तर्क के रूप में रिक्त स्ट्रिंग के साथ (1 वर्ण कम हो सकता है अगर ">" तर्क के रूप में अनुमति दी जाती है) String r="";<T,S>S c(S p,T a){for(T x:(T[])a)if(x instanceof Object[])c("-"+p,x);else r+=p+">"+x+"\n";return(S)r;}और कॉल करते समय वापसी प्रकार पर स्ट्रिंग कलाकारों की आवश्यकता वह गया।

— barteks2x

6

PHP, 77 74 73 बाइट्स

4 बाइट्स बचाए धन्यवाद @manatwork

function f($a,$p=">"){foreach($a as$e)"$e"!=$e?f($e,"-$p"):print"$p$e
";}

पुनरावर्ती कार्य, नकारात्मक स्ट्रिंग सूचकांक के लिए PHP 7.1 या नए की आवश्यकता है।
^{"$e"है Arrayसरणियों के लिए; ऐसा "$e"!=$eही है is_array($e)।}

उपसर्ग के साथ शुरू करो >
एक पहले जोड़ें -प्रत्येक स्तर के लिए उपसर्ग के लिए
परमाणुओं के लिए उपसर्ग + तत्व + न्यूलाइन प्रिंट करें

— टाइटस
स्रोत

1

75 बाइट्स:function f($a,$p=""){foreach($a as$e)echo$p,is_array($e)?f($e,"-"):">$e\n";}

— इस्माइल मिगुएल

1

अगर यह आवश्यक स्वरूपण के लिए गया, तो print_r ($ सरणी) और भी छोटा होगा :)

— ivanivan

1

बस एक त्वरित परीक्षण किया, लेकिन लगता है कि के is_array($e)साथ प्रतिस्थापित किया जा सकता है $e[-1]!==""।

— मैनेटवर्क

1

@manatwork Thats का PHP <7.1 ... PHP 7.1 में, यह $e[-]==""... और उलटी स्थिति के साथ किया जा सकता है $e[-1]>""। अच्छा लगा!

— टाइटस

1

हो सकता है मुझे कुछ कोने के मामले याद आ रहे हों, लेकिन अब ऐसा लगता है कि $e[-1]>""इसे बदला जा सकता है "$e"==$e। कम से कम प्राचीन PHP 5.6 में मैं उपयोग करता हूं।

— मैनेटवर्क

5

C99 (GCC), 201 187 140 112 109

f(char*a){for(long d=1,j;j=d+=*++a>90?92-*a:0;)if(*a<35){for(;j||*++a^34;)putchar(j?"->"[!--j]:*a);puts("");}}

विस्तारित रूप:

f(char*a){
    for(long d=1,j;j=d+=*++a>90?92-*a:0;)
        if(*a<35){
            for(;j||*++a^34;)putchar(j?--j?45:62:*a);
            puts("");
        }
}

यह सही प्रारूप में एक स्ट्रिंग लेता है और अंतिम मिलान खोजने पर समाप्त हो जाता है ]।

यह पुनरावृत्ति का उपयोग नहीं करता है और लंबे प्रकार का उपयोग करता है वास्तव में दूसरा नियम प्राप्त करने के : 2 ^ 32-1 स्तर । अधिकांश स्क्रिप्टिंग भाषाओं में एक सीमित पुनरावृत्ति गहराई होती है या बस स्टैक ओवरफ्लो पर दुर्घटना होती है।

मैं सी में गोल्फ के लिए इस्तेमाल नहीं कर रहा हूँ किसी भी मदद की सराहना की है :)

अपने सुझावों के लिए bolov पर धन्यवाद! टाइटस के लिए विशेष रूप से धन्यवाद जो हमेशा गोल्फ के एक अच्छे दौर के लिए उठे (यहां तक कि सी में भी)!

एक और दो बाइट्स ने इस तथ्य से बचाया कि हम एक बार अंतिम मैच से पहले समाप्त कर सकते हैं ] और एक चारुल मैच की जरूरत नहीं है।

इसका परीक्षण वैंडबॉक्स में किया जा सकता है ।

— क्रिस्टोफ
स्रोत

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— टाइटस

क्या आप दूसरी पंक्ति को छोटा नहीं कर सकते थे for(int d=1 ...? long4 वर्ण हैं, जबकि intकेवल 3 है, और कोई कारण नहीं है कि आपको इसे 2^32 - 1मान्य करने के लिए ऊपर जाने के लिए वैध होने की आवश्यकता है, जिससे आपको एक बाइट की बचत हो।

— रेस्टियोसन

@Restioson int पर हस्ताक्षर किए हैं और इसलिए केवल तब तक काम करते हैं 2^31-1।

— क्रिस्टोफ

चुनौती में कहा गया है कि आप नहीं था कि @Christoph है कि तुलना में किसी भी आगे जाने के लिए।

— रिस्टिऑसन

@ रेस्टिओसन नियम के रूप में चुनौती देता है The maximum level of "layers" is 2^32-1.। 2^31-1से बहुत कम है 2^32-1। थोड़ी देर के लिए 2^32-1फिट नहीं होता है या intयह एक फिट बैठता है (जो कि ज्यादातर सिस्टम / कंपाइलर पर होता है)। इसलिए एक सही उत्तर नहीं दिया जाएगा (जैसे कि यहां अधिकांश उत्तर विफल हो जाते हैं)। unsignedlongint

— क्रिस्टोफ़

4

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

f=(a,s='>')=>a.map(e=>e.map?f(e,'-'+s):s+e).join`
`

संपादित करें: जब @Arnauld ने बताया कि मैं अपने दो दृष्टिकोणों को जोड़ सकता हूं, तब 7 बाइट्स सहेजे गए।

— नील
स्रोत

4

PHP, 129 123 112 109 95 93 91 बाइट्स

for(;a&$c=$argn[++$i];)$c<A?$c<"-"?a&$s?$s=!print"$p>$s
":0:$s.=$c:$p=substr("---$p",$c^i);

पुनरावृत्ति समाधान STDIN से स्ट्रिंग लेता है:
साथ चलाएं echo '<input>' | php -nR '<code>'या इसे ऑनलाइन परीक्षण करें ।

टूट - फूट

for(;a&$c=$argn[++$i];)     // loop $c through input characters
    $c<A                        // not brackets?
        ?$c<"-"                     // comma or quote?
            ?a&$s?$s=!print"$p>$s\n":0  // if $s not empty, print and clear $s
            :$s.=$c                     // digit: append to $s
        :$p=substr("---$p",$c^i)    // prefix plus or minus one "-"
;

खुश हैं कि संख्या उद्धरण में हैं; इसलिए मुझे एक समय में केवल एक कार्रवाई की आवश्यकता है।

ASCII फ़िडलिंग

char    ascii   binary/comment
 "       34
 ,       44
 [       91     0101 1011
 ]       93     0101 1101

 A       65     $c<A    true for comma, quote and digits
 -       45     $c<"-"  true for comma and quote

                =0011 1010 -> 50 -> "2"
i^"["   105^91  ^0101 1011
 i      105      0110 1001
i^"]"   105^93  ^0101 1101
                =0011 0100 -> 52 -> "4"

3 डैश को जोड़ने $pऔर 2 को हटाने के लिए [, 4 के लिए ]एक जोड़ता है [और एक के लिए निकालता है ]।

— टाइटस
स्रोत

अच्छा काम फिर!

— क्रिस्टोफ़

4

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

f=lambda o,d=0:o<''and'\n'.join(f(e,d+1)for e in o)or'-'*d+'>'+o

अभी मेरा जवाब लगातार कोई डैश के साथ शुरू होता है, तो ["foo", "bar"]यह है:

>foo
>bar

— orlp
स्रोत

import sys, pprint; pprint.pprint(sys.argv)43 बाइट्स है, लेकिन मुझे नहीं पता कि यह कोड गोल्फ नियमों को तोड़ता है या नहीं।

— केर्ल

यह एक बाइट बचाता है:f=lambda o,d=0:o<''and'\n'.join(f(e,d+1)for e in o)or'-'*d+'>'+o

— बेन फ्रेंकल

@ कैरेल आप 'p के रूप में इम्पोर्ट पाइप्रिंट' नहीं कर सकते हैं या शायद (अगर यह काम करता है तो पक्का नहीं है) 'p के रूप में इम्पोर्ट करें pprint.pprint' (अच्छाई मुझे अपने फोन कीबोर्ड पर टिक टिक नहीं मिल सकती है)

— कोल

@Cole हम्म .. import sys, pprint.pprint as p; p(sys.argv)अभी भी 43 है लेकिन एक अच्छा सुझाव कोई भी कम नहीं है, डी कोशिश import sys.argv as vवास्तव में कुछ हद तक ~ 48 बाइट्स। यदि कोई sys.argv को समाप्त कर सकता है तो वे बहुत कुछ बचा सकते हैं लेकिन कार्यक्रम तब बहुत बेकार हो जाता है। एक पुनरावर्ती दृष्टिकोण काफी लंबा है def p(L,d=0): [p(i,d+1) if isinstance(i,list) else print(">"*d + i) for i in L], ~ 80 बाइट्स।

— Carel

3

पर्ल ५ , 55 बाइट्स

कोड + -nlझंडे के 53 बाइट्स ।

/"/?print"-"x~-$v.">$_":/]/?$v--:$v++for/]|\[|".*?"/g

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

कुछ नुकीले मामलों की वजह से रेगेक्स के लिए इष्टतम नहीं है जो संभावित रूप से हो सकता है (विशेष रूप से, यदि सरणी के एक तत्व में ब्रैकेट शामिल हैं)।
एक पुनरावर्ती अनाम फ़ंक्शन हालांकि (61 बाइट्स) मुश्किल से लंबा होगा:

sub f{my$v=pop;map{ref?f(@$_,$v+1):"-"x$v.">$_"}@_}sub{f@_,0}

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

लेकिन जिस तरह से पैरामीटर के साथ पर्ल का सौदा होता है वह गोल्फिंग कार्यों के लिए इष्टतम नहीं होता है: कोई वैकल्पिक पैरामीटर का मतलब यह नहीं है कि मुझे दूसरा कार्य करना है (अनाम) पहले वाले को कॉल करना है, और मुझे स्पष्ट रूप से उस लंबे समय के साथ अंतिम पैरामीटर प्राप्त करना होगा my$v=pop।

— बापू
स्रोत

3

माणिक, 49 45 46 बाइट्स

f=->c,p=?>{c.map{|x|x==[*x]?f[x,?-+p]:p+x}*$/}

उदाहरण:

puts f[["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]]

>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

स्पष्टीकरण:

पुनरावर्ती कार्य: यदि x==[*x]तब x एक सरणी है, और हम इस पर पुनरावृति करते हैं। यदि नहीं, तो इसे इंडेंट करें।

— जीबी
स्रोत

3

हास्केल, 104 बाइट्स

l@(x:y)#(a:m)|[(h,t)]<-reads$a:m=y++h++l#t|a<'#'=l#m|a<'-'='\n':l#m|a>'['=y#m|q<-'-':l=q#m
l#_=""
(">"#)

हास्केल के पास अलग-अलग गहराई के साथ नेस्टेड सूची नहीं है, इसलिए मुझे अपने दम पर इनपुट स्ट्रिंग को पार्स करना होगा। सौभाग्य से पुस्तकालय समारोह readsस्ट्रिंग्स (यानी" -चार्ज किए गए सीक्वेंस), इसलिए मुझे यहां थोड़ी मदद मिली है।

उपयोग उदाहरण:

*Main> putStrLn $ (">"#) "[[\"1\",\"2\"],[\"3\",\"4\"]]" 
->1
->2
->3
->4

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

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

फ़ंक्शन #स्ट्रिंग चार के माध्यम से चार से जाता है और अंतिम lके -साथ स्ट्रिंग के रूप में नेस्टिंग स्तर (पहला पैरामीटर ) रखता है >। यदि सूची के प्रमुख को स्ट्रिंग के रूप में पार्स किया जा सकता है, तो लें lऔर स्ट्रिंग को हटाए गए स्ट्रिंग के साथ पुनरावर्ती कॉल के बाद। यदि पहला char एक Space है, तो उसे छोड़ दें। यदि यह एक है ,, तो एक नई लाइन लें और अगर यह है ], तो घोंसले के शिकार के स्तर को कम करें और आगे बढ़ें और बाकी (केवल [बाएं) नेस्टिंग स्तर बढ़ाएं और आगे बढ़ें। खाली इनपुट स्ट्रिंग के साथ पुनरावृत्ति समाप्त होती है। मुख्य फ़ंक्शन (">"#)नेस्टिंग स्तर को ">"कॉल और कॉल करने के लिए सेट करता है #।

— nimi
स्रोत

2

एसडब्ल्यूआई-प्रोलॉग, 115 बाइट्स

p(L):-p(L,[>]).
p([],_):-!.
p([H|T],F):-p(H,[-|F]),p(T,F),!.
p(E,[_|F]):-w(F),w([E]),nl.
w([]).
w([H|T]):-write(H),w(T).

लाइन ब्रेक केवल पठनीयता के लिए जोड़े गए, बाइट काउंट में शामिल नहीं हैं।

pFएक स्तर को गहरा करते समय उपसर्ग में '-' जोड़ते हुए पुनरावर्ती आवर्ती का पता लगाता है । wउपसर्ग सरणी और साथ ही वास्तविक तत्व को आउटपुट में लिखने के लिए उपयोग किया जाता है।

उदाहरण:

?- p(["Atom",["Proton",["Up Quark", "Up Quark", "Down Quark"], "Neutron", ["Up Quark", "Down Quark", "Down Quark"], "Electron"]]).
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

— स्टीवन
स्रोत

2

बैच, 249 बाइट्स

@echo off
set/ps=
set i=
:t
set t=
:l
set c=%s:~,1%
set s=%s:~1%
if "%c%"=="[" set i=-%i%&goto l
if not "%c%"=="]" if not "%c%"=="," set t=%t%%c%&goto l
if not "%t%"=="" echo %i:~1%^>%t%
if "%c%"=="]" set i=%i:~1%
if not "%s%"=="" goto t

आम तौर पर बैच को कॉमा की तुलना करने में परेशानी होती है। नमूना रन:

[Atom,[Proton,[Up Quark,Up Quark,Down Quark],Neutron,[Up Quark,Down Quark,Down Quark],Electron]]
>Atom
->Proton
-->Up Quark
-->Up Quark
-->Down Quark
->Neutron
-->Up Quark
-->Down Quark
-->Down Quark
->Electron

— नील
स्रोत

2

रेटिना , 63 54 52 बाइट्स

मार्टिन एंडर की बदौलत 2 बाइट्स बचाए

.*?".*?"
$`$&¶
T`[] -~`-]_`.(?=.*".*")
-]

-"
>
T`]"

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

व्याख्या

.*?".*?"
$`$&¶

सबसे पहले, प्रत्येक उद्धृत स्ट्रिंग को प्रतिस्थापित करने से सरणी टूट जाती है, जो पहले आई थी, साथ ही साथ, एक नई पंक्ति। इसे इस तरह से तोड़कर, प्रत्येक स्ट्रिंग से पहले बेजोड़ उद्घाटन कोष्ठक को ढूंढना संभव है।

T`[] -~`-]_`.(?=.*".*")

इस लिप्यंतरण का स्थान ले लेगा [साथ -, छोड़ ]अपरिवर्तित, और हर दूसरे चरित्र को नष्ट ( -~सभी प्रिंट योग्य ASCII है)। हालांकि, यह केवल प्रत्येक पंक्ति पर अंतिम स्ट्रिंग से पहले आने वाले वर्णों को बदलता है।

-]

अगले सभी उदाहरणों -]को हटा दिया जाता है। ये मिलान ब्रैकेट जोड़े के अनुरूप हैं, और हम केवल बेजोड़ कोष्ठक चाहते हैं। इन्हें हटाए जाने के बाद, प्रत्येक पंक्ति में -कई एस के बराबर है, इससे पहले कि कितने बेजोड़ उद्घाटन कोष्ठक आए।

-"
>

तीर को बनाने के लिए, -इससे पहले अंतिम "को बदल दिया जाता है >।

T`]"

अंत में, सभी शेष ]s और "s हटा दिए गए हैं।

— बिजनेस कैट
स्रोत

ऐसा लगता है कि यह मानता है कि तार के अंदर (बच गए) उद्धरण नहीं होंगे। मुझे यकीन नहीं है कि यह वैध है लेकिन मैंने स्पष्टीकरण के लिए कहा है।

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

@MartinEnder अच्छा पकड़, मैं इस पर नज़र रखूंगा

— बिजनेस कैट

1

रोड़ा , 54 बाइट्स

f d=""{{|n|{n|f d=`$d-`}if[n is list]else[`$d>$n
`]}_}

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

यह एक फ़ंक्शन है जो स्ट्रीम से इनपुट सरणी को पढ़ता है। प्रत्येक आइटम के लिए, यह या तो खुद को पुनरावर्ती कहता है या आइटम को प्रिंट करता है।

— fergusq
स्रोत

1

पायथन 3, 80 बाइट्स

पायथन के लैंबडैस का समर्थन यह लगता है कि कौन जानता था?

p=lambda l,d=1:[p(i,d+1)if isinstance(i,list)else print("-"*d+">"+i)for i in l]

यह orlp के जवाब के लिए एक काउंटर / तारीफ है ।

— Carel
स्रोत

PPCG में आपका स्वागत है! ऐसा लगता है कि आपने एक अनुगामी लाइनफीड या कुछ और गिना है (क्योंकि मैं केवल 80 बाइट्स गिनता हूं) और आपको आसपास के रिक्त स्थान की आवश्यकता नहीं है =। मुझे यह भी संदेह है कि आप तीनों के बाद सभी रिक्त स्थान छोड़ सकते हैं ), लेकिन मैं पायथन में गोल्फ से बहुत परिचित नहीं हूं।

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

0

ग्रूवी, 92 बाइट्स

x={a,b->if(a instanceof List){a.each{x(it,b+1)}}else{y(a,b)}};y={a,b->println("-"*b+">$a")};

— जादू ऑक्टोपस Urn
स्रोत

0

स्टैक किया गया , 27 बाइट्स

[@.1-'-'*\'>'\,,out]deepmap

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

स्टैक के ऊपर से इनपुट लेता है और STDOUT पर आउटपुट छोड़ता है। यह एक गहरा मानचित्र बनाने, - dबार-बार दोहराने , '>' और स्वयं तत्व के साथ समतल करने के रूप में सरल है।

— कोनोर ओ ब्रायन
स्रोत

0

गामा, 63 वर्ण

\A=@set{i;-1}
[=@incr{i}
]=@decr{i}
"*"=@repeat{$i;-}>*\n
,<s>=

अन्य पार्सिंग समाधानों की तरह, यह मान लेता है कि तारों में कोई बची हुई दोहरी बोली नहीं होगी।

नमूना रन:

bash-4.3$ gema '\A=@set{i;-1};[=@incr{i};]=@decr{i};"*"=@repeat{$i;-}>*\n;,<s>=' <<< '[["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]'
->1
->2
-->1
-->2
->3
>4
---->5
>6

— आदमी काम पर है
स्रोत

0

JQ, 70 67 अक्षर

( 67 64 वर्ण कोड + 3 वर्ण कमांड लाइन विकल्प)

def f(i):if type=="array"then.[]|f("-"+i)else i+. end;.[]|f(">")

नमूना रन:

bash-4.3$ jq -r 'def f(i):if type=="array"then.[]|f("-"+i)else i+. end;.[]|f(">")' <<< '[["1","2"],[["1","2"],"3"],"4",[[[["5"]]]],"6"]'
->1
->2
-->1
-->2
->3
>4
---->5
>6

ऑन लाइन टेस्ट

— आदमी काम पर है
स्रोत

नेस्टेड सरणी कल्पना

पर कैसे?

उदाहरण

नियम

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

गणितज्ञ, 58 57 56 बाइट्स

जावा 7, 153 141 114 बाइट्स

PHP, 77 74 73 बाइट्स

C99 (GCC), 201 187 140 112 109

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

PHP, 129 123 112 109 95 93 91 बाइट्स

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

पर्ल ५ , 55 बाइट्स

माणिक, 49 45 46 बाइट्स

स्पष्टीकरण:

हास्केल, 104 बाइट्स

एसडब्ल्यूआई-प्रोलॉग, 115 बाइट्स

बैच, 249 बाइट्स

रेटिना , 63 54 52 बाइट्स

रोड़ा , 54 बाइट्स

पायथन 3, 80 बाइट्स

ग्रूवी, 92 बाइट्स

स्टैक किया गया , 27 बाइट्स

गामा, 63 वर्ण

JQ, 70 67 अक्षर