चुनौती

आप इस प्रश्न के लिए कार्य करते हैं कि उस सरणी में प्रत्येक पूर्णांक की दूसरी घटना पर पूर्णांक के इनपुट सरणी को विभाजित करें।

पर्याप्त स्पष्ट नहीं है? यहाँ एक उदाहरण है मदद करने के लिए

इनपुट सरणी:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

आउटपुट:

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

स्पष्टीकरण:

यहाँ केवल दूसरे तत्व को बोल्ड में हाइलाइट किया गया है:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5 ]

अब हम इन बोल्ड दूसरी घटनाओं के आसपास बंटवारे वाले ऐरे ब्लॉक रखते हैं:

[2 1] 1 [] 2 [3 2 2 4 5 6 7] 3 [] 7 [0] 5 []

और फ़ाइनल प्राप्त करने के लिए इन विभाजित सरणियों को एक सरणी में लपेटें

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

ध्यान दें कि जब आसन्न दूसरी घटनाएं होती हैं, तो खाली सरणियां होंगी।

नियम

हमेशा की तरह, आपको एसटीडीआईएन, एआरजीवी या फ़ंक्शन तर्क के माध्यम से एक पूरा कार्यक्रम या इनपुट सरणी लेने वाले फ़ंक्शन को लिखना होगा।

इनपुट

इनपुट में किसी भी सुविधाजनक सरणी (या सरणी-जैसे) पूर्णांक का प्रारूप होता है।

उदाहरण के लिए, निम्नलिखित में से कोई भी स्वीकार्य होगा:

2 1 1 1 4 5 6
[2 1 1 1 4 5 6]
[2, 1, 1, 1, 4, 5, 6]

उत्पादन

STDOUT के लिए आउटपुट करते समय, आपका सरणी किसी भी सुविधाजनक (नेस्टेड) सरणी प्रारूप में भी मुद्रित किया जा सकता है, उदाहरण के लिए

[[2 1] [1 4 5 6]]
[[2, 1], [1, 4, 5, 6]]
{{2, 1}, {1, 4, 5, 6}}

(यह आमतौर पर आपकी भाषा में सरणियों का मूल स्ट्रिंग प्रतिनिधित्व होगा।)

यह भी ध्यान दें कि खाली सरणियों का अनुगमन सरणी के भाग के रूप में मुद्रित किया जाना चाहिए।

स्कोरिंग

यह बाइट्स जीत में कोड-गोल्फ इतना छोटा कोड है!

— अनुकूलक
स्रोत

@PeterTaylor कई सवाल आउटपुट और इनपुट दोनों में सरणियों के विभिन्न स्वरूपों के लिए अनुमति देते हैं।

— ऑप्टिमाइज़र

5

""खाली सरणी के रूप में अनुमति देने की बात क्या है ? यह एक विशिष्ट गोल्फ भाषा की ओर फ़ावुरिज्म की खुशबू आ रही है।

— जॉन ड्वोरक

@JDDvorak चैट में चर्चा के बाद, इरादा वास्तव में अधिक समावेशी हो गया और आम तौर पर भाषाओं को अपने मूल प्रतिनिधित्व का उपयोग करने की अनुमति दी गई। मैंने उस क्लीयर को बनाने के लिए अब शब्दों का संपादन किया है।

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

1

क्या मैं सिर्फ उत्पादन कर सकता हूं 2 1, 1 4 5 6?

— jimmy23013

@ user23013 आपके द्वारा चुनी गई भाषा पर निर्भर करता है।

— ऑप्टिमाइज़र

6

एपीएल 25

1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←

उदाहरण:

]display 1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌→──────────────────────────────────────┐
│ ┌→──┐ ┌⊖┐ ┌→────────────┐ ┌⊖┐ ┌→┐ ┌⊖┐ │
│ │2 1│ │0│ │3 2 2 4 5 6 7│ │0│ │0│ │0│ │
│ └~──┘ └~┘ └~────────────┘ └~┘ └~┘ └~┘ │
└∊──────────────────────────────────────┘

पुराना वाला:

{1↓¨(1,(⍳⍴⍵)∊,{1↑1↓⍵}⌸⍵)⊂1,⍵}

यह कुंजी ऑपरेटर (a) के लिए एक अच्छा प्रश्न है जो Dyalog APL v14 के साथ पेश किया गया था। यह बाएं तर्क फ़ंक्शन ({1 the 1 ⍵ and}) लेता है और प्रत्येक अद्वितीय तर्क के लिए देता है, उस तर्क के लिए वेक्टर में सूचकांक। यहां मैं दूसरा इंडेक्स ले रहा हूं, फिर मैं जांचता हूं कि कौन से सूचकांक इस सूची ((∊) index) में मौजूद हैं और मूल वेक्टर को विभाजित करने के लिए परिणामस्वरूप बूलियन का उपयोग करें।

यहाँ ऑनलाइन कोशिश की जा सकती है:

http://tryapl.org

— मोरिस ज़ुक्का
स्रोत

अरे नहीं। अभी भी 24 से कम नहीं है?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र: 25 ... मैं कोशिश कर रहा हूँ ;-)

— मोरिस ज़ूका

मेरे स्वयं के समाधान के बजाय इसे स्वीकार करना :)

— ऑप्टिमाइज़र

केवल 24, और एक उचित कार्य:1↓¨{1,∨⌿<\2=+\∘.=⍨⍵}⊂1∘,

— Adám

दुर्भाग्य से काम नहीं करता है ... dfn में ओमेगा "ए" के समान नहीं है

— मोरिस ज़ुक्का

9

APL (Dyalog 14) (31)

{1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵}

यह एक फ़ंक्शन है जो एक सरणी लेता है और एक नेस्टेड सरणी देता है।

परीक्षा:

      +V← {1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵} 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌───┬┬─────────────┬┬─┬┐
│2 1││3 2 2 4 5 6 7││0││
└───┴┴─────────────┴┴─┴┘
      ⍝ this return value is a real nested array:
      ⎕←'Length: ',⍴V ⋄ (⍳⍴V){⎕←'Array #',⍺,': (', ⍵, ')'}¨V 
Length:  6
Array # 1 : ( 2 1 )
Array # 2 : ()
Array # 3 : ( 3 2 2 4 5 6 7 )
Array # 4 : ()
Array # 5 : ( 0 )
Array # 6 : ()

स्पष्टीकरण:

0,⍵: आसान प्रसंस्करण के लिए, 0सामने की तरफ जोड़ें ⍵। (यह एक घटना के रूप में नहीं गिना जाता है।)
(... )⊂: दिए गए बिटमास्क के अनुसार सरणी को विभाजित करें। 1बिटमेस्क में प्रत्येक पर एक नया समूह शुरू होता है ।
- +\∘.=⍨⍵: (मूल) में प्रत्येक मान के लिए ⍵, सभी घटनाओं को खोजें ⍵। फिर प्रत्येक मान के लिए एक रनिंग योग बनाएं, प्रत्येक स्थिति में प्रत्येक स्थिति के लिए एक वर्ग मैट्रिक्स दिखाते हुए ⍵कि पहले से ही कितने मूल्य आए हैं।
- ↓: मैट्रिक्स को अपनी पंक्तियों द्वारा विभाजित करें, प्रत्येक मूल्य के लिए यह एक सरणी देता है जो प्रत्येक स्थिति के द्वारा कितनी बार हुई है।
- 2⍳⍨¨: इनमें से प्रत्येक सरण में, पहले का सूचकांक ज्ञात कीजिए 2।
- (⍳⍴⍵)∊: प्रत्येक संभावित सूचकांक में ⍵, देखें कि क्या यह दूसरी घटनाओं के सूचकांकों की सूची में निहित है या नहीं। (ये पहले वाले को छोड़कर प्रत्येक समूह को शुरू करते हैं।)
- 1,: 1पहले समूह की शुरुआत को चिह्नित करते हुए, सामने से जोड़ें ।
1↓¨: प्रत्येक समूह से पहला तत्व निकालें। (ये जोड़ा गया है 0, और प्रत्येक मूल्य की दूसरी घटना है।)

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

8

जे, २ 28 २४ चार

रैंडम के लिए विशेष धन्यवाद ।

(1&,<;._1~1,2=+/@(={:)\)

यह इस तरह काम करता है। \इनपुट सरणी के सभी उपसर्गों ( ) पर, हम देखते +/@हैं कि उपसर्ग के कितने ( ) तत्व उस उपसर्ग के अंतिम तत्व ( ={:) के बराबर हैं । जब यह संख्या 2 हो जाती है, तो हम जानते हैं कि यह उस आइटम की दूसरी घटना है, इसलिए हम सरणी का उपयोग करके वहां विभाजित करते हैं <;._1।

   a=.2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
   (={:)\ a
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 1
   +/@(={:)\ a
1 1 2 2 1 3 4 1 1 1 1 2 2 1 2

सॉर्ट ट्रिक्स का उपयोग करके पुरानी बात (1&,<;._1~1,1=i.~(]-{)/:@/:):।

— algorithmshark
स्रोत

(1&,<;._1~1,2=+/@(={:)\)4 बाइट्स छोटा और बहुत सरल है। ( /:@/:हालांकि एक अच्छी चाल है।)

— यादृच्छिक

7

मैथेमेटिका, 58 51 49 बाइट्स

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&

यह एक अनाम फ़ंक्शन है जो सूची की तरह लेता है

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&[{2,1,1,2,3,2,2,4,5,6,7,3,7,0,5}]

और एक नेस्टेड सूची देता है जैसे

{{2, 1}, {}, {3, 2, 2, 4, 5, 6, 7}, {}, {0}, {}}

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

यह कुछ सुंदर अस्पष्ट जादू का उपयोग करता है SplitBy।

मैं एक फ़ंक्शन में प्रत्येक नंबर की घटनाओं का ट्रैक रख रहा हूं f। Mathematica में, आप प्रत्येक इनपुट के लिए एक फ़ंक्शन के मान को अलग-अलग परिभाषित कर सकते हैं, और आपको सभी संभावित इनपुट के लिए मान निर्दिष्ट करने की आवश्यकता नहीं है (यह स्टेरॉयड पर हैश तालिका की तरह अधिक है)।

इसलिए मैं fउन मानों के लिए प्रारंभ करके शुरू करता हूं जो इनपुट में मौजूद हैं (f@#=0;#)&/@।

अब SplitByएक सूची और एक फंक्शन लेता है और "सब्स्लिस्ट्स में सूची को विभाजित करता है जिसमें क्रमिक तत्वों के रन शामिल होते हैं जो fलागू होने पर समान मूल्य देते हैं " (ध्यान दें कि SplitByकोई भी तत्व नहीं हटाता है)। लेकिन (अनिर्दिष्ट) पकड़ है, कि प्रत्येक तत्व पर दो बारf कहा जाता है - जब इसकी तुलना अपने पूर्ववर्ती और उसके उत्तराधिकारी से की जाती है। तो अगर हम करते हैं

 SplitBy[{1,2,3,4},Print]

हमें सिर्फ एक बार ही प्रत्येक नंबर नहीं मिलता है, बल्कि इस प्रिंट को प्राप्त होता है

जो 3 तुलनाओं के लिए 6 कॉल है।

हम सूची को प्रत्येक दूसरी घटना से पहले विभाजित कर सकते हैं , यदि हम एक फ़ंक्शन लिखते हैं जो हमेशा लौटता है Falseलेकिन Trueदूसरी घटना के पहले तत्व की तुलना में जब रिटर्न होता है। उस तत्व पर तीसरी जाँच है (पहली घटना पर दो जाँच, और दूसरी घटना पर पहली जाँच)। इसलिए, हम उपयोग करते हैं ++f[#]==3&। अच्छी बात यह है कि यह पहले Falseसे ही दूसरी घटना के दूसरे चेक पर फिर से लौटता है , जैसे कि मैं Trueलगातार दूसरी घटनाओं के लिए वापस आ सकता हूं , लेकिन फिर भी उनके बीच विभाजन हुआ । इसी तरह, यह दूसरी घटनाओं के बाद विभाजित नहीं होगा , क्योंकि फ़ंक्शन पहले से ही दूसरे चेक पर फिर से लौटता है ।False

अब, प्रश्न यह है कि हम उन दूसरी घटनाओं को भी हटा दें, इसलिए हम प्रत्येक सूची में से पहला तत्व छोड़ते हैं Rest/@। लेकिन निश्चित रूप से, हम इनपुट में बहुत पहले तत्व को नहीं निकालना चाहते हैं, इसलिए हम वास्तव में शुरू करते हैं, एक तत्व aको सूची की शुरुआत के साथ जोड़कर {a}~Join~#। aएक अपरिभाषित चर है, जो गणितज्ञ सिर्फ एक अज्ञात के रूप में मानता है, इसलिए यह किसी भी अन्य मूल्यों को प्रभावित नहीं करेगा f। यह भी सुनिश्चित करता है कि इनपुट में पहला वास्तविक तत्व हर दूसरे तत्व की तरह इसकी दो जांच करता है।

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

वह बहुत चालाक है। तुम भी वास्तव Booleमें वहाँ की जरूरत नहीं है ।

— बेंत की मार

@swish आह, मुझे याद दिलाने के लिए धन्यवाद ... मैंने देखा कि मोबाइल पर रहते हुए, लेकिन इसे बदलने से पहले परीक्षण करना चाहता था।

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

5

पायथन, 148 बाइट्स

def s(a):z=len(a);x=[-1]+sorted({[i for i in range(z)if a[i]==n][1]for n in a if a.count(n)>1})+[z];return[a[x[i]+1:x[i+1]]for i in range(len(x)-1)]

बहुत ही भयावह समाधान। वहाँ एक बेहतर तरीका हो गया है ...

के साथ बुलाओ s([2, 1, 1, 1, 4, 5, 6])।

अनप्लग्ड संस्करण

def split(array):
  indices = [-1]
  second_occurrences = set()

  for n in array:
      if array.count(n) > 1:
          occurrences = [i for i in range(len(array)) if array[i] == n]
          second_occurrences.add(occurrences[1])

  indices += sorted(second_occurrences)
  indices += [len(array)]

  return [array[indices[i]+1:indices[i+1]] for i in range(len(indices)-1)]

— Sp3000
स्रोत

1

व्हाट ... क्या आप अन-गोल्फ संस्करण में संपादित कर सकते हैं? XD 148 अक्षर बहुत लंबी लाइन है;)

— सीन एलाड

1

@ शॉनआर्ड्रेड मैं एक स्पष्टीकरण पोस्ट नहीं करना चाहता था क्योंकि मुझे यकीन था कि मैं बेहतर कर सकता था, लेकिन जब से मुझे परेशानी हो रही है मैंने असंगठित संस्करण पोस्ट किया है: P

— Sp3000

5

हास्केल, 115 113 106 88

f?(x:s)|1<-f x=[]:x%f?s|a:b<-x%f?s=(x:a):b
f?x=[x]
(x%f)h=sum$f h:[1|x==h]
r s=(\_->0)?s

यह उस राशि को संग्रहीत करता है जो अब तक प्रत्येक तत्व तत्वों से उनकी संबंधित राशि तक एक फ़ंक्शन के रूप में दिखाई देता है, जो एक दिलचस्प चाल है।

यह %एक फ़ंक्शन का उपयोग करता है , जो एक फ़ंक्शन f और एक तर्क xदेता है एक नया फ़ंक्शन देता fहै जो उस पर लागू होने वाले रिटर्न पर तर्क देता है यदि यह इससे भिन्न है x, और 1 + f xअन्यथा।

उदाहरण के लिए, 3 % const 0एक फ़ंक्शन है जो 3 को छोड़कर प्रत्येक तर्क के लिए 0 देता है, जिसके लिए यह 1 लौटाता है। अपडेट:foldl बहुत छोटा प्रोग्राम प्राप्त करने के लिए फ्यूज़ किया गया।

— गर्वित हेकलर
स्रोत

यह दिलचस्प लग रहा है। क्या आप एक अनप्लग्ड संस्करण प्रदान कर सकते हैं?

— राडोमाज

4

रूबी 66 डेमो

f=->a{c=Hash.new 0
r=[[]]
a.map{|e|2==(c[e]+=1)?r<<[]:r[-1]<<e}
r}

रूबी stabby लैम्ब्डा जो एक सरणी को पैरामीटर के रूप में लेती है और सरणी की एक सरणी लौटाती है।

— क्रिस्टियन लुपस्कू
स्रोत

4

अजगर: 100 बाइट

def g(l):
 i=j=0;o=[]
 for e in l:
  if l[:i].count(e)==1:o+=[l[j:i]];j=i+1
  i+=1
 return o+[l[j:]]

सीधा समाधान। मैं सूची पर पुनरावृति करता हूं, गिनता हूं कि कोई चरित्र कितनी बार पहले दिखाई दिया, और अंतिम सूची के आउटपुट भाग के बाद से भाग को संलग्न करें।

— Jakube
स्रोत

3

रूबी, 66

f=->a{s=Hash.new 0
r=[[]]
a.map{|e|(s[e]+=1)==2?r<<[]:r[-1]<<e}
r}

व्याख्या

eप्रत्येक तत्व के लिए होने वाली गणना का एक प्रकार है, rएक एरे है जिसमें परिणाम संग्रहीत किया जाता है।
लूप को इनपुट करें, प्रत्येक तत्व के लिए होने वाली गणना को बढ़ाएं 1।
- यदि घटना गिनती है 2, तो हमें विभाजित होने की आवश्यकता है। Arrayपरिणाम के लिए एक खाली जोड़ें ।
- अन्यथा Arrayपरिणाम के अंतिम में केवल तत्व जोड़ें ।

— britishtea
स्रोत

2

अच्छा टोपी!! अरे रुको।

— ऑप्टिमाइज़र

4

क्या अविश्वसनीय संयोग है! आपके सामने मैंने जो जवाब पोस्ट किया है वह लगभग समान है। :)

— क्रिश्चियन लुपस्क्यू

ओह, यह भी 1 चरित्र छोटा है!

— ब्रिटिश काल

यह एक बचत है जिसे आप आसानी से अपने लिए लागू कर सकते हैं। मुझे लगता है कि यह भयानक है कि हमारे पास एक ही समय में एक ही विचार था। : डी

— क्रिश्चियन लुपस्क्यू

3

सीजेएम, 25 24 बाइट्स

q~{_L+:L1$a/,3=S@?}%Sa/p

जैसे STDIN से इनपुट लेता है

[ 2 1 2 1 0 2 2 1 1 3 4 3]

और जैसे आउटपुट

[[2 1] "" [0 2 2 1 1 3 4] ""]

मैं मूल रूप से सरणी के सभी तत्वों पर ध्यान केंद्रित कर रहा हूं, एक के बाद एक उन्हें दूसरे सरणी में डाल रहा है। फिर मुझे दूसरे एरे में करंट एलिमेंट की गिनती मिलती है। अगर इसकी 2, मैं उस स्थान से एक और सरणी शुरू करता हूं। इस तरह की यादृच्छिक सरणी की शुरुआत केवल स्टैक आधारित भाषा में प्राप्त की जा सकती है।

कोड विस्तार :

q~{_L+:L1$a/,3=S@?}%Sa/p
q~{               }%             "Evaluate the input array and map it on this block";
   _                             "Copy the current element in iteration";
    L+:L                         "Add the copy to an initially blank array L and update L";
        1$a/                     "Make another copy of the element and split L on it";
            ,3=                  "This checks if the splitted array is of length 3";
                                 "which indirectly means that L contains the element twice";
               S@?               "If the above is true, replace the element by space";
                    Sa/          "Split the final array on space. This final array contains";
                                 "second occurrence of every integer replaced by a space";
                       p         "Print the stringified version of the final nested array";

इसे यहाँ ऑनलाइन आज़माएँ

मार्टिन बट्स चैट पर 1 बाइट बचा

— अनुकूलक
स्रोत

3

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

s=->a{x=[];b=[[]];a.map{|e|x<<e;x.count(e)==2?b<<[]:b[-1]<<e};b}

— AlexRath
स्रोत

3

पर्ल 5: 36

यकीन नहीं होता अगर यह स्वीकार्य है क्योंकि यहां कोई वास्तविक विभाजन नहीं होता है।

#!perl -pa
$x{$_}++-1or$_=']['for@F;$_="[[@F]]"

उदाहरण:

$ perl spl.pl <<<"2 1 1 2 3 2 2 4 5 6 7 3 7 0 5"
[[2 1 ][ ][ 3 2 2 4 5 6 7 ][ ][ 0 ][]]

— nutki
स्रोत

पूरी तरह से स्वीकार्य है।

— ऑप्टिमाइज़र

अच्छा उत्तर। लेकिन मुझे लगता है कि मानक अभ्यास, -paदो अतिरिक्त बाइट्स के रूप में गिनना है (क्योंकि यह केवल दो बाइट्स की "लागत" है, क्योंकि आप -paeइसके बजाय इसे लिख सकते हैं-e )। तो यह 38 होगा, 36 नहीं।

— msh210

2

सीजेएम, 28 बाइट्स

Lq~{1$1$a/,3=S2$?@++}/-2%S/`

जैसे STDIN पर इनपुट लेता है

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

और आउटपुट को STDOUT की तरह प्रिंट करता है

[[2 1] "" [3 2 2 4 5 6 7] "" [0] ""]

ध्यान दें कि रिक्त स्ट्रिंग और खाली सरणियों CJam में एक ही बात कर रहे हैं, और के रूप में प्रदर्शित कर रहे हैं ""डिफ़ॉल्ट रूप से (यह है खाली सरणियों के देशी प्रतिनिधित्व)।

(मैंने चुनौती पोस्ट होने से थोड़ा पहले इस पर काम करना शुरू कर दिया था, क्योंकि हम चर्चा कर रहे थे कि चुनौती कितनी कठिन होगी।)

व्याख्या

मूल रूप से, मैं सरणी के प्रत्येक तत्व की नकल कर रहा हूं, जब तक कि यह दूसरी घटना न हो, जिस स्थिति में मैं पहली प्रति को किसी स्थान से प्रतिस्थापित करता हूं। गोल्फिंग कारणों से, इस संशोधित सरणी का निर्माण रिवर्स में किया गया है। तो [2 1 1 2 3 2 3]बन जाता है

[3 S 2 2 3 3 2 S 1 S 1 1 2 2]

फिर मैं अंत से हर दूसरे तत्व को चुनता हूं, जो कि मूल सरणी है, लेकिन दूसरी घटनाओं के साथ रिक्त स्थान द्वारा प्रतिस्थापित किया जाता है, अर्थात

[2 1 S S 3 2 S]

अंत में, मैं केवल रिक्त स्थान पर सरणी को विभाजित करता हूं। यहाँ कोड का टूटना है:

L                            "Push empty array.";
 q~                          "Read STDIN an evaluate.";
   {                }/       "For each element of the input.";
    1$1$                     "Copy the array and the element.";
        a/                   "Split the array by that element.";
          ,3=                "Check that it's split into 3 parts.";
             S2$?            "If so, push a space, else, copy the current number.";
                 @++         "Pull up the array from the bottom and add both to the beginning.";
                      -2%    "Pick every second element from the end.";
                         S/  "Split on spaces.";
                           ` "Get the string representation.";

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

चूंकि यह मेरी अपनी चुनौती है, मैं पहले एक मौका दे रहा हूं: पी। मेरे पास मेरे साथ एक 25 बाइट Cjam समाधान है।

— ऑप्टिमाइज़र

खाली सरणियों को सही ढंग से प्रदर्शित नहीं करता है - स्पष्ट रूप से अमान्य!

— feersum

1

@ फ़ेसर्स ने खाली सरणियों को प्रदर्शित किया ""जैसा कि प्रश्न के पहले संशोधन में स्पष्ट रूप से अनुमत है। वर्तमान पुनरीक्षण में कहा गया है "किसी भी सुविधाजनक प्रारूप ... आम तौर पर देशी स्ट्रिंग के रीपेस्टेशन"।

— जॉन ड्वोरक

2

यूनिक्स उपकरण, 100 बाइट्स

grep -o '[-0-9]*'|awk '{print(++A[$0]-2)?$0:"] ["}'|paste -sd' '|sed -e '/]/s/.*/[\0]/' -e's//[\0]/'

स्टड के माध्यम से इनपुट को स्वीकार करता है। यह मूल रूप से सिर्फ हर दूसरी घटना को बदल देता है "] ["। खाली तार के साथ काम नहीं करता है, []एक खाली स्ट्रिंग देगा, जो मुझे लगता है कि खाली सरणी का एक सुविधाजनक प्रतिनिधित्व है :)

— PGY
स्रोत

ठीक है, तो जवाब कल्पना से नहीं मिल रहा है, है ना? (नकारात्मक पूर्णांक के बारे में)। इसके अलावा, क्या 11? यह करने के लिए परिवर्तित हो जाएगा 1][?

— ऑप्टिमाइज़र

यह 11 के लिए अच्छी तरह से काम करता है, लेकिन आप नकारात्मक संख्याओं के बारे में सही हैं, जो निश्चित है, और यह अब सिंगलटन सरणियों को भी स्वीकार करता है।

— पग

2

एपीएल, 42 अक्षर

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}

उदाहरण:

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}2 1 1 2 3 2 2 4 5 6 7 3 7 0 5

आउटपुट:

( 2 1  )(   )(  3 2 2 4 5 6 7  )(   )(  0  )(  )

यहां परीक्षण किया गया।

अगर मुझे एपीएल ... 49 वर्णों में सही संरचना के रूप में व्याख्या की जाने वाली स्ट्रिंग का उत्पादन करना चाहिए

{'1↓1(',',⍬)',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂',⍬)('}

— jimmy23013
स्रोत

एपीएल में वास्तव में एक नेस्टेड सूची का प्रतिनिधित्व कैसे किया जाता है ? हो सकता है कि आपको स्ट्रिंग हेरफेर करने की आवश्यकता न हो

— ऑप्टिमाइज़र

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

— jimmy23013

2

जावा, 223

यह केवल Oracle या OpenJDK JRE पर काम करता है, क्योंकि मैं इस क्विकर का उपयोग क्वांटिफायर के कार्यान्वयन और लुक- बैक में उनके वेरिएबल-लेंथ-लुक-बैक को लागू करने के लिए करता हूं ।

class W{public static void main(String a[]){System.out.print("["+new java.util.Scanner(System.in).nextLine().replaceAll(" *\\b(\\d+)\\b(?=(.*))(?<=^(?=(.*\\b\\1\\b){2}\\2).*)(?<!^(?=(.*\\b\\1\\b){3}\\2).*) *","] [")+"]");}}

अधिकांश कार्य रेगेक्स में किया जाता है, जिसे नीचे कच्चे रूप में दिखाया गया है:

 *\b(\d+)\b(?=(.*))(?<=^(?=(.*\b\1\b){2}\2).*)(?<!^(?=(.*\b\1\b){3}\2).*) *

इससे पहले कि हम ऊपर के रेगेक्स को देखें, हमें समतुल्य .NET रेगेक्स देखें, जो सरल है, क्योंकि यह सीधे चर-लंबाई के लुक-बैक का समर्थन करता है (.NET लुक-बैक सबसे अधिक संभावना है कि दाएं-से-बाएं मिलान मोड) :

 *\b(\d+)\b(?<=(.*\b\1\b){2})(?<!(.*\b\1\b){3}) *

*\b(\d+)\bऔर *अंत में एक नंबर और आसपास के रिक्त स्थान (यदि कोई हो) से मेल खाता है। बाउंड चेक को आंशिक संख्या से मिलान करने से रोकने के लिए है, क्योंकि दोनों तरफ के स्थान वैकल्पिक हैं। यह संख्या को यह जांचने के लिए भी पकड़ लेता है कि क्या यह सरणी में दूसरा स्वरूप है।
(?<=(.*\b\1\b){2})जाँचता है कि उपरोक्त संख्या के 2 उदाहरण पाए जा सकते हैं। (?<!(.*\b\1\b){3})जाँचता है कि पकड़े गए संख्या के कोई 3 उदाहरण नहीं मिल सकते हैं। दोनों स्थितियों ने संयुक्त रूप से कहा कि संख्या के केवल 2 उदाहरण हैं। यह सुनिश्चित करने के लिए बाउंड चेक हैं कि पूरी संख्या का परीक्षण किया गया है।

जावा संस्करण पर वापस। परिवर्तनशील लंबाई को लागू करने के लिए, हम परिवर्तन करते हैं

(?<=var-length-pattern)

सेवा

(?<=^(?=.*var-length-pattern).*)

^{मैं इस तथ्य के बारे में थोड़ा हाथ लहराता हूं कि . लाइन सेपरेटर को बाहर करता है, लेकिन इसे आसानी से तय किया जा सकता है और मैं सिंटैक्स को और जटिल नहीं करना चाहता।}

लुक-फ़ॉरवर्ड हमेशा 0 लंबाई में होता है, और लंबाई चेक लागू होने के कारण गुजरता है * क्वांटिफायर ।

^यह काम करने के लिए आवश्यक नहीं है, लेकिन यह नहीं है में नाकाम रहने के मामले तेजी से विफल रहता है बनाने के लिए। Oracle / OpenJDK में लुक-बैक कार्यान्वयन पैटर्न की न्यूनतम लंबाई को पीछे ले जाकर किया जाता है, फिर मिलान करें, फिर कुल्ला करें और लंबाई बढ़ाकर दोहराएं जब तक कि मैच नहीं मिलता है, या सबसे खराब स्थिति में, पैटर्न की अधिकतम लंबाई तक । के साथ ^, मैं यह सुनिश्चित करता हूं कि उपसर्ग स्ट्रिंग केवल एक बार मेल खाता है।

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

(?=(.*))(?<=^(?=.*var-length-pattern\m).*)
   ^--^                              ^
   mth capturing group               m is the number of the capturing group marked

चूँकि मेरा पैटर्न पहले से ही शुरू है .*, इसलिए मुझे दूसरे को जोड़ने की आवश्यकता नहीं है .*।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

1

पर्ल 108

map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";push@a,[@b];s/.*/Data::Dumper->Dump(\@a)/e;

कार्रवाई में:

perl -MData::Dumper -pe '
    $Data::Dumper::Terse = 1;
    $Data::Dumper::Indent = 0;
    @a=@b=@e=();
    map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";
    push@a,[@b];
    s/.*/Data::Dumper->Dump(\@a)/e;
' <<<$'2 1 1 2 3 2 2 4 5 6 7 3 7 0 5\n2 1 1 1 4 5 6\n'"$(
    sed 's/./& /g;w/dev/stderr' <<< ${RANDOM}${RANDOM}${RANDOM}$'\n'${RANDOM}${RANDOM})"
2 4 4 7 7 2 9 8 8 4 6 0 1 8 
1 0 3 9 3 7 9 
[2,1][][3,2,2,4,5,6,7][][0][]
[2,1][1,4,5,6]
[2,4][7][][9,8][4,6,0,1,8]
[1,0,3,9][7][]

नोट: दो पहली लाइनें $Data::...केवल अच्छे प्रस्तुति के लिए हैं और तीसरी लाइन @a=@b=@e=();टूल को कई लाइनों पर काम करने के लिए है।

— एफ। होरी
स्रोत

1

आर, 76

y=scan();r=split(y,cumsum(ave(y,y,FUN=seq)==2));c(r[1],lapply(r[-1],"[",-1))

उदाहरण के लिए आउटपुट: तीन खाली वैक्टर सहित पांच तत्वों की एक सूची। ( numeric(0))।

$`0`
[1] 2 1

$`1`
numeric(0)

$`2`
[1] 3 2 2 4 5 6 7

$`3`
numeric(0)

$`4`
[1] 0

$`5`
numeric(0)

वैसे: कोड एक चेतावनी संदेश उत्पन्न करता है जिसे अनदेखा किया जा सकता है।

— स्वेन होहेंस्टीन
स्रोत

1

29 जगा

a[$1]++==1{print"-";next}1

यह इनपुट और आउटपुट प्रारूपों के साथ थोड़ी स्वतंत्रता लेता है। इनपुट "सरणी" लंबवत है, प्रति पंक्ति एक नंबर। आउटपुट ऊर्ध्वाधर भी है, प्रति पंक्ति एक संख्या, डैश अलग सरणियों के साथ।

इनपुट:

आउटपुट:

— केविन
स्रोत

1

अजगर 30 32

पायथ के साथ प्रयोग करने का यह मेरा पहला अवसर है। यह मेरे पायथन समाधान के समान ही समाधान है।

VQIq/<QN@QN1~Y]:QZN=ZhN;+Y]>QZ

आप इसे ऑनलाइन आज़मा सकते हैं: Pyth Compiler / Executor

जैसे इनपुट

[2,1,1,2,3,2,2,4,5,6,7,3,7,0,5]

छप जाएगा

[[2, 1], [], [3, 2, 2, 4, 5, 6, 7], [], [0], []]

स्पष्टीकरण:

                                 # Q = input(), Y = [], Z = 0
VQ                               # for loop: N iterates over the indices of Q
  I                              # if 
   q\<QN@QN1                     #    Q[N] appears exactly once in Q[:N]
            ~Y]:QZN              #         append the list [Q[Z:N]] to Y
                   =ZhN          #         and assign Z = N + 1
                       ;         # end if and for loop
                        +Y]>QZ   # print Y + [Q[Z:]]

— Jakube
स्रोत

क्या कोई बेहतर विकल्प है =Y+Y...?

— जकूबे

यह है -~Y...

— अनुकूलक

1

अजगर 2, 84

l=[[]];p=[]
for x in input():p+=[x];b=p.count(x)==2;l+=[[]]*b;l[-1]+=[x][b:]
print l

सूची lअब तक का आउटपुट है। हम तत्वों पर पुनरावृति करते हैं। यदि वर्तमान एक दूसरी उपस्थिति है, तो हम एक नया खाली सबलिस्ट शुरू करते हैं; अन्यथा, हम इसे नवीनतम सबलिस्ट में जोड़ते हैं। अब तक देखे गए तत्वों की सूची में संग्रहीत है p। अजीब बात है, सूची को फिर से संगठित करना इनपुट को कम करने से कम लगता है।

— XNOR
स्रोत

1

शुद्ध बैश 111 94

81 केवल विभाजन के लिए:

for i;do [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i;b[i]+=7;done;c+=("${d# }")
declare -p c

दूसरी लाइन declare -p cसिर्फ वेरिएबल को डंप करती है

नमूना:

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    declare -p c
}

नोट: लाइन local b c d iकेवल फ़ंक्शन को चलाने के लिए कई बार आवश्यक है।

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
declare -a c='([0]="2 1" [1]="" [2]="3 2 2 4 5 6 7" [3]="" [4]="0" [5]="")'

splitIntFunc 2 1 1 1 4 5 6
declare -a c='([0]="2 1" [1]="1 4 5 6")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
1 6 5 3 2 2 4 3 9 4 2 9 7 7 4 
declare -a c='([0]="1 6 5 3 2" [1]="4" [2]="9" [3]="2" [4]="7" [5]="4")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 4 5 2 9 1 1 4 8 7 8 1 0 3 
declare -a c='([0]="2 4 5" [1]="9 1" [2]="" [3]="8 7" [4]="1 0 3")'

सबसे सेक्सी प्रस्तुति (+26) के लिए

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    printf -v l "(%s) " "${c[@]}"
    echo "<$l>"

कुछ इस तरह प्रस्तुत करना होगा:

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
<(2 1) () (3 2 2 4 5 6 7) () (0) () >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
4 3 8 1 4 5 7 9 2 7 8 4 0 
<(4 3 8 1) (5 7 9 2) () (4 0) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
3 1 3 0 2 5 3 6 6 9 2 5 5 
<(3 1) (0 2 5 3 6) (9) () (5) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 2 2 9 1 9 5 0 2 2 7 6 5 4 
<(2) (2 9 1) (5 0 2 2 7 6) (4) >


}

— एफ। होरी
स्रोत

0

स्काला, 122 111

चरित्र संग्रह, के रूप में मुद्रित करें [21][][3224567][][0][], ~~122~~ 111:

def s(a:Any*)=print((("[","")/:a){case((b,c),d)=>if(b.indexOf(d)==c.indexOf(d))(b+d,c)else(b+"][",c+d)}._1+"]")

... या एक चरित्र संग्रह ले और नेस्टेड सूची, ~~135~~ 129:

def s(a:Char*)=(("",List(List[Any]()))/:a){case((b,c),d)=>b+d->(if(b.count(d==)==1)List()::c else(c.head:+d)::c.tail)}._2.reverse

मुझे यकीन है कि कुछ ऐसी बचतें हैं जो मुझे मिल सकती हैं, मैंने बहुत कठिन नहीं देखा है।

— चाड Retz
स्रोत

0

पायथन 220 बाइट्स

नीचे 220 बाइट्स हैं जो दूसरों के बहुत से तुलना में महान नहीं हैं, लेकिन बड़े पूर्णांकों के साथ तेजी से चलता है!

xlist = list(input()); result = []; x = 0
for i in range(len(xlist)):
    if xlist[0:i+1].count(xlist[i]) == 2: result.append(xlist[x:i]);x = i+1
    elif i == len(xlist)-1: result.append(xlist[x:])
print(result)

— एस रिक
स्रोत

नमस्ते, और PPCG में आपका स्वागत है! हालाँकि, आपका कोड वास्तव में बहुत छोटा नहीं है। मैं कुछ स्थानों को देखता हूं जहां आप निश्चित रूप से इसे छोटा कर सकते हैं। कृपया गोल्फिंग जारी रखें।

— 21’16

नमस्कार! यदि आपको मदद की गोल्फ की जरूरत है, तो आप रिक्ति के आसपास निकाल सकते हैं =, परिवर्तन xlistऔर resultकम नाम के लिए है, और चारों ओर खाली स्थानों को हटाना ==, ;और :। यदि आपको अधिक सहायता की आवश्यकता है, तो बस टाइप करें @NoOneIsHere(या कोई उपयोगकर्ता नाम) और I / उपयोगकर्ता मदद करने का प्रयास करेगा।

— NoOneIsHere

-1

जावा: 563 बाइट्स

ध्यान दें कि यह जावा 8 का उपयोग करता है, पूर्व JDK8 फॉर्च्यूनर के कारण कुछ बाइट्स लंबा होगा।

import java.util.*;public class a{static String c(String[]b){List<String>d=new ArrayList<>(Arrays.asList(b));Set<String>e=new HashSet<>();Set<String>f=new HashSet<>();for(int i=0;i<Integer.MAX_VALUE;i++){String g;try{g=d.get(i);}catch(IndexOutOfBoundsException ex){break;}
if(e.contains(g)&&!f.contains(g)){d.remove(i);d.add(i,"]");d.add(i+1,"[");f.add(g);i++;}else{e.add(g);}}
d.add(0,"[[");d.add(d.size(),"]]");StringBuilder sb=new StringBuilder();d.forEach(sb::append);return sb.toString();}
public static void main(String[]args){System.out.println(c(args));}}

— PoweredByRice
स्रोत

मैं लैम्बडा का उपयोग कैसे कर सकता हूं? जब तक आप अधिक "]" और "[" जोड़ते हैं, तब तक सरणी की लंबाई के अनुसार लूपिंग सही नहीं है।

— PoweredByRice

हर बार लंबाई को बढ़ाना अपवाद को पकड़ने जितना लंबा है, मुझे यह भी नहीं लगता कि जावा में CEILING को बदलना संभव है (i = 0 के लिए; i <CEILING; i ++)।

— PoweredByRice

सच में ?

— ऑप्टिमाइज़र

हम्म पता नहीं था कि, बाहर इशारा करने के लिए धन्यवाद।

— PoweredByRice

के बारे में क्या परिवर्तित Integer.MAX_VALUEकरने के लिए 2147483647? यह कम बाइट के साथ समान मूल्य है। इसके अलावा, IndexOutOfBoundsExceptionछोटा किया जा सकता हैException

— चार्ली

एक स्प्लिट सेकंड की तुलना में कम!

चुनौती

नियम

स्कोरिंग

एपीएल 25

APL (Dyalog 14) (31)

जे, २ 28 २४ चार

मैथेमेटिका, 58 51 49 बाइट्स

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

पायथन, 148 बाइट्स

अनप्लग्ड संस्करण

हास्केल, 115 113 106 88

रूबी 66 डेमो

अजगर: 100 बाइट

रूबी, 66

व्याख्या

सीजेएम, 25 24 बाइट्स

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

पर्ल 5: 36

सीजेएम, 28 बाइट्स

व्याख्या

यूनिक्स उपकरण, 100 बाइट्स

एपीएल, 42 अक्षर

जावा, 223

पर्ल 108

आर, 76

29 जगा

अजगर 30 32

स्पष्टीकरण:

अजगर 2, 84

शुद्ध बैश 111 94

सबसे सेक्सी प्रस्तुति (+26) के लिए

स्काला, 122 111

पायथन 220 बाइट्स

जावा: 563 बाइट्स