मेरे रुबिक के क्यूब पर एक चींटी है


44

एक मानक, हल, 3 × 3 × 3 रूबिक के क्यूब में 6 अलग-अलग रंग के चेहरे हैं, जहां प्रत्येक चेहरा एक रंग के वर्गों का 3 × 3 ग्रिड है। सफेद चेहरा पीले के विपरीत, नारंगी के विपरीत लाल, हरे के विपरीत नीला, और जब सफेद ऊपर की ओर इंगित करता है, तो लाल नीले रंग के बाईं ओर होता है:

रूबिक का क्यूब लेआउट

सफेद चेहरे के केंद्र वर्ग पर एक चींटी की कल्पना करें, जो लाल चेहरे का सामना कर रही है। आप उसे 3 कमांड दे सकते हैं:

  • फ़ॉरवर्ड ( ^) - यदि वह आवश्यक हो तो क्यूब के एक छोर पर कदम रखते हुए उस दिशा में एक कदम उठाएँ जो वह अगले ग्रिड स्क्वायर का सामना कर रहा है।
  • दाएं ( >) - 90 ° से दाएं (दक्षिणावर्त) घुमाएं, एक ही ग्रिड वर्ग में रहें।
  • बायाँ ( <) - 90 ° से बाईं ओर (प्रति-दक्षिणावर्त) पर घूमें, एक ही ग्रिड वर्ग में रहें।

आदेशों की एक मनमानी सूची को देखते हुए, चौराहों के रंगों को ढूंढें, जो चींटी का दौरा करते हैं (सफेद शुरुआती वर्ग सहित नहीं)।

उदाहरण के लिए, कमांड अनुक्रम ^^>^^<^^^में एक रास्ता है जो इस तरह दिखता है:

उदाहरण पथ

ग्रिड स्क्वॉयर के रंग क्रम में गए, शुरुआती वर्ग की गिनती नहीं कर रहे हैं white red red green green green yellow, या बस wrrgggy

एक प्रोग्राम या फ़ंक्शन लिखें जो कमांड वर्णों <^>और प्रिंटों की एक स्ट्रिंग में लेता है या वर्णों wyrobg(सफेद, पीला, लाल नारंगी, नीला, हरा) की एक स्ट्रिंग देता है जो घन पर चींटी के पथ से मेल खाती है।

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले जवाब है।

टिप्पणियाँ

  • क्यूब midair में है और चींटी के पास प्रभावी पुल्वीली है, इसलिए वह पूरे क्यूब को पार कर सकती है।
  • क्यूब हमेशा अपने हल की स्थिति में रहता है।
  • एक वर्ग का रंग केवल वर्ग में आंदोलन पर दर्ज किया जाता है, रोटेशन नहीं। शुरुआती सफेद वर्ग को दर्ज नहीं किया जाना चाहिए।
  • इनपुट और / या आउटपुट में एक एकल वैकल्पिक अनुगामी नईलाइन मौजूद हो सकती है।

परीक्षण के मामलों

input : output
[empty string] : [empty string]
^ : w
< : [empty string]
> : [empty string]
><><<<>> : [empty string]
>^ : w
<<^> : w
^<^<^<^< : wwww
^^ : wr
<^^ : wb
>><<<<^^ : wo
<^^^<^^^^<>^>^^>^ : wbbboooggyo
^^^^^^^^^^^^^^ : wrrryyyooowwwr
<<<^<^>^<^<^<^>^^^^<^>>>>>^^<^>^^<^>^>^>^>< : wwgrwgggoooobbbbyrby
^^>^^<^^^ : wrrgggy


2
@ मार्टिनबटनर चींटियों के छह पैर होते हैं, क्यूब्स के छह पहलू होते हैं। <shrug> I dunno ...
डिजिटल ट्रामा

4
यह एक स्टार्टर गोल्फ चुनौती नहीं है ..... मैं एक समन्वय प्रणाली के साथ आने वाले अपने दिमाग को खो रहा हूं जो कठिन कोडित नहीं है।
मैट

2
@DigitalTrauma यह चुनौती हैक्सागोनी जवाब के लिए चिल्ला रही है :-)
लुइस

1
मैं अब तक के सबसे खराब PowerShell कोड के साथ बहुत करीब हूं।
मैट

जवाबों:


18

पर्ल, 156 143 134 128 127 125 120 119 117 113 109 बाइट्स

के लिए +1 शामिल है -p

STDIN, जैसे पर नियंत्रण स्ट्रिंग के साथ चलाएँ

perl -p rubic.pl <<< "^^>^^<^^^"

rubic.pl:

@1=wryobg=~/./g;s##$n=w&$&;$y+=$x-=$y+=$x,@1[0,4,2,5,3,1]=@1while--$n%9;@{$n&&--$y%3}[3,0..2]=@1;$1[$n+9]#eg

व्याख्या

पुराना संस्करण:

@f=gboyrw=~/./g;s##$n=w&$&;$y+=$x-=$y+=$x,@f=@f[2,4,1,3,0,5]while--$n%9;@f=@f[0,$y=1,5,2..4]if$n&&$y--<0;$f[$n+8]#eg

इस प्रश्न की चुनौती एक समन्वय प्रणाली की खोज करना है जो चींटी की स्थिति और दिशा को ट्रैक करना और फिर भी आसानी से चेहरे की पहचान प्राप्त करना आसान बनाता है।

मैंने जिस सिस्टम को चुना था (x,y)वह चींटी के चेहरे पर मानक निर्देशांक डालने के लिए था जो चींटी हमेशा yचेहरे के केंद्र के साथ नकारात्मक दिशा में सामना कर रही होती है (0,0)। इसलिए:

rotate right: (x',y') <- (-y,  x)
rotate left:  (x',y') <- ( y, -x)  alternatve: 3 right rotations
Step forward:   y' <- y-1

यदि yपहले -1से ही चींटी वर्तमान चेहरे को छोड़ देगी और अगले एक पर कदम रखेगी। नए समन्वय प्रणाली में xइसका मूल्य रहता है, लेकिन y'1 हो जाता है।

यह एक चेहरे के भीतर एक आसान समन्वय प्रणाली देता है। मुझे खुद चेहरों के लिए भी कुछ चाहिए। वहां मैं एक सरणी का उपयोग करता हूं जिसमें शामिल है

The face to right of the ant            g in the initial position
The face to the left of of the ant      b
The face behind the ant                 o
The face opposite to the ant            y
The face before the ant                 r
The face the ant is on                  w

तो प्रारंभिक सरणी है (g,b,o,y,r,w)। अगले चेहरे पर जाना अंतिम 4 तत्वों को घुमाने से मेल खाता है, इसलिए सफेद से लाल रंग में जाना इसे बनाता है (g,b,w,o,y,r)। दाएं मुड़ना पहले 5 तत्वों को देने वाला क्रमचय है (o,r,b,y,g,w)। बाईं ओर मुड़ना एक क्रमिक क्रमपरिवर्तन है, लेकिन इसे दाएं 3 बार मोड़कर भी किया जा सकता है, इसलिए इस क्रमांकन को 3 बार लागू करना चाहिए। और 8 बार क्रमपरिवर्तन लागू करके भी नहीं किया जा सकता है। वास्तव में 5 बार क्रमपरिवर्तन को लागू करके सही किया जा सकता है।

इस कार्यक्रम को जानना सरल है:

@f=gboyrw=~/./g                 Set up the initial face orientation
s## ... #eg                     Process each control string character
                                {this is equivalent to s#.#...#eg because
                                the empty regex repeats the last
                                succesful regex)
$n=w&$&                         Calculate n, the number of right
                                rotations+1 modulo 9.
                                This abuses a coincidence of the control
                                characters:
                                 "<" & "w" = "4" -> 3 right rotations
                                 ">" & "w" = "6" -> 5 right rotations
                                 "^" & "w" = "V" = 0 but that is 9 mod 9
                                 so leads to 8 right rtations

$y+=$x-=$y+=$x,                 This is the same as ($x,$y)=(-$y,$x), so
                                a right rotation of the face coordinates
@f=@f[2,4,1,3,0,5]              Right rotation of the face array
   while --$n%9                 Rotate right n-1 times. After this n=0
                                If this was a step then n was effectively 0.
                                So rotate right 8 times leaving n=-9

    ... if $n                   If a step...
               $y--             ... decrease y ...
             &&$y--<0           ... but if y was already negative ...
@f=@f[0,$y=1,5,2..4]            ... change face and set y to 1

$f[$n+8]                        return the last element (current face)
                                if this was a step, otherwise empty

तो उस अंतिम स्टेटमेंट के लिए खाली स्ट्रिंग की ओर ले जाती है और आगे के चेहरे की ओर ले जाती है। इसलिए $_प्रत्येक चरण पर जाने वाले चेहरों द्वारा प्रतिस्थापित किया जाता है।


अगर मुझे समझ में आ रहा है कि यहाँ @1क्या हो रहा है, तो यह एक भयावह भाषा की तरह दिखने वाली एक अद्भुत गाली है।
चार्ल्स

@NotthatCharles हाँ, यह दिखने में बिलकुल दुष्ट है। गंभीर पर्ल कार्यक्रमों में पहली चीज जो आप करते हैं, उस सुविधा का उपयोग करके बंद कर दें use strict। वैसे modulo 3 के लिए धन्यवाद।
टोन हास्पेल

12

ब्रेकीलॉग , 287 बाइट्स

:1:2222:"w":"y":["r":"b":"o":"g"]{h""|[L:I:N:A:B:[C:D:E:F]]hhM("^",(NhI,CwX,EY,B:D:A:FZ;AwX,BY,[C:D:E:F]Z),NhJ,(I1,2313O;I2,(Nh2,N$($(O;Nh1,2222O;Nbh1,3223O;3322O);3322N,2332O;3223N,2233O;2233N,3132O;2332N,3231O);IJ,AX,BY,(M"<",[C:D:E:F]$(Z,N$(O;M">",[C:D:E:F]$)Z,N$)O)),Lb:J:O:X:Y:Z:1&}

इनपुट के रूप में चाल वाले स्ट्रिंग की अपेक्षा करता है, और कोई आउटपुट नहीं, उदाहरण के लिए STDOUT brachylog_main("^^>^^<^^^",_).को लिखेंगे wrrgggy

व्याख्या

§ There are 3 types of tiles we can be on: centers (noted 1), edges (2) and corners (3)
§ When we are on a tile, we can denote adjacent tiles in order: front, left, back, right
§ Similarly, we can denote the adjacent colors depending on the current one of the face
§
§ We start on the center (1) of face white ("w"). The adjacent tiles are 4 edges (2222)
§ The adjacent colors of white are red, blue, orange and green ("r":"b":"o":"g")
§ Yellow is opposite of white ("y")

§ We pass those initial conditions in an array, with the sequence of moves as first
§ element, as input to subpredicate 1


:1:2222:"w":"y":["r":"b":"o":"g"]{...}


§ SUB-PREDICATE 1

h""  § If the sequence of moves is empty, terminate the recursion
|    § Else...

§ Here are the variables' names of the input (which correspond to what's described in
§ the first few paragraphs)
[L:I:N:A:B:[C:D:E:F]]

§ If the move is "^"...
hhM("^",

   § The only way we change from one face to another is if the tile we end up on is of the
   § same type as the tile we started from
   (NhI,      § If this is the case
    CwX,      § Then write the color of the face we're facing, this face will now be the
              § current color
    EY,       § The third color in the list is now the opposite color
    B:D:A:FZ  § The opposite color is now the one we face, the color behind us (the third
              § in the list) is the one we were on, and the other 2 don't change

    § If the tiles are not the same type, then we don't change color
    ; 
    AwX,         § Write the current color, this will remain the color
    BY,          § Opposite color stays the same
    [C:D:E:F]Z), § Other colors stay in the same order since we moved forward
    NhJ,              § The new tile type is the one we were facing
       (I1,2313O;     § If we were on the center, then the adjacent tiles are 2313
       I2,            § Else if we were on an edge
         (Nh2,N$($(O; § then if we were facing an edge (changed face), then the new types
                      § of tiles are a double circular permutation of the previous types
         Nh1,2222O;   § Else if we were facing a center, then the new tiles are 2222
         Nbh1,3223O;  § Else (corners) if the tile to our left is the center, then 3223
         3322O)       § Else 3322

       ;              § Else if we were on a corner
       3322N,2332O;   § then one of those 4 possibilities applies
       3223N,2233O;
       2233N,3132O;
       2332N,3231O)

§ Else if the move is NOT "^"
;
IJ,AX,BY,         § We stay on the same type of tile, same color, same opposite color
(M"<",            § if the move is "turn left"
    [C:D:E:F]$(Z, § Then we circular permute the adjacent colors to the left
    N$(O          § we also circular permute the adjacent tiles to the left
;M">",            § Else if the move is "turn right"
    [C:D:E:F]$)Z, § Then we do the same but with right circular permutations
    N$)O)
),
Lb:J:O:X:Y:Z:1&   § Recursively call sub-predicate 1 with the new input, and the next move

समतुल्य एसडब्ल्यूआई-प्रोलॉग कोड

यदि आप Brachylog के संकलक से परेशान नहीं होना चाहते हैं, तो आप निम्न कोड का उपयोग करके SWI-Prolog में इस समाधान को चला सकते हैं (यह वही है जो Brachylog के संकलक द्वारा उत्पन्न होता है):

:- style_check(-singleton).

:- use_module(library(clpfd)).

brachylog_main(Input,Output) :-
    1=1,
    brachylog_subpred_1([Input,1,2222,"w","y",["r","b","o","g"]],V0).


brachylog_subpred_1(Input,Output) :-
    1=1,
    brachylog_head(Input, "").

brachylog_subpred_1(Input,Output) :-
    1=1,
    [L,I,N,A,B,[C,D,E,F]] = Input,
    brachylog_head([L,I,N,A,B,[C,D,E,F]], V0),
    brachylog_head(V0, M),
    ( 1=1,
    "^" = M,
    ( 1=1,
    brachylog_head(N, I),
    brachylog_write(C, X),
    Y = E,
    Z = [B,D,A,F]
    ;
    1=1,
    brachylog_write(A, X),
    Y = B,
    Z = [C,D,E,F]
    ),
    brachylog_head(N, J),
    ( 1=1,
    I = 1,
    O = 2313
    ;
    1=1,
    I = 2,
    ( 1=1,
    brachylog_head(N, 2),
    brachylog_math_circular_permutation_left(N, V1),
    brachylog_math_circular_permutation_left(V1, O)
    ;
    1=1,
    brachylog_head(N, 1),
    O = 2222
    ;
    1=1,
    brachylog_behead(N, V2),
    brachylog_head(V2, 1),
    O = 3223
    ;
    1=1,
    O = 3322
    )
    ;
    1=1,
    N = 3322,
    O = 2332
    ;
    1=1,
    N = 3223,
    O = 2233
    ;
    1=1,
    N = 2233,
    O = 3132
    ;
    1=1,
    N = 2332,
    O = 3231
    )
    ;
    1=1,
    J = I,
    X = A,
    Y = B,
    ( 1=1,
    "<" = M,
    brachylog_math_circular_permutation_left([C,D,E,F], Z),
    brachylog_math_circular_permutation_left(N, O)
    ;
    1=1,
    ">" = M,
    brachylog_math_circular_permutation_right([C,D,E,F], Z),
    brachylog_math_circular_permutation_right(N, O)
    )
    ),
    brachylog_behead(L, V3),
    brachylog_call_predicate([V3,J,O,X,Y,Z,1], V4).



brachylog_behead(X,Y) :-
    string(X),!,
    sub_string(X, 1, _, 0, Y)
    ;
    number(X),!,
    number_codes(X,[_|T]),
    catch(number_codes(Y,T),_,Y=[])
    ;
    atom(X),!,
    atom_codes(X,[_|T]),
    atom_codes(Y,T)
    ;
    X = [_|Y].

brachylog_math_circular_permutation_left(X,Y) :-
    string(X),!,
    string_codes(X,C),
    C = [H|T],
    append(T,[H],D),
    string_codes(Y,D)
    ;
    number(X),!,
    number_codes(X,C),
    C = [H|T],
    append(T,[H],D),
    number_codes(Y,D)
    ;
    atom(X),!,
    atom_codes(X,C),
    C = [H|T],
    append(T,[H],D),
    atom_codes(Y,D)
    ;
    X = [H|T],!,
    append(T,[H],Y).

brachylog_math_circular_permutation_right(X,Y) :-
    string(X),!,
    string_codes(X,C),
    append(T,[H],C),
    D = [H|T],
    string_codes(Y,D)
    ;
    number(X),!,
    number_codes(X,C),
    append(T,[H],C),
    D = [H|T],
    number_codes(Y,D)
    ;
    atom(X),!,
    atom_codes(X,C),
    append(T,[H],C),
    D = [H|T],
    atom_codes(Y,D)
    ;
    append(T,[H],X),
    Y = [H|T].

brachylog_call_predicate(X,Y) :-
    reverse(X,R),
    R = [N|RArgs],
    number(N),
    reverse(RArgs, Args),
    (
    N = 0,!,
    Name = brachylog_main
    ;
    atom_concat(brachylog_subpred_,N,Name)
    ),
    (
    Args = [UniqueArg],!,
    call(Name,UniqueArg,Y)
    ;
    call(Name,Args,Y)
    ).

brachylog_write(X,Y) :-
    X = [List,Format],
    is_list(List),
    string(Format),!,
    format(Format,List),
    flush_output,
    Y = List
    ;
    write(X),
    flush_output,
    Y = X.

brachylog_head(X,Y) :-
    string(X),!,
    sub_string(X, 0, 1, _, Y)
    ;
    number(X),!,
    number_codes(X,[A|_]),
    number_codes(Y,[A])
    ;
    atom(X),!,
    atom_codes(X,[A|_]),
    atom_codes(Y,[A])
    ;
    X = [Y|_].

4

पॉवरशेल, 882 बाइट्स

प्रयोग

कोड को किसी स्क्रिप्ट में सहेजें और कमांड लाइन से इसे इस तरह से कॉल करें। मान लें कि कार्यशील निर्देशिका वर्तमान निर्देशिका है।

.\WalkingAntcg.ps1 "^^>^^<^^^"

कोड

$o=[char[]]"grbowy";[int]$c=4;[int]$global:x=1;[int]$global:y=1;[int]$f=1;[int]$n=5;
$u={$c=$args[0];$1="341504251435240503210123".Substring($c*4,4);$2=$1*2-match".$($args[1]).";$3=$Matches[0];"$3";"012345"-replace([char[]]"$1$c"-join"|")}
function t{param($o,$x,$y)if($o){switch($y){0{switch($x){0{$x=2}1{$y=1;$x=2}2{$y=2}}}1{switch($x){0{$y=0;$x=1}2{$y=2;$x=1}}}2{switch($x){0{$x=0;$y=0}1{$x=0;$y=1}2{$x=0}}}}}else{switch($y){0{switch($x){0{$y=2}1{$x=0;$y=1}2{$x=0}}}1{switch($x){0{$y=2;$x=1}2{$y=0;$x=1}}}2{switch($x){0{$x=2}1{$x=2;$y=1}2{$y=0;$x=2}}}}}$global:x=$x;$global:y=$y}
([char[]]$args[0]|%{switch($_){'^'{$global:y++;if($global:y-eq3){$global:y=0;$c="$f";$f="$n";$z=&$u $c $f;$f,$n="$($z[0][1])","$($z[1])"}$o[$c]}
"<"{$z=&$u $c $f;$f,$n="$($z[0][0])","$($z[1])";t 0 $global:x $global:y}
">"{$z=&$u $c $f;$f,$n="$($z[0][2])","$($z[1])";t 1 $global:x $global:y}}})-join""

स्पष्टीकरण के साथ कम गोल्फ वाला कोड

# Recorded order of cube colours and their indexes
# Green=0,Red=1,Blue=2,Orange=3,White=4,Yellow=5
$o=[char[]]"grbowy"
[int]$c=4   # Ant is currently on this colour
[int]$global:x=1   # X coordinate on this face
[int]$global:y=1   # Y coordinate on this face
[int]$f=1   # Colour that the Ant is facing
[int]$n=5   # Colour beyond that the ant is facing.
# If the ant moves of this cube to the next this value becomes the one he is facing.
# It is also the only colour not neighboring this current colour.

# Anonymous function that will return the colour facing left and right
$u = {
# Cube relationships relative to position. Groups of 4 colours that are important given the order...
# Green=0-3,Red=4-7,Blue=8-11,Orange=12-15,White=16-19,Yellow=20-23
# Get the colours surrounding the current colour we are on and the surrounding ones
# String version: "owrygwbyrwoybwgygrbogrbo"
$c=$args[0]
#  "341504251435240501230123"
$1="341504251435240503210123".Substring($c*4,4)
# double the string so that we can get the characters before and after the facing colour reliably
# Assign the output to surpress a boolean. $2 is not used. Shorter than a cast
$2=$1*2-match".$($args[1]).";$3=$Matches[0]
# Return two values. First is the colours to the left,current and right as a string.
# Second is the colour beyond the one we are facing. If we were to move forward two blocks
# we would end up on this colour
"$3";"012345"-replace([char[]]"$1$c"-join"|")
}

# function that will transpose the ants position based on right/left rotation.
# Using current x and y determines what the tranposed values are and return them.
function t{
    param($o,$x,$y)
    # X = $1; Y = $2
    # Left 0 Right 1
    if($o){
        # Right Transpose
        # All values are hard coded to rotate to their new positions
        switch($y){
            0{switch($x){0{$x=2}1{$y=1;$x=2}2{$y=2}}}
            # 1,1 is in the center and nothing changes
            1{switch($x){0{$y=0;$x=1}2{$y=2;$x=1}}}
            2{switch($x){0{$x=0;$y=0}1{$x=0;$y=1}2{$x=0}}}
        }
    }else{
        # Left Transpose
        # All values are hard coded to rotate to their new positions
        switch($y){
            0{switch($x){0{$y=2}1{$x=0;$y=1}2{$x=0}}}
            # 1,1 is in the center and nothing changes
            1{switch($x){0{$y=2;$x=1}2{$y=0;$x=1}}}
            2{switch($x){0{$x=2}1{$x=2;$y=1}2{$y=0;$x=2}}}
        }

    }
    # Update global variables with the ones from this function
    $global:x=$x
    $global:y=$y
}

# Process each character passed by standard input
([char[]]$args[0]|%{
    switch($_){
        # Moving Forward
        '^'{
        $global:y++
        if($global:y-eq3){
            # We have walked of the colour onto the next one. Update coordinates to the next colour
            $global:y=0
            $c="$f"
            $f="$n"
            # Get the new neighboring colour indexes
            $z=&$u $c $f
            $f,$n="$($z[0][1])","$($z[1])"
        }  
        # Output the colour we have just moved to.
        $o[$c]
        }
        # Turn Left
        "<"{$z=&$u $c $f;$f,$n="$($z[0][0])","$($z[1])"
        # Transpose the ants location by passing current location to the transposition function.
        t 0 $global:x $global:y
        }
        # Turn Right
        ">"{$z=&$u $c $f;$f,$n="$($z[0][2])","$($z[1])"
        # Transpose the ants location by passing current location to the transposition function.
        t 1 $global:x $global:y
        }
    }
}) -join ""
# Line above converts the output to a single string. 

चींटी वर्तमान स्थिति (रंग, स्थिति और अभिविन्यास) को रिकॉर्ड करने के लिए उपयोग किए जाने वाले बहुत से एकल अक्षर चर का उपयोग करते हैं। चींटी हमेशा सामने आ रही है। जब एक घूर्णन निर्देश पढ़ा जाता है, तो क्यूब उस दिशा में स्थानांतरित हो जाता है। वर्तमान स्थिति के आधार पर नई स्थिति निर्धारित करने के लिए हार्डकैप्ड ट्रांसपोजिशन मेट्रिक्स का उपयोग किया जाता है।

कोड प्रश्न में सभी उदाहरणों को संतुष्ट करता है।


इसे और अधिक गढ़ा जा सकता है, लेकिन यह अब काम करता है इसलिए मुझे अब पुनरावृत्ति को दूर करने की कोशिश करनी होगी।
मैट

3

Tcl / Tk, 422 बाइट्स

rename split S
array se {} [S wyywroorgbbg {}]
proc R a {foreach x [lassign $a y] {lappend b $x}
lappend b $y}
proc < {V H} {set ::H $V
set ::V [lreverse [R $H]]}
proc > {V H} [string map {V H H V} [info b <]]
proc ^ {V H} {
lassign $V x
lassign [set ::V [R $V]] y
set ::H [string map "$x $y $::($x) $::($y)" $::H]
puts -nonewline $y}
set V [S wwrrryyyooow {}]
set H [S wwgggyyybbbw {}]
foreach p [S {*}$argv {}] {$p $V $H}

काश, मैं इसे कोई छोटा नहीं कर सकता। गैर-बाधित संस्करण:

array set opposites [split wyywroorgbbg {}]

proc lrotate xs {
  foreach x [lassign $xs y] {
    lappend ys $x
  }
  lappend ys $y
}

proc < {V H} {
  set ::H $V
  set ::V [lreverse [lrotate $H]]
}

proc > {V H} {
  set ::H [lreverse [lrotate $V]]
  set ::V $H
}

proc ^ {V H} {
  lassign $V x
  lassign [set ::V [lrotate $V]] y
  set ::H [string map [list $x $y $::opposites($x) $::opposites($y)] $::H]
  puts -nonewline $y
}

set V [split wwrrryyyooow {}]
set H [split wwgggyyybbbw {}]
foreach p [split {*}$argv {}] {$p $V $H}
puts {}

यह क्षैतिज और ऊर्ध्वाधर सेल रंगों की सूची को बनाए रखकर काम करता है। ^ <और> सभी कमांड हैं जो सूचियों को ठीक से अनुमति देते हैं। प्रत्येक सूची में वर्तमान सेल पहला है।


3

रूबी, 132

m=?w
g="bgoyr"
x=z=1
gets.bytes{|c|(m,g[2,3]=g[4],m+g[2,2]if(x+=1)%3<1
$><<m)if 93<c.upto(64){x,z,g=2-z,x,g[4]+g[2]+g[0]+g[3]+g[1]}}

यह स्थिति प्रणाली दु: खद रूप से अन्य उत्तरों के समान है। xऔर यात्रा की दिशा होने के zसाथ वर्तमान चेहरे पर अपनी स्थिति को ट्रैक करें +x। फॉरवर्ड हमेशा होता है x+=1, और प्रत्येक चेहरे की सीमा 3 से विभाज्य होती है (हम संख्या की परवाह नहीं करते हैं, बस 3 के साथ इसका मापांक)।

m वर्तमान चेहरा है (यह कुछ बाइट्स बचाता है)

gव्यवस्था की जाती है [left, right, behind, opposite, front]ताकि हम परिवर्तन की जरूरत नहीं है g[0..1]पर^

<केवल >तीन बार करके किया जाता है ।


2

जावा, 619 605 बाइट्स

खैर, यहाँ कुछ भी नहीं जाता है ...

कम से कम यह शक्तियों को हरा!

-14 बाइट्स @KevinCruijssen को धन्यवाद

String t(String f){int h[]={0,0,1},p[]={0,2,0},n[],i,s,r;String o="",d[]="w,g,r,b,o,y".split(",");for(char c:f.toCharArray()){r=r(p);n=h;if(c==94){s=3;for(i=0;i<3;i++)if(h[i]==p[i]&p[i]!=0){if(r==0)n[1]=-1;if(r==1)n[0]=1;if(r==2)n[2]=-1;if(r==3)n[0]=-1;if(r==4)n[2]=1;if(r==5)n[1]=1;s=i;break;}i=0;for(int a:n)p[i++]+=a;if(s<3)h[s]=0;o+=d[r(p)];}s=r>-1&r<2?2:r>2&r<5?1:0;i=r==3|r==5?2:r>0&r<3?1:0;r=h[s];if(c==62){if(r==0){h[s]=h[i];h[i]=0;}else{h[i]=-r;h[s]=0;}}if(c==60){if(r==0){h[s]=-h[i];h[i]=0;}else{h[i]=r;h[s]=0;}}}return o;}int r(int[] p){return p[0]>1?3:p[0]<-1?1:p[1]>1?0:p[1]<-1?5:p[2]>1?2:4;}

स्पष्टीकरण:

कुछ अन्य उत्तरों के विपरीत, जिसमें 2-डी समन्वय प्रणाली का उपयोग किया गया था, मैंने उस स्थान का ट्रैक रखने के लिए 3-डी प्रणाली का उपयोग किया था जहां चींटी थी।

स्विचिंग पक्षों और आंदोलन को सुविधाजनक बनाने के लिए दिशा को 3-डी फैशन में भी रखा गया था।

प्रत्येक चेहरे में एक निर्देशांक, x, y, या z में से एक था, जिसे यह अंकित करने के लिए 2 (या विपरीत चेहरे के लिए -2) पर सेट किया गया था।

स्विचिंग चेहरों को यह जाँच कर पूरा किया गया कि क्या चींटी हटने वाली है (स्थिति और शीर्ष का मान एक समान है, लेकिन 0 नहीं), सुनिश्चित करें कि यह अगले पर तिरछे "बंद" होगा, और शीर्ष को गैर में बदल देगा -diagonal। यह आश्चर्यजनक रूप से आसान था।

टर्न लेना ज्यादा मुश्किल था। यह सुनिश्चित करना कि यह हमेशा एक ही दिशा की आवश्यकता होगी यदि प्रत्येक चरित्र के लिए चेक के अंदर एक अतिरिक्त-और बयान की आवश्यकता होती है, तो मुझे कई बाइट्स की लागत होती है। इसके अलावा, "अप" और "राइट" कुल्हाड़ियों को प्रत्येक पक्ष के लिए कठोर-कोडित किया जाना था।

अघोषित कोड

(विधि में स्पष्टता के लिए पिछले संपादन से अपरिवर्तित)

private static String[] sides="w,g,r,b,o,y".split(",");
public static String traverse(String commands)
{
  int[] heading = {0,0,1};
  int[] pos = {0,2,0};
  int[] newheading;
  int i;
  int saved;
  String out = "";
  for(char command:commands.toCharArray())
  {
     if(command=='^')
     {
        newheading=heading;
        saved=3;
        for(i=0;i<3;i++)
        {
           if(heading[i]==pos[i]&pos[i]!=0)
           {
              saved=determineSide(pos);
              if(saved==0)newheading[1]=-1;
              if(saved==1)newheading[0]=1;
              if(saved==2)newheading[2]=-1;
              if(saved==3)newheading[0]=-1;
              if(saved==4)newheading[2]=1;
              if(saved==5)newheading[1]=1;
              saved=i;
              break;
           }
        }
        i=0;
        for(int c:newheading)
        {
           pos[i++]+=c;
        }
        if(saved<3)heading[saved]=0;
        out+=sides[determineSide(pos)];
     }
     newheading=getPlane(determineSide(pos));
     if(command=='>')
     {
        saved=heading[newheading[0]];
        if(saved==0)
        {
           heading[newheading[0]]=heading[newheading[1]];
           heading[newheading[1]]=0;
        }
        else
        {
           heading[newheading[1]]=-saved;
           heading[newheading[0]]=0;
        }
     }
     if(command=='<')
     {
        saved=heading[newheading[0]];
        if(saved==0)
        {
           heading[newheading[0]]=-heading[newheading[1]];
           heading[newheading[1]]=0;
        }
        else
        {
           heading[newheading[1]]=saved;
           heading[newheading[0]]=0;
        }
     }
  }
  return out;
}
public static int determineSide(int[] pos)
{
  return pos[0]==2?3:pos[0]==-2?1:pos[1]==2?0:pos[1]==-2?5:pos[2]==2?2:4;
}
public static int[] getPlane(int side)
{
  int[] out=new int[2];
  out[0]=side==0|side==1?2:side==3|side==4?1:0;
  out[1]=side==3|side==5?2:side==1|side==2?1:0;
  //side==0?{2,0}:side==1?{2,1}:side==2?{0,1}:side==3?{1,2}:side==4?{1,0}:{0,2};
  return out;
}

1
यह दर्द होता है .... मैं अब यह कोशिश करने और बाहर गोल्फ की प्रतिज्ञा करता हूं! :)
मैट

1
मुझे पता है कि यह एक साल पहले पोस्ट किया गया था, लेकिन गोल्फ के लिए कुछ छोटी चीजें हैं: d[]={"w","g","r","b","o","y"}-> "w,g,r,b,o,y".split(",")(-1 बाइट); 2x '^'-> 94(-2 बाइट्स); 3x ==0-> <1(-3 बाइट्स); 2x ==1-> <2(-2 बाइट्स); आदि के लिए ==2, ==3, ==4, ==5
केविन क्रूज़सेन

@KevinCruijssen सुझावों के लिए धन्यवाद!
ब्लू
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.