Vịt, Vịt, Josephus

49

Cho một mảng Integer:

  1. Bắt đầu từ số đầu tiên
  2. Nhảy về phía trước n vị trí trong đó n là giá trị của vị trí hiện tại
  3. Xóa vị trí hiện tại, làm cho vị trí tiếp theo là vị trí hiện tại.
  4. Đi đến bước 2 cho đến khi còn một số
  5. In số đó

Quy tắc

Mảng kết thúc xung quanh (số tiếp theo sau số cuối cùng trong mảng là số đầu tiên).

Một số không loại bỏ chính nó (Rõ ràng).

Số âm không được phép làm đầu vào.

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

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

Ví dụ từng bước

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number (the 'new' 'current' position)
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3  ] remove number in that position
       ^    take next position (looping)
 ^          jump 3 positions (looping on the end of the array)
[      3  ] remove number in that position
print 3

Ví dụ # 2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

Đây là code-golf , câu trả lời ngắn nhất trong byte thắng!

code-golf  array-manipulation 
— quy trình làm việc
nguồn
14
Thử thách đầu tiên tốt đẹp!
— Luis Mendo
2
@LuisMendo Có .. các thử thách "bỏ qua như ..."
— J42161217
2
@Jenny_mathy Tôi không nghĩ sẽ có một cái tương tự, nhưng như Luis nói, mảng bao quanh tạo ra một thử thách thú vị cho việc chơi golf. Tôi nghĩ: /
— làm việc
3
@EriktheOutgolfer Không thực sự là một bản dupe. Các yếu tố không thể phân biệt và kích thước bước được cố định. Luis gần hơn nhiều, nhưng tôi nghĩ vẫn đủ khác biệt.
— Martin Ender
3
Có cần phải thực sự in số cuối cùng, hoặc nó có thể trả lại không? Có cần phải thực sự trả về số, hoặc nó chỉ có thể hoạt động trên mảng tại chỗ để sau khi hàm được chạy, mảng chỉ chứa số?
— iamnotmaynard

Câu trả lời:

9

Husk , 7 byte

Điều này trả về kết quả dưới dạng một danh sách đơn

ΩεSotṙ←

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

Giải trình

Ω               Until
 ε              the result is a singleton list
     ṙ          Rotate left by
  S   ←         the first element
   ot           Then remove the first element
— H.PWiz
nguồn
7

Haskell , 54 50 48 byte

f[x]=x
f(x:r)=f$snd<$>zip r(drop(x+1)$cycle$x:r)

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

Giải trình:

  • f[x]=x: Nếu danh sách đã cho là danh sách đơn, trả về phần tử của nó.
  • f(x:r)=f$ ...: Mặt khác áp dụng đệ quy fcho danh sách sau:
    • Các yếu tố của danh sách hiện tại đã đạp xe vô tận ( cycle$x:r),
    • với các x+1phần tử đầu tiên bị xóa ( drop(x+1)$),
    • và cắt ngắn theo chiều dài của r. ( snd<$>zip rlà một thay thế ngắn hơn để take(length r)).

Phiên bản 54 byte trước đó:

f=(%)=<<head
_%[x]=x
n%(x:r)|n<1=f r|s<-r++[x]=(n-1)%s

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

— Laikoni
nguồn
6

MATL , 21 byte

1`yy)+ynX\[]w(5Mynq]x

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

1        % Push 1: current position in the array
`        % Do...while
  yy     %   Duplicate top two elements in the stack. Takes input implicitly
         %   in the first iteration.
         %   STACK: array, position, array, position
  )      %   Get specified entry in the array
         %   STACK: array, position, selected entry
  +      %   Add
         %   STACK: array, position (updated)
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements or array
  X\     %   1-based modulus
         %   STACK: array, position (wrapped around)
  []     %   Push empty array
         %   STACK: array, position, []
  w      %   Swap
         %   STACK: array, [], position
  (      %   Write value into specified entry in array. Writing [] removes
         %   the entry
         %   STACK: array (with one entry removed)
  5M     %   Push latest used position. Because of the removal, this now
         %   points to the entry that was after the removed one
         %   STACK: array, position
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements of array
  q      %   Subtract 1
         %   STACK: array, position, number of elements of array minus 1
]        % End. If top of the stack is nonzero, proceed with next iteration
         % STACK: array (containing 1 entry), position
x        % Delete. Implicitly display
         % STACK: array (containing 1 entry)
— Luis Mendo
nguồn
1
Lưu ý: sử dụng xoay danh sách thay vì giữ một con trỏ có thể sẽ làm cho việc này ngắn hơn nhiều.
— Erik the Outgolfer
1
@Erik Cảm ơn. Nhưng bây giờ tôi đã thêm lời giải thích, tôi nghĩ rằng tôi sẽ để nó như thế này
— Luis Mendo
Chà, bạn luôn có thể xóa lời giải thích, nó sẽ được lưu giữ trong lịch sử :)
— Erik the Outgolfer 12/12/17
5

CJam , 15 byte

l~_,({_0=m<1>}*

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

Giải trình

Thay vì theo dõi một con trỏ, tôi chỉ dịch chuyển mảng theo chu kỳ để phần tử hiện tại luôn ở phía trước.

l~     e# Read and evaluate input.
_,(    e# Get its length L and decrement to L-1.
{      e# Run this block L-1 times...
  _0=  e#   Get the first element X.
  m<   e#   Rotate the array left by X positions.
  1>   e#   Discard the first element.
}*
       e# The final element remains on the stack and gets printed implicitly.

Một thay thế thú vị mà không may không lưu bất kỳ byte nào:

l~_{;m<1>_0=}*;
— Martin Ender
nguồn
5

Brain-Flak , 88 byte

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

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

Giải trình

([[]]())                      Push negative N: the stack height - 1
{({}< … >())}{}               Do N times
     (({}))                     Duplicate M: the top of the stack
     {({}< … >[()])}{}          Do M times 
                                  Rotate the stack by 1:
          ({}< … >)               Pop the top of the stack and put it back down after
          ([]){({}{}<>)<>([])}{}  Pushing the rest of the stack on to the other one, in reverse, with the stack height added to each element (to ensure that all are positive)
          <>{({}[<>[]])<>}<>      Push the rest of the stack back, unreversing, and subtracting the stack height from each element
                      {}        Pop the top of stack
— H.PWiz
nguồn
1
Một golf rất lạ nhưng ở đây nó có 88 byte .
— Thuật sĩ lúa mì
1
@WheatWizard Thật tuyệt, thật ngạc nhiên khi tôi đã thử một cái gì đó như thế trước đó.
— H.PWiz
Tôi không bao giờ có thể biết làm thế nào mọi người có thể mã như vậy! Có một dịch giả mã giả hay cái gì đó?
— làm việc
1
@workoverflow không, nó thực sự dễ dàng hơn vẻ ngoài của nó. Nó đã rất nản chí trước khi tôi thực sự bắt đầu, nhưng khi các lệnh đơn giản như vậy, nó rất dễ học.
— H.PWiz
5

Python 2 , 55 byte

def f(a):
 while a[1:]:l=a[0]%len(a);a[:]=a[-~l:]+a[:l]

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

Đầu ra dưới dạng một danh sách đơn, như được cho phép theo mặc định . Đã lưu một vài byte nhờ Dennis , bằng cách nhắc nhở tôi rằng sửa đổi đối số chức năng được cho phép.

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

  • def f(a)- Xác định hàm với tham số a.

  • while a[1:]:- Trong khi avới phần tử đầu tiên bị xóa là trung thực, hãy chạy khối mã để theo dõi. Một danh sách có một yếu tố trở lên là trung thực và danh sách trống là giả mạo trong Python, do đó, danh sách này sẽ dừng lại khi ađạt đến độ dài 1.

  • l=a[0]%len(a)- Lấy phần tử đầu tiên và lấy phần còn lại của phép chia theo độ dài a. Gán kết quả cho l.

  • a[:]=a[-~l:]+a[:l]- Xoay asang trái theo lcác yếu tố và loại bỏ cái đầu tiên, trong khi gán cái này avào vị trí.

Python 2 , 63 byte

f=lambda a,i=0:a[1:]and f(a,a.pop(((a*-~i)[i]+i)%len(a))+1)or a

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

Mặc dù dài hơn, điều này có vẻ thanh lịch hơn nhiều. Cũng cảm ơn các ovs đã giúp đỡ trong trò chuyện.

— Ông Xcoder
nguồn
1
Bạn không thể làm một cái gì đó như a,*b=input()(python3) và lưu vài byte? Tuy nhiên tôi không chắc điều đó sẽ ảnh hưởng như thế nào lvà lát cắt
— Rod
1
@Rod Tôi không nghĩ vậy, tôi cũng cần đánh giá đầu vào trong Python 3
— Ông Xcoder
4

Thạch , 7 byte

ṙḷ/ḊµḊ¿

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

Chương trình đầy đủ.

— Erik là người vượt trội
nguồn
3
Đó ḷ/là thông minh chết tiệt.
— Ông Xcoder
Bạn có thể thêm một lời giải thích, xin vui lòng? Bây giờ tôi đã xem xét Nhanh và Nguyên tử trên các trang GIT được liên kết và + 1-ed dựa trên điều đó, nhưng tôi có thể tưởng tượng không phải ai cũng có bệnh nhân làm điều tương tự. ;)
— Kevin Cruijssen
4

Thạch , 9 byte

ṙḷ/ḊµL’$¡

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

-2 byte nhờ người dùng202729

Giải trình

ṙḷ/ḊµL’$¡  Main Link
     L’$¡  Repeat <length - 1> times
ṙ          Rotate left by
 ḷ/        The first element (from JHT; thanks to user202729)
   Ḋ       Take all but the first element
— HyperNeutrino
nguồn
3

Toán học, 36 byte

sử dụng thuật toán của Martin 

#//.l:{x_,__}:>Rest@RotateLeft[l,x]&

-5 byte từ Misha Lavrov && Martin Ender

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

— J42161217
nguồn
1
Bạn có thể lưu hai byte bằng cách sử dụng mẫu để chọn ra phần tử đầu tiên #//.{x_,y__}:>Rest@RotateLeft[{x,y},x]&. (Điều này dừng khi chỉ có một yếu tố vì {a}không còn phù hợp với mẫu {x_,y__}.)
— Misha Lavrov
1
@MishaLavrov không thể kiểm tra ngay bây giờ, nhưng bạn có thể rút ngắn hơn nữa bằng cách bỏ y, gọi toàn bộ danh sách lvà sau đó sử dụng lthay vì {x,y}.
— Martin Ender
1
@MartinEnder Ý bạn là như thế này - #//.l:{x_,__}:>Rest@RotateLeft[l,x]&?
— Misha Lavrov
1
@MishaLavrov vâng.
— Martin Ender
3

J , 21 17 byte

-4 byte nhờ FrownyFrog

((1<#)}.{.|.])^:_

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

Nguyên:

([:}.{.|.])^:(1<#)^:_

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

^:_ lặp lại cho đến khi kết quả ngừng thay đổi

^:(1<#) nếu độ dài của danh sách lớn hơn 1

{.|.] xoay danh sách sang bên trái lần đầu tiên

[:}. thả phần tử đầu tiên và giới hạn ngã ba

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

— Galen Ivanov
nguồn
@ FrownyFrog Cảm ơn, tôi đã không thử điều này - nó tốt hơn nhiều!
— Galen Ivanov
3

JavaScript (ES6), 54 60 byte

Đã lưu 1 byte nhờ @Shaggy
Phiên bản cố định (+6 byte)

Sửa đổi mảng đầu vào , được giảm xuống thành một singleton.

f=(a,p=0)=>1/a||f(a,p=(p+a[p%(l=a.length)])%l,a.splice(p,1))

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

Hiển thị đoạn mã

Làm sao?

Chúng tôi áp dụng đệ quy thuật toán được mô tả trong thử thách. Chỉ có điều kiện dừng 1/acó vẻ hơi lạ. Khi áp dụng toán tử số học:

  • Mảng của nhiều hơn một yếu tố bị ép buộc NaNvà 1/NaNcũng là NaN(giả).
  • Mảng của chính xác một số nguyên được ép buộc với số nguyên đó, dẫn đến 1/0 = +Infinityhoặc 1/N = positive floatcho N> 0 (cả hai sự thật).
f = (a, p = 0) =>                 // a = input array, p = pointer into this array
  1 / a ||                        // if a is not yet a singleton:
    f(                            //   do a recursive call with:
      a,                          //     a
      p = (                       //     the updated pointer
        p + a[p % (l = a.length)] //
      ) % l,                      //
      a.splice(p, 1)              //     the element at the new position removed
    )                             //   end of recursive call
— Arnauld
nguồn
Xem như splicesửa đổi mảng ban đầu, bạn có thể thực hiện f=(a,p=0)=>1/a||f(a,p=p+a[p]%a.length,a.splice(p,1))với 52 byte
— Shaggy
có vẻ như nó không đưa ra kết quả đúng cho ví dụ từng bước thứ hai, f=(a,p=0)=>1/a?a:f(a,p=(p%a.length+a[p%a.length])%a.length,a.splice(p,1))vẫn ổn nhưng có thể được tối ưu hóa
— Nahuel Fouilleul
@NahuelFouilleul Rất tiếc. Tôi đã nghĩ rằng một số dấu ngoặc đơn xung quanh p+a[p]có thể được gỡ bỏ. Mà - tất nhiên - không phải là trường hợp. Cảm ơn đã báo cáo này!
— Arnauld
Xem sự đồng thuận này , mà @Neil đã chú ý đến tôi ở đây .
— Xù xì
@Shaggy ơi, tôi hiểu rồi. Cảm ơn bạn! (Tôi đã bỏ lỡ liên kết TIO của bạn lần đầu tiên ...)
— Arnauld
3

Java 8, 79 byte

Lambda này chấp nhận a Stack<Integer>và trả về một inthoặc Integer.

l->{for(int i=0,s=l.size();s>1;)l.remove(i=(i+l.get(i%s))%s--);return l.pop();}

Dùng thử trực tuyến

Ung dung

l -> {
    for (
        int i = 0, s = l.size()
        ; s > 1
        ;
    )
        l.remove(
            i = (i + l.get(i % s)) % s--
        );
    return l.pop();
}

Sự nhìn nhận

  • -2 byte nhờ Nahuel Fouilleul
— Jakob
nguồn
1
i%=scó thể bị xóa nếu được l.get(i)thay đổi bởil.get(i%s)
— Nahuel Fouilleul
2

Bình thường , 9 byte

.WtHt.<Zh

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

Điều này đưa ra kết quả dưới dạng một danh sách đơn, như được cho phép theo mặc định .

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

.WtHt.<Zh ~ Full program.

.W        ~ Functional while. It takes three arguments, two functions: A and B
            and a starting value, which in this case is automatically assigned
            to the input. While A(value) is truthy, value is set to B(value).
            Returns the ending value. A's argument is H and B's is Z.
  tH      ~ A (argument H): Remove the first element of H. A singleton list
            turns into [], which is falsy and thus breaks the loop. Otherwise,
            it is truthy and the loops goes on until the list reaches length 1.
     .<Zh ~ B (argument Z): Cyclically rotate Z by Z[0] places, whereas Z[0]
            represents the first element of Z.
    t     ~ And remove the first element.

Lưu ý: Nếu bạn không muốn xem các dấu ngoặc đó, chỉ cần thêm hhoặc evào trước toàn bộ mã.

— Ông Xcoder
nguồn
2

Swift , 87 byte

func f(a:inout[Int]){var i=0,c=0;while(c=a.count,c>1).1{i=(i+a[i%c])%c;a.remove(at:i)}}

Trả về dưới dạng danh sách đơn bằng cách sửa đổi đầu vào . Hãy thử trực tuyến!

Giải trình

func f(a:inout[Int]){
  var i=0,c=0;            // Set the index i to 0
  while(c=a.count,c>1).1{ // While the length of the list > 0:
    i=(i+a[i%c])%c;       //  Add a[i] to i and loop back using modulo
    a.remove(at:i)        //  Remove a[i]
  }
}
— Herman L
nguồn
2

Perl 6 , 46 45 byte

(-1 byte nhờ Brad Gilbert)

{($_,{(|$_ xx*)[.[0]+(1..^$_)]}...1)[*-1][0]}

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

($_, { ... } ... 1)tạo ra một chuỗi các danh sách, bắt đầu với danh sách đầu vào $_, mỗi phần tử liên tiếp được tạo bởi biểu thức dấu ngoặc và kết thúc khi danh sách khớp thông minh 1--ie, có độ dài 1. Phần cuối [* - 1]lấy được phần tử cuối cùng và phần cuối cùng [0]lấy yếu tố duy nhất ra khỏi danh sách đơn lẻ đó.

(|$_ xx *)tạo ra một bản sao phẳng, sao chép vô hạn của phần tử hiện tại. Danh sách này được lập chỉ mục với phạm vi .[0] + (1 ..^ $_)để trích xuất danh sách hữu hạn tiếp theo trong chuỗi.

— Sean
nguồn
1
tâm trí thổi oO
— Adrian
[*-1][0]có thể được kết hợp để [*-1;0]tiết kiệm một byte. Cũng 1..$_-1được viết tốt hơn khi 1..^$_một lần nữa tiết kiệm một byte.
— Brad Gilbert b2gills
@ BradGilbertb2gills Tôi đã thử [*-1;0], nhưng dường như không tương đương bằng cách nào đó. Hàm sau đó trả về một danh sách chứ không phải là một số.
— Sean
Điều đó không ngăn được việc 1..^$_tối ưu hóa
— Brad Gilbert b2gills
1

Perl 5 , 47 43 41 + 2 ( -ap) = 43 byte

$\=splice@F,($_+=$F[$_%@F])%@F,1while@F}{

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

Lấy đầu vào là số cách nhau không gian.

— Xcali
nguồn
có vẻ như nó không hoàn toàn giống với ví dụ từng bước sau đây nhưng dài hơn$x%=@F,splice@F,$x=($x+$F[$x])%@F,1while$#F;$_="@F"
— Nahuel Fouilleul
1
wow oO Cần phải đưa trò chơi của tôi lên.
— Adrian
1

Java 8 , 325 byte

Chơi gôn

static void n(Integer[]j){Integer[]h;int a=0;h=j;for(int i=0;i<j.length-1;i++){if(h.length==a){a=0;}a=(a+h[a])%h.length;h[a]=null;h=m(h);}System.out.print(h[0]);}static Integer[] m(Integer[]array){Integer[]x=new Integer[array.length-1];int z=0;for(int i=0;i<array.length;i++){if(array[i]!=null){x[z]=array[i];z++;}}return x;}

Ung dung:

 interface ArrayLeapFrog {
static void main(String[] z) throws Exception {
    Integer[] j = {6, 2, 3, 4};
    n(j);
}

static void n(Integer[] j) {
    Integer[] h;
    int a = 0;
    h = j;
    for (int i = 0; i < j.length - 1; i++) {
        if (h.length == a) {
            a = 0;
        }
        a = (a + h[a]) % h.length;
        h[a] = null;
        h = m(h);
    }
    System.out.print(h[0]);
}

static Integer[] m(Integer[] array) {
    Integer[] x = new Integer[array.length - 1];
    int z = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != null) {
            x[z] = array[i];
            z++;
        }
    }
    return x;
  }
}
— DevelopDeveloper
nguồn
4
Chào mừng bạn Một vài lời khuyên: Không cần phải đếm các statictừ khóa ở đây. Thông thường các giải pháp đa phương thức được triển khai như các thành viên không tĩnh của một lớp và maintạo một thể hiện để thử nghiệm. Ngoài ra, nếu bạn làm theo cách đó bạn hỗ trợ Java 7 và có thể gửi đơn giản như một giải pháp "Java". Để tham khảo trong tương lai, định dạng đầu vào có xu hướng khá linh hoạt ở đây, vì vậy, ví dụ bạn có thể chọn lấy đầu vào làm List(điều này khá hữu ích cho vấn đề này).
— Jakob
1

APL + THẮNG, 36 byte

¯1↑⍎¨(1⌈¯1+⍴v←,⎕)⍴⊂'v←(1<⍴v)↓v[1]⌽v'

Giải trình:

Nhắc nhở cho màn hình nhập. 

'v←(1<⍴v)↓v[1]⌽v' Loop logic as a string

 (1<⍴v)↓ only drop the first when number of elements n>1

 (1⌈¯1+⍴v←,⎕)⍴⊂ create a nested vector of logic of length 1 max n-1

 ⍎¨ execute each element of the nested vector in turn

¯1↑ take answer from executing final element
— Graham
nguồn
1

Python 2, 61 byte

def f(x):
 while x[1:]:y=x[0]%len(x);x=x[y+1:]+x[:y]
 print x
— R
nguồn
1
Tôi biết một loạt các câu trả lời trăn tồn tại, nhưng tôi đoán rằng tôi cũng có thể thêm câu trả lời của riêng mình.
— Rɪᴋᴇʀ
1

JavaScript, 58 56 59 byte

let f =

a=>{for(i=0,k=a.length;k>1;)i+=a[i%=k],a.splice(i%=k--,1)}
<h2>Test</h2>
Enter or paste a valid array literal within square brackets and click Run.
<blockquote>
   <input id = "array" type="text" length="20">
   <button type="button" onclick="run()">Run</button>
</blockquote>
Result: <pre id="o"></pre>

<script>
    function run() {
       let a = JSON.parse(array.value);
       f(a);
       o.textContent = a;
    }
</script>
Mở rộng đoạn trích

Trả về kết quả là phần tử duy nhất còn lại trong mảng đầu vào được cập nhật tại chỗ.

Hai byte được lưu bằng cách sử dụng câu lệnh được phân tách bằng dấu phẩy thay vì câu lệnh khối trong thân vòng lặp for! Mất ba byte để bỏ qua từ một phần tử bị xóa ở cuối mảng (:

Ít chơi gôn hơn:

a => {
    for(i=0,k=a.length;k>1;) // once less than array length
        i+=a[i%=k],          // the new index
        a.splice(            // delete an element
           i%=k--,           // ensuring index is within array,
                             // and post decrement loop count
           1
        )
}
— traktor53
nguồn
Điều này dường như đưa ra câu trả lời sai cho [3, 5, 7, 9].
— Neil
Sai cho [3,5,7,9]. Giá trị mong đợi 5
— edc65
Hàm không trả về giá trị, tôi không chắc liệu số byte có phù hợp với điều đó hay không, vì nó không thể tự hoạt động ...
— Brian H.
@ edc65 và Neil, cảm ơn - chỉ mục của một phần tử bị xóa ở cuối mảng không được điều chỉnh để bắt đầu mảng rút ngắn.
— traktor53
@BrianH. Hàm sửa đổi tham số của nó, có sự đồng thuận về codegolf.meta.stackexchange.com/a/4942/21348
— edc65
1

Brain-Flak , 104 byte

H.PWiz có một câu trả lời ngắn hơn ở đây mà tôi đã giúp thực hiện, bạn nên kiểm tra nó.

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

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

Giải trình

([[]]())   #Push 1 minus stackheight
{({}()<    #N times
 (({}))    #Get a copy of the top
 {({}[()]< #N times
  ({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>
           #Roll the top to the bottom (From the wiki)
 >)}{}     #End loop
 {}        #Remove one value
>)}{}      #End loop
— Thuật sĩ lúa mì
nguồn
Tôi nghĩ rằng tôi sẽ cạnh tranh . Sau đó, tôi nhận ra rằng cái của tôi gần giống hệt như của bạn , ngoài một "top roll" khác
— H.PWiz
Tôi đã thấy điều đó;). Sử dụng thực tế là mọi thứ đều không tiêu cực là khá thông minh.
— Thuật sĩ lúa mì
1

R , 111 117 126 byte

Cảm ơn @Giuseppe đã chơi hết 11 byte bằng cách thay đổi thành vòng lặp while, nhận thêm 4 bằng cách xóa chức năng và đọc trực tiếp đầu vào của người dùng.

Tôi không cảm thấy tuyệt vời về những gì nó cần để đạt được điều đó - tôi chắc chắn có một giải pháp thanh lịch hơn tồn tại.

i=scan();m=1;while((l=sum(i|1))-1){j=i[m];p=`if`(j+m>l,j%%l+!m-1,j+m);p=`if`(!p,m,p);i=i[-p];m=`if`(p-l,p,1)};i

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

Mã bị đánh cắp

i=scan()
m=1
while((l=sum(i|1))-1){
  j=i[m]
  p=`if`(j+m>l,j%%l+!m-1,j+m)
  p=`if`(!p,m,p)
  i=i[-p]
  m=`if`(p-l,p,1)
}
i
— dấu
nguồn
117 byte - lưu ý rằng vì đây là hàm đệ quy, nên f=cần bao gồm tên
— Giuseppe
1
Tôi thấy đây là một thử thách khá khó khăn với ngôn ngữ chỉ số 1 không có xoay vòng; điều này có khả năng ngắn hơn 1-3 byte với một whilevòng lặp, tôi nghĩ vậy.
— Giuseppe
— Giuseppe
byter 115 trước đây của tôi không hợp lệ vì cả hai chúng tôi đều quên f=một phần của hàm đệ quy. :(
— Giuseppe
Tôi đã cập nhật điểm số cũ và điểm số mới để phản ánh tính đệ quy :) Với vòng lặp 'while', tôi đã đánh bại 4 byte khác bằng cách quét.
— Đánh dấu
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 cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.