Turm zählen bewegt sich 1D

31

Geben Sie bei einer Position mit einer Reihe von Türmen und / oder leeren Feldern aus, wie viele verschiedene Turmbewegungen möglich sind. Ein Turm kann sich nach links oder rechts zu einem leeren Feld bewegen, aber nicht zu einem, bei dem ein anderer Turm überfahren werden muss. Wenn sich ein Turm bewegt, bleiben die anderen Türme an Ort und Stelle.

Zum Beispiel sind von dieser Position aus 6 Züge möglich:

.R..RRR.
  • Der erste Turm (ganz links) kann 1 Feld nach links oder 1 oder 2 Felder nach rechts bewegen (3 Züge).
  • Der nächste Turm kann nur 1 oder 2 Felder nach links ziehen (2 Züge)
  • Der dritte Turm kann sich überhaupt nicht bewegen, da er zwischen zwei anderen Türmen eingeklemmt ist (0 Züge)
  • Der letzte Turm kann nur 1 Feld nach rechts bewegen (1 Zug)

Beachten Sie, dass eine Position möglicherweise überhaupt keine Türme oder gar keine Leerstellen hat.

Eingabe: Eine nicht leere Liste (Zeichenfolge, Array usw.) von Türmen und Leerzeichen. Sie können sie als True/ False, 1/ 0, 'R'/ '.'oder als zwei konsistente, unterschiedliche Einzelbytezeichen oder einstellige Zahlen Ihrer Wahl darstellen. Es liegt an Ihnen, welcher Turm und welcher leere Raum gemeint ist.

Ausgabe: Eine nicht negative Ganzzahl. Ganzzahlige Posen sind auch in Ordnung.

Testfälle

Die Ausgabe ist die Zahl auf der linken Seite.

6 .R..RRR.
0 .
0 R
4 R..RR
3 ...R
8 ..R..R..
0 ......

Für weitere Testfälle sind hier alle Eingaben bis Länge 5.

0 .
0 R
0 ..
1 .R
1 R.
0 RR
0 ...
2 ..R
2 .R.
1 .RR
2 R..
2 R.R
1 RR.
0 RRR
0 ....
3 ...R
3 ..R.
2 ..RR
3 .R..
3 .R.R
2 .RR.
1 .RRR
3 R...
4 R..R
3 R.R.
2 R.RR
2 RR..
2 RR.R
1 RRR.
0 RRRR
0 .....
4 ....R
4 ...R.
3 ...RR
4 ..R..
4 ..R.R
3 ..RR.
2 ..RRR
4 .R...
5 .R..R
4 .R.R.
3 .R.RR
3 .RR..
3 .RR.R
2 .RRR.
1 .RRRR
4 R....
6 R...R
5 R..R.
4 R..RR
4 R.R..
4 R.R.R
3 R.RR.
2 R.RRR
3 RR...
4 RR..R
3 RR.R.
2 RR.RR
2 RRR..
2 RRR.R
1 RRRR.
0 RRRRR
code-golf  counting  chess 
— xnor
quelle

Antworten:

9

Retina , 14 9 Bytes

w`_+R|R_+

Probieren Sie es online! Link enthält Testfälle. Wird _für leeren Raum verwendet, da dies der angenehmste Nicht-Regex-Charakter ist. Zählt die Anzahl der Teilzeichenfolgen, die einem gültigen Turmzug entsprechen. Eine Teilzeichenfolge ist eine gültige Turmbewegung, wenn sie am Anfang oder am Ende mindestens eine _und eine einzelne enthält R.

— Neil
quelle
Oh, Sie haben im Grunde herausgefunden, wie Sie das tun sollen, was ich in meiner Antwort erwähnt habe. Idk, warum ich nicht daran gedacht habe.
— mbomb007
9

Python 3 , 30 29 Bytes

lambda s:sum((s+s).strip())/9

Probieren Sie es online!

-1 Byte dank @JoKing

Die Funktion verwendet eine Python-Byte-Zeichenfolge als Eingabe. Jeder leere Raum wird als Tabulator und jeder Turm als Byte b'\x00'mit Wert codiert 0.

Die Berechnung entspricht lambda s:(s+s).strip().count(b'\t')einer niedrigeren Bytezahl.

— Joel
quelle
6

JavaScript (ES6),  38  33 Bytes

5 Bytes gespart dank @JoKing

Übernimmt die Eingabe als Zeichenfolge. Erwartet ein Leerzeichen für ein leeres Feld und ein beliebiges anderes Zeichen für einen Turm.

s=>(s+s).trim().split` `.length-1

Probieren Sie es online!

Kommentiert

s =>          // s = input, e.g. " R  RRR "
  (s + s)     // double -> " R  RRR  R  RRR "
  .trim()     // remove leading and trailing spaces -> "R  RRR  R  RRR"
  .split` `   // split on spaces -> [ 'R', '', 'RRR', '', 'R', '', 'RRR' ]
  .length - 1 // return the length - 1 -> 6

Python 2 ,  40  33 Bytes

7 Bytes gespart dank @Grimy

lambda s:(s+s).strip().count(' ')

Probieren Sie es online!

— Arnauld
quelle
1
Die Python-Version sollte countanstelle von split( TIO )
— Grimmy
@ Grimy Danke. :)
— Arnauld
4

Perl 6 , 16 Bytes

{+m:ex/s+R|Rs+/}

Probieren Sie es online!

Ein regulärer Ausdruck, der allen vollständigen Vorkommen von Türmen gefolgt von Leerzeichen oder Leerzeichen gefolgt von einem Turm entspricht und die Anzahl der Übereinstimmungen zurückgibt.

— Scherzen
quelle
3

Retina , 23 15 Bytes

Verdoppeln Sie die Anzahl der Felder zwischen den Türmen, greifen Sie mit mindestens einem Turm zu und zählen Sie dann die Anzahl der Felder.

R.+R
$0$0
G`R

Probieren Sie es online!

Obwohl das Programm Leerzeichen anstelle von Punkten verwendet, habe ich Präfix-Code hinzugefügt, damit die bereitgestellten Testfälle einfach eingefügt und verwendet werden können.

Ich hatte gehofft, ich könnte überlappende Übereinstimmungen mit verwenden (?<=R.*) | (?=.*R), aber Überlappungen sind nicht so aggressiv. Es müsste alle möglichen Wege zählen, auf denen eine Übereinstimmung erzielt werden kann, um mit dieser Methode das richtige Ergebnis zu erhalten.

— mbomb007
quelle
1
Scheint, das falsche Ergebnis für zu geben, .R.R.R.obwohl das Ändern der ersten Zeile R.+Rhelfen könnte?
— Neil,
@ Neil behoben. Vielen Dank.
— mbomb007
2

Gelee , 6 Bytes

t1;ḟẠS

Probieren Sie es online!

Ein monadischer Link, der eine Liste 0für Turm und 1Raum erstellt und eine Ganzzahl mit der Anzahl der Züge zurückgibt. Der TIO-Link nimmt die eingefügte Liste der in der Frage angegebenen möglichen Boards, konvertiert in das richtige Format und gibt dann die berechneten und korrekten Antworten aus.

Erläuterung

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum
— Nick Kennedy
quelle
2

C (clang) , 57 Bytes

i,r,o;g(*n,z){for(o=r=i=0;z--;i=-~i*!*n++)o+=*n?r=1,i:r;}

Probieren Sie es online!

  • 1 Dank an @ceilingcat gespeichert

Mir ist aufgefallen, dass es bei leeren Listen nicht funktioniert hat. Jetzt funktioniert es! Plus sparte einige Bytes!

1 = Turm. 0 = Leerzeichen.

für (.. i + = n ++? - i: 1) // zählt Leerzeichen oder setzt zusätzliche Züge zurück => i = - ~ i ! * n ++ (@ceilingcat)

o + = * n? r = 1, i: r; // fügt der Ausgabe -i- (zusätzliche Züge) hinzu, wenn ein Turm getroffen wird, und setzt -r- (Turm getroffen), -i- wird für einen inkrementellen Satz gelöscht.

fügt -r- für jedes Feld hinzu (Turm erfüllt garantiert)

— AZTECCO
quelle
Felsen? Bewegen sich deine Steine?
— Mast
1
@Mast lol sorry! Bearbeitet
— AZTECCO
2

Haskell , 36 Bytes

f s=sum$snd.span(>0)=<<[s,reverse s]

Probieren Sie es online!

Verwendet 1 für leeren Raum, 0 für Turm. Zählt die Anzahl der Einsen, die nicht in einem Anfangsblock von Einsen enthalten sind, und addiert diese zum Ergebnis für die umgekehrte Zeichenfolge.

— xnor
quelle
2

Haskell , 33 Bytes

sum.(t.reverse<>t)
t=snd.span(>0)

Probieren Sie es online!

Anonyme Funktion, die Eingaben als Liste von 1 (Leerzeichen) und 0 (Türme) akzeptiert. Dadurch werden Leerzeichen vom Anfang und Ende der Liste entfernt, die beiden Versionen der Liste verkettet und summiert.

Dies verwendet GHC 8.4.1 oder höher, um auf den <>Operator zuzugreifen, ohne ihn zu importieren.

— Scherzen
quelle
1

Java 11, 35 32 Bytes

s->(s+s).strip().chars().sum()/9

Port von @Joels Python 3 Antwort .
-3 Bytes danke auch an @Joel .

Verwendet NULL-Bytes ( \0) für Türme und Tabulatoren ( \t) für Leerzeichen.

Probieren Sie es online aus.

Ich habe versucht, s->(s+s).trim().chars().sum()/9zunächst als 31-Byte-Zeichen zu verwenden, aber das funktioniert nicht, weil das String#trimeingebaute Zeichen nicht nur führende und nachfolgende Leerzeichen / Tabulatoren / Zeilenumbrüche entfernt, sondern auch alle anderen Bytes, die kleiner oder gleich U+0020(Unicode 32; ein Leerzeichen) sind. Daher werden auch die NULL-Bytes entfernt.
Vielen Dank an Joel , der mir das neue Java 11+ String#strip-Erstellungsprogramm (das ich vergessen habe, dass es hinzugefügt wurde) als Alternative empfohlen hat . Dieser entfernt auch nachfolgende / führende Teile, in diesem Fall jedoch nur Leerzeichen , sodass die NULL-Bytes erhalten bleiben.

Erläuterung:

s->                              // Method with String as parameter & integer return-type
  (s+s)                          //  Concatenate the input to itself
       .strip()                  //  Then trim all leading and trailing tabs
               .chars().sum()    //  Sum the unicode values of the remaining characters
                             /9  //  And divide it by 9 to get the amount of remaining tabs
— Kevin Cruijssen
quelle
1
Mit Java 11+ können String.strip()nur Leerzeichen entfernt werden: 32 Bytes
— Joel
@ Joel Ah, das hast du komplett vergessen! Vielen Dank. :)
— Kevin Cruijssen
1

C , 183 156 151 137 96 91 Bytes

Danke an ceilingcat für 91 Bytes.

c,e;char*z,b[9];main(d){for(gets(z=b);e=*z>81?c-=e*~!d,d=0:e+1,*++z;);printf("%i",d?:c+e);}

R ist ein Turm, alles andere ist ein Raum.

TIO

— girobuz
quelle
Ein paar Dinge - eine Funktion (anstelle eines vollständigen Programms) ist erlaubt, Sie können sich auf undefiniertes Verhalten verlassen (z. B. automatisches Nullsetzen), solange Ihr Programm auf mindestens einem Compiler korrekt funktioniert, es kürzer zu verwenden ist 82oder 'R'es kürzer ist benutze e+e*dals e*(1+d), e=0,d=1;else e++; can be changed to e = -1, d = 1; e ++; , and b [a] `und b[++a]kann durch *bund ersetzt werden*++b
— ASCII
0

Pyth , 7 Bytes

/r6*2Qd

Probieren Sie es online!

Nimmt eine Zeichenfolge Rfür Türme, (Leerzeichen) für Leerzeichen

/     d  # Count spaces in
 r6      #  Strip spaces from
   *2Q   #   2 * input() (= concatenation)
— ar4093
quelle
0

x86-64 - 26 Bytes

Die Eingabe ist ein Array mit bis zu 32 Bits und einer Ganzzahl, die die Anzahl der Quadrate darstellt, wobei 1 für den Turm und 0 für leer steht.

C4 E2 69 F7 C1       shlx        eax,ecx,edx
0B C1                or          eax,ecx  
F3 0F BC C8          tzcnt       ecx,eax  
D3 E8                shr         eax,cl  
F3 0F BD C8          lzcnt       ecx,eax  
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax  
2B C1                sub         eax,ecx  
C3                   ret

Kopiert die Bits so, dass sie links davon hinzugefügt werden, und entfernt die nachfolgenden Nullbits. Ermittelt dann die Anzahl der führenden Nullbits und subtrahiert sie von der Gesamtzahl der Nullbits.

x86-64-Maschinencode - 22 Byte - nur Schachränge mit regulärer Länge.

Die Eingabe ist eine 32-Bit-Ganzzahl, wobei das niederwertigste Byte aus 8 Bits besteht, die die Türme darstellen. 1 ist ein Turm, 0 ist leer.

8A E9                mov         ch,cl  
91                   xchg        eax,ecx
F3 0F BC C8          tzcnt       ecx,eax
D3 E8                shr         eax,cl 
F3 0F BD C8          lzcnt       ecx,eax
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax
2B C1                sub         eax,ecx
C3                   ret

Kopiert die Bits in das nächste signifikante Byte und entfernt die nachfolgenden Nullbits. Ermittelt dann die Anzahl der führenden Nullbits und subtrahiert sie von der Gesamtzahl der Nullbits.

— mich'
quelle
Das funktioniert also nur für Zeilen mit genau 8? Wenn ja, scheint das etwas zu spezifisch für die Herausforderung zu sein.
— ar4093
Es wurde versehentlich davon ausgegangen, dass es sich um reguläre Turmreihen handelte.
— Ich
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.