হাঁস, হাঁস, জোসেফাস

49

একটি পূর্ণসংখ্যার অ্যারে দেওয়া:

  1. প্রথম নম্বর থেকে শুরু করুন
  2. এগিয়ে চলুন n অবস্থানগুলিতে যেখানে n বর্তমান পজিশনের মান is
  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
@ লুইস মেন্ডো হ্যাঁ .. "চ্যালেঞ্জের মতো ..." চ্যালেঞ্জগুলি
— J42161217
2
@ জেনি_ম্যাথী আমি ভাবিনি যে এরকম একটিও হবে, তবে লুইস যেমন বলেছিলেন, মোড়কের অ্যারেটি গল্ফের জন্য একটি আকর্ষণীয় চ্যালেঞ্জ তৈরি করে। আমার মনে হয়: /
— ওয়ার্কওফ্লো
3
পুনঃটুইট করেছেন সেখানকার উপাদানগুলি অবিচ্ছেদ্য এবং ধাপের আকারটি স্থির করা আছে। লুইস এর কাছাকাছি, তবে এখনও আমার মনে হয় যথেষ্ট আলাদা।
— মার্টিন এণ্ডার
3
এটির কি আসলে চূড়ান্ত নম্বর মুদ্রণ করা দরকার, বা এটি কেবল এটি ফেরত দিতে পারে? এটির কি আসলে নম্বরটি ফেরত দেওয়ার দরকার আছে, বা এটি ঠিক জায়গায় জায়গায় অ্যারেতে কাজ করতে পারে তাই ফাংশনটি চালুর পরে অ্যারেটিতে কেবল সংখ্যাটি রয়েছে?
— iamnotmaynard

উত্তর:

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

এমএটিএল , 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

আউটপুট একটি একক তালিকা।

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র
পুরোপুরি সম্পর্কহীন, তবে আমি আপনার ইউনিকর্ন টুপি পছন্দ করি ডেনিস। এক্সডি (এবং অবশ্যই দুর্দান্ত উত্তর, বরাবরের মতো!)
— কেভিন ক্রুইজসেন
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
@ ওয়েট উইজার্ড নিস, আশ্চর্যরকমভাবে আমি এর আগেও এরকম কিছু চেষ্টা করেছি।
— এইচপিউইজ
আমি কখনই জানতে পারি না যে লোকেরা কীভাবে কোড করতে পারে! একটি ছদ্ম-কোড অনুবাদক বা কিছু আছে?
— ওয়ার্কওভারফ্লো
1
@ ওয়ার্কফ্লো না, এটি দেখতে চেয়ে সত্যই সহজ। আমি আসলে শুরু করার আগে এটি খুব দু: খজনক ছিল, কিন্তু যখন আদেশগুলি এই সাধারণ হয়, তখন এটি শিখতে সহজ।
— এইচ.পি.উইজ
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

এটি অনলাইন চেষ্টা করুন!

দীর্ঘতর হলেও এটি আরও মার্জিত বলে মনে হয়। এছাড়াও চ্যাট সাহায্য করার জন্য ovs ধন্যবাদ।

— মিঃ এক্সকোডার
সূত্র
1
আপনি কি a,*b=input()(পাইথন 3) এর মতো কিছু করতে এবং কয়েকটি বাইট সংরক্ষণ করতে পারেননি? তবে আমি নিশ্চিত না যে এটি কীভাবে প্রভাব ফেলবে lএবং স্লাইস
— রড
1
@ রড আমার মনে হয় না, পাইথন 3
— তেও আমাকে
4

জেলি , 7 বাইট

ṙḷ/ḊµḊ¿

এটি অনলাইন চেষ্টা করুন!

পুরো প্রোগ্রাম।

— এরিক দ্য আউটগল্ফার
সূত্র
3
এটাই ḷ/চতুর চালাক।
— মিঃ এক্সকোডার
আপনি কি একটি ব্যাখ্যা যোগ করতে পারেন, দয়া করে? আমি এখন লিঙ্কযুক্ত জিআইটি-পৃষ্ঠাগুলিতে কুইকস এবং পরমাণুগুলি এবং তার ভিত্তিতে + 1-এড দেখেছি, তবে আমি কল্পনা করতে পারি যে রোগীরা একই রকম হয় না। ;)
— কেভিন ক্রুইজসেন
3

গণিত, 36 বাইট

মার্টিনের অ্যালগরিদম ব্যবহার করে 

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

মিশা লাভরভ অ্যান্ড অ্যান্ড মার্টিন ইন্ডার থেকে -5 বাইট

এটি অনলাইন চেষ্টা করুন!

— J42161217
সূত্র
1
প্রথম উপাদানটি বেছে নেওয়ার জন্য প্যাটার্নটি ব্যবহার করে আপনি দুটি বাইট সংরক্ষণ করতে পারেন #//.{x_,y__}:>Rest@RotateLeft[{x,y},x]&। (যখন কেবলমাত্র একটি উপাদান রয়েছে তখন এটি বন্ধ হয়ে যায় কারণ {a}আর প্যাটার্নের সাথে মেলে না {x_,y__}))
— মিশা লাভারভ
1
@ মিশা লাভরভ এই মুহুর্তে পরীক্ষা করতে পারবেন না, তবে আপনি সম্ভবত yপুরো তালিকাটি কল করে lএবং তার lপরিবর্তে ব্যবহার করে নীচে রেখে আরও ছোট করতে পারেন {x,y}।
— মার্টিন এন্ডার
1
@ মার্টিনইেন্ডার আপনি কি এর অর্থ বোঝাতে চান - #//.l:{x_,__}:>Rest@RotateLeft[l,x]&?
— মিশা লাভরভ
1
@ মিশালাভরভ হাঁ
— মার্টিন এন্ডার
3

জে , 21 17 বাইট

-4 বাইট ধন্যবাদ ফ্রাউনফ্রোগের জন্য

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

এটি অনলাইন চেষ্টা করুন!

মূল:

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

কিভাবে এটা কাজ করে:

^:_ ফলাফল পরিবর্তন হওয়া বন্ধ হওয়া পর্যন্ত পুনরাবৃত্তি করুন

^:(1<#) তালিকার দৈর্ঘ্য যদি 1 এর চেয়ে বেশি হয়

{.|.] তালিকার প্রথম আইটেমের সময় বাম দিকে ঘোরান

[:}. প্রথম উপাদানটি ফেলে দিন এবং কাঁটাচামচটি ক্যাপ করুন

এটি অনলাইন চেষ্টা করুন!

— গ্যালেন ইভানভ
সূত্র
@ ফ্রাউনফ্র্যাগ ধন্যবাদ, আমি এটি চেষ্টা করিনি - এটি আরও ভাল!
— গ্যালেন ইভানভ
3

জাভাস্ক্রিপ্ট (ES6), 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বা 1/N = positive floatজন্য এন> 0 (উভয় truthy)।
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 আমার নজরে আনা এখানে ।
— শেগি
@ শেগি ওহ, আমি দেখছি ধন্যবাদ! (আমি আপনার টিআইও লিঙ্কটি প্রথমবারের মতো মিস করেছি ...)
— অ্যানাআল্ড
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%=sl.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সামনে।

— মিঃ এক্সকোডার
সূত্র
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)}}

হিসেবে ফেরত পাঠায় Singleton তালিকা দ্বারা ইনপুট পরিবর্তন । এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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)ইনপুট তালিকার সাথে সূচনা করে $_প্রতিটি ক্রমিক উপাদান তৈরি হয় যা ব্রেস এক্সপ্রেশন দ্বারা উত্পাদিত হয় এবং তালিকাটি স্মার্ট-মেলে যখন সমাপ্ত হয় - 11 এর দৈর্ঘ্য হয়, ট্রেলিং [* - 1]চূড়ান্ত উপাদানটি অর্জন করে এবং চূড়ান্ত হয় [0]সিঙ্গলটন তালিকার বাইরে একমাত্র উপাদানটি নিয়ে যায়।

(|$_ xx *)বর্তমান উপাদানটির একটি ফ্ল্যাট, অনন্তরূপে অনুলিপি করা কপি উত্পন্ন করে। এই তালিকাটি .[0] + (1 ..^ $_)সিরিজের পরবর্তী সীমাবদ্ধ তালিকাটি বের করার জন্য সীমার সাথে সূচিযুক্ত।

— শন
সূত্র
1
প্রস্ফুটিত কিছু মনে ওও
— আদ্রিয়ান
[*-1][0][*-1;0]বাইট সংরক্ষণে একত্রিত করা যায় । এছাড়াও 1..$_-1ভাল হিসাবে লেখা হয় 1..^$_আবার একটি বাইট সংরক্ষণ।
— ব্র্যাড গিলবার্ট ডিসি
@ ব্র্যাডগিলবার্টব 2 গিলগুলি আমি চেষ্টা করেছি [*-1;0], তবে এটি কোনওভাবেই সমতুল্য বলে মনে হচ্ছে না। ফাংশনটি তখন একটি সংখ্যার পরিবর্তে একটি তালিকা দেয়।
— শন
এটি 1..^$_অপ্টিমাইজেশন থামায় না
— ব্র্যাড গিলবার্ট
1

পার্ল 5 , 47 43 41 + 2 ( -ap) = 43 বাইট

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

এটি অনলাইন চেষ্টা করুন!

স্থান পৃথক সংখ্যা হিসাবে ইনপুট নেয় akes

— 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। ফাংশনটি এর প্যারামিটারটি পরিবর্তন করে, সেই কোডগলফ.মেটা.স্ট্যাকেক্সেঞ্জাও
— /
1

ব্রেন-ফ্লাক , 104 বাইট

এইচ.পি.উইজের একটি সংক্ষিপ্ত উত্তর রয়েছে যা আমি তৈরি করতে সাহায্য করেছি, আপনার এটি পরীক্ষা করা উচিত।

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

([[]]())   #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
— গম উইজার্ড
সূত্র
আমি ভেবেছিলাম আমি প্রতিযোগিতা করব । তখন আমি বুঝতে পেরেছিলাম যে ভিন্ন ভিন্ন "শীর্ষ রোল" বাদে আমার প্রায় আপনার মতোই ছিল
— এইচপিউইজ
আমি দেখেছি;)। সবকিছু অ-নেতিবাচক হ'ল এই বিষয়টি ব্যবহার করে চালাক।
— গম উইজার্ড
1

আর , 111 117 126 বাইট

কিছুটা লুপ পরিবর্তন করে 11 বাইট বন্ধ করে গল্ফ করার জন্য @ জিউস্প্পকে ধন্যবাদ, ফাংশনটি সরিয়ে এবং সরাসরি ব্যবহারকারী ইনপুট পড়ে আরও 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=অন্তর্ভুক্ত করা দরকার
— জিউসেপ্পে
1
অ্যারে আবর্তন ছাড়াই 1 ভিত্তিক সূচক ভাষার সাথে আমি এটি বেশ কঠিন চ্যালেঞ্জ পেয়েছি; এটি সম্ভবত whileলুপের সাথে কমপক্ষে ১-২ বাইট কম ।
— জিউসেপ
— জিউসেপ
আমার পূর্ববর্তী 115 বাইটারটি অবৈধ ছিল যেহেতু আমরা দুজনই f=পুনরাবৃত্ত ফাংশনের অংশটি ভুলে গিয়েছিলাম । :(
— জিউসেপ
আমি পুনরাবৃত্তির প্রতিফলনের জন্য পুরানো স্কোর এবং নতুন স্কোরটি আপডেট করেছি :) 'যখন' লুপের সাথে আমি স্ক্যান ব্যবহার করে আরও 4 টি বাইট গল্ফ করলাম।
— চিহ্নিত করুন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.