41

যেকোন যুক্তিসঙ্গত বিন্যাসে অ-নেতিবাচক পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে, এটির পুনরাবৃত্তি করুন, আপনি যে পদক্ষেপে পদক্ষেপ নেবেন যতগুলি উপাদান ততটুকু এড়িয়ে চলে।

এখানে একটি কাজের উদাহরণ:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | []
 ^ First element, always include it
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0]
    ^ Skip 0 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1]
          ^ Skip 1 element
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2]
                   ^ Skip 2 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2, 3]
Skip 3 elements; you're done

আর একটি কাজের উদাহরণ, এতটা সমান-ডেল্টাস নয়:

[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | []
 ^ First element, always include it
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4]
                ^ Skip 4 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3]
                            ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3]
                                        ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3, 4]
Skip 4 elements; you're done

একটি সীমার বাইরে উদাহরণ:

[0, 2, 0, 2, 4, 1, 2] | []
^ First element, always include it
[0, 2, 0, 2, 4, 1, 2] | [0]
    ^ Skip 0 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2]
             ^ Skip 2 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2, 4]
Skip 4 elements; you're done (out of bounds)

বিধি

আপনি এইগুলির মধ্যে কোনও বিরক্তিকর ঠকাই ব্যবহার নাও করতে পারেন , তারা চ্যালেঞ্জটিকে বিরক্তিকর এবং উদ্বেগজনক করে তোলে।
আপনার কেবল চূড়ান্ত ফলাফলটি ফেরত / মুদ্রণ করা উচিত। STDERR আউটপুট উপেক্ষা করা হয়।
আপনি কোনও বেসে অঙ্কের স্ট্রিং হিসাবে ইনপুটটি পেতে পারেন না (যেমন "প্রথম ক্ষেত্রে" 0102513162 ")।
ইনপুট দেওয়ার জন্য আপনাকে অবশ্যই বাম থেকে ডান ক্রমটি ব্যবহার করতে হবে।
কাজের উদাহরণ হিসাবে, আপনি সীমা ছাড়িয়ে যান, অন্যথায় অন্যথায়, মৃত্যুদন্ড কার্যকর হবে।
আপনার 00 টি উপাদান এড়িয়ে যাওয়ার জন্য ব্যবহার করা উচিত ।
[]ইনপুট হিসাবে খালি তালিকা ( ) দেওয়া , আপনার ফিরে আসা উচিত []।

পরীক্ষার মামলা

[]                                                     => []
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                     => [0, 1, 3, 7]
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]                   => [5, 2, 1, 0]
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2]                         => [0, 1, 2, 3]
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] => [4, 3, 3, 4]
[0, 2, 0, 2, 4, 1, 2]                                  => [0, 2, 4]

এটি কোড-গল্ফ , তাই সংক্ষিপ্ত উত্তর জেতে!

code-golf array-manipulation

— এরিক দ্য আউটগল্ফার
সূত্র

1

আমার অ্যারেতে পিছনে শূন্য রাখা কি ঠিক আছে? আমাকে ~ 18 বাইট বাঁচাতে হবে

— রোমান গ্রাফ

@ এরিকথ আউটগল্ফার আমরা কী স্ট্রিং অ্যারে আউটপুট দিতে পারি এবং ফাঁকা স্ট্রিংগুলি পেছনে ফেলে দিতে পারি?

— TheLethalCoder

1

@ দ্য লেথলকোডার দুঃখিত, আমি বলব না যেহেতু এটি যুক্তিসঙ্গত ইমো নয় ... আপনি কি কেবল ট্রিলিং ""এস সরাতে পারবেন না ?

— এরিক আউটগল্ফার

2

@ রোমানগ্রাফ দুঃখিত তবে না, এটি আপনার 0পক্ষে আউটপুটটির পিছনে থাকা উচিত এমন সমস্যাগুলি খুব অস্পষ্ট হবে ।

— এরিক আউটগল্ফার

14

পাইথন 2 , 36 বাইট

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

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

— যষ্টি
সূত্র

আমি আউটগল্ফড হওয়ার আশা করছিলাম, তবে এটি খারাপভাবে নয় :)

— মিঃ এক্সকোডার

আপনি কি এর x[0]বদলে করতে পারবেন না x[:1]?

— এরিক আউটগল্ফার

@ এরিকথ আউটগল্ফার হ্যাঁ, তবে এটির একটি তালিকা হওয়া দরকার, তাই এটি হবে[x[0]]

— রোড

@ রড আপনি যে কোনও উপায়ে কোনও বাইট সংরক্ষণ করছেন না x[:1]...f=lambda x:x and[x[0]]+f(x[x[0]+1:])

— এরিক দি আউটগল্ফার

13

পাইথন 2 , 49 44 * 41 বাইট

^{ক্রস আউট 44 এখনও নিয়মিত 44 :(}

* -3 কেবলমাত্র ASCII- এর জন্য ধন্যবাদ ।

l=input()
while l:print l[0];l=l[l[0]+1:]

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

চ্যাটটিতে ওপি অনুমোদিত হওয়ায় ফলাফলগুলি একটি নতুন লাইনের দ্বারা পৃথক করে মুদ্রণ করে। আমি মনে করি না এটি একটি পুনরাবৃত্তি পূর্ণ প্রোগ্রাম হিসাবে কোনও সংক্ষিপ্ত পেতে পারে ।

কিভাবে কাজ করে?

l=input() - স্ট্যান্ডার্ড ইনপুট থেকে তালিকাটি পড়ে।
while l: - পাইথনে খালি তালিকা মিথ্যা বলে সত্যই অপব্যবহার করে, তালিকাটি খালি না হওয়া পর্যন্ত লুপ হয়।
print l[0]; - তালিকার প্রথম উপাদানটি মুদ্রণ করে।
l=l[l[0]+1:]- "খরগোশের মতো এড়ানো" - l[0]+1তালিকা থেকে প্রথমটি ছাঁটাই ।

একটি উদাহরণ নেওয়া যাক

[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]ইনপুট হিসাবে তালিকাটি দেওয়া , কোড নিম্নলিখিতটি সম্পাদন করে (উপরের ব্যাখ্যা অনুসারে) - অ্যারের প্রথম আইটেমটি মুদ্রণ করে 5:, প্রথমটি 6: ছাঁটাই করে [2, 1, 2, 1, 0, 0]। তারপরে আমরা 2প্রথম 3 টি মুদ্রণ ও ছাঁটাই করি [1,0,0]। তেমনি, আমরা আউটপুট 1, প্রথম 2 ক্রপ, এবং আমরা পেতে [0]। অবশ্যই, 0মুদ্রিত হয় এবং প্রোগ্রামটি শেষ হয়।

— মিঃ এক্সকোডার
সূত্র

46 বাইট

— এএসসিআইআই-

11

হাস্কেল, 29 27 26 বাইট

j(x:y)=x:j(drop x y)
j x=x

Zgarb ধন্যবাদ 1 বাইট সংরক্ষণ করা।

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

— ক্রিশ্চিয়ান লুপাস্কু
সূত্র

f x=xদ্বিতীয় লাইনে একটি বাইট সংরক্ষণ করে।

— Zgarb

9

জাভাস্ক্রিপ্ট (ES6), 42 39 35 বাইট

a=>a.map((n,i)=>a.splice(i+1,n))&&a

let f = 
a=>a.map((n,i)=>a.splice(i+1,n))&&a

console.log(f([]))                                                     // => []
console.log(f([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))                     // => [0, 1, 3, 7]
console.log(f([5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]))                   // => [5, 2, 1, 0]
console.log(f([0, 1, 0, 2, 5, 1, 3, 1, 6, 2]))                         // => [0, 1, 2, 3]
console.log(f([4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2])) // => [4, 3, 3, 4]
console.log(f([0, 2, 0, 2, 4, 1, 2]))                                  // => [0, 2, 4]

স্নিপেট প্রসারিত করুন

পুরাতন সমাধান 39 বাইট

a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

-3 বাইটস @PPirarateBay ধন্যবাদ

— জোহান কার্লসন
সূত্র

39 বাইটa=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

8

05 এ বি 1 ই , 10 9 বাইট

[¬Dg>#=ƒ¦

05AB1E এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!

— আদনান
সূত্র

হ্যাঁ, আমি যা ভাবছিলাম তার থেকে এটি বেশ ভাল।

— ম্যাজিক অক্টোপাস উরান

8

গণিত, 46 44 বাইট by

SequenceCases[#,{x_,y___}/;Tr[1^{y}]<=x:>x]&

বিকল্প:

SequenceCases[#,{x_,y___}/;x>=Length@!y:>x]&
SequenceCases[#,l:{x_,___}/;x>Tr[1^l]-2:>x]&

— মার্টিন ইন্ডার
সূত্র

7

সি #, 68 বাইট

a=>{for(int i=0;i<a.Count;i+=a[i]+1)System.Console.Write(a[i]+" ");}

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

সম্পূর্ণ / ফর্ম্যাট সংস্করণ:

namespace System
{
    class P
    {
        static void Main()
        {
            Action<Collections.Generic.List<int>> f = a =>
            {
                for (int i = 0; i < a.Count; i += a[i] + 1)
                    System.Console.Write(a[i] + " ");
            };

            f(new Collections.Generic.List<int>() { });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 0, 2, 5, 1, 3, 1, 6, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 2, 0, 2, 4, 1, 2 });Console.WriteLine();

            Console.ReadLine();
        }
    }
}

একটি তালিকা ফিরিয়ে দেওয়া 107 বাইটে দীর্ঘতর।

a=>{var l=new System.Collections.Generic.List<int>();for(int i=0;i<a.Count;i+=a[i]+1)l.Add(a[i]);return l;}

— TheLethalCoder
সূত্র

2

কেন কেউ এটিকে অবমূল্যায়ন করেছে?

— দ্য লেথালকোডার

আপনার স্কোরকে গোল করতে এবং একটি নিখুঁত 5 কে করতে?

— থমাস আইয়ুব

@ থমাস আইয়ুব আমরা কেবল ধরে নিতে পারি যে এটি ওসিডি সহ কেউ ছিল।

— TheLethalCoder

6

কান্ড , 8 6 বাইট

←TU¡Γ↓

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

-২ বাইট (এবং একটি সম্পূর্ণ নতুন সমাধান ধারণা) লিওকে ধন্যবাদ!

ব্যাখ্যা

আমি তালিকা প্যাটার্ন ম্যাচ ফাংশন ব্যবহার করছি Γ। এটি fমাথা xএবং লেজের সাথে একটি ফাংশন এবং একটি তালিকা নেয় xsএবং এটি প্রয়োগ fকরে xএবং xs। যদি তালিকাটি খালি থাকে, তবে Γএই ক্ষেত্রে খালি তালিকার সাথে সামঞ্জস্য করে একটি ডিফল্ট মান দেয়। আমরা fহতে গ্রহণ করি ↓, যা xথেকে উপাদানগুলি ড্রপ করে xs। এই ফাংশনটি পুনরাবৃত্তি হয় এবং ফলস্বরূপ উপাদানগুলি একটি তালিকাতে সংগ্রহ করা হয়।

←TU¡Γ↓  Implicit input, e.g. [0,2,0,2,4,1,2]
    Γ↓  Pattern match using drop
   ¡    iterated infinitely: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[],[],[],...
  U     Cut at first repeated value: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[]]
 T      Transpose: [[0,2,4],[2,0,1],[0,2,2],[2,4],[4,1],[1,2],[2]]
←       First element: [0,2,4]

— Zgarb
সূত্র

আপনি the এর ডিফল্ট মানটি ফেলে দিতে পারেন, এবং সবকিছু এখনও যাদুতে কাজ করবে :)

— লিও

অথবা, এমনকি কম বাইট জন্য, tio.run/##yygtzv7//1HbhJDQQwvPTX7UNvn////RBjpGOiBsomOoYxQLAA

— লিও

@ লীও ওহ, ও যে চালাক!

— Zgarb

আপনি কেন সিডব্লিউ করলেন?

— এরিক দি আউটগল্ফার

@ এরিক দ্য অটগল্ফার এটি একটি ভুল ছিল (আমি আমার ফোনে আছি এবং দৃশ্যত দুর্ঘটনাক্রমে কিছু ধাক্কা দিয়েছি)। আমি এটিকে পূর্বাবস্থায়

— ফেলার

5

পাইথন 2 , 59 55 বাইট

l=input()
i=0
while l[i:]:i+=1;l[i:i+l[i-1]]=[]
print l

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

— Arfie
সূত্র

1

আপনি বাইট সংরক্ষণ করতে l[i:i+l[i-1]]=[]পরিবর্তে ব্যবহার করতে পারেনdel l[i:i+l[i-1]]

— রড

1

56 বাইট

— ASCII-

5

পাইথ, 22 বাইট

VQ aY.(Q0VeY .x.(Q0 ;Y

অপ্রয়োজনীয় বাইট সরানো হয়েছে

— ডেভ
সূত্র

আমি সেখানে 23 বাইট দেখতে পাচ্ছি।

— এরিক আউটগল্ফার

টাইপো :) দুঃখিত ...

— ডেভ

3

আমি নিশ্চিত না কেন আপনার ভোট কেন কম আছে। এমন একটি সম্ভাবনা রয়েছে যে আপনি যখন নিজের উত্তর ঠিক করার জন্য সম্পাদনা করেছেন তখন এটি "স্বয়ংক্রিয় ডাউন ভোট" তৈরি করেছিল। এই স্বয়ংক্রিয় ডাউনভোটের কারণগুলি বিভ্রান্তিকর এবং ভয়ঙ্কর তবে যদি সিস্টেমটি আপনার উত্তরটিকে হিউরিস্টিকের ভিত্তিতে "নিম্ন মানের" হিসাবে বিবেচনা করে তবে তা ঘটে। এটিও সম্ভব যে কেউ আপনার উত্তর পছন্দ করতে পারে নি, তবে আমি এই মুহুর্তে এটিতে কোনও ভুল দেখতে পাচ্ছি না তবে কেন এটি হবে তা আমি নিশ্চিত নই।

— গম উইজার্ড

আপনি পাইথ ব্যবহার করছেন বলে আমি আনন্দিত!

— isaacg

4

পাইথন 2 , 60 42 41 বাইট

^{-18 লুইস মেন্ডো}
^{-1 বাইট ধন্যবাদ জোনাথন ফ্রেচকে ধন্যবাদ}

x=input()
i=0
while 1:print x[i];i-=~x[i]

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

— যষ্টি
সূত্র

i-=~x[i]এর চেয়ে এক বাইট ছোট i+=1+x[i]।

— জোনাথন ফ্রেচ

3

রেটিনা , 36 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

.+
$*
((1)*¶)(?<-2>1*¶)*
$1
%M`.
0$

ইনপুট এবং আউটপুট একটি ট্রেলিং লাইনফিডের সাথে লাইনফিড-বিভক্ত।

এটি অনলাইন চেষ্টা করুন! (সুবিধাজনক টেস্ট স্যুটগুলির জন্য মঞ্জুরি দেওয়ার জন্য লাইনফিডের পরিবর্তে কমা ব্যবহার করুন))

— মার্টিন ইন্ডার
সূত্র

3

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

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

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

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack

— রিলে
সূত্র

7

পবিত্র বাজে! আমি একটি সমাধান লিখেছিলাম এবং তারপরে এটি পোস্ট করার জন্য স্ক্রোল করেছিলাম তবে দেখা যাচ্ছে যে আমরা ঠিক একই সমাধান বাইট-বাই-বাইট লিখেছি ! মত এমনকি ছোটখাট বিস্তারিত ({}[()]<{}>)বনাম ({}<{}>[()])একই ছিল! কি কাকতালীয়!

— ডিজেএমসিএমহেম

@ ডিজেএমসিমেহেম সমস্ত খ্যাতি এক্সডি চুরি করছে

— ক্রিস্টোফার

আমি বাইট অভিন্ন সমাধানের জন্য একটি বাইটও তৈরি করেছি , তবে আমি এটি 4 বাইট নিচে গল্ফ করেছি । কিছুটা বিলম্বিত প্রতিযোগিতা :)

— গম উইজার্ড

2

ম্যাথামেটিকাল, 64 50 বাইট

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={}

— user202729
সূত্র

আমি এই ঝরঝরে কোডটি আরও গল্ফ করে প্রতিহত করতে পারি না; আমার উত্তর নীচে।

— মিঃ উইজার্ড

2

সি # (.নেট কোর) , 68 বাইট

n=>{var t="";for(int i=0;i<n.Length;i+=n[i]+1)t+=n[i]+" ";return t;}

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

পূর্ণসংখ্যার অ্যারের হিসাবে ইনপুট নেয়, এড়িয়ে যাওয়া মানগুলি সহ একটি স্ট্রিং দেয়।

— jkelm
সূত্র

এটি করার দুর্দান্ত উপায় এবং মুদ্রণের মতো একই গণিতে আসে।

— TheLethalCoder

আমি সহজ সমাধান পছন্দ করি। এখনও লিনকিউ শিখতে হবে, যদিও আমি দেখেছি যে

— এতগুলি

এটি সংক্ষিপ্ত করে কারণ আপনি বেশিরভাগ সময় নিদারুণভাবে ফিরে আসতে পারেন। যদিও এটি অন্তর্ভুক্ত রিটার্ন using System.Linq;এবং একটি সাধারণ লুপের মধ্যে টস আপ ।

— TheLethalCoder

2

আর, 58 বাইট

f=function(x,p=1){cat(z<-x[p]);if(p+z<sum(x|1))f(x,p+z+1)}

পুনরাবৃত্তি ফাংশন। xযুক্তি হিসাবে ভেক্টর নেয় এবং একটি পয়েন্টারকে সূচিত করে p। এটি এর সাথে সম্পর্কিত এন্ট্রি প্রিন্ট করে , সীমা xছাড়িয়ে যায় কিনা p+x[p]তা পরীক্ষা করে এবং না হলে নতুন পয়েন্টারের জন্য ফাংশনটি কল করে।

f=function(x,p=1,s=x[1])`if`((z<-x[p]+p+1)>sum(x|1),s,f(x,z,c(s,x[z])))

এটি একটি তুলনামূলক সমাধান যা অঙ্কগুলি মুদ্রণের পরিবর্তে উপযুক্ত ভেক্টরকে ফেরত দেয়।

— JAD
সূত্র

একটি ইনপুট সম্পর্কে কি numeric(0)? ওরফে খালি অ্যারে।

— জিউসেপে

@ জিউস্পেপ আমি যখন আমার পিসির পিছনে থাকি তখন আমি এটি একবার দেখে নেব

— জেএডি

55 বাইট

— জিউসেপ

2

জাভা (ওপেনজেডিকে 8) , 53 বাইট

@ PunPun1000 এবং @TheLethalCoder কে ধন্যবাদ

a->{for(int n=0;;n+=1+a[n])System.out.println(a[n]);}

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

— রোমান গ্রাফ
সূত্র

আমার সি # উত্তরের মতো ফলাফলগুলি মুদ্রণ করা কি আপনাকে কিছু বাঁচাতে পারে?

— TheLethalCoder

@ দ্য লেথাল কোডার ইল চেষ্টা করুন

— রোমান গ্রাফ

আপনি nলুপ মধ্যে সরানো একটি বাইট সংরক্ষণ করতে পারেন ?

— TheLethalCoder

প্লাস এটি এই মুহুর্তে কাজ করে না বলে মনে হচ্ছে।

— TheLethalCoder

আপনি এর পরে একটি পেরেন মিস করছেন (a[n+=1+a[n]]। সঠিক মান আউটপুট করার পরে ফাংশনটিও একটি ত্রুটি ছুড়ে ফেলে, এটি অনুমোদিত কিনা তা আমি কনসেন্সাসটি জানি না (প্রশ্নটি স্ট্যান্ডার্ড ত্রুটিতে কিছু বলবে না তা উপেক্ষা করা হয়)। যদি সেই উদ্দেশ্য ছিল তবে আপনি n<a.lengthলুপটির জন্য সরিয়ে ফেলতে পারেন । অবশেষে টিআইও কোডটি প্যারেনের মতো চলবে না। ফাংশনটি একটি Consumer<int[]>এবং ব্যবহার হওয়া উচিতfunc.accept(test)

— PunPun1000

2

এলিস , 15 বাইট

/$.. \h&
\I@nO/

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

দশমিক পূর্ণসংখ্যার একটি লাইনফিড-বিচ্ছিন্ন তালিকা ইনপুট এবং আউটপুট।

ব্যাখ্যা

/   Switch to Ordinal mode.
I   Read a line.
.   Duplicate it.
n   Logical NOT (gives truthy if we're at EOF).
/   Switch to Cardinal.
    The IP wraps around to the left.
\   Switch to Ordinal.
$@  Terminate the program if we're at EOF.
.   Duplicate the input line again.
O   Print it.
\   Switch to Cardinal.
h   Increment the value.
&   Store the result in the iterator queue.
    The program wraps around to the beginning.

পুনরাবৃত্তকারী কাতারে একটি পূর্ণসংখ্যা n সংরক্ষণ করার ফলে পরবর্তী কমান্ডটি n বার কার্যকর করা হয় । মিররগুলি যেমন /কমান্ড নয়, তাই পরবর্তী আদেশটি হবে I। সুতরাং আমরা যদি কেবল একটি মান x পড়ে এবং মুদ্রিত করি তবে আমরা পরবর্তী পুনরাবৃত্তিতে x + 1 মানগুলি পড়ব , যার মধ্যে শেষটি স্ট্যাকের শীর্ষে শেষ হবে। এটি প্রয়োজনীয় সংখ্যা তালিকার উপাদানগুলি এড়িয়ে যায়।

— মার্টিন ইন্ডার
সূত্র

2

গণিত , 37 (30?)

ব্যবহারকারী 202729 এর সূক্ষ্ম পদ্ধতিতে আরও গল্ফ করা।

±{a_,x___}={a}~Join~±{x}~Drop~a
±_={}

নিয়মগুলি পরিষ্কারভাবে আউটপুট ফর্ম্যাটটি নির্দিষ্ট করে বলে মনে হচ্ছে না, তাই সম্ভবত:

±{a_,x___}=a.±{x}~Drop~a
±_={}

দ্বিতীয় ফাংশনের আউটপুট দেখতে দেখতে: 0.2.4.{}- উল্লেখযোগ্যভাবে {}এখনও একটি খালি সেট হিসাবে ফিরে আসে, চূড়ান্ত বিধি অনুসারে।

— Mr.Wizard
সূত্র

1

±Drop[{x},a]এর চেয়ে কম অগ্রাধিকার রয়েছে ±{x}~Drop~aবলেই হতে পারে । ±Infix

— জংহওয়ান মিন

@ জাংহওয়ানমিন আমি এটি মিস করেছি; ধন্যবাদ!

— মিঃ উইজার্ড

2

কমন লিস্প, 51 বাইট

(do((x(read)(nthcdr(1+(print(car x)))x)))((not x)))

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

— Renzo
সূত্র

2

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

0 থেকে একটি ধারণার ভিত্তিতে 4 বাইট সংরক্ষণ করুন

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

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

সটীক

([]){{}            #{Until the stack is empty}
  (({})<>())<>     #{Put n+1 to the offstack}
  {({}[()]<{}>)}{} #{Remove n items from the top}
([])}{}            #{End until}
<>                 #{Swap stacks}
{({}[()]<>)<>}<>   #{Move everything back onto the left stack decrementing by 1}

— গম উইজার্ড
সূত্র

1

রুবি, 36 33 31

f=->l{a,*l=l;a&&f[l.drop(p a)]}

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

— ক্রিশ্চিয়ান লুপাস্কু
সূত্র

আপনাকে f=শিরোনাম উপাদান হিসাবে বিয়োগ করতে দেওয়া হচ্ছে ।

— canhascodez

@ সেথরিন এমনকি যদি আমাকে এটি পুনরাবৃত্তভাবে বলা প্রয়োজন?

— ক্রিশ্চিয়ান লুপাস্কু

হুঁ, ভাল প্রশ্ন। আমি মনে করি না। আমি আপনার সমাধানটি সম্পর্কে এরকম অনেক কিছুই করেছি।

— canhascodez

1

পাইথন 2.4, 85 বাইট

এটি দিয়ে পাইথনটিতে জয়ের কোনও সুযোগ নেই তবে আমি অনলাইনারদের পছন্দ করি এবং এটি অন্যের কাছে আকর্ষণীয় হতে পারে।
দেখা যাচ্ছে, বোঝার ভিতরে বিল্ডিং তালিকার অ্যাক্সেস করার জন্য অভিনব যাদু কৌশল রয়েছে তবে এটি কেবল ২.৪ এ কাজ করে এবং <= 2.3 এ কিছু সম্পাদনা
locals()['_[1]']রয়েছে। পাইথন _[1]এটি তৈরির সময় তালিকার গোপন নাম তৈরি করে এবং এটি সংরক্ষণ করে locals। নাম _[2], _[3]... নেস্টেড তালিকার জন্য ব্যবহৃত হয় are

lambda n:[j for i,j in enumerate(n)if i==len(locals()['_[1]'])+sum(locals()['_[1]'])]

সুতরাং এটি ইতিমধ্যে যুক্ত হওয়া উপাদানগুলির সংখ্যা এবং তাদের যোগফল গণনা করে। ফলাফল হ'ল পরবর্তী পছন্দসই উপাদানের সূচক।
আমি মনে করি, গণনা এড়ানোর একটি উপায় থাকা উচিত। সূচক সরাসরি ইনপুট অ্যারের অ্যাক্সেস: [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]। তবে আমি এটিকে সূচি-বহির্ভূত পরিসীমা থেকে রক্ষা করার জন্য কোনও কমপ্যাক্ট উপায় বের করতে পারি না (এটি অনিলাইনার রাখার সময়)

— ডেড পসুম
সূত্র

1

সুইফট, 63 বাইট

func a(d:[Int]){var i=0;while i<d.count{print(d[i]);i+=d[i]+1}}

এটি আমার প্রথম এন্ট্রি, তাই আমি নিয়মে 100% নিশ্চিত নই তবে আশা করি এই উত্তরটি যথেষ্ট ices সিস্টেমে কীভাবে ইনপুট পাবেন সে সম্পর্কে আমি কিছুটা নিয়ম সম্পর্কে অনিশ্চিত। আমার কোনও সংক্ষিপ্ত উত্তর আছে যদি আমাকে কোথাও এমন কোনও ক্রিয়াকলাপ অনুমান করার অনুমতি দেওয়া হয় যা ইনপুটটি ফিরে আসতে পারে।

— AnonymousReality
সূত্র

পিপিসিজিতে আপনাকে স্বাগতম! ডিফল্ট নিয়মগুলি হ'ল আপনি হয় এমন কোড রাখতে পারেন যা একটি সম্পূর্ণ প্রোগ্রাম হিসাবে কাজ করে, সুতরাং এসটিডিআইএন এবং আউটপুট (সাধারণত) এসটিডিআউটে ইনপুট (সাধারণত) অথবা কোনও ফাংশন, সুতরাং ফাংশন পরামিতি এবং আউটপুট থেকে সাধারণত ইনপুট (সাধারণত) থেকে ফাংশন রিটার্ন

— স্টিফেন

@ স্টেপহেন - ধন্যবাদ! আমার ধারণা এটি তখন আমার অন্যান্য সংস্করণটিকে অবৈধ করে তোলে। আরও অবদান রাখার প্রত্যাশায়!

— AnonymousReality

1

পার্ল 6 , 31 বাইট

{(@_,{.[1+.[0]..*]}...^0)[*;0]}

এটা পরীক্ষা করো

সম্প্রসারিত:

{  # bare block lambda with implicit parameter ｢@_｣
  (
    # generate a sequence

    @_,

    {
      .[ # index into previous value in the sequence
        1 + .[0]  # start by skipping one plus the first element
                  # of the previous value in the sequence
        ..  *     # use that to create a Range with no end
      ]
    }

    ...^  # keep doing that until: (and throw away last value)
    0     # it generates an empty list

  )[ *; 0 ]  # from every value in the sequence, get the first element
}

কোডটি কীভাবে কাজ করে তা বুঝতে সহায়তা করার জন্য এটি ছাড়াই [*;0]নিম্নলিখিতগুলির মতো ক্রম তৈরি হবে:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2],
   (1, 0, 2, 5, 1, 3, 1, 6, 2),
         (2, 5, 1, 3, 1, 6, 2),
                  (3, 1, 6, 2)

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

1

জেলি , 8 বাইট

ḢṄ‘ṫ@µL¿

একটি পূর্ণ প্রোগ্রাম ফলাফল মুদ্রণ করে প্রত্যেকের পরে একটি নতুন লাইন থাকে (খালি তালিকা কোনও আউটপুট দেয় না)।

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

কিভাবে?

ḢṄ‘ṫ@µL¿ - Main link: list of non-negative integers  e.g. [2,5,4,0,1,2,0]
       ¿ - while:           Iteration:  1                  2             3          4        5
      L  -   length (0 is falsey)       7                  4             3          1        0
     µ   - ...do:                                                                            stop
Ḣ        -   head (pop & modify)        2 ([5,4,0,1,2,0])  0 ([1,2,0])   1 ([2,0])  0 ([0])
 Ṅ       -   print it (and yield it)   "2\n"              "0\n"         "1\n"      "0\n"
  ‘      -   increment                  3                  1             2          1
   ṫ@    -   tail from index            [0,1,2,0]          [1,2,0]      [0]         []
         -
         -                       i.e. a resulting in the printing of: '''2
                                                                         0
                                                                         1
                                                                         0
                                                                         '''

— জোনাথন অ্যালান
সূত্র

অবশেষে একটি জেলি উত্তর! বিটিডাব্লু আমি এটি 7 বাইটে করতে পারি।

— এরিক আউটগল্ফার

এবং আমার কাছে 18 বাইটে তালিকা-ফেরত ফাংশনও রয়েছে।

— এরিক আউটগল্ফার

1

পাইথন 3 , 35 বাইট

f=lambda h=0,*t:t and[h,*f(*t[h:])]

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

আপনার ইনপুট f(*l)যেখানে আছে তা দিয়ে এটি চালান l। যুক্তিযুক্তভাবে ইনপুট জন্য নিয়ম প্রসারিত, কিন্তু আমি কেবল উন্নত আনপ্যাকিং পছন্দ করি love

— Evpok
সূত্র

1

এপিএল (ডায়ালগ ইউনিকোড) , 20 বাইট ^{এসবিসিএস}

{⍵≡⍬:⍬⋄(⊃,∘∇1↓⊃↓⊢)⍵}

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

— ngn
সূত্র

আপনি dfn এর ভিতরে সেই স্বতন্ত্র ফাংশনটি যেভাবে ব্যবহার করছেন তা সৃজনশীল।

— এরিক দি আউটগল্ফার

1

পার্ল 5 , 36 30 + 1 (-a) = 31 বাইট

$i+=$F[$i]+say$F[$i]while$i<@F

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

সংখ্যার স্থান পৃথকীকরণের তালিকা হিসাবে এটির ইনপুট নেয়।

— Xcali
সূত্র

1

পাওয়ারশেল , 25 বাইট

$args|?{!$s--}|%{($s=$_)}

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

— mazzy
সূত্র

খরগোশের মতো এড়িয়ে যান!

বিধি

পরীক্ষার মামলা

পাইথন 2 , 36 বাইট

পাইথন 2 , 49 44 * 41 বাইট

কিভাবে কাজ করে?

একটি উদাহরণ নেওয়া যাক

হাস্কেল, 29 27 26 বাইট

জাভাস্ক্রিপ্ট (ES6), 42 39 35 বাইট

পুরাতন সমাধান 39 বাইট

05 এ বি 1 ই , 10 9 বাইট

গণিত, 46 44 বাইট by

সি #, 68 বাইট

কান্ড , 8 6 বাইট

ব্যাখ্যা

পাইথন 2 , 59 55 বাইট

পাইথ, 22 বাইট

পাইথন 2 , 60 42 41 বাইট

রেটিনা , 36 বাইট

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

ম্যাথামেটিকাল, 64 50 বাইট

সি # (.নেট কোর) , 68 বাইট

আর, 58 বাইট

জাভা (ওপেনজেডিকে 8) , 53 বাইট

এলিস , 15 বাইট

ব্যাখ্যা

গণিত , 37 (30?)

কমন লিস্প, 51 বাইট

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

সটীক

রুবি, 36 33 31

পাইথন 2.4, 85 বাইট

সুইফট, 63 বাইট

পার্ল 6 , 31 বাইট

সম্প্রসারিত:

জেলি , 8 বাইট

কিভাবে?

পাইথন 3 , 35 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 20 বাইট এসবিসিএস

পার্ল 5 , 36 30 + 1 (-a) = 31 বাইট

পাওয়ারশেল , 25 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 20 বাইট ^{এসবিসিএস}