ด้วยอาร์เรย์ของจำนวนเต็มที่ไม่เป็นลบงานของคุณคือการเก็บองค์ประกอบบางอย่างเท่านั้นตามที่อธิบายไว้ด้านล่าง

• [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1]สมมติว่าอาร์เรย์คือ

• ก่อนรับองค์ประกอบแรกของอาร์เรย์, n. เก็บnองค์ประกอบแรกและทิ้งองค์ประกอบถัดไป (ทิ้งองค์ประกอบที่n+1th) [1, 2, 4, 11, 5, 2, 0, 13, 10, 1]อาร์เรย์ใหม่คือ

• จากนั้นคุณคว้าองค์ประกอบตามที่ลบออกและทำสิ่งเดียวกัน นำกระบวนการไปใช้ใหม่[1, 2, 11, 5, 2, 0, 13, 10, 1]

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

• ตอนนี้คุณควรส่งออกผลลัพธ์

อินพุต / เอาต์พุตอาจถูกถ่าย / จัดให้ในรูปแบบมาตรฐานใด ๆ อาร์เรย์จะไม่ว่างเปล่าและจะมีเฉพาะจำนวนเต็มที่ไม่เป็นลบ ช่องโหว่มาตรฐานทั้งหมดถูกห้าม

นี่คือโค้ดกอล์ฟเพื่อให้โค้ดที่สั้นที่สุดเป็นไบต์ชนะ!

กรณีทดสอบ

อินพุต -> เอาท์พุท

[1, 2, 3, 4, 5] -> [1, 3, 4]

[6, 1, 0, 5, 6] -> [6, 1, 0, 5, 6]

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

[2, 2, 2, 2, 2, 2] -> [2, 2]

[1, 2, 3, 1, 2, 3, 1, 2, 3] -> [1, 2]

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

* กรณีทดสอบสุดท้ายเกี่ยวข้องกับ0ดังนั้นฉันตัดสินใจที่จะโพสต์กระบวนการดังกล่าวว่ามีความชัดเจน:

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

^{( ได้รับแรงบันดาลใจจากการท้าทายนี้โดยErik the Outgolfer )}

Pyth, 18 ไบต์

#IgZlQB .(Q=Z@QZ)Q

ลองที่นี่

JavaScript (ES6), 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]))) // --> []

Haskell , 50 ไบต์

g.pure.(0:)เป็นฟังก์ชั่นที่ไม่ระบุชื่อการกลับรายการของInts, (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ใช้อาร์กิวเมนต์ tuple ซึ่งเป็นตัวแทนของรายการแยก aคือรายการขององค์ประกอบเริ่มต้นที่เก็บไว้ในขั้นตอนก่อนหน้า_คือองค์ประกอบที่จะยกเลิกbเป็นองค์ประกอบถัดไปที่จะใช้เป็นความยาวและcเป็นองค์ประกอบที่เหลือ
  • หากมีองค์ประกอบเพียงพอในส่วนที่สองของ tuple เพื่อเลือก a bดังนั้นการแยกใหม่จะดำเนินการและเรียกgซ้ำ มิฉะนั้นจะหยุดด้วยaผลลัพธ์
• ฟังก์ชั่นที่ไม่ระบุชื่อg.pure.(0:)เริ่มต้นมันทั้งหมดโดยการเรียกgกับ tuple ([],0:l)ที่lป้อนข้อมูลและได้รับการทิ้งทันทีโดย 0g
  • pureที่นี่ใช้Applicativeอินสแตนซ์สำหรับสิ่งอันดับ (ไบนารี) และด้วยประเภทผลลัพธ์([Int],[Int])ทำให้การโต้แย้งเป็นองค์ประกอบที่สองในสิ่งอันดับด้วยสิ่งอันดับที่[]เป็นองค์ประกอบแรก

Python 3 , 59 ไบต์

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

ลองออนไลน์!

Haskell , 51 ไบต์

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

ลองออนไลน์! ตัวอย่างการใช้: f [1,2,3,4,5].

Java 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);}

ลองใช้ออนไลน์

ลำดับการควบคุมสำหรับปัญหานี้น่ารำคาญมาก การวนซ้ำแต่ละครั้งเราต้องลบองค์ประกอบและรับองค์ประกอบที่ตำแหน่งถัดไปและการดำเนินการทั้งสองนี้จำเป็นต้องมีการตรวจสอบช่วง (และอาจทำให้เกิดการเสร็จสมบูรณ์ของโปรแกรม) กลยุทธ์หนึ่งคือการดำเนินการทั้งสองอย่างในการวนซ้ำครั้งเดียวพร้อมการอัพเดทดัชนีที่ได้รับการปกป้องโดยการตรวจสอบช่วงของตัวเอง กลยุทธ์อื่นที่กลายเป็นสั้นกว่าคือการสลับระหว่างการดำเนินการแต่ละรอบการวนซ้ำซึ่งเป็นสิ่งที่โซลูชันนี้ทำ

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

ลองออนไลน์!

Perl 5 , 38 + 1 (-a) = 39 ไบต์

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

ลองออนไลน์!

Haskell, 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

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 :: []เช่นในบางภาษา (เช่น caml)

เปิด

คุณสามารถเริ่มต้น 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

นี้ควรผลิตไฟล์กับผลที่ถูกต้องจากแฟ้มการป้อนข้อมูลoutputinput

คำอธิบาย

เพื่อแนะนำวิธีแก้ปัญหาฉันจะนำเสนอโซลูชันขนาด 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คือการเพิ่มจำนวนเต็มเสมอก่อนที่จะดึงมันออกมาและลดลงหลังจากนั้น ดังนั้น@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 บรรทัดว่างที่ท้าย)
• เพิ่มหนึ่งซับเพื่อทดสอบในบรรทัดคำสั่ง

Pyth, 32 ไบต์

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

ลองออนไลน์

C # (. NET Core) 74 ไบต์

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

ลองออนไลน์!

สิ่งนี้ใช้เวลาในรายการของ ints และแก้ไขมัน ฉันได้เห็นคำตอบของ Java บางส่วนที่เกี่ยวกับการนำเข้าโดยใช้ชื่อที่ผ่านการรับรองในนิยามอาร์กิวเมนต์ของแลมบ์ดา หากไม่ได้รับอนุญาตฉันสามารถลบคำตอบนี้ได้

R , 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
  }
}