Hiện trường là:

Peter đang ở phòng tập thể dục với bạn thân Brian khi Brian đột nhiên đang rất cần người hít phải. Brian quản lý để nói với Peter mã số cho khóa kết hợp của mình trước khi anh ngã xuống sàn.

Khoảnh khắc Peter đến tủ đồ của Brian và nhìn thấy những gì chỉ số đang chỉ vào, Stewie phục kích anh ta và phun một bình xịt hơi cay vào mặt anh ta, do đó làm chói mắt Peter.

Peter bây giờ phải cố gắng mở khóa mà không cần nhìn vào nó. Anh ta bắt đầu xoay mặt số sang phải, đếm các số trong khi anh ta vượt qua chúng. Sau đó, tại số chính xác bắt đầu xoay mặt số sang trái, vẫn đếm và cuối cùng xoay nó sang phải cho đến khi khóa mở.

Các thách thức:

Viết hàm / chương trình có hai đầu vào, kết hợp từ Brian và vị trí chỉ báo. Đầu ra các số Peter phải tính.

Quy tắc:

• Sự kết hợp và vị trí chỉ báo phải là các đối số riêng biệt.
• Đầu vào có thể là từ dấu nhắc lệnh hoặc là đối số chức năng.
• Đầu ra phải được in ra màn hình / hiển thị khác (không vào tệp)
• Giả sử rằng vị trí bắt đầu không giống với số đầu tiên và cả ba số trong tổ hợp là duy nhất
• Đó là khóa được hiển thị trong hình bên dưới, với các số có thể: 0-39.

Hướng dẫn:

Để mở khóa bên dưới, bạn cần làm theo một bộ hướng dẫn:

1. Bạn phải biết mã của bạn. Giả sử bây giờ (38, 16, 22).
2. Xoay mặt số 3 lần sang phải (vượt qua số bắt đầu ba lần), sau đó dừng khi số đầu tiên (38) thẳng hàng với chỉ báo
3. Xoay mặt số đầy đủ 1 rẽ sang trái, chuyển số đầu tiên và dừng khi số thứ hai (16) thẳng hàng với chỉ báo.
4. Xoay mặt số sang phải và dừng khi số thứ ba (22) thẳng hàng với chỉ báo
5. Kéo khóa xuống

Thí dụ:

Input
38 16 22
33  

Output
33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  39   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22

Quy tắc golf tiêu chuẩn áp dụng.

Các giải pháp được đăng sau đó vẫn có thể giành chiến thắng nếu chúng ngắn hơn câu trả lời của Dennis.

CJam, 52 39 byte

q~[3X0].{@40,m<1$({(+W%}&:T*T@#)T<)}e_p

Hãy thử trực tuyến trong trình thông dịch CJam .

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

q~      e# Read and evaluate all input. This pushes the initial position
        e# as an integer and the combination as an array.
[3X0]   e# Push [3 1 0]. This encodes the respective numbers of full turns
.{      e# For each number in the combination (N) and the corresponding 
        e# number of full turns (F):
  @     e#   Rotate the initial position on top of the stack.
  40,m< e#   Push [0 ... 39] and rotate it that many units to the left.
        e#   For position P, this pushes [P P+1 ... 39 0 ... P-2 P-1].
  1$(   e#   Copy F and subtract 1.
  {     e#   If the result is non-zero:
    (+  e#     Rotate the array of length 40 one unit to the left.
    W%  e#     Reverse it.
  }&    e#   For position P, this pushes [P P-1 ... 0 39 ... P+2 P+1].
  :T*   e#   Save in T and repeat the array F.
  T@    e#   Push T. Rotate N on top of the stack.
  #)    e#   Find the index of N in T and add 1 to it.
  T<    e#   Keep that many elements from the beginning of T.
  )     e#   Pop the last element of the result (N).
}       e# N is the new initial position.
e_p     e# Flatten the resulting array and print it.

Groovy, 189 175 byte

Giả sử chỉ báo được truyền dưới dạng arg0 và kết hợp được truyền dưới dạng arg1, arg2 và arg3 trên dòng lệnh ...

i=(args[0]as int)+1
r={i--;i=i<0?39:i;print"$i "}
l={i=++i%40;print"$i "} 
M={j,c->while(i!=j as int){c()}}
120.times{r()}
M(args[1],r)
40.times{l()}
M(args[2],l)
M(args[3],r)

Perl 5 , 129 + 1 (-a) = 130 byte

sub c{$f=pop;do{say$f;$f+=$_[0];$f=$f==-1?39:$f==40?0:$f}while$f-$_[1]}$p=3;c(2*!$p-1,@F[$_,$p]),$p=$_ for 3,3,3,0,0,1,2;say$F[2]

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

Làm sao?

sub c{                       # Takes 3 parameters: increment, ending position, starting position
  $f=pop;                    # first place to start counting
  do{
    say$f;                   # output current position
    $f+=$_[0];               # move position
    $f=$f==-1?39:$f==40?0:$f # roll over when passing zero
  }while$f-$_[1]             # stop when ending positition reached
}

# @F gets defined by the -a command line option
# @F holds the combination followed by the starting position

$p=3;                       # starting position is in array index 3, this variable will track the array index of
                            # the current position on the dial

c(2*!$p-1,@F[$_,$p]),$p=$_  # call the movement function (c), setting direction to the left (1) or right (-1) as needed
                            # based on the array index of the previous position (go left when moving from array index 0)
for 3,3,3,0,0,1,2;          # list of the array index of the next position

say$F[2]                    # output final position

Python 2, 262 byte

Nó cảm thấy rất lâu. Nhưng cũng có rất nhiều biến chuyển đang diễn ra.

def f(l,s):
 r=lambda a,b,c=1:range(a,b,c)
 a=r(39,l[0],-1);b=r(l[0],-1,-1)
 c=r(l[1],l[2]-1,-1)if l[2]<l[1]else r(l[1],-1,-1);c.extend(r(39,l[2]-1,-1))
 return'  '.join(`x`for x in sum([r(s,-1,-1),a,b,a,b,a,b,r(39,l[0],-1),r(l[0],40),r(0,40),r(0,l[1]+1),c],[]))

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

Tôi nghĩ rằng tôi có thể ghép một số phần tốt hơn trong dòng cuối cùng của mình nhưng tôi vẫn chưa quen với môn đánh gôn và tôi không biết làm thế nào để giải quyết sự kết hợp danh sách đó một cách ngắn gọn.

Bất kỳ ý tưởng về việc cải thiện điều này?

Haskell , 135 112 byte

s!t=[s..39]++[0..mod(t-1)40]
s#t=[s,s-1..0]++[39,38..mod(t+1)40]
(a%b)c s=[s#s,s#s,s#s,s#a,a!a,a!b,b#c,[c]]>>=id

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

Đã lưu 23 byte nhờ Laikoni