स्वचालित रूप से एक सरणी

Question

हर कोई नेस्टेड सूची प्यार करता है! हालांकि, कभी-कभी नेस्टेड सूची बनाना कठिन होता है। आपको यह तय करना होगा कि क्या आप इसे अधिक से अधिक घोंसला बनाना चाहते हैं, या यदि आपको इसे उखाड़ने की आवश्यकता है। तो आपकी चुनौती के लिए, आपको एक सूची "ऑटोनॉस्ट" चाहिए। किसी सूची को स्वचालित करने के लिए, सूची में मौजूद प्रत्येक जोड़ी की तुलना करें।

• यदि दूसरा आइटम छोटा है, तो दोनों तत्वों को बंद करके और उनके बीच ब्रैकेट्स डालकर अलग करें, जैसे:

    } {
  {2 , 1}
  

  उदाहरण के लिए, {2, 1}बन जाता है {2}, {1}, और {3, 2, 1}बन जाता है{3}, {2}, {1}

• यदि दूसरा आइटम समान है, तो कुछ भी नहीं बदलें। उदाहरण के लिए, {1, 1, 1}वही रहता है, और {2, 1, 1, 1}बन जाएगा {2}, {1, 1, 1}।

• यदि दूसरा आइटम बड़ा है, तो प्रत्येक निम्न आइटम को एक स्तर गहरा घोंसला दें। उदाहरण के लिए, {1, 2}बन जाएगा {1, {2}}और {1, 2, 3}बन जाएगा{1, {2, {3}}}

चुनौती

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो संख्याओं की सूची में लेता है, और ऑटोनॉइड होने के बाद उसी सूची को वापस करता है। इस इनपुट को अपनी भाषाओं के मूल सूची प्रारूप (या निकटतम विकल्प) या एक स्ट्रिंग के रूप में लें। आपको घुंघराले ब्रेसिज़ का उपयोग करने की ज़रूरत नहीं है जैसे मैंने अपने उदाहरणों में किया था। जब तक यह सुसंगत है, आप अपनी भाषा में जो भी प्रकार के कोष्ठक हैं, का उपयोग कर सकते हैं। आप सुरक्षित रूप से मान सकते हैं कि सूची में केवल पूर्णांक होंगे। आप यह भी मान सकते हैं कि सूची में कम से कम 2 नंबर होंगे। यहाँ कुछ नमूना IO है:

{1, 3, 2}                         -->   {1, {3}, {2}}
{1, 2, 3, 4, 5, 6}                -->   {1, {2, {3, {4, {5, {6}}}}}}
{6, 5, 4, 3, 2, 1}                -->   {6}, {5}, {4}, {3}, {2}, {1}
{7, 3, 3, 2, 6, 4}                -->   {7}, {3, 3}, {2, {6}, {4}}
{7, 3, 1, -8, 4, 8, 2, -9, 2, 8}  -->   {7}, {3}, {1}, {-8, {4, {8}, {2}, {-9, {2, {8}}}}}

स्टैंडर्ड कमियां लागू होती हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है!

Comments

क्या हम अपनी भाषा के स्ट्रिंग प्रारूप में इनपुट ले सकते हैं?

— डाउनगेट

पूर्णांक का अधिकतम आकार क्या है?

— thepiercingarrow

@thepiercingarrow मैं वास्तव में बहुत ज्यादा परवाह नहीं करता। यह कुछ भी हास्यास्पद नहीं होगा। आपको कम से कम संभाल करने में सक्षम होना चाहिए, [-100, 100]लेकिन मैं विशाल इनपुट देने की योजना नहीं बना रहा हूं।

— जेम्स

"अगर दूसरे मद में छोटा होता है, तो घोंसला सभी तत्वों के बाद एक स्तर अधिक है, एक बंद कोष्ठक डालने से। फिर, एक खुला कोष्ठक डालने सुनिश्चित करें कि सभी कोष्ठक मिलान किया रहने बनाने के लिए,। उदाहरण के लिए, {2, 1}हो जाता है {2}, {1}" कैसे है कि एक स्तर उच्चतर ? एक स्तर अधिक होगा {2}, 1। आपके पास जो है वही स्तर है।

— msh210 7

@ msh210 हाँ, यह एक खराब व्याख्या थी। वर्तमान बेहतर है?

— जेम्स

Answer 1

MATL , 48 43 बाइट्स

YY_XKx"@K<?93]44@K-?91]@XKV]v93Gd0>sQY"h4L)

यह इनपुट और आउटपुट में वर्ग कोष्ठक का उपयोग करता है। आउटपुट में विभाजक के रूप में रिक्त स्थान के बिना कॉमा है।

ध्यान दें कि MATL में एक नेस्टेड सूची के रूप में आउटपुट की व्याख्या नहीं की जाएगी। यह अन्य भाषाओं में होगा, और यह चुनौती में आउटपुट विनिर्देश को संतुष्ट करता है।

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

व्याख्या

YY_XKx   % Push -inf. Copy to clipboard K (represents previous input entry). Delete
"        % Take numerical array implicitly. For each entry:
  @K<    %   Is current entry less than the previous one?
  ?93]   %   If so, push 93 (ASCII for ']')
  44     %   Push 44 (ASCII for comma)
  @K-    %   Is current entry different from the previous one?
  ?91]   %   If so, push 91 (ASCII for '[')
  @XKV   %   Push current entry, copy into clipboard K, convert to string
]        % End for each
v        % Concat vertically all stack contents, converting to char
93       % Push 93 (ASCII for ']') (to be repeated the appropriate number of times)
Gd0>sQ   % Determine how many times the input increases, plus 1
Y"       % Repeat 93 that many times
h        % Concat horizontally with previous string. Gives a row array, i.e. string
4L)      % Remove first char, which is an unwanted comma. Display implicitly

Answer 2

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

a#b|a<b=",{"|a>b="},{"|1<2=","
f(a:b:c)=show a++a#b++f(b:c)++['}'|a<b]
f[x]=show x++"}"
('{':).f

उपयोग उदाहरण: ('{':).f $ [7,3,3,2,6,4] ->"{7},{3,3},{2,{6},{4}}"।

जैसा कि हास्केल के पास नेस्टेड सूची नहीं है, मैं एक स्ट्रिंग के रूप में परिणाम लौटाता हूं। घोंसले के शिकार एल्गोरिथ्म आसान है: ए) प्रिंट नंबर, बी) अगर अगली संख्या अधिक है (कम, बराबर), प्रिंट ,{( },{, ,), सी) बाकी सूची के साथ एक पुनरावर्ती कॉल करें, तो डी) प्रिंट }अगर संख्या है कम अगले एक, ई) लगा देना में सब कुछ की तुलना में {और }।

Comments

क्षमा करें, मैं

— दुखी

Answer 3

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

p,*i=eval(input())
c=[p]
a=b=[c]
for x in i:
 if x>p:b=c
 if x!=p:c=[];b+=[c]
 c+=[x];p=x
print(a)

उदाहरण:

$ python3 autonest.py <<< "[7, 3, 1, -8, 4, 8, 2, -9, 2, 8]"
[[7], [3], [1], [-8, [4, [8], [2], [-9, [2, [8]]]]]]

Answer 4

जावा 8 197 187 193 192 बाइट्स

---

इस टिप्पणी पर मेरे साथ काम करने वाले सभी टिप्पणीकारों का शुक्रिया। यह 187 बाइट्स तक नीचे गिरा था, जब तक मुझे एक महंगा बग नहीं मिला। हालांकि ब्लैक मैजिक की शक्ति के कारण "ऑपरेटर" से नीचे चला जाता है -> "बाइट की गिनती एक स्वस्थ 192 बाइट्स में होती है।

---

String a(int[]b){int l=b.length,d=1,i=0;String c="{";for(;i<l-1;i++)if(b[i]>b[i+1])c+=b[i]+"},{";else if(b[i]<b[i+1]){d++;c+=b[i]+",{";}else c+=b[i]+",";c+=b[l-1];while(d-->0)c+="}";return c;}

Comments

क्षमा करें ठीक ऊपर @Blue

— रोहन झुनझुनवाला

इसके अलावा, सुझावों की एक जोड़ी: 1. आप एक अनुक्रम के बजाय एक सरणी के रूप में इनपुट ले सकते हैं: (int [] b) 2. आप कॉमा (int l = b.length) का उपयोग करके एक ही समय में कई ints को परिभाषित कर सकते हैं, d = 1, मैं = 0)। 3. आपको जितना संभव हो उतने गोरों की गति को हटा देना चाहिए (चर असाइनमेंट के बीच)। उम्मीद है की यह मदद करेगा!

— ब्लू

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

— माल्टीसेन

ओह ठीक है मेरी क्षमायाचना @ मैल्टीसेन मैं इसे एक पूर्ण जावा कार्यक्रम में एम्बेड करूँगा। मैं सिर्फ "फ़ंक्शन या प्रोग्राम" जो "रिटर्न" कह रहा था से दूर जा रहा था। तो क्या मुझे अपना आउटपुट प्रिंट करने के लिए इसे रिफैक्ट करना चाहिए

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला क्षमा करें, अधिक स्पष्ट होना चाहिए था। जब मैंने "स्निपेट" कहा, तो मैं आपके कोड के बारे में बात नहीं कर रहा था, बल्कि आपके प्रारूपण के बारे में बात कर रहा था। जब किसी पोस्ट में कोड डालने की कोशिश की जाती है, तो "स्निपेट" बटन पर क्लिक न करें, बल्कि इसे एक कोड ब्लॉक (4 रिक्त स्थान या ctrl-k) में

— डालें

Answer 5

सी, 145 138 बाइट्स

7 बाइट्स के लिए जियाकोमो के लिए धन्यवाद!

#define P printf(
n;main(c,v,p,t)char**v;{p=-101;for(v++;*v;v++){t=atoi(*v);if(t<p)P"}{");if(t>p)P"{",n++);P"%d ",p=t);}for(;n--;)P"}");}

इनपुट को कमांड लाइन आर्ग्युमेंट्स के माध्यम से लिया जाता है और आउटपुट को स्टडआउट दिया जाता है।

नमूना रन:

$ ./autonest 7 3 1 -8 4 8 2 -9 2 8
{7 }{3 }{1 }{-8 {4 {8 }{2 }{-9 {2 {8 }}}}}

Comments

स्रोत केt=atoi(*v); बजाय उपयोग की कोशिश करेंsscanf(*v,"%d",&t);

— जियाको गारबेलो

for(;*++v;)पहले 4 को बचाने के लिए उपयोग करें और फिर 10 और के लिए if(t<p)P"}{");if(t>p)P"{",n++);उपयोग के t>p?P"}{"):P"{",n++);लिए प्रेरित किया ।

— जियाको गारबेलो

Answer 6

CJam, 51 49 48 46 बाइट्स

इस तथ्य को उजागर करता है कि अंतिम ब्रैकेट की संख्या आसन्न जोड़ी की संख्या से अधिक है जो सरणी में बढ़ रही है।

और मैं ewऑपरेटर को नहीं जानता, इससे पहले कि मुझे फिर से लागू करना पड़े।

इनपुट वर्ग कोष्ठक द्वारा सीमांकित अंतरिक्ष अलग सूची है।

'[q~_W=\2ew_{~\_@-g)["["S"]["]=}%@@{~>M']?}%']

व्याख्या

'[q~_W=\2ew_{~\_@-g)["["S"]["]=}%@@{~>M']?}%']
'[                                             e# Opening bracket
  q~                                           e# Read the input
    _W=\2ew                                    e# Save the last item and turn array into array of pair of next item and the item itself.
            _                                  e# We need two copies of that item                                       
             {~\_@-g)["["S"]["]=}%             e# Build the "body" that consist of the item and the suitable delimiter, space if equal, opening brace if the first item is the smallest, otherwise, closing bracket and opening bracket.
                                  @@           e# Put in the last item. (It was omitted in previous phase)
                                    {~<']""?}% e# Create the closing bracket as many as the number of increasing adjacent pair
                                               '] e# And one more bracket.

मैं यह पता लगाऊंगा कि प्रीटीप्रिनटिंग पर निर्भर होने के बजाय वास्तविक नेस्टेड सरणी के साथ यह कैसे करना है।

अंत में, पीटीई MATL के जवाब के साथ बराबर है ।

Comments

अंत में, MATL के उत्तर को पीटें अब नहीं :-P

— लुइस मेंडो

@LuisMendo ऊ।

— अकांगका जूल

Answer 7

रेटिना, 71 70 बाइट्स

सूचियाँ अंतरिक्ष से अलग होती हैं, घुंघराले ब्रेसिज़ के साथ {1 2 3}:। नकारात्मक संख्याएं समर्थित नहीं हैं, इसलिए यदि यह समस्या है, तो मैं अपना उत्तर हटा दूंगा। रेटिना + नकारात्मक संख्या = इसके लायक नहीं है।

\d+
$*
+`\b(1+) (1+\1\b.*)
$1 {$2}
+`\b(1(1+)1*) (\2)\b
$1} {$2
1+
$.0

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

Answer 8

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

a=>a.map(r=>l-r?(n=l<r?m:n).push(m=[l=r]):m.push(l),l=a[0],o=n=[m=[]])&&o

स्पष्टीकरण: लगातार समान वस्तुओं का मामला आसान है; आइटम सिर्फ अंतरतम सरणी में जोड़ा गया है (यहां mचर द्वारा दर्शाया गया है ; nवह सरणी जिसमें mइसका अंतिम तत्व है, जबकि oआउटपुट है)। विभिन्न मदों के मामले में, आइटम हमेशा एक नए अंतरतम सरणी में जाता है, एकमात्र अंतर यह है कि क्या वह सरणी भाई या पिछले अंतरतम सरणी का बच्चा है। अतिरिक्त गोल्फ के लिए मैंने सरणियों की स्थापना की ताकि प्रारंभिक वस्तु लगातार बराबर आइटम के रूप में गिना जाए।