আমার রুবিকের কিউবে একটি পিঁপড়া রয়েছে


44

একটি স্ট্যান্ডার্ড, সমাধান করা, 3 × 3 × 3 রুবিকের কিউবটিতে 6 টি ভিন্ন বর্ণের মুখ রয়েছে, যেখানে প্রতিটি মুখ একটি বর্ণের স্কোয়ারের 3 × 3 গ্রিড। সাদা মুখটি হলুদ রঙের, লাল বিপরীত কমলা, নীল বিপরীত সবুজ এবং সাদা উপরের দিকে উঠলে নীল বাম দিকে লাল হয়:

রুবিকের কিউব বিন্যাস

কল্পনা করুন একটি পিঁপড়া সাদা মুখের মুখের চত্বরে বসে আছে, লাল মুখের মুখোমুখি। আপনি তাকে 3 টি আদেশ দিতে পারেন:

  • ফরোয়ার্ড ( ^) - পরবর্তী গ্রিড স্কোয়ারের দিকে সে যে দিকে মুখ করে রয়েছে তার দিকে একটি পদক্ষেপ নিন, যদি প্রয়োজন হয় তবে ঘনক্ষেত্রের এক প্রান্তে পা বাড়ান।
  • ডান ( >) - একই গ্রিড স্কোয়ারে থাকা, 90 by দ্বারা ডানদিকে (ঘড়ির কাঁটার দিকে) ঘোরান।
  • বাম ( <) - একই গ্রিড স্কোয়ারে থাকা, 90 by দ্বারা বাম দিকে (ঘড়ির কাঁটার বিপরীতে) ঘোরান।

কমান্ডগুলির একটি স্বেচ্ছাসেবী তালিকা দেওয়া, পিঁপড়া পরিদর্শন করে এমন স্কোয়ারের রঙগুলি সন্ধান করুন (সাদা প্রারম্ভিক বর্গ সহ নয়)।

উদাহরণস্বরূপ, কমান্ড সিকোয়েন্সটির ^^>^^<^^^এমন একটি পথ রয়েছে যা দেখতে দেখতে এটি:

উদাহরণ পাথ

গ্রিড স্কোয়ারগুলির রঙগুলি পর্যায়ক্রমে পরিদর্শন করা হয়েছে, প্রারম্ভিক বর্গক্ষেত্র গণনা করছে না white red red green green green yellow, বা ঠিক wrrgggy

একটি প্রোগ্রাম বা ফাংশন লিখুন যা কমান্ডের অক্ষরগুলির <^>একটি স্ট্রিং wyrobgনেয় এবং কিউবের উপর পিঁপড়ার পথের সাথে মিলে যায় এমন অক্ষরের একটি স্ট্রিং (সাদা, হলুদ, লাল কমলা, নীল, সবুজ) মুদ্রণ করে বা প্রদান করে ।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী। টাইব্রেকার এর আগের উত্তর।

নোট

  • কিউবটি মাঝপথে রয়েছে এবং পিঁপড়ার কার্যকর পুলভিলি রয়েছে, তাই তিনি ঘনক্ষেত্রের পুরো অংশটি অতিক্রম করতে পারেন।
  • কিউব সর্বদা তার সমাধান অবস্থায় থাকে।
  • স্কোয়ারের রঙটি কেবল স্কোয়ারে চলাচলে রেকর্ড করা হয়, ঘোরানো নয়। শ্বেত বর্গক্ষেত্রটি রেকর্ড করা উচিত নয়।
  • ইনপুট এবং / অথবা আউটপুটে একটি একক alচ্ছিক ট্রেলিং নিউলাইন উপস্থিত থাকতে পারে।

পরীক্ষার মামলা

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


2
@ মার্টিনব্যাটনার পিঁপড়ার ছয়টি পা, কিউবগুলির ছয়টি দিক রয়েছে। <শুক্র> আমি ডুন্নো ...
ডিজিটাল ট্রমা

4
এটি কোনও স্টার্টার গল্ফিং চ্যালেঞ্জ নয় ..... আমি খুব কম কোডড নয় এমন একটি সমন্বয় ব্যবস্থা নিয়ে আমার মন হারাচ্ছি।
ম্যাট

2
@ ডিজিটাল ট্রামুমা এই চ্যালেঞ্জটি হেক্সাগনির উত্তরের জন্য চিৎকার করছে :-)
লুইস মেন্ডো

1
আপনার দেখা সবচেয়ে খারাপ পাওয়ারশেল কোডটির সাথে আমি এতটা ঘনিষ্ঠ।
ম্যাট

উত্তর:


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লাগানো যে পিপড়াটি সর্বদা মুখের কেন্দ্রস্থল সহ the ণাত্মক দিকে মুখ করে থাকে (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বিটটি হ'ল ভয়ঙ্কর ভাষার বৈশিষ্ট্যটির মতো দেখতে একটি আশ্চর্যজনক অপব্যবহার।
চার্লস

@ নোটহাট চার্লস হ্যাঁ, এটি দেখতে যতটা মন্দ তা দেখায়। গুরুতর পার্ল প্রোগ্রামগুলিতে আপনি প্রথমে যা করেন তা হ'ল বৈশিষ্ট্যটি ব্যবহার করে বন্ধ করা 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

সমতুল্য এসডাব্লুআই-প্রোলগ কোড

আপনি যদি ব্র্যাচল্যাগের সংকলকটি বিরক্ত করতে না চান তবে আপনি এই সমাধানটি নিম্নলিখিত কোডটি ব্যবহার করে এসডাব্লুআই-প্রোলোগে চালাতে পারেন (এটি ব্র্যাচলগের সংকলক দ্বারা উত্পন্ন হয়):

:- 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

টিসিএল / টাকা, 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 বাইটস @ কেভিন ক্রুজসেনকে ধন্যবাদ thanks

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
কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন টিপসটির জন্য আপনাকে ধন্যবাদ!
নীল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.