Đưa ra một loạt các số nguyên không âm, nhiệm vụ của bạn là chỉ giữ một số phần tử nhất định của nó, như được mô tả dưới đây.

• Hãy nói rằng mảng là [1, 3, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Đầu tiên lấy phần tử đầu tiên của mảng , n. Giữ các nyếu tố đầu tiên và loại bỏ yếu tố tiếp theo (loại bỏ n+1thứ). Mảng mới là [1, 2, 4, 11, 5, 2, 0, 13, 10, 1].

• Sau đó, bạn lấy phần tử theo sau phần tử bị loại bỏ và thực hiện chính xác điều tương tự. Áp dụng lại quy trình, chúng tôi nhận được[1, 2, 11, 5, 2, 0, 13, 10, 1]

• Bạn lặp lại quy trình cho đến khi bạn đến bên ngoài giới hạn của mảng / không còn phần tử nào trong mảng. Chúng tôi dừng lại vì 11cao hơn chiều dài của mảng.

• Bây giờ bạn nên xuất kết quả.

Đầu vào / đầu ra có thể được lấy / cung cấp dưới mọi hình thức tiêu chuẩn. Mảng sẽ không bao giờ trống và sẽ chỉ chứa các số nguyên không âm. Tất cả các sơ hở tiêu chuẩn đều bị cấm.

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Các trường hợp thử nghiệm

Đầu vào -> Đầu ra

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

* Trường hợp thử nghiệm cuối cùng liên quan 0, vì vậy tôi quyết định đăng quá trình sao cho rõ ràng hơn:

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

^{( Lấy cảm hứng từ thử thách này của Erik the Outgolfer )}

Bình thường, 18 byte

#IgZlQB .(Q=Z@QZ)Q

Hãy thử nó ở đây.

JavaScript (ES6), 45 byte

f=(a,k=0,x=a[k])=>1/x?f(a.splice(x,1)&&a,x):a

Các trường hợp thử nghiệm

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 byte

g.pure.(0:)là một hàm ẩn danh lấy và trả về một danh sách Ints, sử dụng như (g.pure.(0:))[1,2,3,4,5].

g.pure.(0:)
g(a,_:b:c)=g$splitAt b$a++b:c
g(a,_)=a

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

• Hàm glấy một đối số tuple đại diện cho một danh sách phân chia. alà danh sách các phần tử ban đầu được giữ ở bước trước, _là phần tử cần loại bỏ, blà phần tử tiếp theo được sử dụng làm độ dài và clà phần tử còn lại.
  • Nếu có đủ các phần tử trong phần thứ hai của bộ dữ liệu để chọn a b, thì phần tách mới được thực hiện và gđệ quy. Mặt khác, nó dừng lại với akết quả.
• Hàm ẩn danh g.pure.(0:)bắt đầu tất cả bằng cách gọi gvới bộ dữ liệu ([],0:l), đây llà đầu vào và 0bị loại bỏ ngay lập tức g.
  • pureở đây sử dụng Applicativethể hiện cho các bộ dữ liệu (nhị phân) và với loại kết quả, ([Int],[Int])thuận tiện đặt đối số của nó làm phần tử thứ hai trong một bộ với []phần tử đầu tiên.

Python 3 , 59 byte

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

Hãy thử trực tuyến!

Haskell , 51 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng : f [1,2,3,4,5].

Java 8, 68 byte

Lambda này chấp nhận một đột biến List<Integer>(hỗ trợ remove(int), ví dụ ArrayList). Đầu ra là đầu vào đột biến. Chỉ định cho 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);}

Dùng thử trực tuyến

Luồng điều khiển cho vấn đề này rất khó chịu. Mỗi lần lặp chúng ta phải loại bỏ một phần tử và lấy phần tử ở vị trí tiếp theo và cả hai thao tác này đều yêu cầu kiểm tra phạm vi (và có thể kích hoạt hoàn thành chương trình). Một chiến lược là thực hiện cả hai thao tác trong một vòng lặp đơn, với cập nhật chỉ mục được bảo vệ bởi kiểm tra phạm vi của chính nó. Một chiến lược khác, hóa ra là ngắn hơn, là xen kẽ giữa các hoạt động mỗi lần lặp vòng lặp, đó là những gì giải pháp này làm.

APL (Dyalog Classic) , 32 byte

1∘{n∇⍣(n≤≢w)⊢w←⍵/⍨(n←1+⍺⊃⍵)≠⍳≢⍵}

Giải trình

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

Hãy thử trực tuyến!

Perl 5 , 38 + 1 (-a) = 39 byte

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

Hãy thử trực tuyến!

Haskell, 99 byte (88 mà không thụt lề)

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 byte

O@0kdd<C-v><C-a>Y<C-v><C-x>gg@a<Esc>"add<C-a>Y<C-x>@a

<C-?>tương ứng với Control + ?, và <Esc>để Escaperõ ràng. Mỗi trong số này được tính cho 1 byte (xem meta ).

Đầu vào

Tệp đầu vào phải chứa 1 số nguyên trên mỗi dòng + 1 dòng trống ở cuối, ví dụ:

1
2
3
4
5
⁣

Chúng ta có thể thấy mỗi dòng của tệp đầu vào là một thành phần mảng, chẳng hạn như 1 :: 2 :: 3 :: 4 :: 5 :: [], trong một số ngôn ngữ (ví dụ như caml).

Phóng

Bạn có thể bắt đầu vi bằng lệnh sau và nhập đột quỵ giải pháp bằng đột quỵ:

vi -u NONE input

Bạn cũng có thể sử dụng một lớp lót này:

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

Điều này sẽ tạo ra một tệp outputcó kết quả chính xác từ một tệp đầu vào input.

Giải thích

Để giới thiệu giải pháp, trước tiên tôi sẽ trình bày một giải pháp 19 byte chỉ hoạt động cho các mảng không có 0. Giải pháp này sử dụng macro đệ quy, được sử dụng với một chút sửa đổi trong giải pháp cuối cùng:

Yqa@0ddYgg@aquggY@a

Giải thích về một giải pháp một phần

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

Mẹo ở đây là sử dụng thanh "0ghi để lưu trữ số nguyên hiện tại (và ngắt dòng, rất quan trọng). Do đó, lệnh @0cho phép nhảy ncác dòng (gọi ngiá trị của "0). Nếu bước nhảy vượt quá số lượng dòng trong tệp, macro sẽ thất bại, do đó chương trình sẽ dừng lại (bên ngoài giới hạn mảng, theo yêu cầu).

Nhưng giải pháp này không hoạt động nếu đầu vào chứa 0. Thật vậy, nếu "0giá trị đăng ký bằng 0, thì @0sẽ nhảy một dòng (do ngắt dòng), không 0như chúng ta thích. Vì vậy, lệnh tiếp theo ( dd) sẽ không xóa số nguyên thứ 0, nhưng số 1 (không chính xác).

Một giải pháp hợp lệ để xử lý 0là luôn luôn tăng số nguyên trước khi kéo nó và giảm nó ngay sau đó. Do đó, @0lệnh sẽ nhảy n+1các dòng ( nlà số nguyên hiện tại đã được tăng lên). Một klệnh sau đó là cần thiết để đi đến dòng n(dòng trước). Sử dụng thủ thuật này, một dòng trống là cần thiết ở cuối tệp đầu vào, để tránh nhảy ra khỏi mảng (do đó, chấm dứt chương trình), vì bây giờ chúng ta luôn luôn nhảy n+1các dòng, trước khi nhảy đến dòng trước đó.

Giải thích về giải pháp cuối cùng

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)

Viết nội dung macro bên trong tệp trước khi đăng ký, nó cho phép lưu một vài byte:

• tránh viết qa...qvà hoàn tác mọi thay đổi sau khi đăng ký
• tránh :let @a="...")

Chỉnh sửa

# 1

• viết nội dung macro trên dòng đầu tiên (thay vì dòng cuối cùng)
• thay đổi đầu vào (1 dòng trống ở cuối)
• thêm một lớp lót để kiểm tra trong dòng lệnh

Bình thường, 32 byte

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

Dùng thử trực tuyến

C # (.NET Core) , 74 byte

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

Hãy thử trực tuyến!

Điều này có trong một danh sách các số nguyên và sửa đổi nó. Tôi đã thấy một số câu trả lời Java xoay quanh việc nhập khẩu bằng cách sử dụng tên đủ điều kiện trong định nghĩa đối số Lambda. Nếu điều này không được phép, tôi có thể loại bỏ câu trả lời này.

R , 64 53 byte

f=function(a,i=1,d=a[i]+1)"if"(is.na(d),a,f(a[-d],d))

Hàm đệ quy. Có một đầu vào bắt buộc a, danh sách để bỏ qua. ilà chỉ số của số thứ cần nhảy qua (mặc định là 1) và dlà chỉ mục của mục tiếp theo sau khi giá trị được yêu cầu đã bị xóa, đây cũng là chỉ mục của mục cần xóa. Trả về numeric(0), một vector trống, cho đầu ra trống.

Hãy thử trực tuyến!

Ung dung:

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