Xóa mọi N-th N


41

Nhiệm vụ

Trong thử thách này, đầu vào của bạn là một danh sách các số nguyên dương không trống, được đưa ra ở định dạng gốc của ngôn ngữ của bạn. Đầu ra của bạn là cùng một danh sách, trong cùng một định dạng, với một số yếu tố bị loại bỏ. Bạn sẽ loại bỏ mọi lần xuất hiện 1, mỗi lần xuất hiện thứ hai 2, mỗi lần xuất hiện thứ ba 3, v.v. Nói chung, đối với mỗi số nguyên dương N, bạn sẽ xóa mọi Nlần xuất hiện trong Ndanh sách, bắt đầu với Nlần xuất hiện thứ.

Thí dụ

Xem xét danh sách đầu vào

[3,2,6,1,1,6,2,3,2,6,6,6,6,1,6,6,3,3,7,2]

Đầu tiên, chúng tôi loại bỏ mọi sự xuất hiện của 1:

[3,2,6,    6,2,3,2,6,6,6,6,  6,6,3,3,7,2]

Sau đó, mỗi lần xuất hiện của 2:

[3,2,6,    6,  3,2,6,6,6,6,  6,6,3,3,7  ]

Sau đó, mỗi lần xuất hiện thứ ba của 3:

[3,2,6,    6,  3,2,6,6,6,6,  6,6,  3,7  ]

Các số 45không xảy ra trong đầu vào, vì vậy chúng có thể được bỏ qua. Tiếp theo, chúng tôi xóa mọi lần xuất hiện thứ sáu của 6:

[3,2,6,    6,  3,2,6,6,6,    6,6,  3,7  ]

Chỉ có một lần xuất hiện 7, vì vậy cũng có thể bỏ qua. Do đó, đầu ra đúng là

[3,2,6,6,3,2,6,6,6,6,6,3,7]

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

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

[1] -> []
[2] -> [2]
[1,1,1] -> []
[2,2,2] -> [2,2]
[1,1,2,2,2,3,3,3,3] -> [2,2,3,3,3]
[1,2,3,1,2,3,1,2,3,1,2,3] -> [2,3,3,2,3]
[3,2,6,1,1,6,2,3,2,6,6,6,6,1,6,6,3,3,7,2] -> [3,2,6,6,3,2,6,6,6,6,6,3,7]
[5,4,5,4,3,5,4,5,4,5,4,3,5,4,5,3,3,3,4,5,4,5,4,5,4,3,3,3,5,4] -> [5,4,5,4,3,5,4,5,4,3,5,4,5,3,3,4,5,5,4,4,3,3,5,4]
[6,4,5,8,2,9,3,1,8,5,3,5,5,6,3,5,1,2,3,9,3,5,8,7,5,9,1,3,4,8,2,3,4,7,8,5,8,5,3,1] -> [6,4,5,8,2,9,3,8,5,3,5,5,6,3,9,3,5,8,7,5,9,4,8,2,3,4,7,8,5,8,5,3]
[4,4,9,12,9,4,4,4,12,9,12,9,12,4,12,4,4,9,4,9,12,4,12,4,4,12,4,4,9,12,9,12,9,4,9,12,4,9,12,9,12,9,4,9,12,12,4,4,12,4] -> [4,4,9,12,9,4,4,12,9,12,9,12,4,12,4,9,4,9,12,4,12,4,12,4,4,9,12,9,12,4,9,12,9,9,12,9,4,9,12,12,4,4,12]
[2,2,11,11,11,11,6,2,2,6,6,2,2,2,2,6,11,6,11,11,2,11,2,6,6,11,2,11,6,2,6,6,6,6,6,11,2,11,11,6,6,6,11,6,2,6,2,6,6,2,11,2,2,11,11,11,11,2,6,2] -> [2,11,11,11,11,6,2,6,6,2,2,6,11,6,11,11,2,11,6,11,2,11,6,6,6,6,6,2,11,11,6,6,6,11,6,2,6,6,11,2,11,11,11,11,2,6]
[20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102] -> [20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,21,22,101,102,20,21,22,100,102,20,21,22,100,101,20,21,22,100,101,102,20,21,22,100,101,102,20,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,22,100,101,102,20,21,100,101,102]

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ. Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

## Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình, hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

## Perl, 43 + 2 (-p flag) = 45 bytes

Bạn cũng có thể đặt tên ngôn ngữ thành một liên kết mà sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Câu trả lời:


15

Thạch , 10 8 byte

=;\S€%af

Cảm ơn @ Sp3000 vì đã chơi golf 2 byte!

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

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

=;\S€%af    Main link. Input: A (list)

 ;\         Compute the cumulative concatenations of the elements of A, i.e., the
            list of A's prefixes.
=           Compare the elements of the nth prefix with the nth element of A.
   S€       Compute the sum of the resulting arrays.
     %      Take the nth sum modulo the nth element of A.
      a     Logical AND; replace the nth remainder with the nth element of A
            if the remainder is non-zero.
        f   Filter; remove the zeroes (which do not occur in A) from the result.

bước so sánh đó hoạt động như thế nào? và là các tiền tố của [5,4,3,2,1] [[5], [5,4], [5,4,3], [5,4,3,2], [5,4, 3,2,1]] hoặc [[1], [2,1], [3,2,1], [4,3,2,1], [5,4,3,2,1]]?
quintopia

@quintopia Jelly nằm từ trái sang phải, vì vậy đây là lần đầu tiên. =so sánh các số nguyên. Ví dụ, [3,2,1]=;\so sánh 3với các yếu tố [3], 2với những người thân của [3, 2]1với những người [3, 2, 1], đem lại cho [1, [0, 1], [0, 0, 1]].
Dennis

Ah tôi đã thiếu rằng nó đang so sánh một danh sách với một danh sách theo từng yếu tố.
quintopia

34

ôi, 10 byte

Đầu vào dự kiến ​​trên STDIN, một số trên mỗi dòng.

++a[$1]%$1

Giải trình

Giữ một bộ đếm cho mỗi số trong một mảng kết hợp, chỉ in nếu modulo giá trị bộ đếm nkhông bằng không. In ấn là ngầm. Phiên bản dài:

++a[$1]%$1{print $0}

19

Pyth, 18 15 14 10 9 byte

f%/aYTTTQ

Tôi nghĩ rằng đây là mã đầu tiên tôi đã viết có năm tham chiếu biến liên tiếp trong chín byte.

Tôi muốn giải pháp thao tác mảng ( u.DG%HgxHGH{QQ, 14 byte) không quá dài.

f%/aYTTTQ       Implicit: Q=input
                 lambda T:
    Y              Variable: starts as empty list.
   a T             Append T to Y. Mutates Y.
  /   T           Number of elts of Y that equal T.
 %     T         Modulo by T
f       Q       Filter that lambda over Q.

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


9

Python, 57 byte

lambda l:[n for i,n in enumerate(l)if l[:i+1].count(n)%n]

8

Perl 6 , 28 byte

{$_=$;grep {++.{$^n}%$n},@_} # 28 bytes
{
  $_=$;        # put $_ in a clean state
  grep {
    ++.{$^n}   # increment $_{ $n } and declare $n as an argument
    % $n       # check if the count is not divisible by $n
  }, @_        # the input
}

Sử dụng:

# give it a lexical name for ease of use
my &code = {...}

sub check ( @a, @b ){
  say try { so all code(@a) »==« @b } // False
}

check [1], []; # True
check [2], [2]; # True
check [1,1,1], []; # True
check [2,2,2], [2,2]; # True
check [1,1,2,2,2,3,3,3,3], [2,2,3,3,3]; # True
check [1,2,3,1,2,3,1,2,3,1,2,3], [2,3,3,2,3]; # True
check [3,2,6,1,1,6,2,3,2,6,6,6,6,1,6,6,3,3,7,2], [3,2,6,6,3,2,6,6,6,6,6,3,7]; # True

Kiểm tra kỹ xem các phần tử chính xác có bị loại bỏ không

# have to change it to a pure number
# when checking $_         V
my &code = {$_=$;grep {++.{+$^n}%$n},@_}
# only matters here because we are using
# a subclass of Int but want it to use
# the same key as a normal Int

sub F ( Int $v ) { IntStr.new: $v, "Fail($v)" }
# prove that it passes through unchanged
say [F(2)];
# (Fail(2))

say code [3,2,6,F(1),F(1),6,F(2),3,2,6,6,6,F(6),F(1),6,6,F(3),3,7,F(2)];
# (3 2 6 6 3 2 6 6 6 6 6 3 7)

7

Nghiêm túc, 22 17 byte

k╗,;`;;╜o;╗c%`M@░

Bãi rác Hex:

6bbb2c3b603b3bbd6f3bbb6325604d40b0

Dùng thử trực tuyến

Giải trình:

k╗                                Put empty list in reg0
  ,;                              Two copies of input
    `        `M                   Map over the list
     ;;                           Make 2 extra copies of n
       ╜o                         Load reg0 and push the n onto it
         ;╗                       Put a copy back in reg0
           c                      Count the number of copies of n in the list
            %                     Take the result modulo n
               @░                 Filter the original list with the resulting list

10
Ngôn ngữ này ...
Nico

6

JavaScript ES6, 34 byte

a=>a.filter(v=>f[v]=-~f[v]%v,f=[])

Hóa ra là giống như thuật toán Perl của Brad.

Chỉnh sửa: Đã lưu 2 byte nhờ @ edc65.


Tốt lưu 2 byte loại bỏ các dấu ngoặc đơn bên tronga=>a.filter(v=>f[v]=-~f[v]%v,f=[])
edc65

5

Toán học, 40 38 36 byte

Select[(f@#=#)&/@#,++f[#]~Mod~#>0&]&

Đây là một hàm không tên lấy và trả về a List. Nó định nghĩa một hàm được đặt tên fkhi được thực thi (để theo dõi các số), nhưng đảm nhiệm việc đặt lại các định nghĩa có liên quan vềf trước đó.

Giải trình

Cách các hàm (hoặc định nghĩa hàm) hoạt động trong Mathematica thực sự mạnh mẽ. Như trong Haskell (ví dụ), các hàm chỉ có thể bị quá tải và được xác định cho một số loại nhất định, mà còn cho các giá trị riêng lẻ (hoặc các mẫu đối số tùy ý, thực tế). Nhưng nó thậm chí còn mạnh hơn Haskell ở chỗ a) các giá trị này có thể được định nghĩa là tác dụng phụ trong luồng điều khiển và b) các giá trị cũng có thể được xác định lại bất cứ lúc nào. Điều đó có nghĩa là các hàm thực sự là các bảng tra cứu khá mạnh mẽ (có thể tùy ý tính toán giá trị thay vì chỉ lưu trữ nó).

Nếu chúng ta loại bỏ golf từ mã, nó sẽ trông giống như thế này:

g[list_] := (
  Map[
    (f[#] = #) &,
    list
  ];
  Select[
    list,
    Mod[++f[#], #] > 0 &
  ]
)

Vì vậy, trước tiên, chúng tôi lặp qua đầu vào và xác định f[x] = x, cho tất cả xtrong danh sách. fcuối cùng sẽ được sử dụng để theo dõi tần suất mỗi số đã xuất hiện trong danh sách. Tại sao chúng ta không tính từ 0? Vòng lặp trong danh sách là a Map. Biểu thức f[x] = ytrả về y(ngoài việc lưu trữ định nghĩa hàm). Vì vậy, bằng cách đặt f[x]thành x, bản đồ sẽ tự đánh giá vào danh sách đầu vào. Điều đó tiết kiệm hai byte bởi vì sau đó chúng tôi không cần phải cung cấp listlại một cách rõ ràng Select. Bắt đầu từ xthay vì 0không ảnh hưởng đến tính toán vì chúng tôi chỉ quan tâm đến Mod[f[x], x].

(Thông thường chúng ta chỉ cần sử dụng một cái gì đó như f[_] = 0một định nghĩa dự phòng để tránhMap , nhưng chúng ta không biết nếu chức năng của chúng ta đã được sử dụng trước đó, điều này sẽ để lại một số giá trị trước đó được xác định sẽ gây rối với việc đếm của chúng ta.)

Sau đó, Selectlọc danh sách bằng cách chỉ giữ lại các phần tử trong đó hàm không tên được chuyển qua làm đối số thứ hai mang lại True. Hàm đó trước tiên tăng giá trị của f[x](trong đó xlà phần tử danh sách hiện tại), để đếm các lần xuất hiện, và sau đó nó sẽ lấy modulo đếm kết quả x. Chúng tôi muốn loại bỏ tất cả các yếu tố mà điều này mang lại 0.


5

CJam, 17 byte

Lq~{:X+_Xe=X%},p;

Chỉ cần đánh ... J? Không chắc chắn những gì tôi mong đợi cho thử thách này, thực sự. Lưu ý rằng đó ""là đại diện của CJam về một mảng trống.

Dùng thử trực tuyến | Bộ kiểm tra (trường hợp cuối cùng quá dài cho permalink)

Giải trình

L                     Push empty array (let's call it L)
 q~                   Push input and evaluate

   {         },       Filter the array elements by...
    :X                   Save number to variable X
      +                  Append to L

       _                 Duplicate
        Xe=              Count occurences of X
           X%            Take modulo X

                      The top element is popped to determine whether or not to keep that
                      element, with the updated L kept on the stack for the next iteration

               p      Print the resulting filtered array
                ;     Pop L, which is now equal to the input array

4

JavaScript ES6, 55 byte

a=>a.filter((v,i)=>a.filter((w,j)=>j<=i&v==w).length%v)

Giải trình

a=>                            //a -> input array
 a.filter(                     //filter array. only keep elements if inside function returns truthy
      (v,i)=>                  //inside function to decide whether to keep items. v -> item; i -> index
           a.filter((w,j)=>    //get all ocurrences of v that occur before index i
                j<=i&v==w      //(this is done by keeping all items w at index j, if j <= i and v == w
           ).length%v          //get length (count ocurrences), and mod v.
                               //this will only be falsy if the number of ocurrences of v up to this index is divisible by v. (0 -> falsy, positive -> truthy) 
 )                             //so, we don't keep every second 2, every third 3, etc.

3

J, 18 byte

#~((0<]|+/@:=){:)\

Sử dụng:

   (#~((0<]|+/@:=){:)\) 1 2 3 1 2 3 1 2 3 1 2 3
2 3 3 2 3

Phương pháp khá đơn giản. Chúng tôi đếm số lần xuất hiện của một số cho đến số đó và chỉ chọn số đó nếu số đó chia số đếm.

Nhiều lời giải thích đến sau.

Hãy thử trực tuyến tại đây.


2

PowerShell, 56 byte

param($a)$b=,0*($a|sort)[-1];$a|%{if(++$b[$_-1]%$_){$_}}

Sử dụng một mánh khóe trợ giúp tương tự như câu trả lời của Rainer P , mà tôi đã phát triển độc lập nhưng rõ ràng tôi đã có FGITW'd.

Đưa đầu vào như một mảng với param($a). Sau đó, chúng tôi tạo mảng trình trợ giúp của mình $bdưới dạng một mảng có số không bằng cách sử dụng toán tử dấu phẩy kết hợp với toán tử nhân quá tải. Điều này tạo ra $bbằng @(0,0,0...0)với $b.lengthbằng số tối đa trong $a.
(Cắm nhanh cho câu trả lời "Hiển thị ngôn ngữ của bạn" nơi tôi mô tả chi tiết này)

Tiếp theo là đầu ra của chúng tôi. Chúng tôi lặp qua mọi phần tử của mảng đầu vào $a|%{...}và mỗi vòng lặp kiểm tra một ifcâu lệnh. Điều kiện tăng trước giá trị trong mảng trình trợ giúp của chúng tôi tương ứng với phần tử hiện tại, sau đó kiểm tra xem đó có phải là bội số của phần tử hiện tại với toán tử modulo hay không. Nếu nó là bội số, ý %chí sẽ bằng 0falsey, vì vậy ifkhông thực thi. Mặt khác, chúng tôi xuất phần tử hiện tại.

Tận dụng lợi thế của kiểu chữ ngầm để tiết kiệm định dạng đầu ra. Nếu một hàm hoặc chương trình trả về nhiều phần tử và bạn lưu kết quả vào một biến, PowerShell sẽ tự động tạo biến đó dưới dạng một mảng. Thí dụ:

PS C:\Tools\Scripts\golfing> $testc = .\remove-every-nth-n.ps1 @(2,2,2)

PS C:\Tools\Scripts\golfing> $testc
2
2

PS C:\Tools\Scripts\golfing> $testc.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------             
True     True     Object[]                                 System.Array

1

R, 110 98 99 92 byte

function(a){for(i in 1:max(a))for(j in seq_along(b<-which(a==i)))if(j%%i<1)a[b[j]]=0;a[a>0]}

Chỉnh sửa viết lại hoàn toàn sửa lỗi với trường hợp kiểm tra 2/3 Chỉnh sửa 2 Lưu 7 byte nhờ @ Alex-A


1
92 byte:function(a){for(i in 1:max(a))for(j in seq_along(b<-which(a==i)))if(j%%i<1)a[b[j]]=0;a[a>0]}
Alex A.

1

MATL , 20 byte

tu"t@=f@@h0h)0w(]tg)

Điều này sử dụng bản phát hành hiện tại (10.2.1) của ngôn ngữ / trình biên dịch.

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

Giải trình

tu        % implicitly input array. Duplicate and get unique elements
"         % for each unique element, say "i"
  t       % duplicate
  @=f     % indices of occurrences of i
  @@h0h   % build index representing i-th occurrences (Matlab's i:i:end)
  )       % keep only indices of i-th occurrences
  0w(     % set those entries to 0
]         % end for loop
tg)       % keep nonzeros only. Implicit display


1

C #, 224 byte

List<int>R(List<int>l,int n=1){l=l.Where(w=>w!=0&&w!=1).ToList();for(int i=0,t=0;i<l.Count;i++){if(l[i]==n&&++t==n){l[i]=0;t=0;}}return !l.Any()||n>l.Max()?l:R(l,++n);}

Mã này sử dụng đệ quy. Vớiusing câu lệnh là 224 byte (160 cho chính mã phương thức).

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

List <int> R(List <int> l, int n = 1)
{
    l = l.Where(w => w > 1).ToList();
    for (int i = 0, t = 0; i < l.Count; i++)
    {
        if (l[i] == n && ++t == n)
        {
            l[i] = 0;
            t = 0;
        }
    }
    return !l.Any() || n > l.Max() ? l : R(l, ++n);
}

Bạn sẽ có thể lưu một vài ký tự bằng cách xóa câu lệnh continue. Một cái gì đó như (chưa được kiểm tra)for(int i=0,t=0;i<l.Count;i++)if(l[i]==n&&++t==n)l[i]=t=0;
Peter Taylor

@ peter-taylor, bạn nói đúng, cảm ơn. Ngoài ra, đã phải thêm một số mã để sửa lỗi.
Dmitry Stepanov

Nếu bạn đã nhập System.Linqthì !l.Any()ngắn hơn l.Count<1, ngắn hơn l.Count==0.
Peter Taylor

@ peter-taylor cảm ơn, tôi cũng thay thế w != 0 && w !=1bằng w > 1.
Dmitry Stepanov

mảng cũng phải tốt và chúng sẽ ngắn hơn một chút int [] R (int [] l, int n = 1)
raggy

0

C # - 177 byte

void r(List<int> i){for(int c=1,k=1,m=i.Max();k<=m;k++){var n=new List<int>();foreach(var o in i)if(o==k&&c++==k)c = 1;else n.Add(o);i=n;}Console.WriteLine(string.Join(" ",i));}

Bị đánh cắp

void r(List<int> i)
{
    for (int c = 1, k = 1, m = i.Max(); k <= m; k++)
    {
        var n = new List<int>();
        foreach (var o in i)
            if (o == k && c++ == k)
                c = 1;
            else
                n.Add(o);
        i = n;
    }
    Console.WriteLine(string.Join(" ", i));
}

4
Tôi tin rằng bạn sẽ phải đếm các câu lệnh sử dụng, trong trường hợp này, nó sẽ dài 241 byte.
LegionMammal978

0

Toán học, 63 byte

Fold[Delete[#,Position[#,#2][[#2;;;;#2]]~Check~{}]&,#,Union@#]&

Khá thú vị để chơi golf! Bỏ qua các tin nhắn thỉnh thoảng bật lên.


0

Ruby, 120 byte

->a{1.upto(a.max).each{|i|k=0;a.length.times.each{|j|k+=1if a[j]==i;a[j]=''if k%i==0&&a[j]==i;a[j]}};a.select{|i|i!=''}}

0

TI-BASIC, 47 byte

Input X
For(I,1,dim(∟X
∟X(I
If fPart(sum(∟X=Ans),1,I)/Ans
Ans→L₁(1+dim(L₁
End
L₁

Điều này sử dụng thực tế là, trên một máy tính mới, L₁được khởi tạo và xóa. Lưu ý rằng việc cố gắng hiển thị danh sách trống trong TI-BASIC sẽ gây ra lỗi.


0

APL, 16 ký tự

{⍵/⍨×⍵|+/¨⍵=,\⍵}

Bằng tiếng Anh:

  • ,\⍵: vectơ của tiền tố vectơ cho đến phần tử thứ n của đối số
  • +/¨⍵=: trên mỗi vectơ tiền tố, đếm xem có bao nhiêu phần tử bằng chính phần tử thứ n
  • ×⍵|: dấu hiệu của mod (nghĩa là: 0 nếu phần còn lại của phép chia là 0, 1 nếu không)
  • ⍵/⍨: của đối số chỉ giữ lại phần tử trong đó mod là 0

0

Vợt 179 byte

(λ(l)(define m(apply max l))(let g((n 1)(c 0))(set! l(for/list((i l))(if(= i n)(begin 
(set! c(+ 1 c))(if(= 0(modulo c n))0 i))i)))(if(< n m)(g(+ 1 n)0)(filter(λ(x)(> x 0))l))))

Ung dung:

(define f
  (λ(l)
    (define m (apply max l))
    (let loop ((n 1) (c 0))
      (set! l (for/list ((i l))
                (if (= i n)
                    (begin
                      (set! c (+ 1 c))
                      (if (= 0 (modulo c n))
                          0 i ))                  ; replace by 0
                    i )))
      (if (< n m)
          (loop (+ 1 n) 0)
          (filter (λ(x)(> x 0)) l)                ; remove all 0s
          ))))

Kiểm tra:

(f '[1]) 
(f '[2]) 
(f '[1 1 1]) 
(f '[2 2 2]) 
(f '[1 1 2 2 2 3 3 3 3])
(f '[1 2 3 1 2 3 1 2 3 1 2 3]) 
(f '[3 2 6 1 1 6 2 3 2 6 6 6 6 1 6 6 3 3 7 2])

Đầu ra:

'()
'(2)
'()
'(2 2)
'(2 2 3 3 3)
'(2 3 3 2 3)
'(3 2 6 6 3 2 6 6 6 6 6 3 7)
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.