Problembeschreibung

Stellen Sie sich vor, Sie sind eine Schildkröte auf einem Gitter. Du erhältst zwei Zahlen f und b und siehst nach Osten. Sie marschieren über das Raster und zählen dabei jede Zelle, auf die Sie stoßen, gemäß den folgenden Regeln:

• Standardmäßig schreiben Sie die Zählung in die Zelle, in der Sie sich befinden, und gehen dann vorwärts.
• Wenn die Zählung durch f teilbar ist , schreiben Sie Fin die Zelle , in der Sie sich befinden, biegen nach rechts ab und gehen vorwärts.
• Wenn die Zählung durch b teilbar ist , schreiben Sie Bin die Zelle , in der Sie sich befinden, biegen links ab und gehen vorwärts.
• Wenn die Zählung sowohl durch f als auch durch b teilbar ist , schreiben Sie FBin die Zelle , in der Sie sich befinden, und gehen vorwärts.
• Wenn du einen Platz erreichst, auf dem du schon warst, hörst du auf.

Wenn Sie beispielsweise diese Regeln mit f = 3 und b = 5 befolgen, wird ein Muster wie das folgende generiert:

    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

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die zwei Zahlen als Eingabe akzeptiert, die f und b entsprechen , und als Ausgabe das Muster für diese Zahlen erzeugt, das durch die obigen Regeln gegeben ist.

Formatierungsanforderungen:

• Jede Zelle ist zwei Zeichen breit
• Der Zelleninhalt wird innerhalb dieser beiden Zeichen rechtsbündig ausgerichtet
• Zellen in derselben Zeile werden durch ein Leerzeichen begrenzt
• Die erste Spalte der Zellen muss eine nicht leere Zelle enthalten
• Alle Zeilen müssen nicht leere Zellen enthalten
• Ein nachgestelltes Leerzeichen ist nicht erforderlich, aber zulässig
• Die Gesamtbreite jeder Zeile darf jedoch das Dreifache der Anzahl nicht leerer Spalten nicht überschreiten

Ihr Code muss für bereitgestellte Testfälle funktionieren.

Standardlücken sind nicht zulässig.

Das ist Code Golf; kürzeste Antwort in Bytes gewinnt.

Testfälle

(f = 3, b = 5 Fall hier aus Höflichkeitsgründen wiederholt).

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

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

Weniger golfen

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

Prüfung

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>

Python 2, 379 338 326 Bytes

Nimmt die Eingabe als zwei durch Komma getrennte Zahlen an. Z.B. 4,5oder(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))

Version, die funktioniert, wenn der Pfad länger als 99, 384, 343, 330 Bytes ist

Zeigt 2 signifikante Ziffern an.

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

Beispiele:

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) (abgeschnittene Version)

                                              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: Vielen Dank an Jonathan Allan, Copper und shooqie, die mir ein paar Bytes gespart haben.

Excel VBA, 347 421 Bytes

Neue Version, um den Whitespace-Anforderungen gerecht zu werden. Das in meiner ersten Version nicht zu haben, war ein Versehen in meinem Teil, aber das fordert seinen Tribut im bytecount ... Es schneidet jetzt den verwendeten Bereich ab und fügt ihn in die Zelle ein 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

Hier ist die alte Version, in die das Endergebnis nicht verschoben wurde 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

Beginnt bei 70, 70 (oder BR70 in Excel) und geht darum herum. Die Funktion wird mit den Parametern fund aufgerufen b:Call t(4, 16)

@Neil hat mir gerade ein paar Bytes gerettet, danke!

Excel VBA, _{284 278 277 261 259 255 254 253} 251 Bytes

SubRoutine , die, als Eingabewerte nimmt F, Bund gibt sie an Zellen , die auf dem Sheets(1)Objekt (das auf die beschränkt Sheets(1)Objekt 2 Bytes zu speichern)

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

Verwendung:

Call G(3, 4)

C 349 Bytes

Kompiliert mit gcc (mit vielen Warnungen)

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

Eine etwas stärker eingerückte Version:

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

Hier ist eine 364-Byte-Version, die Zahlen größer als 100 verarbeitet

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

Perl, 275 Bytes

Einrückungen dienen der Lesbarkeit und sind nicht Teil des Codes.

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

Erläuterung:

Der Code verfolgt einen Hash aller Orte, an denen sich die Schildkröte befunden hat, und den entsprechenden Wert, der dort gespeichert ist %m. Zum Beispiel: in 3 5, $m{0,2}enthält 2und $m{1,-3}= 26. Es geht so weiter, bis es einen bereits definierten Ort erreicht. Darüber hinaus werden die aktuellen Grenzen des Schildkrötenpfades verfolgt $a,$b,$c,$dund als Maximum und Minimum verwendet.

Sobald es an einer Stelle angekommen ist, an der es bereits war, druckt es den Pfad unter Verwendung der Begrenzungen aus, wobei alles mit Leerzeichen aufgefüllt ist.

Es gibt keine Begrenzung für die Größe des Pfads oder der Zahlen.

PHP , 292 Bytes

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

Probieren Sie es online!

Einzüge werden der Übersichtlichkeit halber nicht mitgezählt.

Folgt ungefähr dem gleichen Algorithmus wie die Perl-Antwort. Verfolgen Sie, wo sich die Schildkröte in einem 2D-Array $abefunden hat, $u, $d, $l, $rverfolgen Sie , wohin die Schildkröte zeigt, und verfolgen Sie die Grenzen für den Druck. str_padDamit können wir sicherstellen, dass jeder Eintrag für die Druckformatierung genau 3 Stellen breit ist.

Aus irgendeinem Grund kann ich nicht verstehen, dass PHP nichts dagegen hat, wenn ich die Hälfte der Variablen nicht auf 0 initialisiere, aber die Formatierung vermasselt, wenn ich andere nicht initialisiere, obwohl nicht initialisierte Variablen normalerweise als 0 behandelt werden, wenn sie zum ersten Mal vorhanden sind gebraucht. Daher das $x=$y=$u=$l=0bisschen.

Python 2 , 267 262 258 249 245 243 Bytes

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

Probieren Sie es online!