场景

经过一整天的辛苦工作，在办公室里浏览并浏览了stackexchange.com之后，我终于在16:58走出家门，已经疲倦了。因为我仍然只是一名实习生，所以我目前的交通方式是骑自行车。我前往值得信赖的Peugeot Reynolds 501，但是在我不能驶向它之前，我需要将其解锁。该锁是通过框架和前轮的标准四位数密码锁（0-9）。当我尝试保持清醒时，我将手向上拉以进入组合。

挑战

因为我的手指很疲劳，所以我想用最少的动作将锁调到正确的位置。一移动定义为旋转一个位置（36度），例如，从5737到移动一5738。但是，我能够同时抓取最多三个连续的环，并将它们旋转为一个，这仅算作一个动作。例如，从到到仅有一个移动。从到移动不是一个动作，因为数字1,2和4向同一方向移动，但独立于数字3。57376837562657376838

因此，对于给定的组合，我可以在自行车锁上看到（任何4位整数），使锁解锁的最低移动量是多少，是的，我可以随时朝任一方向旋转。我的意思是，我可以在一个方向上转动一些数字，而在另一个方向上转动其他数字：对于每次解锁，并非我的所有动作都是顺时针或顺时针方向。

因为我很懒，所以我的解锁码是0000。

这是我无法打扰的代码编写工作，因此以字节数为单位的最短程序获胜。

输入来自stdin，您的代码应输出每次移动后每一步都能看到的组合，包括末尾的0000。每个组合输出都应以空格/换行符/逗号/句号/＆符号分隔。

例子

Input: 1210
0100
0000

Input: 9871
9870
0980
0090
0000

Input: 5555
4445&3335&2225&1115&0005&0006&0007&0008&0009&0000

Input: 1234
0124 0013 0002 0001 0000

我尝试将其发布在http://bicycles.stackexchange.com上，但他们不喜欢它...

免责声明：第一次打高尔夫球，所以任何损坏的信息/遗失信息都请通知我！我也手动完成了所有示例，因此可能会有涉及较少动作的解决方案！

编辑：对于具有多个具有相等移动量（实际上是全部）的解决方案路径的答案，没有首选的解决方案。

Matlab，412 327字节

打高尔夫球（感谢@AndrasDeak打高尔夫球s！）：

s=dec2bin('iecbmgdoh'.'-97)-48;s=[s;-s];T=1e4;D=Inf(1,T);P=D;I=NaN(T,4);for i=1:T;I(i,:)=sprintf('%04d',i-1)-'0';end;G=input('');D(G+1)=0;for k=0:12;for n=find(D==k);for i=1:18;m=1+mod(I(n,:)+s(i,:),10)*10.^(3:-1:0)';if D(m)==Inf;D(m)=k+1;P(m)=n-1;end;end;end;end;n=0;X='0000';while n-G;n=P(n+1);X=[I(n+1,:)+48;X];end;disp(X)

该代码使用一些动态编程来查找从给定数字到0000仅使用可能的步骤的最短“路径” 。挑战基本上是最短的路径难题（或者，您可以将这些步骤视为可交换的组。），但是要解决有效的困难。基本结构是两个10000个元素的数组，一个数组用于存储获取该索引的步骤数，另一个数组用于存储指向图形中上一个“节点”的指针。它同时计算所有其他可能数字的“路径”。

例子：

9871
0981
0091
0001
0000

1210
0100
0000

Examples by @noisyass:

7478
8578
9678
0788
0899
0900
0000

3737
2627
1517
0407
0307
0207
0107
0007
0008
0009
0000

Own Example (longest sequence, shared with 6284)

4826
3826
2826
1826
0826
0926
0026
0015
0004
0003
0002
0001
0000    

完整代码（包括一些注释）：

%steps
s=[eye(4);1,1,0,0;0,1,1,0;0,0,1,1;1,1,1,0;0,1,1,1];
s=[s;-s];


D=NaN(1,10000);%D(n+1) = number of steps to get to n
P=NaN(1,10000);%P(n+1) was last one before n

I=NaN(10000,4);%integer representation as array
for i=0:9999; 
    I(i+1,:)=sprintf('%04d',i)-'0';
end

G=9871; % define the current number (for the golfed version replaced with input('');
D(G+1)=0;
B=10.^(3:-1:0); %base for each digit

for k=0:100; %upper bound on number of steps;
    L=find(D==k)-1;
    for n=L; %iterate all new steps
        for i=1:18; %search all new steps
            m=sum(mod(I(n+1,:)+s(i,:),10) .* [1000,100,10,1]);
            if isnan(D(m+1))
                D(m+1) = k+1;
                P(m+1)=n;
            end
        end
    end
end
n=0;%we start here
X=[];
while n~=G
    X=[I(n+1,:)+'0';X];
    n=P(n+1);
end
disp([I(G+1,:)+'0';X,''])

批处理-288字节

即使您说它们必须是连续的（圆环），但我还是根据逻辑假设（按照示例）假定我可以跳过中间的圆环，例如从1234to 0224。

设置/像素=
设置a =％x：〜0,1％＆设置b =％x：〜1,1％＆设置c =％x：〜2,1％＆设置d =％x：〜3,1％
：l
@echo％x％＆if％a％== 0（如果％d％NEQ 0置位/ ad = d-1），否则置位/ aa = a-1
@if％b％NEQ 0置位/ ab = b-1
@if％c％NEQ 0 set / ac = c-1
@if％x％NEQ 0000 set x =％a %% b %% c %% d％＆goto l

这是我的批处理解决方案：236个字节。

编辑：更正的解决方案

设置/像素=
设置a =％x：〜0,1％＆设置b =％x：〜1,1％＆设置c =％x：〜2,1％＆设置d =％x：〜3,1％
：l
@echo％x％＆set k = 1＆if％a％== 0（如果％d％NEQ 0 set / ad = d-1＆set k = 0），否则set / aa = a-1＆set k = 1
@if％b％NEQ如果％k％== 1 set / ab = b-1＆set k = 0
@if％c％NEQ 0如果％k％== 0 set / ac = c-1
@if％x％NEQ 0000 set x =％a %% b %% c %% d％＆goto l

新的解决方案（根据基础注释修复）重288个字节。

Haskell-310字节

import Data.Char
import Data.List
r=replicate
h=head
a x=map(:x)[map(`mod`10)$zipWith(+)(h x)((r n 0)++(r(4-j)q)++(r(j-n)0))|j<-[1..3],n<-[0..j],q<-[1,-1]]
x!y=h x==h y
x#[]=(nubBy(!)$x>>=a)#(filter(![(r 4 0)])x)
x#y=unlines.tail.reverse.map(intToDigit<$>)$h y
main=do x<-getLine;putStrLn$[[digitToInt<$>x]]#[]

通过对已经达到的每个组合应用每个可能的转弯，直到其中一个是正确的组合，来反复构建新的组合列表，以实现此目的。每次迭代都会从列表中删除重复项，以防止内存使用量成倍增长。

作为强力解决方案，这是非常低效的，可能需要几分钟才能运行。

我在Haskell方面经验不足，因此可能会做得更好。