Các thách thức

Viết hàm lấy hai số nguyên dương n và k làm đối số và trả về số người cuối cùng còn lại sau n sau khi tính ra mỗi người thứ k .

Đây là một thử thách chơi gôn, vì vậy mã ngắn nhất sẽ thắng.

Vấn đề

n người (được đánh số từ 1 đến n ) đang đứng trong một vòng tròn và mỗi k -th được tính cho đến khi một người còn lại (xem bài viết wikipedia tương ứng ). Xác định số của người cuối cùng này.

Ví dụ: k = 3 hai người sẽ bị bỏ qua và người thứ ba sẽ bị loại. Tức là với n = 7, các số sẽ được tính theo thứ tự 3 6 2 7 5 1 (chi tiết 1 2 3 4 5 6 7 1 2 4 5 7 1 4 5 1 4 1 4 ) và do đó câu trả lời là 4 .

Ví dụ

J(7,1) = 7      // people are counted out in order 1 2 3 4 5 6 [7]
J(7,2) = 7      // people are counted out in order 2 4 6 1 5 3 [7]
J(7,3) = 4      // see above
J(7,11) = 1
J(77,8) = 1
J(123,12) = 21

GolfScript, 17 byte

{{@+\)%}+\,*)}:f;

Đưa n kvào ngăn xếp và để lại kết quả trên ngăn xếp.

Mổ xẻ

Điều này sử dụng sự lặp lại g(n,k) = (g(n-1,k) + k) % nvới g(1, k) = 0(như được mô tả trong bài viết Wikipedia) với đệ quy được thay thế bằng một nếp gấp.

{          # Function declaration
           # Stack: n k
  {        # Stack: g(i-1,k) i-1 k
    @+\)%  # Stack: g(i,k)
  }+       # Add, giving stack: n {k block}
  \,*      # Fold {k block} over [0 1 ... n-1]
  )        # Increment to move from 0-based to 1-based indexing
}:f;

Máy đăng ký Minsky (25 trạng thái không dừng)

Về mặt kỹ thuật không phải là một chức năng, nhưng nó nằm trong mô hình điện toán không có chức năng ...

Đây là một biến thể nhỏ trong trường hợp thử nghiệm chính của thử thách diễn giải MRM đầu tiên của tôi :

Đầu vào trong sổ đăng ký nvà k; đầu ra trong đăng ký r; nó được giả định rằng r=i=t=0trên mục nhập. Hai hướng dẫn tạm dừng đầu tiên là trường hợp lỗi.

Con trăn, 36

Tôi cũng đã sử dụng công thức từ wikipedia:

J=lambda n,k:n<2or(J(n-1,k)+k-1)%n+1

Ví dụ:

>>> J(7,3)
4
>>> J(77,8)
1
>>> J(123,12)
21

Toán học, 38 36 byte

Cùng một công thức Wikipedia:

1~f~_=1
n_~f~k_:=Mod[f[n-1,k]+k,n,1]

C, 40 ký tự

Đây là khá nhiều công thức mà bài viết wikipedia liên kết ở trên đưa ra:

j(n,k){return n>1?(j(n-1,k)+k-1)%n+1:1;}

Để đa dạng, đây là một triển khai thực sự chạy mô phỏng (99 ký tự):

j(n,k,c,i,r){char o[999];memset(o,1,n);for(c=k,i=0;r;++i)(c-=o[i%=n])||(o[i]=!r--,c=k);
return i;}

dc, 27 byte

[d1-d1<glk+r%1+]dsg?1-skrxp

Sử dụng sự tái phát từ bài viết Wikipedia. Giải trình:

# comment shows what is on the stack and any other effect the instructions have
[   # n
d   # n, n
1-  # n-1, n
d   # n-1, n-1, n
1<g # g(n-1), n ; g is executed only if n > 1, conveniently g(1) = 1
lk+ # g(n-1)+(k-1), n; remember, k register holds k-1
r%  # g(n-1)+(k-1) mod n
1+  # (g(n-1)+(k-1) mod n)+1
]
dsg # code for g; code also stored in g
?   # read user input => k, n, code for g
1-  # k-1, n, code for g
sk  # n, code for g; k-1 stored in register k
r   # code for g, n
x   # g(n)
p   # prints g(n)

J, 45 ký tự

j=.[:{.@{:]([:}.]|.~<:@[|~#@])^:(<:@#)>:@i.@[

Chạy mô phỏng.

Ngoài ra, sử dụng công thức (31 ký tự):

j=.1:`(1+[|1-~]+<:@[$:])@.(1<[)

Tôi hy vọng Howard không bận tâm rằng tôi đã điều chỉnh định dạng đầu vào một chút cho phù hợp với động từ dyadic trong J.

Sử dụng:

   7 j 3
4
   123 j 12
21

GolfScript, 32 24 byte

:k;0:^;(,{))^k+\%:^;}/^)

Cách sử dụng: Yêu cầu hai tham số n và k nằm trong ngăn xếp và để lại giá trị đầu ra.

(cảm ơn Peter Taylor đã gợi ý cách tiếp cận lặp lại và nhiều lời khuyên khác)

Cách tiếp cận cũ (đệ quy) của 32 ký tự:

{1$1>{1$(1$^1$(+2$%)}1if@@;;}:^;

Đây là GolfScript đầu tiên của tôi, vì vậy xin vui lòng cho tôi biết những lời chỉ trích của bạn.

R, 48

J=function(n,k)ifelse(n<2,1,(J(n-1,k)+k-1)%%n+1)

Chạy phiên bản với các ví dụ: http://ideone.com/i7wae

Groovy, 36 byte

def j(n,k){n>1?(j(n-1,k)+k-1)%n+1:1}

Haskell, 68

j n=q$cycle[0..n]
q l@(i:h:_)k|h/=i=q(drop(k-1)$filter(/=i)l)k|1>0=i

Liệu mô phỏng thực tế. Trình diễn:

GHCi> j 7 1
7
GHCi> j 7 2
7
GHCi> j 7 3
4
GHCi> j 7 11
1
GHCi> j 77 8
1
GHCi> j 123 12
21

Scala, 53 byte

def?(n:Int,k:Int):Int=if(n<2)1 else(?(n-1,k)+k-1)%n+1

C, 88 ký tự

Liệu mô phỏng, không tính toán công thức.
Dài hơn nhiều so với công thức, nhưng ngắn hơn so với mô phỏng C khác.

j(n,k){
    int i=0,c=k,r=n,*p=calloc(n,8);
    for(;p[i=i%n+1]||--c?1:--r?p[i]=c=k:0;);
    return i;
}

Ghi chú:
1. Phân bổ bộ nhớ và không bao giờ phát hành.
2. Phân bổ n*8thay vì n*4, vì tôi sử dụng p[n]. Có thể phân bổ (n+1)*4, nhưng đó là nhiều nhân vật hơn.

C ++, 166 byte

Chơi gôn

#include<iostream>
#include <list>
int j(int n,int k){if(n>1){return(j(n-1,k)+k-1)%n+1;}else{return 1;}}
int main(){intn,k;std::cin>>n>>k;std::cout<<j(n,k);return 0;}

Ung dung:

#include<iostream>
#include <list>
int j(int n,int k){
    if (n > 1){
        return (j(n-1,k)+k-1)%n+1;
    } else {
        return 1;
    }
}
int main()
{
    int n, k;
    std::cin>>n>>k;
    std::cout<<j(n,k);
    return 0;
}

J, 8 byte

1&|.&.#:

       1&|.&.#: 10
    5

       1&|.&.#: 69
    11

        1&|.&.#: 123456
    115841

        1&|.&.#: 123245678901234567890x NB. x keeps input integral
    98917405212792722853

All credit to Roger Hui, co-inventor of J and all-round uber-genius
www.jsoftware.com for free j software across many platforms

Explanation
    (J works right-to-left)
     #:       convert input to binary
     &.       a&.b <=> perform b, perform a, perform reverse of b
     1&|.     rotate bitwise one bit left

So
    1&|.&.#: 10

    a. #:            convert input (10) TO binary -> 1 0 1 0
    b. 1&|.          rotate result 1 bit left -> 0 1 0 1
    c. due to the &. perform convert FROM binary -> 5 (answer)

Ruby, 39 byte

def J(n,k)
n<2?1:(J(n-1,k)+k-1)%n+1
end

Phiên bản đang chạy với các trường hợp thử nghiệm: http://ideone.com/pXOUc

Q, 34 byte

f:{$[x=1;1;1+mod[;x]f[x-1;y]+y-1]}

Sử dụng:

q)f .'(7 1;7 2;7 3;7 11;77 8;123 12)
7 7 4 1 1 21

Ruby, 34 byte

J=->n,k{n<2?1:(J(n-1,k)+k-1)%n+1}

Haskell, 29

Sử dụng công thức từ wikipedia.

1#_=1
n#k=mod((n-1)#k+k-1)n+1

JavaScript (ECMAScript 5), 48 byte

Sử dụng ECMAScript 5 vì đó là phiên bản JavaScript mới nhất tại thời điểm câu hỏi này được hỏi.

function f(a,b){return a<2?1:(f(a-1,b)+b-1)%a+1}

Phiên bản ES6 (không cạnh tranh), 33 byte

f=(a,b)=>a<2?1:(f(a-1,b)+b-1)%a+1

Giải trình

Không có nhiều để nói ở đây. Tôi chỉ đang thực hiện chức năng mà bài viết Wikipedia cung cấp cho tôi.

05AB1E , 11 byte

L[Dg#²<FÀ}¦

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

L           # Range 1 .. n
 [Dg#       # Until the array has a length of 1:
     ²<F }  #   k - 1 times do:
        À   #     Rotate the array
          ¦ #   remove the first element

8 , 82 byte

Mã

: j >r >r a:new ( a:push ) 1 r> loop ( r@ n:+ swap n:mod ) 0 a:reduce n:1+ rdrop ;

SED (Sơ đồ hiệu ứng ngăn xếp) là:n k -- m

Cách sử dụng và giải thích

Thuật toán sử dụng một mảng các số nguyên như thế này: nếu giá trị của mọi người là 5 thì mảng đó sẽ là [1,2,3,4,5]

: j \ n k -- m
    >r                               \ save k
    >r a:new ( a:push ) 1 r> loop    \ make array[1:n]
    ( r@ n:+ swap n:mod ) 0 a:reduce \ translation of recursive formula with folding using an array with values ranging from 1 to n
    n:1+                             \ increment to move from 0-based to 1-based indexing
    rdrop                            \ clean r-stack
;

ok> 7 1 j . cr
7
ok> 7 2 j . cr
7
ok> 7 3 j . cr
4
ok> 7 11 j . cr
1
ok> 77 8 j . cr
1
ok> 123 12 j . cr
21

J , 24 byte

1+1{1([:|/\+)/@,.1|.!.0#

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

Một cách tiếp cận lặp lại dựa trên giải pháp lập trình động.

Giải trình

1+1{1([:|/\+)/@,.1|.!.0#  Input: n (LHS), k (RHS)
                       #  Make n copies of k
                 1|.!.0   Shift left by 1 and fill with zero
    1          ,.         Interleave with 1
             /@           Reduce using
           +                Addition
        |/\                 Cumulative reduce using modulo
  1{                      Select value at index 1
1+                        Add 1

J , 19 byte

1+(}:@|.^:({:@])i.)

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

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

1+(}:@|.^:({:@])i.)   Left: k, Right: n
                i.    Generate [0..n-1]
        ^:            Repeat:
   }:@|.                Rotate left k items, and remove the last item
          ({:@])        n-1 (tail of [0..n-1]) times
1+                    Add one to make the result one-based

Phi tiêu , 33 byte

f(n,k)=>n<2?1:(f(n-1,k)+k-1)%n+1;

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

Japt , 15 byte

_é1-V Å}h[Uõ] Ì

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

Một byte có thể được lưu bằng cách lập chỉ mục 0 , nhưng thực tế nó không phải là một chỉ mục nên tôi quyết định chống lại điều đó.

Giải trình:

         [Uõ]      :Starting with the array [1...n]
_      }h          :Repeat n-1 times:
 é1-V              : Rotate the array right 1-k times (i.e. rotate left k-1 times)
      Å            : Remove the new first element
              Ì    :Get the last value remaining

Japt -h, 10 byte

õ
£=éVn1¹v

Thử nó

Powershell, 56 byte

param($n,$k)if($n-lt2){1}else{((.\f($n-1)$k)+$k-1)%$n+1}

Quan trọng! Kịch bản gọi chính nó đệ quy. Vì vậy, tiết kiệm kịch bản như f.ps1tập tin trong thư mục hiện hành. Ngoài ra, bạn có thể gọi một biến khối tập lệnh thay vì tập tin tập lệnh (xem tập lệnh kiểm tra bên dưới). Các cuộc gọi đó có cùng độ dài.

Kịch bản thử nghiệm:

$f = {

param($n,$k)if($n-lt2){1}else{((&$f($n-1)$k)+$k-1)%$n+1}

}

@(
    ,(7, 1, 7)
    ,(7, 2, 7)
    ,(7, 3, 4)
    ,(7, 11, 1)
    ,(77, 8, 1)
    ,(123,12, 21)
) | % {
    $n,$k,$expected = $_
    $result = &$f $n $k
    "$($result-eq$expected): $result"
}

Đầu ra:

True: 7
True: 7
True: 4
True: 1
True: 1
True: 21