Vẽ đường đi của kiến Langton .

Sự miêu tả

Hình vuông trên một mặt phẳng được tô màu khác nhau hoặc đen hoặc trắng. Chúng tôi tùy ý xác định một hình vuông là "con kiến". Con kiến ​​có thể di chuyển theo bất kỳ hướng nào trong bốn hướng hồng y ở mỗi bước cần thiết. Con kiến ​​di chuyển theo các quy tắc dưới đây:

• Tại hình vuông màu trắng, xoay phải 90 °, lật màu của hình vuông, di chuyển về phía trước một đơn vị
• Tại hình vuông màu đen, xoay trái 90 °, lật màu của hình vuông, di chuyển về phía trước một đơn vị

Thông số kỹ thuật

• Đầu vào: một số nguyên N nằm trong khoảng từ 0 đến 725 (đã bao gồm).
• Đầu ra: một lưới 17 x 17 đại diện cho "đường dẫn" của con kiến ​​như bước N.

Quy tắc

• Con kiến ​​bắt đầu quay mặt sang phải (đồng hồ 3 giờ).
• Con kiến ​​bắt đầu ở trung tâm của lưới điện.
• Sử dụng _#@cho hình vuông màu trắng, hình vuông màu đen và con kiến ​​tương ứng.
• Lưới ban đầu hoàn toàn trắng.
• Bạn có thể tạo một chương trình hoàn chỉnh hoặc một chức năng trên một ngôn ngữ được diễn giải.
• Nhập bằng stdin hoặc đối số.

Ví dụ

Cập nhật: trường hợp đầu ra N = 450 bị sai.

N = 0

_________________
_________________
_________________
_________________
_________________
_________________
_________________
_________________
________@________
_________________
_________________
_________________
_________________
_________________
_________________
_________________
_________________

N = 1

_________________
_________________
_________________
_________________
_________________
_________________
_________________
_________________
________#________
________@________
_________________
_________________
_________________
_________________
_________________
_________________
_________________

N = 450

_________________
_________________
___________##____
____##______##___
___#__##___##_#__
__###_#@#__#__#__
__#_#_#_#__#_#___
_____###___#_____
_____#___________
_____#__###______
___#_#_#__#_#_#__
__#__#_#____###__
__#_##__##___#___
___##______##____
____##___________
_________________
_________________

GolfScript - 67 ký tự

~17.'_'*n+*\153:|;{|/()[124^.2/6+:6.1&17*)\2&(*|+:|;]@++}*|/();'@'@

Giải pháp Python của hallvabo tương tự như thế này, vì vậy tôi sẽ chỉ mô tả những khác biệt chính.

Bảng được lưu trữ dưới dạng một chuỗi thay vì một mảng. Điều này là để chúng ta có thể cập nhật một giá trị trên bảng với ít ký tự hơn (vì các chuỗi luôn luôn phẳng) và do đó, việc đưa nó đến định dạng đầu ra mong muốn là dễ dàng.

Vị trí con kiến ​​được tăng theo công thức ((d&1)*17+1)*((d&2)-1)(nghĩa là .1&17*)\2&(*), trong đó d là hướng. Chúng tôi sử dụng biến 6để chúng tôi có thể bỏ qua việc khởi tạo.

Ruby 1.9, 104 ký tự

f=->z{l=[*[r=1]*17,2]*17;c=152;z.times{c+=r=(r*r>1?r/18:-r*18)*l[c]*=-1};l[c]=0;l.map{|a|putc"@_
#"[a]}}

Nhập thông qua đối số chức năng.

• (146 -> 142) Nội tuyến m
• (142 -> 140) Kiểm tra r*r>1thay vìr.abs>1
• (142 -> 128) Sử dụng String#scanđể tạo đầu ra. Thay đổi ==để>
• (128 -> 125) Đã xóa biến lỗi thời
• (125 -> 122) Thay thế String#trbằng một điều kiện
• (122 -> 122) Bây giờ tạo cùng một đầu ra như các ví dụ được cập nhật
• (122 -> 111) Sử dụng số nguyên thay vì ký tự khi tạo đường dẫn của kiến.
• (111 -> 109) Sắp xếp lại một số biểu thức để lưu dấu ngoặc đơn
• (109 -> 108) Mã hiện là một hàm
• (108 -> 104) In từng ký tự

Con trăn, 123

n = đầu vào ()
d = x = 152
g = (17 * [95] + [10]) * 17
trong khi n: d + = g [x] / 2; g [x] ^ = 124; x + = (1, -18, -1,18) [d% 4]; n- = 1
g [x] = 64
in "% c" * 306% tuple (g)

Chỉ cần làm lại một chút về giải pháp Python của tôi từ http://golf.shinh.org/p.rb?Langtons+Ant .

GolfScript 96 94 89

Ngôn ngữ ghét yêu thích của tôi đã trở lại với một loạt các loại sắp xếp có thể đọc được.

Phiên bản 89, cuối cùng tôi đã quản lý để tích hợp @ vào vòng lặp đầu ra.

~289[0:c]*145:b;{.b>\b<)!..c++(4%:c[1 17-1-17]=b+:b;@++}@*{{(b(:b!.++'_#@@'1/=\}17*n\}17*

Phiên bản 94:

~306[0:c]*152:b;{.b<\b>(!..c++(4%:c[1 18-1-18]=b+:b;\++}@*{{('_#'1/=\}17*(;n\}17*].b<\b>(;'@'\

Đã bình luận:

               #Initialization.
~                  #Parse input.
306[0:c]*          #Make array of 306 0s, set c to 0 in the middle of that operation.
152:b;             #Set b to 152, remove 152 from the stack.
                   #b is a value for the ant's position, c for its rotation.

               #Run the algorithm.
{                  #Start of block.
    .b<\b>(        #Split the array at index b into before, after and value at b.
    !..            #Not the value and make 2 copies of it.
    c++            #Add the 2 copies to c.
    (4%:c          #Subtract 1, modulus by 4 and save the result to c.
    [1 18-1-18]=   #Define an array and take element number c.
    b+:b;          #Add b to the value, save result to b, remove result from stack.
    \++            #Reform the array.
}@*                #Switch the input to the top of the stack and run the block input times.

               #Convert array of 1s and 0s to the correct characters.
{                  #Start of block.
    {              #Start of block.
        ('_#'1/=   #Take the first array element, convert it to either '_' or '#'.
        \          #Switch the array to the top of the stack.
    }17*           #Execute block 17 times.
    (;n\           #Discard the 18th element of the line, write a lineshift.
}17*               #Execute block 17 times.

               #Insert the @.
]                  #Put everything in an array.
.b<\b>(            #Split the array at index b into before, after and value at b.
;'@'\              #Ditch the value at b, write a @ and shift it into place.

Chỉnh sửa, tôi cũng có thể tạo một phiên bản lớn, ở đây có các lần lặp 59 * 59 và 10500:

~59:a.*[0:c]*1741:b;{.b>\b<)!..c++(4%:c[1 a-1-59]=b+:b;@++}@*{{(b(:b!.++'_#@@'1/=\}a*n\}a*

.

___________________________________________________________
___________________________________________________________
_________________________##__##____________________________
________________________#__@_###___________________________
_______________________###__#_#_#__________________________
_______________________#####_#__##_________________________
________________________#___##_##_#________________________
_________________________###___#__##_______________________
__________________________#___##_##_#______________________
___________________________###___#__##_____________________
____________________________#___##_##_#__##________________
_____________________________###___#__##__##_______________
______________________________#___##_##__##___#____________
________________________####___###___#___#__###____________
_______________________#____#___#___##_####___#____________
______________________###____#___#_#______#_##_#___________
______________________###____#_##_____#_##__#_##___________
_______________________#____#___##_#_#_____##______________
_______________________#_#______#_#####__#___#_____________
______________________#___#####__________##_######_________
______________________###__##__#_##_#_#_#___##_#_##________
____________________##__#_#######_#___#__###____##_#_______
___________________#__#__######_##___#__#_##___#___#_______
__________________#____#_#_##_#__######_#######___#________
__________________#_####_##_#_####____##__##_#_##_#________
___________________#____####___#__#_######_##____###_______
______________________#___#_##_#_###_#__##__##___###_______
_________________________#######____#__##_##_#_____#_______
_________________####__##_##__####_##_##_##__#_____#_______
________________#____#_#___###_##_###____#_####____#_______
_______________###_______###_#_#_#####____#_#______#_______
_______________#_#___###_####_##_#___##_###_##_____#_______
_____________________##_##__####____####_#_#_#_____#_______
________________#____#__##___###__###_____###______#_______
________________##___##_###_####__#______###___##__#_______
________________##_#_####_____#___#__#_##_###_##___#_______
_______________####_##___##_####__#_#__#__#__###___#_______
_______________#_##_###__#_#_##_#_#_____#_#_____#_#________
___________________#_#__#____##_##__#_#__###_##____________
___________________##_#____#__#####_#____#____#__#_#_______
__________________#_##_#__#____##_##_#__###______###_______
________________#_#___#__#__#__#__###___##__##____#________
_______________###_#_#####_######_###_#######_#_##_________
_______________#_#_#____#####___##__#####_#####____________
_________________#__##___#______#__#_##__###_###___________
______________####___#####_#########___#_#_________________
_________##____#__#_____###_#_#___#_###__###_______________
________#__#__####_##___###_##___###_##_____##_____________
_______###____#_##_#_#####___#____#__#__##_###_____________
_______#_#####_#_#___##__##_____#____#___#__#______________
___________######_####__##_#___#__##__#_#_##_______________
_________##______#_###_##__####___#___###__________________
__________#__#_#####__#___#_##___#__#__#___________________
__________##_###_#######_____#_____#_##____________________
_________#_#__##_##______#___##____#_______________________
________#__#_####________###__##__#________________________
________#_##_###____________##__##_________________________
_________##________________________________________________
__________##_______________________________________________

Windows PowerShell, 119 118

for($p,$n,$g=144,+"$args"+,1*289;$n--){$d+=$g[$p]*=-1
$p+='B0@R'[$d%4]-65}$g[$p]=0
-join'@_#'[$g]-replace'.{17}',"$&
"

PHP, 350 309 307 312 174 161 166 159 151 149 147 144 143

<?$p=144;while($i=$argv[1]--){$g[$p]=$a=2-$g[$p];$d+=--$a;$p+=(1-($d&2))*(1+16*($d&1));}while($i++<288)echo$i%17?$i!=$p?$g[$i]?"#": _:"@":"\n";

Bị đánh cắp

$p = 144; // Set initial pointer

while($i = $argv[1]--){ // Ends at -1
    $g[$p] = $a = 2 - $g[$p]; // Either returns true (2) or false(0)

    $d += --$a; // Adds 1 (2-1) or removes 1 (0-1) from the direction

    $p += (1 - ($d & 2)) * (1 + 16 * ($d & 1));
}

while($i++ < 288)
    echo $i % 17? $i != $p? $g[$i]? "#" : @_ : "@" : "\n"; // Prints the correct character

350 -> 309: Các kỹ thuật nén khác nhau với các vòng lặp for (), cũng được cập nhật để hiển thị đầu ra chính xác.
309 -> 307: Chuyển đổi vòng lặp main cho () thành vòng lặp while ().
307 -> 312: Quên thay đổi nó để sử dụng argv.
312 -> 174: Được mã hóa lại dựa trên câu trả lời khác.
174 -> 161: Không còn mặc định toàn bộ mảng.
161 -> 166: Argv thắng lại.
166 -> 159: Không cần xác định lại argv [1].
159 -> 151: Không còn mặc định bất cứ điều gì, PHP tự động thực hiện.
151 -> 149: Đã xóa một bộ dấu ngoặc đơn, thứ tự các thao tác loại bỏ nhu cầu.
149 -> 147: Rút ngắn vòng lặp for () cuối cùng, không cần niềng răng.
147 -> 144:Vòng lặp for () cuối cùng bây giờ là vòng lặp while ().
144 -> 143: Được sử dụng một biến tạm thời để lưu một ký tự.

C, 166 162

Đây là bản dịch của phương pháp Delphi của tôi sang C, cho thấy C có thể nhỏ gọn như thế nào. Tôi đã mượn thủ thuật dòng mới có điều kiện từ fR0DDY (cảm ơn bạn đời!):

g[289]={0},a=144,d,i,N;main(){scanf("%d",&N);while(N--)g[a]=2-g[a],d+=g[a]-1,a+=(1-(d&2))*(1+d%2*16);for(g[a]=1;i<289;)printf("%s%c",i++%17?"":"\n","_@#"[g[i]]);}

Phiên bản nhận xét, thụt lề trông như thế này:

g[289]={0}, // g: The grid is initially completely white. (size=17*17=289)
a=144, // a: Ant position starts at the center of the grid (=8*17+8=144)
d, // Assume 0=d: Ant start 'd'irection faces right (=0, see below)
i,
N;
main(){
  scanf("%d",&N);
  while(N--)
    // Flip the color of the square:
    g[a]=2-g[a],
    // Turn 90° right if at an '_' space, 90° left otherwise :
    d+=g[a]-1,
    // Move one unit forward;
    //   For this, determine the step size, using the two least significant bits of d.
    //   This gives the following relation :
    //     00 = 0 =  90° = right =   1
    //     01 = 1 = 180° = down  =  17
    //     10 = 2 = 270° = left  = - 1
    //     11 = 3 =   0° = up    = -17
    //   (d and 2) gives 0 or 2, translate that to 1 or -1
    //   (d and 1) gives 0 or 1, translate that to 1 or 17
    //   Multiply the two to get an offset 1, 17, -1 or -17 :
    a+=(1-(d&2))*(1+d%2*16);
  // Place the ant and print the grid :
  for(g[a]=1;i<289;)
    printf("%s%c",i++%17?"":"\n","_@#"[g[i]]); // 0 > '_', 1='@', 2 > '#'
}

Delphi, 217

var g,a:PByte;i,d,Word;begin g:=AllocMem(306);a:=g+153;Read(i);for n:=1to i do begin a^:=2-a^;d:=d-1+a^;a:=a+(1-2and d)*(1+17*(1and d))end;a^:=1;for n:=1to 306do if n mod 18=0then WriteLn else Write('_@#'[1+g[n]])end.

Mã thụt lề và nhận xét đọc như thế này:

var
  g,a:PByte;
  i,d,n:Int32;
begin
  g:=AllocMem(306); // g: The grid is initially completely white. (size=18*17=306)
  // Assume 0=d: Ant start 'd'irection faces right (=0, see below)
  a:=g+153; // a: Ant position starts at the center of the grid (=8*18+9=153)
  Read(i);
  for n:=1to i do
  begin
    // Flip the color of the square;
    a^:=2-a^;
    // Turn 90° right if at an '_' space, 90° left otherwise;
    d:=d-1+a^;
    // Move one unit forward;
    //   For this, determine the step size, using the two least significant bits of d.
    //   This gives the following relation :
    //     00 = 0 =  90° = right =   1
    //     01 = 1 = 180° = down  =  18
    //     10 = 2 = 270° = left  = - 1
    //     11 = 3 =   0° = up    = -18
    //   (d and 2) gives 0 or 2, translate that to 1 or -1
    //   (d and 1) gives 0 or 1, translate that to 1 or 18
    //   Multiply the two to get an offset 1, 18, -1 or -18 :
    a:=a+(1-2and d)*(1+17*(1and d))
  end;
  // Place the ant and print the grid :
  a^:=1; // 0 > '_', 1='@', 2 > '#'
  for i:=1to 306do
    if i mod 18=0then // we insert & abuse column 0 for newlines only (saves a begin+end pair)
      WriteLn
    else
      Write('_@#'[1+g[i]])
end.

Đầu vào:

450

Đầu ra:

_________________
_________________
___________##____
____##______##___
___#__##___##_#__
__###_#@#__#__#__
__#_#_#_#__#_#___
_____###___#_____
_____#___________
_____#__###______
___#_#_#__#_#_#__
__#__#_#____###__
__#_##__##___#___
___##______##____
____##___________
_________________
_________________

C 195 ký tự

x=144,T,p=1,i,N[289]={0},a[]={-17,1,17,-1};c(t){p=(p+t+4)%4;x+=a[p];}main(){scanf("%d",&T);while(T--)N[x]=(N[x]+1)%2,c(N[x]?1:-1);for(;i<289;i++)printf("%s%c",i%17?"":"\n",i-x?N[i]?'#':'_':'@');}

http://www.ideone.com/Dw3xW

Tôi nhận được điều này cho 725.

_________________
_________________
___________##____
____##______##___
___#___##__##_#__
__###____#_#__#__
__#_#_#__#_#_#___
______###____#__@
_______###__#__#_
_____#_#____#___#
___#_#_#_##____#_
__#__#_#_#_#_###_
__#_##_#_____####
___##_#____#_####
____###___####_#_
_______#__#__##__
________####_____

sed, 480 ký tự

#n
1{s/.*/_________________/;h;H;H;H;G;G;G;G;s/^\(.\{152\}\)_/\1@/;s/$/;r/;ta;};x;:a;/;r/br;/;d/bd;/;l/bl;/;u/bu;:w;y/rdlu/dlur/;bz;:b;y/rdlu/urdl/;bz;:r;s/@\(.\{17\}\)_/#\1@/;tw;s/@\(.\{17\}\)#/#\1!/;tw;s/_\(.\{17\}\)!/@\1_/;tb;s/#\(.\{17\}\)!/!\1_/;tb;:d;s/_@/@#/;tw;s/#@/!#/;tw;s/!_/_@/;tb;s/!#/_!/;tb;:l;s/_\(.\{17\}\)@/@\1#/;tw;s/#\(.\{17\}\)@/!\1#/;tw;s/!\(.\{17\}\)_/_\1@/;tb;s/!\(.\{17\}\)#/_\1!/;tb;:u;s/@_/#@/;tw;s/@#/#!/;tw;s/_!/@_/;tb;s/#!/!_/;tb;:z;h;${s/!/@/;s/;.//p}

Có thể giảm xuống 478 ký tự bằng cách xóa dòng đầu tiên và chạy với -n

Yêu cầu N dòng cho đầu vào, ví dụ. khi chạy như

seq 450 | sed -f ant.sed

đầu ra:

_________________
_________________
___________##____
____##______##___
___#__##___##_#__
__###_#@#__#__#__
__#_#_#_#__#_#___
_____###___#_____
_____#___________
_____#__###______
___#_#_#__#_#_#__
__#__#_#____###__
__#_##__##___#___
___##______##____
____##___________
_________________
_________________

Perl, 110 ký tự

$p=144;$p+=(1,-17,-1,17)[($d+=($f[$p]^=2)+1)%4]for 1..<>;$f[$p]=1;print$_%17?'':$/,qw(_ @ #)[$f[$_]]for 0..288

Số được đọc từ dòng đầu tiên của STDIN. Phần còn lại của đầu vào được bỏ qua.

Hơi dễ đọc hơn:

$p=144;
$p += (1,-17,-1,17)[($d+=($f[$p]^=2)+1) % 4] for 1..<>;
$f[$p]=1;
print $_%17 ? '' : $/, qw(_ @ #)[$f[$_]] for 0..288

Chỉnh sửa

• (112 → 111) Không cần cập nhật $dvới giá trị modulo-4.

• (111 → 110) Bây giờ có thể nội tuyến $dtăng

Phụ lục (109 ký tự)

Chúng ta có thể rút ngắn một ký tự nếu bạn vui khi gặp trường hợp đặc biệt N=0thất bại (nó không tạo ra @ký tự cho con kiến). Tất cả các đầu vào khác hoạt động chính xác:

$p+=(1,-17,-1,17)[($d+=($f{$p+0}^=2)+1)%4]for 1..<>;$f{$p}=1;print$_%17-9?'':$/,qw(_ @ #)[$f{$_}]for-144..144

Sự khác biệt là bây giờ chúng ta sử dụng %fthay vì @fvậy chúng ta có thể sử dụng các chỉ số tiêu cực và chúng ta lặp lại từ -144..144thay vì 0..288. Nó tiết kiệm phải khởi tạo $p.

Toán học, 94 ký tự

a@_=d=1;a@Nest[#+(d*=(a@#*=-1)I)&,9-9I,Input[]]=0;Grid@Array["@"[_,"#"][[a[#2-# I]]]&,17{1,1}]

> <>, 122 byte

Có nguy cơ bị hoại tử sợi nhỏ, tôi nghĩ viết một câu trả lời trong> <> sẽ là một thử thách thú vị ...

1&f8r\
1-:?!\r:@@:@$:@@:@g:2*1+&+4%:&}1$-@p{:3$-5gaa*-$@+@5gaa*-+r
2}p70\~
a7+=?\:@@:@g4+5go$1+:
o053.>~1+:64*=?;a
dedc_#@

Chương trình này hy vọng số lượng các bước tính toán sẽ có mặt trên ngăn xếp trước khi thực hiện.