กำหนดรายการของจำนวนเต็มที่ไม่เป็นลบในรูปแบบที่เหมาะสมให้วนซ้ำข้ามองค์ประกอบมากเท่าจำนวนเต็มที่คุณพูด

นี่คือตัวอย่างการทำงาน:

[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" สำหรับกรณีแรก)
• คุณต้องใช้คำสั่งซื้อจากซ้ายไปขวาสำหรับการป้อนข้อมูล
• เช่นเดียวกับในตัวอย่างที่ใช้งานได้หากคุณออกนอกขอบเขตการดำเนินการจะสิ้นสุดลงหากไม่เช่นนั้น
• คุณควรใช้0สำหรับการข้ามองค์ประกอบ 0
• ที่ได้รับรายการที่ว่างเปล่า ( []) เป็น input []คุณควรกลับ

กรณีทดสอบ

[]                                                     => []
[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]

นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดชนะ!

Python 2 , 36 ไบต์

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

ลองออนไลน์!

Python 2 , 49 44 * 41 ไบต์

^{ข้ามออก 44 ยังคงเป็นปกติ 44 :(}

* -3 ต้องขอบคุณ @

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

ลองออนไลน์!

พิมพ์ผลลัพธ์ที่คั่นด้วยบรรทัดใหม่ตามที่ OP อนุญาตในการแชท ผมไม่คิดว่ามันจะได้รับการใด ๆ สั้นเป็นโปรแกรมเต็มรูปแบบที่ไม่ใช่ recursive

มันทำงานอย่างไร

• l=input() - อ่านรายการจากอินพุตมาตรฐาน

• while l: - ละเมิดความจริงที่ว่ารายการว่างเปล่าเป็นเท็จใน Python วนซ้ำจนกว่ารายการนั้นจะว่างเปล่า

• print l[0]; - พิมพ์องค์ประกอบแรกของรายการ

• l=l[l[0]+1:]- "ข้ามเหมือนกระต่าย" - จดจ้องที่แรกl[0]+1จากรายการ

ลองยกตัวอย่าง

ได้รับรายการ[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]เป็น input ดำเนินรหัสดังต่อไปนี้ (ตามคำอธิบายข้างต้น) - พิมพ์รายการแรกของอาร์เรย์: 5ตัดแรก [2, 1, 2, 1, 0, 0]6: จากนั้นเราพิมพ์2และตัดแต่ง 3: [1,0,0]แรก ในทำนองเดียวกันเราส่งออก1พืช 2 [0]ครั้งแรกและเราได้รับ แน่นอน0มีการพิมพ์และโปรแกรมจะสิ้นสุดลง

Haskell, 29 27 26 bytes

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

บันทึก 1 ไบต์ขอบคุณ Zgarb

ลองออนไลน์

JavaScript (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 ไบต์ขอบคุณ @ThePirateBay

05AB1E , 10 9 ไบต์

[¬Dg>#=ƒ¦

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

Mathematica, 46 44 ไบต์

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

ทางเลือก:

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

C #, 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;}

Husk , 8 6 ไบต์

←TU¡Γ↓

ลองออนไลน์!

-2 ไบต์ (และแนวคิดการแก้ปัญหาใหม่ทั้งหมด) ขอบคุณ Leo!

คำอธิบาย

Γฉันใช้ฟังก์ชั่นรายการรูปแบบการแข่งขัน มันต้องใช้ฟังก์ชั่น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]

Python 2 , 59 55 ไบต์

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

ลองออนไลน์!

Pyth, 22 ไบต์

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

ลบ byte ที่ไร้ประโยชน์

Python 2 , 60 42 41 ไบต์

^{-18 ไบต์ขอบคุณ Luis Mendo
-1 ไบต์ขอบคุณ Jonathan Frech}

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

ลองออนไลน์!

เรติน่า 36 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

อินพุตและเอาต์พุตถูกแยก linefeed ด้วยการลาก linefeed

ลองออนไลน์! (ใช้เครื่องหมายจุลภาคแทน linefeeds เพื่ออนุญาตให้ใช้ชุดทดสอบที่สะดวก)

Brain-Flak , 64 ไบต์

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

ลองออนไลน์!

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

Mathematica, 64 50 ไบต์

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

C # (. NET Core) , 68 ไบต์

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

ลองออนไลน์!

รับอินพุตเป็นอาร์เรย์ของจำนวนเต็มส่งคืนสตริงที่มีค่าที่ไม่ถูกข้าม

R, 58 ไบต์

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

ฟังก์ชั่นวนซ้ำ ใช้เวลาเวกเตอร์xเป็นอาร์กิวเมนต์และ intiates 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])))

นี่เป็นวิธีแก้ปัญหาที่เทียบเคียงได้ซึ่งจะส่งคืนเวกเตอร์ที่เหมาะสมแทนที่จะพิมพ์ตัวเลข

Java (OpenJDK 8) , 53 ไบต์

ขอบคุณ @ PunPun1000 และ @TheLethalCoder

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

ลองออนไลน์!

อลิซ 15 ไบต์

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

ลองออนไลน์!

อินพุตและเอาต์พุตรายการจำนวนเต็มทศนิยมที่คั่นด้วย linefeed

คำอธิบาย

/   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 ในการคำนวณซ้ำครั้งถัดไปโดยที่ค่าสุดท้ายจะสิ้นสุดที่ด้านบนสุดของสแต็ก สิ่งนี้จะข้ามองค์ประกอบรายการหมายเลขที่ต้องการ

Mathematica , 37 (30?)

การตีกอล์ฟต่อไปด้วยวิธีการที่ดีของผู้ใช้ 2,02729

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

กฎดูเหมือนจะไม่ระบุรูปแบบผลลัพธ์อย่างชัดเจนดังนั้นอาจจะ:

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

เอาต์พุตสำหรับฟังก์ชันที่สองมีลักษณะดังนี้: 0.2.4.{}- {}ยังคงส่งคืนสำหรับชุดที่ว่างเปล่าซึ่งเป็นไปตามกฎสุดท้าย

Lisp สามัญ, 51 ไบต์

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

ลองออนไลน์!

Brain-Flak , 64 60 ไบต์

4 ไบต์บันทึกตามแนวคิดจาก0 '

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

ลองออนไลน์!

ข้อเขียน

([]){{}            #{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}

ทับทิม, 36 33 31

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

ลองออนไลน์

Python 2.4, 85 ไบต์

ไม่มีโอกาสที่จะชนะด้วยไพ ธ อน แต่ฉันรักผู้บุกรุกและสิ่งนี้อาจน่าสนใจสำหรับผู้อื่น
ปรากฎว่ามีเคล็ดลับมายากลแฟนซีในการเข้าถึงรายการสิ่งก่อสร้างภายในความเข้าใจ แต่ใช้งานได้เฉพาะใน 2.4 และมีการแก้ไขบางอย่างใน <= 2.3
locals()['_[1]']มันคือ งูหลามสร้างชื่อลับสำหรับรายการในขณะที่มันถูกสร้างขึ้นและเก็บไว้ใน_[1] localsนอกจากนี้ยังมีชื่อ_[2], _[3]... ถูกนำมาใช้สำหรับรายการที่ซ้อนกัน

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 ... ]เช่นเดียวกับการเข้าถึงอาร์เรย์การป้อนข้อมูลโดยตรงจากดัชนี: แต่ฉันไม่สามารถหาวิธีกะทัดรัดในการปกป้องมันจากดัชนีออกนอกช่วง (ในขณะที่รักษามันไว้ที่จุดเริ่มต้น)

Swift, 63 ไบต์

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

นี่เป็นรายการแรกของฉันเลยฉันไม่แน่ใจ 100% เกี่ยวกับกฎ แต่หวังว่าคำตอบนี้จะพอเพียง ฉันไม่แน่ใจเกี่ยวกับกฎเล็กน้อยเกี่ยวกับวิธีการป้อนข้อมูลเข้าสู่ระบบ ฉันมีคำตอบที่สั้นกว่านี้หากฉันได้รับอนุญาตให้ทำหน้าที่บางอย่างที่สามารถส่งคืนอินพุตได้

Perl 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)

เยลลี่ขนาด 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
                                                                         '''

Python 3 , 35 ไบต์

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

ลองออนไลน์!

เรียกมันด้วยf(*l)ที่lเป็นเข้าของคุณ เนื้อหายืดกฎสำหรับอินพุต แต่ฉันรักการเปิดออกขั้นสูง

APL (Dyalog Unicode) , 20 ไบต์^SBCS

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

ลองออนไลน์!

Perl 5 , 36 30 + 1 (-a) = 31 ไบต์

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

ลองออนไลน์!

ใช้อินพุตเป็นช่องว่างคั่นรายการตัวเลข

PowerShellขนาด 25 ไบต์

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

ลองออนไลน์!