与Rubik's一起骑车


43

我儿子闲着扭动魔方时,发现魔方一直回到已解决状态。我很确定他一开始就认为这是某种巫术魔术,但我解释说,如果继续重复相同的动作顺序,它将始终返回其原始状态。最终。

当然,作为一个孩子,他不得不自己尝试一下,并选择了一个他认为很棘手的“随机”序列。在大约十次重复之后,他迷失了方向,问我要重复几次。我不知道他使用的顺序,我告诉他我不知道,但是我们可以编写一个程序来找出答案。

这就是您要进入的地方。当然,我可以打些东西,但他想自己打。但是,他不是一个很快的打字员,所以我需要尽可能短的程序

目的

给定一系列旋转,输出必须执行的次数最少,才能使多维数据集返回其原始状态。这是代码高尔夫,因此最少字节获胜。您可以编写程序或函数,所有其他通常的默认设置都适用。

输入项

输入是一系列动作,采取字符串,列表或其他适合您的语言的格式。如果采用字符串形式,请在移动之间随意使用分隔符(或不使用分隔符)。

必须考虑六个“基本”动作及其相反的动作:

R - Turn the right face clockwise
L - Turn the left face clockwise
U - Turn the up (top) face clockwise
D - Turn the down (bottom) face clockwise
F - Turn the front face clockwise
B - Turn the back face clockwise

反向符号'通过在字母后面加上一个撇号来表示。这表示您逆时针旋转该脸部,因此逆时针旋转F'正面,F F'它会立即返回到原始状态。

对于感兴趣的人,此挑战使用的是一套有限的Singmaster符号。如果您想观看Ruwix的实际动画,可以使用一些不错的动画

输出量

输出只是必须执行输入序列的最小次数。

例子

Input                Output

FF'               ->      1
R                 ->      4
RUR'U'            ->      6
LLUUFFUURRUU      ->     12
LUFFRDRBF         ->     56
LF                ->    105
UFFR'DBBRL'       ->    120
FRBL              ->    315

这是一个(相当幼稚的)求解器,用于比较您用Java编写的答案。它还接受2两次移动(因此第四种情况等效于L2U2F2U2R2U2)。

import java.util.ArrayList;
import java.util.List;

public class CycleCounter{

    public static void main(String[] args){
        int[] cube = new int[54];
        for(int i=0;i<54;i++)
            cube[i] = i;

        String test = args.length > 0 ? args[0] : "RUR'U'";
        List<Rotation> steps = parse(test);
        System.out.println(steps.toString());

        int count = 0;
        do{
            for(Rotation step : steps)
                cube = step.getRotated(cube);
            count++;
        }while(!isSorted(cube));

        System.out.println("Cycle length for " + test + " is " + count);        
    }

    static List<Rotation> parse(String in){
        List<Rotation> steps = new ArrayList<Rotation>();
        for(char c : in.toUpperCase().toCharArray())
            switch(c){
                case 'R':steps.add(Rotation.R);break;
                case 'L':steps.add(Rotation.L);break;
                case 'U':steps.add(Rotation.U);break;
                case 'D':steps.add(Rotation.D);break;
                case 'F':steps.add(Rotation.F);break;
                case 'B':steps.add(Rotation.B);break;
                case '\'':
                    steps.add(steps.get(steps.size()-1));
                case '2':
                    steps.add(steps.get(steps.size()-1));
                    break;
            }
        return steps;
    }

    static boolean isSorted(int[] in){for(int i=0;i<in.length-1;i++)if(in[i]>in[i+1])return false;return true;}

    enum Rotation{
        R(new int[]{-1,-1,42,-1,-1,39,-1,-1,36, -1,-1,2,-1,-1,5,-1,-1,8, 20,23,26,19,-1,25,18,21,24, -1,-1,11,-1,-1,14,-1,-1,17, 35,-1,-1,32,-1,-1,29,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1}),
        L(new int[]{9,-1,-1,12,-1,-1,15,-1,-1, 27,-1,-1,30,-1,-1,33,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, 44,-1,-1,41,-1,-1,38,-1,-1, -1,-1,6,-1,-1,3,-1,-1,0, 47,50,53,46,-1,52,45,48,51}),
        U(new int[]{2,5,8,1,-1,7,0,3,6, 45,46,47,-1,-1,-1,-1,-1,-1, 9,10,11,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, 18,19,20,-1,-1,-1,-1,-1,-1, 36,37,38,-1,-1,-1,-1,-1,-1}),
        D(new int[]{-1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,24,25,26, -1,-1,-1,-1,-1,-1,42,43,44, 29,32,35,28,-1,34,27,30,33, -1,-1,-1,-1,-1,-1,51,52,53, -1,-1,-1,-1,-1,-1,15,16,17}),
        F(new int[]{-1,-1,-1,-1,-1,-1,18,21,24, 11,14,17,10,-1,16,9,12,15, 29,-1,-1,28,-1,-1,27,-1,-1, 47,50,53,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,8,-1,-1,7,-1,-1,6}),
        B(new int[]{51,48,45,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,0,-1,-1,1,-1,-1,2, -1,-1,-1,-1,-1,-1,26,23,20, 38,41,44,37,-1,43,36,39,42, 33,-1,-1,34,-1,-1,35,-1,-1});

        private final int[] moves;
        Rotation(int[] moves){
            this.moves = moves;
        }

        public int[] getRotated(int[] cube){
            int[] newCube = new int[54];
            for(int i=0;i<54;i++)
                if(moves[i]<0)
                    newCube[i] = cube[i];
                else
                    newCube[moves[i]] = cube[i];
            return newCube;
        }
    }
}

我认为“顺时针”是指“面对时是顺时针”?
msh210 '16

@ msh210正确。
Geobits's

7
在学点上,我认为您应该明确表示您想要最小的数字。否则,我只能输出组的大小并引用拉格朗日定理...
Peter Taylor

2
@PeterTaylor Pedantry被接受了。
Geobits '16

4
可以为Shuffle提供500点赏金。尚未确定。
lirtosiast '16

Answers:


16

Pyth,66 63字节

l.uum.rW}Hdd@_sm_B.iFP.>c3Zk3xZHG_r_Xz\'\39Nf!s}RTcZ2y=Z"UDLRFB

在线尝试:演示测试套件。请注意,该程序有点慢,并且在线编译器无法计算的答案RU2D'BD'。但请放心,它可以在大约12秒内在我的笔记本电脑上进行计算。

该程序(偶然地)也接受2两次移动。

完整说明:

解析加扰:

首先,我将处理'输入字符串中的撇号。我只是将它们替换为,3并用运行长度对该字符串进行解码。由于Pyth的解码格式需要在char前面加上数字,因此我会事先反转字符串。_r_Xz\'\39。所以之后我将其反向。

描述已解决的多维数据集状态:

=Z"UDLRFB将所有6次移动分配给的字符串Z

我们可以通过描述每个立方体块的位置来描述立方体状态。例如,我们可以说应该在UL(左上)处的边缘当前在FR(右前)处。为此,我需要生成所有已解决的多维数据集:f!s}RTcZ2yZyZ生成的所有可能子集"UDLRFB"。显然,这也会生成子集"UDLRFB"和子集"UD"。第一个没有意义,因为在所有6个侧面都看不到一块,第二个没有意义,因为没有边缘片,可以从顶部和底部看到。所以我删除所有的子集,包含序列"UD""LR""FB"。这给了我以下27件:

'', 'U', 'D', 'L', 'R', 'F', 'B', 'UL', 'UR', 'UF', 'UB', 'DL', 'DR', 'DF', 'DB', 
'LF', 'LB', 'RF', 'RB', 'ULF', 'ULB', 'URF', 'URB', 'DLF', 'DLB', 'DRF', 'DRB'

这也包括空字符串和所有六个1个字母的字符串。我们可以将它们解释为立方体中间的一块和6个中心块。显然,它们不是必需的(因为它们不移动),但是我会保留它们。

做一些动作:

我将进行一些字符串翻译以执行移动。要形象化这个想法,请查看中的角点URF。当我R移动时会发生什么?在该贴U面移动到B面,贴纸F移到U面上和贴纸R脸上停留在R脸上。可以说,位于的棋子URF移动到了位置BRU。这种模式适用于右侧的所有零件。每一个标签就是在F脸上移动到U当脸部R进行移动,每一个标签就是在U脸上移动到B脸上,对每一个标签B移到D每贴纸上D移到F。我们可以将R移动的变化解码为FUBD

以下代码生成所有6个必需的代码:

_sm_B.iFP.>c3Zk3
['BRFL', 'LFRB', 'DBUF', 'FUBD', 'RDLU', 'ULDR']
    ^       ^       ^       ^       ^       ^
 U move  D move  L move  R move  F move  B move

然后执行以下操作,H切换到多维数据集状态G

m.rW}Hdd@...xZHG
m              G   map each piece d in G to:
 .rW   d              perform a rotated translation to d, but only if:
    }Hd                  H appears in d (d is currently on the face H)
            xZH           get the index of H in Z
        @...              and choose the code in the list of 6 (see above)

计算重复次数:

其余的几乎是微不足道的。我只是反复地对已求解的多维数据集执行输入加扰,直到到达先前访问的位置。

l.uu<apply move H to G><parsed scramble>N<solved state>
u...N   performs all moves of the scramble to the state N
.u...   do this until cycle detected, this returns all intermediate states
l       print the length

13

GAP,792 783 782 749 650个字节

这似乎正在工作。如果它弄乱了,请告诉我。

感谢@Lynn建议我分解一些原始动作。

感谢@Neil建议不要Inverse(X)使用X^3

用法示例: f("R");

R:=(3,39,21,48)(6,42,24,51)(9,45,27,54)(10,12,18,16)(13,11,15,17);L:=(1,46,19,37)(4,49,22,40)(7,52,25,43)(30,36,34,28)(29,33,35,31);U:=(1,10,27,28)(2,11,26,29)(3,12,25,30)(37,43,45,39)(40,44,42,38);A:=R*L^3*F*F*B*B*R*L^3;D:=A*U*A;;F:=(1,3,9,7)(2,6,8,4)(10,48,36,43)(13,47,33,44)(16,46,30,45);B:=(27,25,19,21)(26,22,20,24)(39,28,52,18)(38,31,53,15)(37,34,54,12);d:=NewDictionary((),true);AddDictionary(d,'R',R);AddDictionary(d,'L',L);AddDictionary(d,'U',U);AddDictionary(d,'D',D);AddDictionary(d,'F',F);AddDictionary(d,'B',B);f:=function(s) local i,p,b,t;p:=();
for c in s do if c='\'' then t:=t^2;else t:=LookupDictionary(d,c);fi;p:=p*t;od;return Order(p);end;

这是带有一些解释的非高尔夫代码

  # Here we define the primitive moves
R:=(3,39,21,48)(6,42,24,51)(9,45,27,54)(10,12,18,16)(13,11,15,17);
L:=(1,46,19,37)(4,49,22,40)(7,52,25,43)(30,36,34,28)(29,33,35,31);
U:=(1,10,27,28)(2,11,26,29)(3,12,25,30)(37,43,45,39)(40,44,42,38);
#D:=(7,34,21,16)(8,35,20,17)(9,36,19,18)(48,46,52,54)(47,49,53,51);
F:=(1,3,9,7)(2,6,8,4)(10,48,36,43)(13,47,33,44)(16,46,30,45);
B:=(27,25,19,21)(26,22,20,24)(39,28,52,18)(38,31,53,15)(37,34,54,12);

# Here we define D in terms of other primitive moves, saving on bytes
# Thanks @Lynn
# This is actually doable with a maximum of 3 of the primitive moves
# if a short enough sequence can be found.
D:=U^(R*L^3*F*F*B*B*R*L^3);

# create dictionary and add moves to it with appropriate char labels
d:=NewDictionary((),true);
AddDictionary(d,'R',R);
AddDictionary(d,'L',L);
AddDictionary(d,'U',U);
AddDictionary(d,'D',D);
AddDictionary(d,'F',F);
AddDictionary(d,'B',B);

f:=function(s)
    local c,p,t;

    # p will become the actual permutation passed to the function
    p:=();

    for c in s do
        if c='\'' then
            # The last generator we mutiplied (that we still have in t)
            # should have been its inverse. Compensate by preparing to
            # multiply it two more times to get t^3=t^-1. Thanks @Neil.
            t:=t^2;
        else
            t:=LookupDictionary(d,c);
        fi;
        p:=p*t;
    od;

    return Order(p);

end;

一举一动是身份的第四根,因此您的反向不需要。
尼尔

你或许可以代替455在你的排列,并保存3个字节。
林恩

本人于1981年在Singmaster中发现的Benson的结果表明:“让A =RL⁻F²B²RL⁻¹,然后AUA =D。”实际上,A:=R*L*L*L*F*F*B*B*R*L*L*L;D:=A*U*A;它比您的定义短D(但我无法对其进行测试...)
Lynn

^-1顺便说一句,GAP真的不允许您为逆写吗?
林恩

是的,我完全不使用^ -1。我认为@Neil几乎是同一句话,除了^ 3(实际上是最短的)。另外,是的,我可以将动作分解为其他动作,这样做应该可以节省几个字节,这只是找到最短分解的问题。
利亚姆

10

Mathematica,413401字节

Evaluate[f/@Characters@"RFLBUD"]=LetterNumber@"ABFEJNRMDAEHIMQPCDHGLPTOBCGFKOSNADCBILKJEFGHQRST"~ArrayReshape~{6,2,4};
r[c_,l_]:=(b=Permute[c,Cycles@f@l];MapThread[(b[[#,2]]=Mod[b[[#,2]]+{"F","B","L","R"}~Count~l{-1,1,-1,1},#2])&,{f@l,{3,2}}];b);
p@s_:=Length[c={#,0}&~Array~20;NestWhileList[Fold[r,#,Join@@StringCases[s,x_~~t:""|"'":>Table[x,3-2Boole[t==""]]]]&,c,(Length@{##}<2||c!=Last@{##})&,All]]-1

说明

魔方是由20个可移动立方体(8个角,12个边缘)组成的。可以给每个立方体一个数字:

角落

N   starting position
1     UFR
2     UBR
3     UBL
4     UFL
5     DFR
6     DBR
7     DBL
8     DFL

边缘

N   starting position
9     UF
10    UR
11    UB
12    UL
13    FR
14    BR
15    BL
16    FL
17    DF
18    DR
19    DB
20    DL

请注意,在扭转立方体时,立方体不再处于其起始位置。例如,R完成后,多维数据集1将从UFR移到新位置UBR

在这种表示法中,可以通过cubies的8次移动来描述90度转弯。例如,R

from  to
UFR   UBR
UBR   DBR
DBR   DFR
DFR   UFR
UR    BR
BR    DR
DR    FR
FR    UR

由于每个多维数据集都有一个唯一的起始位置,因此每个位置都有一个独特的起始位置。也就是说,规则UFR->UBR就是1->2R将cubie的起始位置上的cubie 1移到cubie 的起始位置上的手段2)。因此,R可以进一步简化为一个周期

Cycles[{{1,2,6,5}, {10,14,18,13}}]

为了完全解决魔方,我们还需要将立方体对准其相应的起始方向。立方体的面用不同的颜色绘制,我在解决立方体时经常使用的方案是

face color
U    yellow
D    white
F    red
B    orange
R    green
L    blue

当我们分析角的方向时,除黄色或白色之外的颜色都将被忽略,而黄色和白色被视为相同的颜色。

假设立方体1位于其起始位置UFR,则黄色小平面可以与三个不同的平面对齐。我们使用整数表示这些情况,

0  yellow on U  (correct)
1  yellow on R  (120 degree clockwise)
2  yellow on F  (120 degree counterclockwise)

假设cubie 1打开DFL,其三个可能的方向是

0  yellow on D  (correct)
1  yellow on L  (120 degree clockwise)
2  yellow on F  (120 degree counterclockwise)

当我们分析边缘的方向时,仅当边缘具有绿色或蓝色小平面时,才会忽略红色和橙色,而忽略黄色和白色。

假设立方体10位于其起始位置UR,则绿色小平面可以与两个不同的平面对齐。它的两个可能的方向是

0  green on R  (correct)
1  green on U  (180 degree)

假设cubie 10打开DF,其两个可能的方向是

0  green on D  (correct)
1  green on F  (180 degree)

数组用于存储多维数据集的状态。多维数据集的起始状态为

{{1,0},{2,0},{3,0},{4,0},{5,0},{6,0},{7,0},{8,0},{9,0},{10,0},{11,0},{12,0},{13,0},{14,0},{15,0},{16,0},{17,0},{18,0},{19,0},{20,0}}

这意味着每个小腿都以正确的方向处于其起始位置。

之后R,多维数据集的状态变为

{{5,2},{1,1},{3,0},{4,0},{6,1},{2,2},{7,0},{8,0},{9,0},{13,1},{11,0},{12,0},{18,1},{10,1},{15,0},{16,0},{17,0},{14,1},{19,0},{20,0}}

这意味着cubie 5现在是上位置1UFR与取向)2,cubie 1现已在位置2UBR与取向)1,cubie 3是现在仍然在位置3UBL与取向)0,等等。


测试用例

p["FF'"]            (* 1   *)
p["R"]              (* 4   *)
p["RUR'U'"]         (* 6   *)
p["LLUUFFUURRUU"]   (* 12  *)
p["LUFFRDRBF"]      (* 56  *)
p["LF"]             (* 105 *)
p["UFFR'DBBRL'"]    (* 120 *)
p["FRBL"]           (* 315 *)

7

Haskell,252个字节

r=[-2..2]
s=mapM id[r,r,r]
t m p@[x,y,z]=case m of"R"|x>0->[x,z,-y];"L"|x<0->[x,-z,y];"U"|y>0->[-z,y,x];"D"|y<0->[z,y,-x];"F"|z>0->[y,-x,z];"B"|z<0->[-y,x,z];c:"'"->t[c]$t[c]$t[c]p;_->p
f m=length$s:fst(span(/=s)$tail$iterate(flip(foldl$flip$map.t)m)s)

样品运行:

*Main> f ["F","F'"]
1
*Main> f ["R"]
4
*Main> f ["R","U","R'","U'"]
6
*Main> f ["L","L","U","U","F","F","U","U","R","R","U","U"]
12
*Main> f ["L","U","F","F","R","D","R","B","F"]
56
*Main> f ["L","F"]
105
*Main> f ["U","F","F","R'","D","B","B","R","L'"]
120
*Main> f ["F","R","B","L"]
315
*Main> f ["R","U","U","D'","B","D'"]  -- maximum possible order
1260

此处的主要观察结果是,将Rubik立方体建模为点的5×5×5网格而不是定向立方体的3×3×3网格更为简单。角立方变成2×2×2点的立方体,边缘立方变成2×2×1点的正方形,并移动5×5×2点的旋转切片。


这真的很聪明!我认为用替换c:"'"可以c:_节省两个字节。
林恩

谢谢!我一直在为测试用例寻找1260序列,但不能为它烦恼:)
Geobits,2016年

@Lynn,这不起作用,因为它_也匹配空列表。
安德斯·卡塞格

很好,但似乎与对另一个问题codegolf.stackexchange.com/a/44775/15599的回答非常相似。如果您受到启发,则应该承认。
水平河圣

@steveverrill,哇,看起来确实很相似,但是不,我没看过。我的答案是我自己的独立作品。(我承认,当然,扬德沃夏克想出了大部分我之前做过同样的想法。)
安德斯Kaseorg

7

Ruby,225个字节

->s{n=0
a=[]
b=[]
64.times{|i|a<<j=[(i&48)-16,(i&12)-4,i%4-1];b<<j*1}
d=1
(n+=1
s.reverse.chars{|c|m="UFRDBL".index(c)
m ?(e=m/3*2-1
b.each{|j|j[m%=3]*e>0&&(j[m-2],j[m-1]=j[m-1]*e*d,-j[m-2]*e*d)}
d=1):d=-1})until n>0&&a==b
n}

类似安德斯Kaseorg的答案,由Jan德沃夏克的启发回答上一个问题。

但是,与这些答案不同的是,我不需要125个cubics。我使用27个立方体的魔方,但矩形。在已解决状态下,拐角处为+/-1,+/-4,+/-16

我生成了一个由64个cubices组成的数组,每个cubices的中心都从中选择x=[-1,0,1,2], y=[-4,0,4,8], z=[-16-0,16,32]。坐标为2、8和32的小腿是不必要的,但它们没有伤害,因此出于打高尔夫球的原因而留在了小腿上。隔间的长度,宽度和深度不同:(1、4、16),这意味着很容易检测它们是否在正确的位置但方向错误。

通过脸部转向移动每个多维数据集时都会对其进行跟踪。如果立方体在与人脸相对应的轴上的坐标为正(乘以e=-1U,F,R或e=1D,B,L),那么将通过在其他2轴上交换坐标并应用适当的符号更改为坐标之一。通过乘以来控制e*d

以相反的顺序扫描输入序列。只要“正常”旋转是沿逆时针方向而不是顺时针方向进行的,这没有什么区别。这样做的原因是,如果'找到一个符号,则d可以将的值从1更改为-1,以使后面的面朝相反的方向旋转。

取消测试程序

f=->s{n=0                                      #number of repeats=0
  a=[]                                         #empty array for solved position
  b=[]                                         #empty array for current position
  64.times{|i|
    a<<j=[(i&48)-16,(i&12)-4,i%4-1]            #generate 64 cubies and append them to the solved array
    b<<j*1                                     #duplicate them and append to active array
  }
  d=1                                          #default rotation direction anticlockwise (we scan the moves in reverse)                              
  (                                            #start of UNTIL loop
    n+=1                                       #increment repeat counter
    s.reverse.chars{|c|                        #reverse list of moves and iterate through it
      m="UFRDBL".index(c)                      #assign move letter to m (for ' or any other symbol m is false)
      m ?                                      #if a letter
        (e=m/3*2-1                             #e=-1 for UFR, 1 for DBL
        b.each{|j|                             #for each cubie 
          j[m%=3]*e>0&&                        #m%=3 picks an axis. If the cubie is on the moving face of the cube
         (j[m-2],j[m-1]=j[m-1]*e*d,-j[m-2]*e*d)#rotate it: exchange the coordinates in the other 2 axes and invert the sign of one of them according to direction
        }                                      #as per the values of e and d. 
        d=1                                    #set d=1 (in case it was -1 at the start of the b.each loop)
      ):
      d=-1                                     #ELSE the input must be a ', so set d=-1 to reverse rotation of next letter
    }
   )until n>0&&a==b                            #end of UNTIL loop. continue until back at start position a==b
n}                                             #return n

p f["FF'"]               #      1
p f["R"]                 #      4
p f["RUR'U'"]            #      6
p f["LLUUFFUURRUU"]      #     12
p f["LUFFRDRBF"]         #     56
p f["LF"]                #    105
p f["UFFR'DBBRL'"]       #    120
p f["FRBL"]              #    315

7

Python 2,343字节

def M(o,v,e):
 k=1
 for m in e:
  for c in'ouf|/[bPcU`Dkqbx-Y:(+=P4cyrh=I;-(:R6'[m::6]:i=~ord(c)%8*k;j=(ord(c)/8-4)*k;o[i],o[j]=o[j]-m/2,o[i]+m/2;v[i],v[j]=v[j],v[i];k=-k
V=range(20)
o,v,e=[0]*20,V[:],[]
for c in raw_input():i='FBRLUD'.find(c);e+=i<0and e[-1:]*2or[i]
M(o,v,e);n=1
while any(o[i]%(2+i/12)for i in V)or v>V:M(o,v,e);n+=1
print n

输入来自标准输入。

给定的扭曲顺序在虚拟立方体上重复执行,直到返回到已求解状态。立方体状态存储为长度均为20的方向向量和置换向量。

方向是任意定义的:如果可以在不调用R或L四分之一圈的情况下将其移动到适当的位置,则可以正确定向边缘立方体。角锥的方向被认为是相对于F和B面的。


样品用量

$ echo FRBL|python rubiks-cycle.py
315

$ echo RULURFLF|python rubiks-cycle.py
1260

在线演示测试套件


3
函数名称和参数的不错选择!
尼尔

3

Clojure,359个字节

这可能是我第二最长的代码高尔夫。意识到我可以从向量中删除尾随零AF使我非常高兴:D

#(let[I(clojure.string/replace % #"(.)'""$1$1$1")D(range -2 3)S(for[x D y D z D][x y z])A[0 1]B[0 0 1]C[1]D[-1]E[0 -1]F[0 0 -1]](loop[P S[[n R]& Q](cycle(map{\F[A[B A D]]\B[E[F A C]]\L[D[C B E]]\R[C[C F A]]\U[B[E C B]]\D[F[A D B]]}I))c 0](if(=(> c 0)(= P S))(/ c(count I))(recur(for[p P](if(>(apply +(map * n p))0)(for[r R](apply +(map * r p)))p))Q(inc c)))))

少打高尔夫球:

(def f #(let [I (clojure.string/replace % #"(.)'""$1$1$1")
              D [-2 -1 0 1 2]
              S (for[x D y D z D][x y z])
              L   {\F [[ 0  1  0][[0  0  1][ 0 1  0][-1  0 0]]]
                   \B [[ 0 -1  0][[0  0 -1][ 0 1  0][ 1  0 0]]]
                   \L [[-1  0  0][[1  0  0][ 0 0  1][ 0 -1 0]]]
                   \R [[ 1  0  0][[1  0  0][ 0 0 -1][ 0  1 0]]]
                   \U [[ 0  0  1][[0 -1  0][ 1 0  0][ 0  0 1]]]
                   \D [[ 0  0 -1][[0  1  0][-1 0  0][ 0  0 1]]]}]
          (loop [P S c 0 [[n R] & Q] (cycle(map L I))]
            (if (and (> c 0) (= P S))
              (/ c (count I))
              (recur (for[p P](if(pos?(apply +(map * n p)))
                                (for[r R](apply +(map * r p)))
                                p))
                     (inc c)
                     Q)))))

这仅实现了所选5 x 5 x 5多维数据集子集的3D旋转。本来我会用3 x 3 x 3,花了一段时间才意识到为什么我没有得到正确的结果。好的测试用例!一些额外的字节用于拳头编码"RUR'U'""RURRRUUU"


3

大概9 6个字节

¶-7)8%

在线尝试!(直到Dennis更新TIO Cubically解释器后,才能工作)

说明:

¶-7)8%
¶       read a string, insert into code
 -7     add 1 to notepad (subtracts the 7th face "sum" from notepad, defaulted to -1)
   )8   jump back to start of code if cube unsolved
     %  print notepad

该语言将主导所有挑战>:D


3
所有这些新奇的esolangs。在我们那个时代,-7意味着减7不加一个气愤地摇摇沃克
凯尔德coinheringaahing

@cairdcoinheringaahing确实。:P补充了一些解释。
MD XF

1

干净,255字节

与几乎完全相同的Haskell答案是作为该问题的答案而衍生的,该问题在完成时将作为重复项关闭,因此我在此处发布了答案。

import StdEnv,StdLib
a=[-2..2];b=diag3 a a a
?m=iter(size m*2-1)\p=:(x,y,z)=case m.[0]of'F'|z>0=(y,~x,z);'U'|y>0=(~z,y,x);'R'|x>0=(x,z,~y);'B'|z<0=(~y,x,z);'D'|y<0=(z,y,~x);'L'|x<0=(x,~z,y);_=p
$l=length(takeWhile((<>)b)(tl(iterate(map(sseq(map?l)))b)))+1

在线尝试!

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.