거북이를위한 피즈 버즈

35

문제 설명

당신이 격자의 거북이라고 상상해보십시오. 두 개의 숫자 f 와 b 가 주어지고 동쪽을 향하고 있습니다. 다음 규칙에 따라 발생하는 각 셀을 계산하여 그리드에서 행진을 수행합니다.

  • 기본적으로 셀 수를 셀에 쓴 다음 앞으로 나아갑니다.
  • 카운트를 f 로 나눌 수있는 경우 들어 F있는 셀에 쓴 다음 오른쪽으로 돌고 앞으로갑니다.
  • 카운트를 b 로 나눌 수 있다면 현재 B있는 셀에 쓴 다음 왼쪽으로 돌고 앞으로갑니다.
  • 카운트를 f 와 b 로 나눌 수 있으면 현재 FB있는 셀에 쓴 다음 앞으로갑니다.
  • 이미 가본 사각형에 도달하면 중지합니다.

예를 들어, f = 3 및 b = 5를 사용하여 이러한 규칙을 따르면 다음과 같은 패턴이 생성됩니다.

    F 28 29 FB  1  2  F
   26                 4
 F  B                 B  F
23                       7
22                       8
 F  B                 B  F
   19                11
    F 17 16 FB 14 13  F

도전

f 와 b에 해당하는 두 숫자를 입력으로 받아들이고 위의 규칙에 따라 주어진 숫자에 대한 패턴을 출력 하는 프로그램이나 함수를 작성하십시오 .

포맷 요구 사항 :

  • 각 셀의 너비는 두 자입니다
  • 이 두 문자 내에서 셀 내용이 올바르게 정렬됩니다.
  • 같은 행의 셀은 공백으로 구분됩니다.
  • 셀의 첫 번째 열은 비어 있지 않은 셀을 포함해야합니다
  • 모든 행은 비어 있지 않은 셀을 포함해야합니다.
  • 후행 공백은 필요하지 않지만 허용됩니다.
  • 그러나 각 행의 총 너비는 비어 있지 않은 열 수의 3 배를 초과하지 않아야합니다.

제공된 테스트 사례에 대해 코드가 작동해야합니다.

표준 허점은 허용되지 않습니다.

이것은 코드 골프입니다. 바이트 단위의 최단 답변이 이깁니다.

테스트 사례

(여기서 편의상 f = 3, b = 5 사례를 반복 함).

f=3, b=5 ->
    F 28 29 FB  1  2  F
   26                 4
 F  B                 B  F
23                       7
22                       8
 F  B                 B  F
   19                11
    F 17 16 FB 14 13  F

f=4, b=10 ->
 F 25 26 27  F
23          29
22        1  2  3  F
21                 5
FB                 6
19                 7
18           B  9  F
17          11
 F 15 14 13  F

f=3, b=11 ->
 F 16 17  F
14       19
13     1  2  F
 F  B        4
   10        5
    F  8  7  F

f=5, b=9 ->
    F 41 42 43 44  1  2  3  4  F
   39                          6
   38                          7
   37                          8
 F  B                          B  F
34                               11
33                               12
32                               13
31                               14
 F 29 28  B              B 17 16  F
         26             19
          F 24 23 22 21  F

f=5, b=13 ->
    F 31 32 33 34  F
   29             36
   28        1  2  3  4  F
   27                    6
 F  B                    7
24                       8
23                       9
22              B 12 11  F
21             14
 F 19 18 17 16  F
code-golf  grid 
— H 월터스
소스
1
100에 도달하기 전에 입력이 항상 충돌로 이어질 것이라고 보장합니까?
— Martin Ender
예. 더 일반적으로, 제공된 테스트 케이스에서 코드가 작동하는 한 잘 진행됩니다.
— H Walters
1
당신이 (거북이) 시작하는 특정 장소가 있습니까?
— Kritixi Lithos
@KritixiLithos No. 그리드의 왼쪽 / 위쪽 / 오른쪽 / 아래쪽은 거북이의 이동 방식에 따라 정의되며 f와 b에 따라 다릅니다.
— H Walters
f와 b는 항상 정수입니까?
— corvus_192

답변:

1

자바 스크립트 (ES6), 230 (240)

(f,b)=>(d=>{for(g=[s=x=y=d];!(r=g[y]=g[y]||[])[x];d&1?d&2?y?--y:g=[,...g]:++y:d&2?x?--x:g=g.map(r=>[,...r]):++x)o=++s%f?'':(++d,'F'),s%b||(--d,o+='B'),r[x]=o||s})(0)||g.map(r=>[...r].map(c=>` ${c||' '}`.slice(-2)).join` `).join`
`

덜 골프

(f,b)=>{
  for(g=[s=x=y=d=0]; !(r = g[y]= g[y]||[])[x]; )
  {
    o=++s%f?'':(++d,'F')
    s%b||(--d,o+='B')
    r[x]=o||s,
    d&1
      ? d&2 ? y ? --y : g=[,...g] : ++y
      : d&2 ? x ? --x : g=g.map(r=>[,...r]) : ++x
  }
  return g.map(r=>[...r].map(c=>` ${c||' '}`.slice(-2)).join` `)
          .join`\n`
}

테스트

F=
(f,b)=>(d=>{for(g=[s=x=y=d];!(r=g[y]=g[y]||[])[x];d&1?d&2?y?--y:g=[,...g]:++y:d&2?x?--x:g=g.map(r=>[,...r]):++x)o=++s%f?'':(++d,'F'),s%b||(--d,o+='B'),r[x]=o||s})(0)||g.map(r=>[...r].map(c=>` ${c||' '}`.slice(-2)).join` `).join`
`


function update()
{
  var i = I.value.match(/\d+/g)||[],f=+i[0],b=+i[1]
  O.textContent = (f>0 & b>0) ? F(f,b) : ''
}  

update()
<input id=I value="3 5" oninput="update()">
<pre id=O></pre>
스 니펫 확장

— edc65
소스
5

파이썬 2, 379 338 326 바이트

쉼표로 구분 된 두 숫자로 입력을받습니다. 예 :4,5또는(4,5)

d=x=y=i=q=Q=e=E=0
p={}
f,b=input()
while(x,y)not in p:
 i+=1;l,r=i%b<1,i%f<1;d=(d+r-l)%4;p[x,y]=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2);q=min(q,x);Q=max(Q,x);e=min(e,y);E=max(E,y)
 if d%2:x+=(d==1)*2-1
 else:y+=(d!=2)*2-1
h,w=E-e+1,Q-q+1
A=[h*['  ']for x in' '*w]
for x,y in p:A[x-q][y-e]=p[x,y]
print'\n'.join(map(' '.join,A))

경로가 99보다 길면 작동하는 버전, 384 343 330 바이트

유효 숫자 2 자리를 표시합니다.

d=x=y=i=q=Q=e=E=0
p={}
f,b=input()
while(x,y)not in p:
 i+=1;l,r=i%b<1,i%f<1;d=(d+r-l)%4;p[x,y]=[[`i%100`,'F'][r],' F'[r]+'B'][l].rjust(2);q=min(q,x);Q=max(Q,x);e=min(e,y);E=max(E,y)
 if d%2:x+=(d==1)*2-1
 else:y+=(d!=2)*2-1
h,w=E-e+1,Q-q+1
A=[h*['  ']for x in' '*w]
for x,y in p:A[x-q][y-e]=p[x,y]
print'\n'.join(map(' '.join,A))

예 :

input=(4,16)

 F 21 22 23  F
19          25
18          26
17          27
FB  1  2  3  F
15           5
14           6
13           7
 F 11 10  9  F

input=(6,7) (절단 버전)

                                              F 63 64 65 66 67 FB  1  2  3  4  5  F                                             
                               F 57 58 59 60  B                                   B  8  9 10 11  F                              
                              55                                                                13                              
                   F 51 52 53  B                                                                 B 15 16 17  F                  
                  49                                                                                        19                  
                  48                                                                                        20                  
          F 45 46  B                                                                                         B 22 23  F         
         43                                                                                                          25         
         42                                                                                                          26         
         41                                                                                                          27         
    F 39  B                                                                                                           B 29  F   
   37                                                                                                                      31   
   36                                                                                                                      32   
   35                                                                                                                      33   
   34                                                                                                                      34   
 F  B                                                                                                                       B  F
31                                                                                                                            37
30                                                                                                                            38
29                                                                                                                            39
28                                                                                                                            40
27                                                                                                                            41
FB                                                                                                                            FB
25                                                                                                                            43
24                                                                                                                            44
23                                                                                                                            45
22                                                                                                                            46
21                                                                                                                            47
 F  B                                                                                                                       B  F
   18                                                                                                                      50   
   17                                                                                                                      51   
   16                                                                                                                      52   
   15                                                                                                                      53   
    F 13  B                                                                                                           B 55  F   
         11                                                                                                          57         
         10                                                                                                          58         
         09                                                                                                          59         
          F 07 06  B                                                                                         B 62 61  F         
                  04                                                                                        64                  
                  03                                                                                        65                  
                   F 01 00 99  B                                                                 B 69 68 67  F                  
                              97                                                                71                              
                               F 95 94 93 92  B                                   B 76 75 74 73  F                              
                                              F 89 88 87 86 85 FB 83 82 81 80 79  F

@ 편집 : 많은 바이트를 절약 해 준 Jonathan Allan, Copper 및 shooqie에게 감사드립니다.

— TFeld
소스
Heh, 그 N, 4N 패턴은 꽤 시원합니다.
— steenbergh
잘 했어. 당신은 변경할 수 있습니다 while((x,y)not in p.keys()):에 while(x,y)not in p:와 for x,y in p.keys():에 for x,y in p. 당신은 변경할 수 있습니다 l,r=i%b==0,i%f==0에 l,r=i%b<1,i%f<1와 d=(d+[0,1][r]-[0,1][l])%4에 d=(d+r-l)%4. 당신은 변경할 수 있습니다 s=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2);p[(x,y)]=s로 p[(x,y)]=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2). 더있을 수 있습니다
— Jonathan Allan
h*[' ']for x in range대신에 바이트를 저장할 수 있습니다 [' ']*h for x in range. 또한 x+=[-1,1][d==1]로 교체 x+=(d==1)*2-1하거나 y+=[1,-1][d==2]로 교체 할 수 있습니다 y+=(d!=2)*2-1. 또한 f,b=inputtt오타입니까?
— 구리
p[(x,y)]=> p[x,y](Python 2에서 작동하는지 확실하지 않음)
— shooqie
4

Excel VBA, 347 421 바이트

공백 요구 사항을 처리하기위한 새로운 버전. 내 첫 번째 버전에서 이것을 가지고 있지 않은 것은 내 부분에 대한 감독 이었지만 바이트 수에 많은 비용이 들었습니다 ... 이제 사용 된 범위를 잘라서 cell에 붙여 넣습니다 A1.

Sub t(f, b)
x=70:y=70:Do:s=s+ 1
If Cells(y,x).Value<>"" Then
ActiveSheet.UsedRange.Select:Selection.Cut:Range("A1").Select:ActiveSheet.Paste:Exit Sub
End If
If s Mod f=0 Then Cells(y,x).Value="F":q=q+1
If s Mod b=0 Then Cells(y,x).Value=Cells(y,x).Value & "B":q=q+3
If Cells(y,x).Value="" Then Cells(y,x).Value=s
Select Case q Mod 4
Case 0:x=x+1
Case 1:y=y+1
Case 2:x=x-1
Case 3:y=y-1
End Select:Loop:End Sub

최종 결과를 이전 버전으로 옮기지 않은 이전 버전은 다음과 같습니다. A1

Sub t(f,b)
x=70:y=70:Do:s=s+1:if Cells(y,x).Value<>"" then exit sub
If s Mod f=0 Then
Cells(y,x).Value="F":q=q+1
End If
If s Mod b=0 Then
Cells(y,x).Value=Cells(y,x).Value & "B":q=q+3
End If
If Cells(y,x).Value="" Then Cells(y,x).Value=s
Select Case q mod 4
Case 0:x=x+1
Case 1:y=y+1
Case 2:x=x-1
Case 3:y=y-1
End Select:Loop:End Sub

70, 70 (또는 Excel의 BR70)에서 시작하여 그 주위를 걷습니다. 함수는f및 b매개 변수로 .Call t(4, 16)

@ Neil은 방금 바이트를 절약했습니다. 감사합니다!

— 스티븐 버그
소스
1
당신이 교체하는 경우 q=q-1와 q=q+3와 Select Case q함께 Select Case q Mod 4당신은 앞의 두 문장의 제거 얻을 수 있습니다.
— Neil
However, the total width of each row must not exceed 3 times the number of non-empty columns난 그냥 큰 격자를 설정하고 국경에서 다소 떨어져 시작을 피하기 위해 추가 된 것 같아요
— Karl Napf
1
@KarlNapf 수정되었습니다.
— steenbergh
3

엑셀 VBA, 284 278 277 261 259 255 254 253 251 바이트

Sub값로서 입력 얻어 루틴 F, B온 셀 및 출력 Sheets(1)객체 (제한하는 Sheets(1)목적은 2 바이트를 저장)

Sub G(F,B)
Set A=Sheet1
R=99:C=R
Do
I=I+1
Y=Cells(R,C)
If Y<>""Then A.UsedRange.Cut:[A1].Select:A.Paste:End
If I Mod F=0Then Y="F":J=J+1
If I Mod B=0Then Y=Y+"B":J=J+3
Cells(R,C)=IIf(Y="",i,Y)
K=J Mod 4
If K Mod 2Then R=R-K+2 Else C=C+1-K
Loop
End Sub

용법:

Call G(3, 4)
— 테일러 스캇
소스
2

C, 349 바이트

gcc로 컴파일 (많은 경고와 함께)

#define z strcpy(G[x][y],
char G[99][99][3];d=3,x=49,y=49,i=1,q,s=99,t,u=99,v;F(f,b){for(;!*G[x][y];i++){q=(!(i%f))<<1|!(i%b);q==3&&z"FB");if(q==2)z"F"),d=(d+3)%4;if(q==1)z"B"),d=(d+1)%4;!q&&sprintf(G[x][y],"%d",i);if(d%2)x+=d-2;else y+=d-1;s=s>x?x:s;t=t<x?x:t;u=u>y?y:u;v=v<y?y:v;}for(y=u;y<=v;puts(""),y++)for(x=s;x<=t;x++)printf("%2s ",G[x][y]);}

약간 더 들여 쓰기 된 버전 :

#define z strcpy(G[x][y],
char G[99][99][3];
d=3,x=49,y=49,i=1,q,s=99,t,u=99,v;

F(f,b)
{
    for(;!*G[x][y];i++)
    {
        q=(!(i%f))<<1|!(i%b);
        q==3&&z"FB");
        if(q==2)z"F"),d=(d+3)%4;
        if(q==1)z"B"),d=(d+1)%4;
        !q&&sprintf(G[x][y],"%d",i);
        if(d%2)x+=d-2;else y+=d-1;
        s=s>x?x:s;t=t<x?x:t;u=u>y?y:u;v=v<y?y:v;
    }
    for(y=u;y<=v;puts(""),y++)for(x=s;x<=t;x++)printf("%2s ",G[x][y]);
}

다음은 100보다 큰 숫자를 처리하는 364 바이트 버전입니다.

#define g G[x][y]
#define z strcpy(g,
char G[99][99][9];d=3,x=49,y=49,i=1,q,s=99,t,u=99,v;F(f,b){for(;!*g;i++){q=(!(i%f))<<1|!(i%b);q==3&&z"FB");if(q==2)z" F"),d=(d+3)%4;if(q==1)z" B"),d=(d+1)%4;!q&&sprintf(G[x][y],"%2d",i);if(d%2)x+=d-2;else y+=d-1;s=s>x?x:s;t=t<x?x:t;u=u>y?y:u;v=v<y?y:v;}for(y=u;y<=v;puts(""),y++)for(x=s;x<=t;x++)printf("%2s ",g+strlen(g)-2);}
— 제리 예레미아
소스
1

펄, 275 바이트

들여 쓰기는 가독성을 위해 제공되며 코드의 일부가 아닙니다.

($f,$e)=@ARGV;
for($i=$x=1,$y=0;!$m{"$x,$y"};$i++){
    ($g,$m{"$x,$y"})=$i%$e&&$i%$f?($g,$i):$i%$f?($g+1,B):$i%$e?($g-1,F):($g,FB);
    ($g%=4)%2?($y+=$g-2):($x+=1-$g);
    ($a>$x?$a:$b<$x?$b:$x)=$x;
    ($c>$y?$c:$d<$y?$d:$y)=$y
}
for$k($c..$d){
    printf("%*s",1+length$i,$m{"$_,$k"})for$a..$b;
    say
}

설명:

이 코드는 거북이가 있었던 모든 장소의 해시와에 저장된 적절한 값을 추적하여 작동합니다 %m. 예를 들면 다음과 같습니다. in 3 5, $m{0,2}contains 2, and $m{1,-3}= 26. 이미 정의 된 장소에 도달 할 때까지이 방식으로 계속됩니다. 또한 거북이 경로의 현재 경계를 추적하여$a,$b,$c,$d 최대 및 최소로 .

그것이 이미 존재했던 장소에 도달하면, 공백으로 채워진 모든 경계를 사용하여 경로를 인쇄합니다.

경로의 크기 나 숫자의 크기에는 제한이 없습니다.

— 가브리엘 베 나미
소스
1

PHP , 292 바이트

for($x=$y=$u=$l=0;!$q[$x][$y];$s="") {
    ++$i%$argv[1]?:$a-=1+$s="F";
    $i%$argv[2]?:$a+=1+$s.="B";
    $q[$x][$y]=$s?:$i;
    $z=[1,-2,-1,2][$a=($a+4)%4];
    $y+=$z%2;
    $x+=~-$z%2;
    $u>$y?$u=$y:$d>$y?:$d=$y;
    $l>$x?$l=$x:$r>$x?:$r=$x;
}
for(;$l++<=$r;print"\n")for($j=$u-1;$j++<=$d;)echo str_pad($q[$l-1][$j],3," ",0);

온라인으로 사용해보십시오!

들여 쓰기는 명확성을위한 것이며 계산되지 않습니다.

Perl 답변과 거의 동일한 알고리즘을 따릅니다. 거북이가 2D 배열의 위치를 $a추적하고 거북이가 향하는 위치를 $u, $d, $l, $r추적하며 인쇄 경계를 추적합니다. str_pad인쇄 형식에 대해 각 항목의 너비가 정확히 3 칸인지 확인할 수 있습니다.

어떤 이유로 든 내가 이해할 수없는 이유는 PHP가 변수의 절반을 0으로 초기화하지는 않지만 다른 변수를 초기화하지 않으면 서식을 고정시키는 것입니다. 초기화되지 않은 변수는 처음에는 0으로 처리되지만 일반적으로 익숙한. 따라서 $x=$y=$u=$l=0비트.

— 젠더 홀
소스
0

파이썬 2 , 267 262 258 249 245 243 바이트

f,b=input()
X=x=Y=y=i=p=0
g={}
S=sorted
while(p in g)<1:i+=1;g[p]='F'[i%f:]+'B'[i%b:]or`i`;p+=1j**(i/f-i/b);X,_,x=S([X,x,int(p.real)]);Y,_,y=S([Y,y,int(p.imag)])
j=Y
while j<=y:print' '.join(g.get(i+j*1j,'').rjust(2)for i in range(X,x+1));j+=1

온라인으로 사용해보십시오!

— 아피
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.