场景是：

当Brian突然需要他的吸入器时，Peter和他的伙伴Brian在健身房。Brian倒在地板上之前设法告诉Peter密码到他的密码锁。

当彼得到达Brian的储物柜并看到指示器所指的那一刻，Stewie伏击了他，并在他的脸上喷了满罐胡椒粉，使Peter蒙蔽了双眼。

彼得现在必须尝试打开锁而不要看它。他开始将表盘向右旋转，并在传递数字时对数字进行计数。然后，他以正确的数字开始将表盘向左旋转，仍在计数，最后将其向右旋转直到锁打开。

挑战：

编写一个函数/程序，它接受两个输入，即来自Brian的组合和指示器位置。输出彼得必须数的数字。

规则：

• 组合和指标位置必须是单独的参数。
• 输入可以来自命令提示符，也可以作为函数参数。
• 输出必须打印到屏幕上/否则显示（不记录到文件中）
• 假定起始位置与第一个数字不同，并且组合中的所有三个数字都是唯一的
• 下图所示为锁，可能的数字为0-39。

说明：

要打开下面的锁，您需要按照以下说明进行操作：

1. 您必须知道您的代码。假设现在是（38，16，22）。
2. 将拨盘向右旋转3次（通过起始数字3次），然后在第一个数字（38）与指示器对准时停止
3. 将拨盘向左旋转1圈，传递第一个数字，并在第二个数字（16）与指示器对齐时停止。
4. 将拨盘向右旋转，并在第三个数字（22）与指示器对准时停止
5. 拉下锁

例：

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

适用标准代码高尔夫规则。

如果发布的解决方案比丹尼斯的答案短，则仍然可以获胜。

CJam，52 39字节

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

在CJam解释器中在线尝试。

怎么运行的

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，189175字节

假设指标在命令行上以arg0的形式传递，而组合以arg1，arg2和arg3的形式传递...

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字节

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]

在线尝试！

怎么样？

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字节

感觉好久。但是还有很多事情要做。

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],[]))

在线尝试！

我认为我可以在最后一行中更好地连接某些部分，但是我仍然是打高尔夫球的新手，而且我不知道如何在短时间内解决该列表组合。

有任何改善建议吗？

哈斯克尔， 135112字节

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

在线尝试！

感谢Laikoni，节省了23个字节