बत्तख, बत्तख, जोसेफस

49

एक पूर्णांक सरणी को देखते हुए:

  1. पहले नंबर से शुरू करें
  2. जहां वर्तमान स्थिति का मान है वहां n n स्थिति को आगे बढ़ाएं
  3. वर्तमान स्थिति हटाएं, जिससे यह पता चले कि अगली स्थिति वर्तमान स्थिति क्या थी।
  4. गोटो स्टेप 2 जब तक एक नंबर बाकी है
  5. उस नंबर को प्रिंट करें

नियम

सरणी रैप-अराउंड (सरणी में अंतिम संख्या के बाद अगला नंबर पहला नंबर है)।

एक शून्य खुद को हटा देता है (जाहिर है)।

इनपुट के रूप में नकारात्मक संख्या की अनुमति नहीं है।

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

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

चरण-दर-चरण उदाहरण

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number (the 'new' 'current' position)
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3  ] remove number in that position
       ^    take next position (looping)
 ^          jump 3 positions (looping on the end of the array)
[      3  ] remove number in that position
print 3

उदाहरण # 2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

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

code-golf  array-manipulation 
— workoverflow
स्रोत
14
अच्छी पहली चुनौती!
— लुइस मेंडो
2
@LuisMendo हाँ .. "एक तरह छोड़ें ..." चुनौतियां
— J42161217
2
@ जेनी_मैथी मुझे नहीं लगा कि ऐसा ही होगा, लेकिन जैसा कि लुइस ने कहा, रैपराउंड सरणी गोल्फिंग के लिए एक दिलचस्प चुनौती है। मुझे लगता है: /
— वर्कओवरफ्लो
3
@EriktheOutgolfer वास्तव में एक डुबकी नहीं है। वहां के तत्व अप्रभेद्य हैं और चरण आकार निश्चित है। लुइस बहुत करीब है, लेकिन अभी भी पर्याप्त रूप से अलग मुझे लगता है।
— मार्टिन एंडर
3
क्या इसे वास्तव में अंतिम संख्या प्रिंट करने की आवश्यकता है, या क्या यह इसे वापस कर सकता है? क्या यह वास्तव में नंबर वापस करने की आवश्यकता है, या यह सिर्फ सरणी में जगह पर काम कर सकता है इसलिए फ़ंक्शन को चलाने के बाद, सरणी में बस नंबर होता है?
— Inotnotayaynard

जवाबों:

7

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

f[x]=x
f(x:r)=f$snd<$>zip r(drop(x+1)$cycle$x:r)

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

स्पष्टीकरण:

  • f[x]=x: यदि दी गई सूची एक एकल सूची है, तो उसके तत्व को वापस लौटाएं।
  • f(x:r)=f$ ...: अन्यथा पुन f: निम्न सूची में लागू होता है:
    • वर्तमान सूची के तत्व असीम रूप से चक्रीय होते हैं ( cycle$x:r),
    • x+1हटाए गए पहले तत्वों के साथ ( drop(x+1)$),
    • और की लंबाई तक काट दिया गया r। ( snd<$>zip rएक छोटा विकल्प है take(length r))।

पिछला 54 बाइट संस्करण:

f=(%)=<<head
_%[x]=x
n%(x:r)|n<1=f r|s<-r++[x]=(n-1)%s

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

— Laikoni
स्रोत
6

MATL , 21 बाइट्स

1`yy)+ynX\[]w(5Mynq]x

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

1        % Push 1: current position in the array
`        % Do...while
  yy     %   Duplicate top two elements in the stack. Takes input implicitly
         %   in the first iteration.
         %   STACK: array, position, array, position
  )      %   Get specified entry in the array
         %   STACK: array, position, selected entry
  +      %   Add
         %   STACK: array, position (updated)
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements or array
  X\     %   1-based modulus
         %   STACK: array, position (wrapped around)
  []     %   Push empty array
         %   STACK: array, position, []
  w      %   Swap
         %   STACK: array, [], position
  (      %   Write value into specified entry in array. Writing [] removes
         %   the entry
         %   STACK: array (with one entry removed)
  5M     %   Push latest used position. Because of the removal, this now
         %   points to the entry that was after the removed one
         %   STACK: array, position
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements of array
  q      %   Subtract 1
         %   STACK: array, position, number of elements of array minus 1
]        % End. If top of the stack is nonzero, proceed with next iteration
         % STACK: array (containing 1 entry), position
x        % Delete. Implicitly display
         % STACK: array (containing 1 entry)
— लुइस मेंडो
स्रोत
1
नोट: पॉइंटर रखने के बजाय लिस्ट रोटेशन का उपयोग करना संभवतः इसे बहुत कम कर देगा।
— एरिक आउटफोलर
1
@ एरिक धन्यवाद। लेकिन अब जब मैंने स्पष्टीकरण जोड़ा तो मुझे लगता है कि मैं इसे इस तरह छोड़ दूंगा
— लुइस मेंडू
खैर, आप हमेशा स्पष्टीकरण को हटा सकते हैं, इसे इतिहास में रखा जाएगा :)
— एरिक द आउटगोलर
6

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

f=lambda x:x and f((x+x*x[0])[x[0]:][1:len(x)])or x

आउटपुट एक सिंगलटन सूची है।

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

— डेनिस
स्रोत
पूरी तरह से असंबंधित, लेकिन मुझे आपकी गेंडा टोपी, डेनिस पसंद है। xD (और हमेशा की तरह अच्छा जवाब!)
— केविन क्रूज़सेन
5

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

l~_,({_0=m<1>}*

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

व्याख्या

एक पॉइंटर का ट्रैक रखने के बजाय, मैं सिर्फ एरे को साइकल रूप से शिफ्ट करता हूं ताकि वर्तमान तत्व हमेशा सामने रहे।

l~     e# Read and evaluate input.
_,(    e# Get its length L and decrement to L-1.
{      e# Run this block L-1 times...
  _0=  e#   Get the first element X.
  m<   e#   Rotate the array left by X positions.
  1>   e#   Discard the first element.
}*
       e# The final element remains on the stack and gets printed implicitly.

एक मजेदार विकल्प जो दुर्भाग्य से किसी भी बाइट को नहीं बचाता है:

l~_{;m<1>_0=}*;
— मार्टिन एंडर
स्रोत
5

ब्रेन-फ्लैक , 88 बाइट्स

([[]]()){({}<(({})){({}<({}<([]){({}{}<>)<>([])}{}>)<>{({}[<>[]])<>}<>>[()])}{}{}>())}{}

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

व्याख्या

([[]]())                      Push negative N: the stack height - 1
{({}< … >())}{}               Do N times
     (({}))                     Duplicate M: the top of the stack
     {({}< … >[()])}{}          Do M times 
                                  Rotate the stack by 1:
          ({}< … >)               Pop the top of the stack and put it back down after
          ([]){({}{}<>)<>([])}{}  Pushing the rest of the stack on to the other one, in reverse, with the stack height added to each element (to ensure that all are positive)
          <>{({}[<>[]])<>}<>      Push the rest of the stack back, unreversing, and subtracting the stack height from each element
                      {}        Pop the top of stack
— H.PWiz
स्रोत
1
एक बहुत ही अजीब गोल्फ लेकिन यहाँ यह 88 बाइट्स में है ।
— गेहूं जादूगर
1
@WheatWizard नाइस, आश्चर्य की बात है कि मैंने पहले जैसा कुछ करने की कोशिश की।
— एच। वाइज
मैं कभी नहीं जान सकता कि लोग कैसे कोड कर सकते हैं! क्या कोई छद्म कोड अनुवादक या कुछ और है?
— वर्कओवरफ्लो
1
@workoverflow नहीं, यह ईमानदारी से लग रहा है की तुलना में आसान है। यह वास्तव में शुरू होने से पहले बहुत चुनौतीपूर्ण था, लेकिन जब आज्ञाएं सरल होती हैं, तो यह सीखना आसान होता है।
— H.PWiz
5

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

def f(a):
 while a[1:]:l=a[0]%len(a);a[:]=a[-~l:]+a[:l]

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

एक एकल सूची के रूप में आउटपुट, जैसा कि डिफ़ॉल्ट रूप से अनुमति है । डेनिस की बदौलत कुछ बाइट्स को बचाया , मुझे याद दिलाते हुए कि फ़ंक्शन तर्क को संशोधित करने की अनुमति है।

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

  • def f(a)- एक पैरामीटर के साथ एक फ़ंक्शन को परिभाषित करता है a।

  • while a[1:]:- जबकि aपहले निकाले गए तत्व सत्य है, अनुसरण करने के लिए कोड का ब्लॉक चलाएं। एक तत्व या अधिक के साथ एक सूची सत्य है, और खाली सूची पायथन में झूठी हैं, इसलिए यह a1 की लंबाई तक पहुंचने के बाद बंद हो जाएगा ।

  • l=a[0]%len(a)- पहले तत्व को लें, और उसकी लंबाई के शेष भाग को प्राप्त करें a। को परिणाम सौंपें l।

  • a[:]=a[-~l:]+a[:l]- तत्वों aद्वारा बाईं ओर घुमाएं l, और पहले एक को हटा दें, जबकि इसे aजगह में असाइन करें ।

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

f=lambda a,i=0:a[1:]and f(a,a.pop(((a*-~i)[i]+i)%len(a))+1)or a

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

हालांकि अब, यह बहुत अधिक सुरुचिपूर्ण लगता है। चैट में मदद करने के लिए ओवर्स का भी धन्यवाद।

— श्री Xcoder
स्रोत
1
क्या आप कुछ ऐसा नहीं कर सकते a,*b=input()(python3) और कुछ बाइट्स बचा सकते हैं? हालाँकि मुझे यकीन नहीं है कि यह कैसे प्रभावित होगा lऔर स्लाइस
— रॉड
1
@ मुझे ऐसा नहीं लगता, मुझे पायथन 3 में भी इनपुट का मूल्यांकन करने की आवश्यकता होगी
— श्री एक्सकोडर
4

जेली , 7 बाइट्स

ṙḷ/ḊµḊ¿

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

पूरा कार्यक्रम।

— आउटगोल्फर को एरिक करें
स्रोत
3
यह ḷ/बहुत चालाक है।
— श्री Xcoder
क्या आप एक स्पष्टीकरण जोड़ सकते हैं, कृपया? मैंने अब लिंक किए गए GIT-Pages पर Quicks और Atoms को देखा है, और + 1-एड उसी पर आधारित है, लेकिन मैं कल्पना कर सकता हूं कि हर किसी के पास मरीज ऐसा करने के लिए नहीं होंगे। ;)
— केविन क्रूज़सेन
3

गणितज्ञ, 36 बाइट्स

मार्टिन के एल्गोरिथ्म का उपयोग करता है 

#//.l:{x_,__}:>Rest@RotateLeft[l,x]&

मीशा लावरोव और& मार्टिन एंडर से -5 बाइट्स

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

— J42161217
स्रोत
1
आप पहले तत्व को बाहर निकालने के लिए पैटर्न का उपयोग करके दो बाइट्स बचा सकते हैं #//.{x_,y__}:>Rest@RotateLeft[{x,y},x]&। (यह तब रुकता है जब केवल एक तत्व होता है क्योंकि {a}अब पैटर्न से मेल नहीं खाता {x_,y__}।)
— मिशा लावरोव
1
@MishaLavrov अभी परीक्षण नहीं कर सकता है, लेकिन आप संभवतः इसे छोड़ सकते हैं, आगे बढ़ने से y, पूरी सूची को कॉल करने से lऔर फिर lइसकी तुलना में {x,y}।
— मार्टिन एंडर
1
@MartinEnder आप इस तरह मतलब है - #//.l:{x_,__}:>Rest@RotateLeft[l,x]&?
— मिशा लावरोव
1
@ मिशालवॉव येप।
— मार्टिन एंडर
3

जे , 21 17 बाइट्स

-4 बाइट्स FrownyFrog के लिए धन्यवाद

((1<#)}.{.|.])^:_

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

मूल:

([:}.{.|.])^:(1<#)^:_

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

^:_ तब तक दोहराएं जब तक परिणाम बदलना बंद न हो जाए

^:(1<#) यदि सूची की लंबाई 1 से अधिक है

{.|.] सूची को बाईं ओर उसके पहले आइटम बार में घुमाएं

[:}. पहला तत्व छोड़ें और कांटा कैप करें

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

— गैलेन इवानोव
स्रोत
@ FrownyFrog धन्यवाद, मैंने यह कोशिश नहीं की - यह बहुत बेहतर है!
— गैलन इवानोव
3

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

@ बाइट फिक्स्ड संस्करण (+6 बाइट्स) के लिए 1 बाइट धन्यवाद

इनपुट सरणी को संशोधित करता है , जो एक सिंगलटन पर कम हो जाता है।

f=(a,p=0)=>1/a||f(a,p=(p+a[p%(l=a.length)])%l,a.splice(p,1))

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

कोड स्निपेट दिखाएं

कैसे?

हम चुनौती में वर्णित एल्गोरिदम को पुन: लागू करते हैं। केवल स्टॉप की स्थिति 1/aथोड़ी अजीब लग सकती है। अंकगणित ऑपरेटर को लागू करते समय:

  • एक से अधिक तत्वों की सरणियों के लिए मजबूर किया जाता है NaNऔर 1/NaNयह भी NaN(झूठा) है।
  • ठीक एक पूर्णांक की सारणियाँ उस पूर्णांक के लिए सुसंगत हैं, जो 1/0 = +Infinityया तो N> 0 (दोनों सत्य) के 1/N = positive floatलिए अग्रणी है ।
f = (a, p = 0) =>                 // a = input array, p = pointer into this array
  1 / a ||                        // if a is not yet a singleton:
    f(                            //   do a recursive call with:
      a,                          //     a
      p = (                       //     the updated pointer
        p + a[p % (l = a.length)] //
      ) % l,                      //
      a.splice(p, 1)              //     the element at the new position removed
    )                             //   end of recursive call
— Arnauld
स्रोत
spliceमूल सरणी को संशोधित करते हुए , आप 52 बाइट्स केf=(a,p=0)=>1/a||f(a,p=p+a[p]%a.length,a.splice(p,1)) लिए कर सकते हैं
— झबरा
ऐसा लगता है कि यह दूसरे चरण के कदम के लिए सही परिणाम नहीं देता है, उदाहरण के लिए, f=(a,p=0)=>1/a?a:f(a,p=(p%a.length+a[p%a.length])%a.length,a.splice(p,1))ठीक है लेकिन इसे अनुकूलित किया जा सकता है
— नहुएल फौइउल
@ नहुएलफौइलुल उफ़। मैंने कुछ बिंदु पर सोचा कि आसपास के कोष्ठकों p+a[p]को हटाया जा सकता है। जो निश्चित रूप से - मामला नहीं है। यह रिपोर्ट करने के लिए धन्यवाद!
— अरनौलड
देखें इस आम सहमति है, जो @Neil मेरे ध्यान में लाया यहाँ ।
— झबरा
@ शगुन ओह, मैं देख रहा हूं। धन्यवाद! (मुझे आपका TIO लिंक पहली बार याद आया ...)
— अरनौलड
3

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

यह लैम्ब्डा एक को स्वीकार करता है Stack<Integer>और एक रिटर्न intया Integer।

l->{for(int i=0,s=l.size();s>1;)l.remove(i=(i+l.get(i%s))%s--);return l.pop();}

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

Ungolfed

l -> {
    for (
        int i = 0, s = l.size()
        ; s > 1
        ;
    )
        l.remove(
            i = (i + l.get(i % s)) % s--
        );
    return l.pop();
}

स्वीकृतियाँ

  • -2 बाइट्स नाहुएल फोइउलुल के लिए धन्यवाद
— जेकब
स्रोत
1
i%=sयदि l.get(i)द्वारा बदला गया हो तो हटा दिया जा सकता हैl.get(i%s)
— नाहुले फौलेउल
2

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

.WtHt.<Zh

यहाँ यह कोशिश करो!

यह परिणाम को एकल सूची के रूप में आउटपुट करता है, जैसा कि डिफ़ॉल्ट रूप से अनुमति है ।

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

.WtHt.<Zh ~ Full program.

.W        ~ Functional while. It takes three arguments, two functions: A and B
            and a starting value, which in this case is automatically assigned
            to the input. While A(value) is truthy, value is set to B(value).
            Returns the ending value. A's argument is H and B's is Z.
  tH      ~ A (argument H): Remove the first element of H. A singleton list
            turns into [], which is falsy and thus breaks the loop. Otherwise,
            it is truthy and the loops goes on until the list reaches length 1.
     .<Zh ~ B (argument Z): Cyclically rotate Z by Z[0] places, whereas Z[0]
            represents the first element of Z.
    t     ~ And remove the first element.

नोट: यदि आप उन ब्रैकेट को नहीं देखना चाहते हैं, तो बस पूरे कोड को जोड़ें hया eसामने रखें।

— श्री Xcoder
स्रोत
2

स्विफ्ट , 87 बाइट्स

func f(a:inout[Int]){var i=0,c=0;while(c=a.count,c>1).1{i=(i+a[i%c])%c;a.remove(at:i)}}

एक के रूप में देता है सिंगलटन सूची से इनपुट को संशोधित । इसे ऑनलाइन आज़माएं!

व्याख्या

func f(a:inout[Int]){
  var i=0,c=0;            // Set the index i to 0
  while(c=a.count,c>1).1{ // While the length of the list > 0:
    i=(i+a[i%c])%c;       //  Add a[i] to i and loop back using modulo
    a.remove(at:i)        //  Remove a[i]
  }
}
— हरमन एल
स्रोत
2

पर्ल 6 , 46 45 बाइट्स

(ब्रैड गिल्बर्ट को -1 बाइट)

{($_,{(|$_ xx*)[.[0]+(1..^$_)]}...1)[*-1][0]}

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

($_, { ... } ... 1)सूचियों का एक क्रम उत्पन्न करता है, इनपुट सूची के साथ शुरू होता है $_, प्रत्येक क्रमिक तत्व ब्रेस एक्सप्रेशन द्वारा उत्पन्न किया जा रहा है, और जब सूची स्मार्ट से मेल खाती है 1-ie, 1. की लंबाई है 1. अनुगामी [* - 1]अंतिम तत्व प्राप्त करता है, और अंतिम [0]एकमात्र एकल तत्व को उस एकल सूची से निकालता है।

(|$_ xx *)वर्तमान तत्व की एक फ्लैट, अनंत प्रतिकृति प्रतिलिपि बनाता है। इस सूची को श्रृंखला .[0] + (1 ..^ $_)में अगली परिमित सूची निकालने की सीमा के साथ अनुक्रमित किया गया है ।

— शॉन
स्रोत
1
माइंड ब्लो ओओ
— एड्रियन
[*-1][0][*-1;0]एक बाइट को बचाने में जोड़ा जा सकता है । एक बाइट को बचाने के 1..$_-1रूप में भी बेहतर लिखा गया है 1..^$_।
— ब्रैड गिल्बर्ट b2gills
@ ब्रैडगिल्बर्ब २गिल्स मैंने कोशिश की [*-1;0], लेकिन ऐसा लगता है कि यह किसी भी तरह समतुल्य नहीं है। फ़ंक्शन तब एक संख्या के बजाय एक सूची देता है।
— सीन
यह 1..^$_अनुकूलन बंद नहीं करता है
— ब्रैड गिल्बर्ट b2gills
1

पर्ल 5 , 47 43 41 + 2 ( -ap) = 43 बाइट्स

$\=splice@F,($_+=$F[$_%@F])%@F,1while@F}{

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

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

— Xcali
स्रोत
ऐसा लगता है कि यह कदम उदाहरण के साथ कदम के रूप में बिल्कुल वैसा ही नहीं है, लेकिन लंबे समय तक है$x%=@F,splice@F,$x=($x+$F[$x])%@F,1while$#F;$_="@F"
— नाहुएल फौइउल
1
वाह ऊ मेरे खेल को पाने की जरूरत है।
— एड्रियन
1

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

golfed:

static void n(Integer[]j){Integer[]h;int a=0;h=j;for(int i=0;i<j.length-1;i++){if(h.length==a){a=0;}a=(a+h[a])%h.length;h[a]=null;h=m(h);}System.out.print(h[0]);}static Integer[] m(Integer[]array){Integer[]x=new Integer[array.length-1];int z=0;for(int i=0;i<array.length;i++){if(array[i]!=null){x[z]=array[i];z++;}}return x;}

Ungolfed:

 interface ArrayLeapFrog {
static void main(String[] z) throws Exception {
    Integer[] j = {6, 2, 3, 4};
    n(j);
}

static void n(Integer[] j) {
    Integer[] h;
    int a = 0;
    h = j;
    for (int i = 0; i < j.length - 1; i++) {
        if (h.length == a) {
            a = 0;
        }
        a = (a + h[a]) % h.length;
        h[a] = null;
        h = m(h);
    }
    System.out.print(h[0]);
}

static Integer[] m(Integer[] array) {
    Integer[] x = new Integer[array.length - 1];
    int z = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != null) {
            x[z] = array[i];
            z++;
        }
    }
    return x;
  }
}
— DevelopingDeveloper
स्रोत
4
स्वागत हे! कुछ सुझाव: staticयहां कीवर्ड की गणना करने की आवश्यकता नहीं है। आमतौर पर बहु-विधि समाधान एक वर्ग के गैर-स्थैतिक सदस्यों के रूप में लागू किया जाता है, और mainपरीक्षण के लिए एक उदाहरण बनाता है। इसके अलावा, यदि आप ऐसा करते हैं तो आप जावा 7 का समर्थन करते हैं और बस "जावा" समाधान के रूप में प्रस्तुत कर सकते हैं। भविष्य के संदर्भ के लिए, इनपुट प्रारूप यहां काफी लचीला है, इसलिए उदाहरण के लिए आप इनपुट को चुनना पसंद कर सकते हैं List(जो इस समस्या के लिए काफी मददगार है)।
— जैकब
1

एपीएल + विन, 36 बाइट्स

¯1↑⍎¨(1⌈¯1+⍴v←,⎕)⍴⊂'v←(1<⍴v)↓v[1]⌽v'

स्पष्टीकरण:

स्क्रीन इनपुट के लिए संकेत। 

'v←(1<⍴v)↓v[1]⌽v' Loop logic as a string

 (1<⍴v)↓ only drop the first when number of elements n>1

 (1⌈¯1+⍴v←,⎕)⍴⊂ create a nested vector of logic of length 1 max n-1

 ⍎¨ execute each element of the nested vector in turn

¯1↑ take answer from executing final element
— ग्राहम
स्रोत
1

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

def f(x):
 while x[1:]:y=x[0]%len(x);x=x[y+1:]+x[:y]
 print x
— Rɪᴋᴇʀ
स्रोत
1
मुझे पता है कि अजगर के जवाब का एक गुच्छा मौजूद है, लेकिन मुझे लगा कि मैं अपना खुद का भी जोड़ सकता हूं।
— R
1

जावास्क्रिप्ट, 58 56 59 बाइट्स

let f =

a=>{for(i=0,k=a.length;k>1;)i+=a[i%=k],a.splice(i%=k--,1)}
<h2>Test</h2>
Enter or paste a valid array literal within square brackets and click Run.
<blockquote>
   <input id = "array" type="text" length="20">
   <button type="button" onclick="run()">Run</button>
</blockquote>
Result: <pre id="o"></pre>

<script>
    function run() {
       let a = JSON.parse(array.value);
       f(a);
       o.textContent = a;
    }
</script>
स्निपेट का विस्तार करें

परिणाम को इनपुट एरे में शेष एकमात्र तत्व के रूप में लौटाता है जिसे जगह में अद्यतन किया जाता है।

लूप बॉडी में ब्लॉक स्टेटमेंट के बजाय अल्पविराम से अलग स्टेटमेंट का उपयोग करके दो बाइट्स को बचाया गया! तीन बाइट्स सरणी के अंत में हटाए गए तत्व से छोड़ने के लिए खो गए (:

कम गोल्फ वाला:

a => {
    for(i=0,k=a.length;k>1;) // once less than array length
        i+=a[i%=k],          // the new index
        a.splice(            // delete an element
           i%=k--,           // ensuring index is within array,
                             // and post decrement loop count
           1
        )
}
— traktor53
स्रोत
यह गलत उत्तर देने के लिए लगता है [3, 5, 7, 9]।
— नील
के लिए गलत [3,5,7,9]। अपेक्षित मान 5
— edc65
फ़ंक्शन मान वापस नहीं करता है, मुझे यकीन नहीं है कि बाइट गिनती उचित है कि इसे ध्यान में रखते हुए, क्योंकि यह खुद काम नहीं कर सकता है ...
— ब्रायन एच।
@ edc65 और नील, धन्यवाद - सरणी के अंत में हटाए गए तत्व के सूचकांक को छोटा सरणी की शुरुआत में समायोजित नहीं किया जा रहा था।
— traktor53
@BrianH। फ़ंक्शन अपने पैरामीटर को संशोधित करता है, उस कोडगुल्फ.मेटा.स्टैकएक्सचेंज.com
— a/
1

ब्रेन-फ्लैक , 104 बाइट्स

H.PWiz का यहाँ एक छोटा जवाब है जिसे मैंने बनाने में मदद की है, आपको इसकी जाँच करनी चाहिए।

([[]]()){({}()<(({})){({}[()]<({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>>)}{}{}>)}{}

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

व्याख्या

([[]]())   #Push 1 minus stackheight
{({}()<    #N times
 (({}))    #Get a copy of the top
 {({}[()]< #N times
  ({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>
           #Roll the top to the bottom (From the wiki)
 >)}{}     #End loop
 {}        #Remove one value
>)}{}      #End loop
— गेहूं का जादूगर
स्रोत
मुझे लगा कि मैं मुकाबला करूंगा । तब मुझे एहसास हुआ कि मेरा भी लगभग एक जैसा ही था , एक अलग "टॉप रोल" के अलावा
— H.PWiz
मैंने देखा ;)। इस तथ्य का उपयोग करना कि सब कुछ गैर-नकारात्मक है, बल्कि चालाक है।
— गेहूं जादूगर
1

आर , 111 117 126 बाइट्स

थोड़ी देर के लूप में बदलकर 11 बाइट्स को बंद करने के लिए @Giuseppe के लिए धन्यवाद, फ़ंक्शन को हटाकर और उपयोगकर्ता इनपुट को सीधे पढ़कर एक और 4 मिला।

मुझे इस बारे में बहुत अच्छा नहीं लग रहा है कि इसे वहाँ लाने के लिए क्या - मुझे यकीन है कि एक और अधिक सुंदर समाधान मौजूद है।

i=scan();m=1;while((l=sum(i|1))-1){j=i[m];p=`if`(j+m>l,j%%l+!m-1,j+m);p=`if`(!p,m,p);i=i[-p];m=`if`(p-l,p,1)};i

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

अघोषित कोड

i=scan()
m=1
while((l=sum(i|1))-1){
  j=i[m]
  p=`if`(j+m>l,j%%l+!m-1,j+m)
  p=`if`(!p,m,p)
  i=i[-p]
  m=`if`(p-l,p,1)
}
i
— निशान
स्रोत
117 बाइट्स - ध्यान दें कि चूंकि यह एक पुनरावर्ती कार्य है, इसलिए इस नाम f=को शामिल करने की आवश्यकता है
— Giuseppe
1
मुझे यह एक कठिन चुनौती मिली, जिसमें १ आधारित इंडेक्स भाषा के बिना ऐरे रोटेशन के साथ; यह संभावित रूप से 1-3 बाइट्स whileलूप से छोटा है , मुझे लगता है।
— ग्यूसेप
— Giuseppe
मेरे पिछले 115 बायटर अमान्य थे क्योंकि हम दोनों f=पुनरावर्ती फ़ंक्शन का हिस्सा भूल गए थे । :(
— ग्यूसेप
मैंने पुनरावृत्ति को प्रतिबिंबित करने के लिए पुराने स्कोर और नए स्कोर को अपडेट किया :) स्कैन के साथ 'जबकि' लूप के साथ मैंने एक और 4 बाइट को बंद कर दिया।
— मार्क
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.