एक मेंढक की तरह छोड़ो!

Question

गैर-नकारात्मक पूर्णांक की एक सरणी को देखते हुए, आपका कार्य केवल इसके कुछ तत्वों को रखना है, जैसा कि नीचे वर्णित है।

• मान लीजिए कि सरणी है [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]।

• सबसे पहले, सरणी के पहले तत्व मिल n। पहले nतत्वों को रखें और अगले को त्यागें ( n+1वें को त्यागें )। नया ऐरे है [1, 2, 4, 11, 5, 2, 0, 13, 10, 1]।

• फिर, आप निकाले गए तत्व का अनुसरण करते हैं और ठीक उसी कार्य को करते हैं। प्रक्रिया को फिर से लागू करते हुए, हम प्राप्त करते हैं[1, 2, 11, 5, 2, 0, 13, 10, 1]

• आप इस प्रक्रिया को तब तक दोहराते हैं जब तक कि आप सरणी के सीमा के बाहर नहीं पहुँच जाते हैं / सरणी में कोई तत्व नहीं बचे हैं। हम रोकते हैं क्योंकि 11सरणी की लंबाई से अधिक है।

• अब आपको परिणाम का उत्पादन करना चाहिए।

इनपुट / आउटपुट किसी भी मानक रूप में लिया / दिया जा सकता है। सरणी कभी खाली नहीं होगी, और इसमें केवल गैर-नकारात्मक पूर्णांक होंगे। सभी मानक कमियां निषिद्ध हैं।

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

---

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

इनपुट -> आउटपुट

[१, २, ३, ४, ५] -> [१, ३, ४]

[६, १, ०, ५, ६] -> [६, १, ०, ५, ६]

[1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1] -> [1, 2, 11, 5, 2, 0, 13, 10, 1]

[२, २, २, २, २, २] -> [२, २]

[१, २, ३, १, २, ३, १, २, ३] -> [१, २]

[३, १, २, ४, ०] -> [] *

* अंतिम परीक्षण मामले में शामिल है 0, इसलिए मैंने इस तरह की प्रक्रिया को पोस्ट करने का फैसला किया, जो स्पष्ट है:

[3, 1, 2, 4, 0] --> [3, 1, 2, 0] --> [1, 2, 0] --> [1, 0] --> [0] --> [] )

^{( एरिक द आउटगोलर द्वारा इस चुनौती से प्रेरित )}

Comments

मैंने सभी परीक्षण मामलों को पूरी तरह से हाथ से लिखा है, कृपया मुझे सूचित करें यदि आपको लगता है कि कोई गलती है!

के 2बजाय पहले चरण में क्यों निकाला जाता है 3?

— लीक नन

@LeakyNun मेरी गलती। ठीक करना। मुझे पिंग करें अगर मैंने कोई और गलती की है

सुझाया गया टेस्ट केस:[1, 2, 3, 1, 2, 3, 1, 2, 3]

— रॉड

तो स्पष्ट करने के लिए, जब आप अपने नए " n" पर जाते हैं, तो आप हमेशा nतत्वों को रखने के लिए सरणी की शुरुआत से शुरू करते हैं? नहीं (जैसा कि मैंने पहली नज़र में सोचा था) उन nतत्वों को रखें जहाँ nआप पहले तत्व का मूल्यांकन कर रहे हैं?

— ब्रायन जे

Answer 1

पायथ, 18 बाइट्स

#IgZlQB .(Q=Z@QZ)Q

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

Comments

नहीं ।

— लीक नून

@ LeakyNun और मुझे लगा कि मैंने इसे पर्याप्त परीक्षण किया है! रफ़ू

— एरिक Outgolfer

कम से कम दिए गए टेस्टकेस की जांच करें।

— लीक नून

कभी कभी मुझे लगता है कि @LeakyNun कोड मुझे क्या यह वास्तव में हालांकि ... फिक्सिंग ... तय की तुलना में अलग परिणाम दे रहा है (ओह और btw मैं थोड़ा परीक्षण मामलों TBF बंद स्वरूपण दूर करने के लिए आलसी हूँ)

— एरिक Outgolfer

Answer 2

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

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

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

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

console.log(JSON.stringify(f([1, 2, 3, 4, 5]))) // --> [1, 3, 4]
console.log(JSON.stringify(f([6, 1, 0, 5, 6]))) // --> [6, 1, 0, 5, 6]
console.log(JSON.stringify(f([1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]))) // --> [1, 2, 11, 5, 2, 0, 13, 10, 1]
console.log(JSON.stringify(f([2, 2, 2, 2, 2, 2]))) // --> [2, 2]
console.log(JSON.stringify(f([1, 2, 3, 1, 2, 3, 1, 2, 3]))) // -> [1, 2]
console.log(JSON.stringify(f([3, 1, 2, 4, 0]))) // --> []

Answer 3

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

g.pure.(0:)के Intरूप में उपयोग की एक सूची लेने और लौटने के लिए एक अनाम फ़ंक्शन है (g.pure.(0:))[1,2,3,4,5]।

g.pure.(0:)
g(a,_:b:c)=g$splitAt b$a++b:c
g(a,_)=a

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

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

• फ़ंक्शन gएक स्प्लिट सूची का प्रतिनिधित्व करते हुए एक टपल तर्क लेता है। aपिछले चरण में रखे गए प्रारंभिक तत्वों की सूची है, _जिसे छोड़ दिया जाने वाला bतत्व है, लंबाई के रूप में उपयोग किया जाने वाला अगला तत्व है, और cशेष तत्व हैं।
  • यदि tuple के दूसरे भाग में a को चुनने के लिए पर्याप्त तत्व हैं b, तो एक नया विभाजन किया जाता है और gपुनरावृत्ति करता है। अन्यथा, यह aपरिणाम के रूप में साथ रुकता है ।
• अनाम फ़ंक्शन g.pure.(0:)यह सब gटुपल के साथ कॉल करके शुरू करता है ([],0:l), जहां lइनपुट है और इसके 0द्वारा तुरंत खारिज कर दिया जाता है g।
  • pureयहाँ Applicative(बाइनरी) टुपल्स के लिए उदाहरण का उपयोग किया गया है , और परिणाम प्रकार के साथ ([Int],[Int])आसानी से अपना तर्क दूसरे तत्व के []रूप में पहले तत्व के साथ टपल में रखा गया है।

Answer 4

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

f=lambda a,i=0:f(a[:a[i]]+a[a[i]+1:],a[i])if i<len(a)else a

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

Comments

प्रभावशाली! मेरे पास 65-बाइट गैर-पुनरावर्ती दृष्टिकोण (पायथन 2 में) था।

Answer 5

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

f s=s%s
s%(n:_)|(x,_:z)<-splitAt n s=(x++z)%z
s%_=s

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: f [1,2,3,4,5]।

Answer 6

जावा 8, 68 बाइट्स

यह लैम्ब्डा एक उत्परिवर्तनीय List<Integer>( remove(int)जैसे, समर्थन करता है ArrayList) को स्वीकार करता है । आउटपुट उत्परिवर्तित इनपुट है। को सौंपा Consumer<List<Integer>>।

l->{for(int i=0,f=0;i<l.size();f^=1)i=f>0?l.remove(i)*0+i:l.get(i);}

यह ऑनलाइन की कोशिश करो

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

Answer 7

APL (Dyalog Classic) , 32 बाइट्स

1∘{n∇⍣(n≤≢w)⊢w←⍵/⍨(n←1+⍺⊃⍵)≠⍳≢⍵}

व्याख्या

1∘{                             } bind 1 as starting left argument (⍺)
                             ⍳≢⍵  generate indexes for right argument (⍵)
                   (n←1+⍺⊃⍵)      n is 1+item at position ⍺ 
              w←⍵/⍨         ≠     w is ⍵ with item at n removed
   n∇⍣(n≤≢w)⊢                     recurse with n as left and w as right arg if n <= length of w

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

Answer 8

पर्ल 5 , 38 + 1 (-ए) = 39 बाइट्स

splice@F,$p=$F[$p],1while$p<@F;say"@F"

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

Answer 9

हास्केल, 99 बाइट्स (इंडेंटेशन के बिना 88)

f x y
 |y>=l=f x$l-1
 |e>=l=x
 |True=f (take e x ++ drop (1+e) x) e
 where e=x!!y
       l=length x

Comments

मैं शायद "ट्रू" के बजाय "1 = 1" का उपयोग करके 1 बाइट बचा सकता था, शायद "++" के पास के दो रिक्त स्थान भी निकाले जा सकते थे

— जियाको टेका पिगानी

Answer 10

VI, 31 25 बाइट्स

O@0kdd<C-v><C-a>Y<C-v><C-x>gg@a<Esc>"add<C-a>Y<C-x>@a

<C-?>से मेल खाती है Control + ?, और <Esc>करने के लिए Escapeस्पष्ट रूप से। इनमें से प्रत्येक 1 बाइट के लिए गिना जाता है ( मेटा देखें )।

इनपुट

इनपुट फ़ाइल में अंत में 1 पूर्णांक प्रति पंक्ति + 1 रिक्त पंक्ति होनी चाहिए, उदाहरण:

1
2
3
4
5
⁣

हम इनपुट फ़ाइल की प्रत्येक पंक्ति को एक एरे तत्व के रूप में देख सकते हैं, जैसे कि 1 :: 2 :: 3 :: 4 :: 5 :: []कुछ भाषाओं में (उदाहरण के लिए कैमल)।

प्रक्षेपण

आप निम्न आदेश के साथ vi शुरू कर सकते हैं, और स्ट्रोक द्वारा समाधान स्ट्रोक टाइप कर सकते हैं:

vi -u NONE input

आप इस एक-लाइनर का उपयोग भी कर सकते हैं:

vi -u NONE -c ':exec "norm O@0kdd\<C-v>\<C-a>Y\<C-v>\<C-x>gg@a\<Esc>\"add\<C-a>Y\<C-x>@a"' -c ":w output" -c ':q' input

यह outputएक इनपुट फ़ाइल से सही परिणाम के साथ एक फ़ाइल का उत्पादन करना चाहिए input।

स्पष्टीकरण

समाधान को पेश करने के लिए, मैं पहली बार केवल बिना सरणियों के लिए काम कर रहा एक 19-बाइट्स समाधान पेश करूंगा 0. यह समाधान एक पुनरावर्ती मैक्रो का उपयोग करता है, अंतिम समाधान में थोड़ा संशोधन के साथ उपयोग किया जाता है:

Yqa@0ddYgg@aquggY@a

आंशिक समाधान की व्याख्या

Y                       # yank first line (first integer + line break) to "0 register
 qa                     # start recording a macro ("a register)
   @0                   # jump n lines, where n is the content of the "0 register
     dd                 # delete the current line (n+1th line)
       Y                # yank current line (integer after the previously deleted line)
        gg              # go back to the first line
          @a            # recurse on macro "a"
            q           # finish recording the macro
             u          # cancel modifications done by the execution of the macro
              gg        # go back to the first line
                Y@a     # apply the recorded macro with first parameter equal to the first integer

यहाँ चाल "0वर्तमान पूर्णांक (और लाइन ब्रेक, बहुत महत्वपूर्ण) को संग्रहीत करने के लिए रजिस्टर का उपयोग करना है । इसलिए, कमांड लाइनों @0को कूदने की अनुमति देता है n( nमूल्य को कॉल करें "0)। यदि कूद फ़ाइल में लाइनों की संख्या से अधिक है, तो मैक्रो विफल हो जाएगा, इसलिए प्रोग्राम बंद हो जाएगा (सरणी सीमा के बाहर, आवश्यकतानुसार)।

लेकिन इनपुट होने पर यह समाधान काम नहीं करता है 0। वास्तव में, यदि "0रजिस्टर वैल्यू बराबर है 0, तो @0एक लाइन कूद जाएगी (लाइन ब्रेक के कारण), 0जैसा कि हम पसंद करते हैं। तो अगला कमांड ( dd) 0 वें पूर्णांक को नहीं हटाएगा, लेकिन 1 (सही नहीं)।

संभाल करने के लिए एक वैध समाधान यह 0है कि हमेशा पूर्णांक को yanking करने से पहले बढ़ाएँ, और उसके बाद इसे घटाएँ। इस प्रकार, @0कमांड n+1लाइनों को कूद देगा ( nवर्तमान पूर्णांक है जिसे बढ़ा दिया गया है)। kलाइन n(पिछली पंक्ति) पर जाने के लिए एक कमांड आवश्यक है । इस ट्रिक का उपयोग करते हुए, इनपुट फ़ाइल के अंत में एक खाली लाइन की आवश्यकता होती है, ताकि हम एरे के बाहर कूदने से बच सकें (इस प्रकार, प्रोग्राम को समाप्त करना), क्योंकि हम अब हमेशा n+1लाइन जंप करते हैं, पिछली लाइन पर जाने से पहले।

अंतिम समाधान की व्याख्या

O                                                       # insert a new line at the beginning of the file, enter insert mode to write the macro content
 @0                                                     # jump n lines                                                       
   k                                                    # go to the previous line
    dd                                                  # delete this line
      <C-v><C-a>                                        # type Control+A (C-v is needed because we are in insert mode) to increment the current integer
                Y                                       # yank the incremented integer
                 <C-v><C-x>                             # decrement the current integer
                           gg                           # go to the first line
                             @a                         # recurse on macro "a"
                               <Esc>                    # exit insert mode : at this step, the first line of the file contains the macro content @0kdd^AY^Xgg@a
                                    "add                # copy @0kdd^AY^Xgg@a line to the register "a and delete the line
                                        <C-a>           # increment the first integer
                                             Y          # yank it (into "0)
                                              <C-x>     # decrement the first integer
                                                   @a   # apply macro in a" (initial @0 will jump n+1 lines, since we incremented the first integer before calling the macro)

फ़ाइल के अंदर मैक्रो सामग्री को लिखने से पहले यह कुछ बाइट्स को बचाने की अनुमति देता है:

• qa...qपंजीकरण के बाद सभी परिवर्तनों को लिखने और पूर्ववत करने से बचा जाता है
• बचता है :let @a="...")

संपादित करता

# 1

• पहली पंक्ति पर मैक्रो सामग्री लिखें (अंतिम पंक्ति के बजाय)
• परिवर्तन इनपुट (अंत में 1 रिक्त लाइन)
• कमांड-लाइन में परीक्षण करने के लिए एक-लाइनर जोड़ें

Answer 11

पायथ, 32 बाइट्स

VlQIgNlQBK@QNI!K=QYBIgKlQB.(QK;Q

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

Comments

पायथ की तुलना में बहुत अधिक सुरुचिपूर्ण हो सकता है :) #VlQ.(Q@QN;Q12 बाइट्स में काम करता है, और मुझे पूरा यकीन है कि इसे और भी अधिक बढ़ाया जा सकता है

— डेव

पुराने स्कूल पायथोनिक दृष्टिकोण को रखकर आप W<Zl=Q+<Q@QZ>Qh@QZ=Z@QZ)Q(25) कर सकते हैं । हालांकि पिज़्ज़ेकम का दृष्टिकोण बहुत बेहतर है।

@KaranElangovan के लिए माफी माँगने के लिए कुछ भी नहीं, वे सिर्फ आपकी मदद करने की कोशिश कर रहे हैं।

— लीक से

अंतिम परीक्षण के मामले के लिए तय, यह 15 बाइट्स के लिए आता है #VlQ .(Q@QN)%;Q:। अजगर गोल्फरों से प्रतिक्रिया का स्वागत किया जाएगा, मैं अभी भी सीख रहा हूँ!

— डेव

यह दृष्टिकोण अमान्य है। इतना ही नहीं यह परिणाम केवल प्रिंट नहीं करता है, दफन यह भी परीक्षण के मामलों में विफल रहता है (कम से कम दूसरा आखिरी)। क्या आप इस उत्तर को हटा सकते हैं / ठीक कर सकते हैं?

Answer 12

सी # (.NET कोर) , 74 बाइट्स

n=>{for(int i=n[0];i<n.Count;){n.RemoveAt(i);i=i<n.Count?n[i]:n.Count+1;}}

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

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

Comments

यदि आप लैम्ब्डा परिभाषाओं में पैरामीटर प्रकारों की चूक की बात कर रहे हैं, तो इसकी अनुमति है ।

— जकॉब

@ जाकोब मैं समझता हूँ कि। मैं बस के System.Collections.Generic.List<int>बजाय के लिए थोड़ा गंदा लग रहा है using System.Collections.Genericऔर कि बाइट गिनती में जोड़ने। लेकिन मुझे लगता है कि यह किसी सरणी का उपयोग करने से अलग नहीं है।

— jkelm

ओह मैं समझा। usingयदि आप चाहें तो आप इसका उपयोग कर सकते हैं; जब तक लांबा स्वयं उस कथन पर भरोसा नहीं करता, जिसे आपको बाइट की गिनती में शामिल नहीं करना है। व्यक्तिगत रूप से मैं हमेशा टेस्ट कोड में पूरी तरह से योग्य नामों का उपयोग करता हूं ताकि यह स्पष्ट और आसानी से सत्यापित हो सके कि लैम्ब्डा उपयोग करता है क्या आयात करता है।

— जैकब

Answer 13

आर , 64 53 बाइट्स

f=function(a,i=1,d=a[i]+1)"if"(is.na(d),a,f(a[-d],d))

पुनरावर्ती कार्य। एक अनिवार्य इनपुट है, aसूची, जिसे छोड़ना है। i(डिफॉल्ट्स टू 1) कूदने के लिए चीजों की संख्या का dसूचकांक है , और आवश्यक मूल्य हटा दिए जाने के बाद अगले आइटम का सूचकांक है, जिसे हटाए जाने वाले आइटम का सूचकांक भी है। रिटर्न numeric(0), एक खाली वेक्टर, खाली आउटपुट के लिए।

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

Ungolfed:

f <- function(a, i = 1, d = a[i] + 1) {
  if(is.na(d)) {   # d is NA if and only if a[i] is out of bounds
    a
  } else {
    f( a[-d], d, a[d] + 1 )   # a[-d] is a with the item at index d removed
  }
}