Fizz Buzz dla żółwi

35

opis problemu

Wyobraź sobie, że jesteś żółwiem na siatce. Otrzymałeś dwie liczby f i b , i patrzysz na wschód. Przeprowadzasz marsz przez siatkę, licząc każdą napotkaną komórkę, zgodnie z następującymi zasadami:

  • Domyślnie zapisujesz liczbę w komórce, w której się znajdujesz, a następnie idziesz naprzód.
  • Jeśli liczba jest podzielna przez f , piszesz Fdo komórki, w której się znajdujesz, następnie skręcasz w prawo, a następnie idziesz naprzód.
  • Jeśli liczba jest podzielna przez b , piszesz Bdo komórki jesteś w, a następnie skręcić w lewo, a następnie pieszo do przodu.
  • Jeśli liczba jest podzielna przez f i b , piszesz FBdo komórki, w której się znajdujesz, a następnie idziesz naprzód.
  • Jeśli dojdziesz do kwadratu, na którym już byłeś, przestajesz.

Na przykład przestrzeganie tych reguł przy użyciu f = 3 i b = 5 wygeneruje taki wzór:

    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

Wyzwanie

Napisać program lub funkcji, które przyjmuje dwa numery jako wejścia, odpowiadające F i B , i wytwarza na wyjściu wzorzec dla tych liczb podanych w powyższych zasad.

Wymagania dotyczące formatowania:

  • Każda komórka ma szerokość dwóch znaków
  • Zawartość komórki jest wyrównana do prawej w obrębie tych dwóch znaków
  • Komórki w tym samym rzędzie są oddzielone spacją
  • Pierwsza kolumna komórek musi zawierać niepustą komórkę
  • Wszystkie wiersze muszą zawierać niepuste komórki
  • Końcowe białe znaki nie są wymagane, ale dozwolone
  • Jednak całkowita szerokość każdego wiersza nie może przekraczać 3-krotności liczby niepustych kolumn

Twój kod musi działać dla podanych przypadków testowych.

Standardowe luki są niedozwolone.

To jest kod golfowy; najkrótsza odpowiedź w bajtach wygrywa.

Przypadki testowe

(f = 3, b = 5 przypadek powtórzony tutaj dla wygody grzecznościowej).

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 Walters
źródło
1
Czy mamy gwarancję, że dane wejściowe zawsze doprowadzą do kolizji, zanim dojdziemy do 100?
— Martin Ender,
Tak. Mówiąc bardziej ogólnie, dopóki twój kod działa dla dostarczonych przypadków testowych, możesz iść.
— H Walters,
1
Czy jest jakieś miejsce, w którym zaczynasz (żółw)?
— Kritixi Lithos
@KritixiLithos Nie. Lewą / górną / prawą / dolną część siatki określa sposób poruszania się żółwia, który zależy od f i b.
— H Walters,
Czy fib są zawsze liczbami całkowitymi?
— corvus_192,

Odpowiedzi:

1

JavaScript (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`
`

Mniej golfa

(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`
}

Test

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>
Rozwiń fragment kodu

— edc65
źródło
5

Python 2, 379 338 326 bajtów

Pobiera dane wejściowe jako dwie liczby, oddzielone przecinkiem. Na przykład. 4,5lub(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))

Wersja, która działa, jeśli ścieżka jest dłuższa niż 99, 384 343 330 bajtów

Pokazuje 2 cyfry znaczące.

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

Przykłady:

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) (wersja obcinana)

                                              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

@Edit: Podziękowania dla Jonathana Allana, Coppera i shooqie za zaoszczędzenie mi kilku bajtów.

— TFeld
źródło
Heh, te wzory N, 4N są całkiem fajne.
— steenbergh,
Dobra robota. Możesz zmienić while((x,y)not in p.keys()):na while(x,y)not in p:i for x,y in p.keys():na for x,y in p. Możesz zmienić l,r=i%b==0,i%f==0na l,r=i%b<1,i%f<1i d=(d+[0,1][r]-[0,1][l])%4na d=(d+r-l)%4. Możesz zmienić s=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2);p[(x,y)]=sna p[(x,y)]=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2). Może być więcej
— Jonathan Allan,
Możesz zapisać bajt za pomocą h*[' ']for x in rangezamiast [' ']*h for x in range. Ponadto x+=[-1,1][d==1]można go zastąpić x+=(d==1)*2-1i y+=[1,-1][d==2]można go zastąpić y+=(d!=2)*2-1. Czy f,b=inputttliterówka?
— Miedziany
p[(x,y)]=> p[x,y](nie jestem pewien, czy to działa w Pythonie 2)
— shooqie,
4

Excel VBA, 347 421 bajtów

Nowa wersja, aby sprostać wymaganiom dotyczącym białych znaków. Brak tego w mojej pierwszej wersji był niedopatrzeniem z mojej strony, ale odbija się to na liczbie bajtów ... Teraz odcina i wkleja używany zakres do komórki 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

Oto stara wersja, do której nie przeniesiono wyniku końcowego 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

Zaczyna się od 70, 70 (lub BR70 w Excelu) i obchodzi go. Funkcja jest wywoływana z parametrami fi bjako:Call t(4, 16)

@ Neil właśnie zapisał mi garść bajtów, dzięki!

— Steenbergh
źródło
1
Jeśli zastąpi q=q-1się q=q+3i Select Case qz Select Case q Mod 4czym można się pozbyć dwóch poprzednich wypowiedzi.
— Neil
However, the total width of each row must not exceed 3 times the number of non-empty columnsWydaje mi się, że zostało to dodane, aby uniknąć konfiguracji dużej siatki i zacząć nieco dalej od granicy
— Karl Napf
1
@KarlNapf Naprawiono.
— steenbergh
3

Excel VBA, 284 278 277 261 259 255 254 253 251 bajtów

Subrutynowe które ma jako wartości wejściowe, F, Ba wyjścia do komórek na Sheets(1)przedmiot (który jest ograniczony do Sheets(1)przedmiotu zaoszczędzić 2 bajty)

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

Stosowanie:

Call G(3, 4)
— Taylor Scott
źródło
2

C, 349 bajtów

Kompiluje z gcc (z dużą ilością ostrzeżeń)

#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]);}

Nieco bardziej wcięta wersja:

#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]);
}

Oto wersja 364 bajtów, która obsługuje liczby większe niż 100

#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);}
— Jerry Jeremiasz
źródło
1

Perl, 275 bajtów

W celu zapewnienia czytelności podano wcięcia i nie stanowi ono części kodu.

($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
}

Wyjaśnienie:

Kod działa poprzez śledzenie skrótu wszystkich miejsc, w których przebywał żółw, oraz zapisania odpowiedniej wartości %m. Na przykład: in 3 5, $m{0,2}zawiera 2i $m{1,-3}= 26. Kontynuuje się w ten sposób, aż dotrze do miejsca, które zostało już zdefiniowane. Dodatkowo śledzi bieżące granice ścieżki żółwia, wykorzystując $a,$b,$c,$djako maksima i minimum.

Kiedy dotrze do miejsca, w którym już był, drukuje ścieżkę, używając granic, wszystko wypełnione spacjami.

Nie ma ograniczeń co do wielkości ścieżki ani wielkości liczb.

— Gabriel Benamy
źródło
1

PHP , 292 bajtów

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);

Wypróbuj online!

Wcięcia są dla jasności, nie liczone.

Stosuje ten sam algorytm co odpowiedź Perla. Śledź, gdzie żółw był w układzie 2D, $aśledzi, gdzie żółw jest zwrócony, i $u, $d, $l, $rśledź granice drukowania. str_padpozwala nam upewnić się, że każdy wpis ma dokładnie 3 spacje dla formatowania wydruku.

Z jakiegoś powodu nie mogę pojąć, PHP nie przeszkadza mi, że nie inicjuję połowy zmiennych na 0, ale psuje formatowanie, jeśli nie inicjuję innych, chociaż zwykle traktuje niezainicjowane zmienne jako 0, gdy są one pierwsze używany. Stąd $x=$y=$u=$l=0trochę.

— Xanderhall
źródło
0

Python 2 , 267 262 258 249 245 243 bajtów

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

Wypróbuj online!

— Arfie
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.