Fizz Buzz per le tartarughe

35

Descrizione del problema

Immagina di essere una tartaruga su una griglia. Si è dato due numeri f e B , e il gioco è rivolto verso est. Esegui una marcia attraverso la griglia, contando ciascuna delle celle che incontri, secondo le seguenti regole:

  • Per impostazione predefinita, scrivi il conteggio nella cella in cui ti trovi, quindi vai avanti.
  • Se il conteggio è divisibile per f , scrivi Fnella cella in cui ti trovi, quindi gira a destra, quindi cammina in avanti.
  • Se il conteggio è divisibile per b , scrivi Bnella cella in cui ti trovi, quindi gira a sinistra, quindi cammina in avanti.
  • Se il conteggio è divisibile per due F e B , si scrive FBalla cella si è in, poi a piedi in avanti.
  • Se raggiungi una piazza in cui sei già stato, ti fermi.

Ad esempio, seguendo queste regole usando f = 3 eb = 5 genererà un modello come questo:

    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

La sfida

Scrivi un programma o una funzione che accetta due numeri come input, corrispondenti a f e b , e produce come output il modello per questi numeri dato dalle regole precedenti.

Requisiti di formattazione:

  • Ogni cella è larga due caratteri
  • Il contenuto della cella è allineato a destra all'interno di questi due caratteri
  • Le celle nella stessa riga sono delimitate da uno spazio
  • La prima colonna di celle deve contenere una cella non vuota
  • Tutte le righe devono contenere celle non vuote
  • Gli spazi bianchi finali non sono richiesti, ma sono ammessi
  • Tuttavia, la larghezza totale di ogni riga non deve superare 3 volte il numero di colonne non vuote

Il codice deve funzionare per i casi di test forniti.

Le scappatoie standard non sono ammesse.

Questo è il codice golf; vince la risposta più breve in byte.

Casi test

(f = 3, b = 5 caso ripetuto qui per comodità di cortesia).

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
fonte
1
Abbiamo la garanzia che l'input porterà sempre a una collisione prima di arrivare a 100?
— Martin Ender,
Sì. Più in generale, fintanto che il codice funziona per i casi di test forniti, sei a posto.
— H Walters,
1
C'è un posto specifico in cui tu (la tartaruga) inizi?
— Kritixi Lithos,
@KritixiLithos No. Il lato sinistro / superiore / destro / inferiore della griglia è definito da come viaggia la tartaruga, che dipende da f e b.
— H Walters,
Feb sono sempre numeri interi?
— corvus_192,

Risposte:

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

Meno golf

(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>
Espandi frammento

— edc65
fonte
5

Python 2, 379 338 326 byte

Accetta input come due numeri, separati da una virgola. Per esempio. 4,5o(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))

Versione che funziona se il percorso è più lungo di 99, 384 343 330 byte

Mostra 2 cifre significative.

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

Esempi:

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) (versione troncata)

                                              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

@Modifica: grazie a Jonathan Allan, Copper e shooqie per avermi risparmiato un sacco di byte.

— TFeld
fonte
Heh, quei modelli N, 4N sono piuttosto belli.
— Steenbergh,
Buon lavoro. Puoi cambiare while((x,y)not in p.keys()):in while(x,y)not in p:e for x,y in p.keys():in for x,y in p. Puoi cambiare l,r=i%b==0,i%f==0in l,r=i%b<1,i%f<1e d=(d+[0,1][r]-[0,1][l])%4in d=(d+r-l)%4. Puoi cambiare s=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2);p[(x,y)]=sin p[(x,y)]=[[`i`,'F'][r],' F'[r]+'B'][l].rjust(2). Potrebbero essercene di più
— Jonathan Allan,
È possibile salvare un byte con h*[' ']for x in rangeinvece di [' ']*h for x in range. Inoltre, x+=[-1,1][d==1]può essere sostituito con x+=(d==1)*2-1e y+=[1,-1][d==2]può essere sostituito con y+=(d!=2)*2-1. Inoltre, è f,b=inputttun errore di battitura?
— Rame
p[(x,y)]=> p[x,y](non sono sicuro che funzioni in Python 2, comunque)
— shooqie
4

Excel VBA, 347 421 byte

Nuova versione, per gestire i requisiti degli spazi bianchi. Non avere questo nella mia prima versione è stata una svista da parte mia, ma questo ha un peso nel byte secondario ... Ora taglia e incolla la gamma usata su cella 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

Ecco la vecchia versione a cui non è stato spostato il risultato finale 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

Inizia a 70, 70 (o BR70 in Excel) e lo circonda. La funzione viene chiamata con i parametri fe bcome:Call t(4, 16)

@Neil mi ha appena salvato un mucchio di byte, grazie!

— steenbergh
fonte
1
Se si sostituisce q=q-1con q=q+3e Select Case qcon, Select Case q Mod 4è possibile eliminare le due dichiarazioni precedenti.
— Neil,
However, the total width of each row must not exceed 3 times the number of non-empty columnsImmagino che questo sia stato aggiunto per evitare di impostare solo una grande griglia e iniziare un po 'lontano dal confine
— Karl Napf,
1
@KarlNapf Risolto.
— Steenbergh,
3

Excel VBA, 284 278 277 261 259 255 254 253 251 byte

Subroutine che riceve l'input come valori, F, Be uscite per le cellule sul Sheets(1)oggetto (che è limitato alla Sheets(1)oggetto da salvare 2 byte)

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

Uso:

Call G(3, 4)
— Taylor Scott
fonte
2

C, 349 byte

Compila con gcc (con molti avvisi)

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

Una versione leggermente più rientrata:

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

Ecco una versione di 364 byte che gestisce numeri maggiori di 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 Jeremiah
fonte
1

Perl, 275 byte

Il rientro viene fornito per essere leggibile e non fa parte del codice.

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

Spiegazione:

Il codice funziona tenendo traccia di un hash di tutti i luoghi in cui la tartaruga è stata e il valore appropriato, memorizzato %m. Ad esempio: in 3 5, $m{0,2}contiene 2e $m{1,-3}= 26. Continua in questo modo fino a raggiungere un luogo che è già stato definito. Inoltre, tiene traccia degli attuali confini del percorso della tartaruga, usando $a,$b,$c,$dcome massimi e minimi.

Una volta raggiunto un posto in cui è già stato, stampa il percorso usando i confini, tutto imbottito di spazi.

Non vi è alcun limite alla dimensione del percorso, né alla dimensione dei numeri.

— Gabriel Benamy
fonte
1

PHP , 292 byte

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

Provalo online!

I rientri sono per chiarezza, non conteggiati.

Segue più o meno lo stesso algoritmo della risposta Perl. Traccia dove si trova la tartaruga in un array 2D, $atraccia dove la tartaruga si trova di fronte e $u, $d, $l, $rtraccia i confini per la stampa. str_padci consente di garantire che ogni voce abbia esattamente 3 spazi di larghezza per la formattazione della stampa.

Per qualche motivo che non riesco a capire, a PHP non importa che non inizializzi la metà delle variabili su 0, ma rovina la formattazione se non ne inizializzo altre, anche se di solito tratta le variabili non inizializzate come 0 quando sono le prime Usato. Da qui il $x=$y=$u=$l=0po '.

— Xanderhall
fonte
0

Pitone 2 , 267 262 258 249 245 243 byte

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

Provalo online!

— Arfie
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.