Conteggio torre si sposta 1D

31

Data una posizione con una fila di torri e / o spazi vuoti, emettere quante diverse mosse di torre sono possibili. Una torre può spostarsi a sinistra oa destra in uno spazio vuoto, ma non in uno che richiede il passaggio su un'altra torre. Quando una torre si muove, le altre torre rimangono al loro posto.

Ad esempio, da questa posizione sono possibili 6 mosse :

.R..RRR.
  • La prima torre (più a sinistra) può spostare di 1 spazio a sinistra o 1 o 2 spazi a destra (3 mosse)
  • La torre successiva può spostare solo 1 o 2 spazi a sinistra (2 mosse)
  • La terza torre non può muoversi affatto perché è stretta tra altre due (0 mosse)
  • L'ultima torre può muovere solo 1 spazio a destra (1 mossa)

Si noti che una posizione potrebbe non avere affatto torri o spazi vuoti.

Input: un elenco non vuoto (stringa, matrice, ecc.) Di torri e spazi vuoti. Puoi rappresentarli come True/ False, 1/ 0, 'R'/ '.'o due caratteri distinti a byte singolo distinti o numeri di una cifra a tua scelta. Dipende da te quale si intende torre e che significa spazio vuoto.

Output: un numero intero non negativo. Anche i float con numeri interi vanno bene.

Casi test

L'output è il numero a sinistra.

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

Per altri casi di test, qui ci sono tutti gli input fino alla lunghezza 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
fonte

Risposte:

9

Retina , 14 9 byte

w`_+R|R_+

Provalo online! Il link include casi di test. Utilizza _lo spazio vuoto in quanto è il personaggio non regex più piacevole. Funziona contando il numero di sottostringhe che corrispondono a una mossa Rook valida. Una sottostringa è una mossa Torre valida se contiene almeno una _più una Rall'inizio o alla fine.

— Neil
fonte
Oh, in pratica hai capito come fare quello che ho menzionato nella mia risposta. Idk perché non ci ho pensato.
— mbomb007,
9

Python 3 , 30 29 byte

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

Provalo online!

-1 byte grazie a @JoKing

La funzione accetta una stringa di byte Python come input. Ogni spazio vuoto è codificato come una scheda e ogni torre è codificata come un byte b'\x00'con valore 0.

Il calcolo equivale a lambda s:(s+s).strip().count(b'\t')quando si ha un conteggio di byte inferiore.

— Joel
fonte
6

JavaScript (ES6),  38  33 byte

5 byte salvati grazie a @JoKing

Accetta l'input come stringa. Si aspetta uno spazio per un quadrato vuoto e qualsiasi altro personaggio per una torre.

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

Provalo online!

Commentate

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 byte

Salvato 7 byte grazie a @Grimy

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

Provalo online!

— Arnauld
fonte
1
La versione di Python dovrebbe usare countinvece di split( TIO )
— Grimmy
@Grimy Grazie. :)
— Arnauld
4

Perl 6 , 16 byte

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

Provalo online!

Una regex che corrisponde a tutte le istanze esaustive di torri seguite da spazi o spazi seguiti da una torre e restituisce il numero di corrispondenze.

— Jo King
fonte
3

Retina , 23 15 byte

Raddoppia il numero di spazi tra le torri, le linee grep con almeno una torre, quindi conta il numero di spazi.

R.+R
$0$0
G`R

Provalo online!

Sebbene il programma utilizzi spazi anziché punti, ho aggiunto il prefisso in modo che i casi di test forniti possano essere facilmente incollati e utilizzati.

Speravo di poter usare partite sovrapposte (?<=R.*) | (?=.*R), ma le sovrapposizioni non sono così aggressive. Dovrebbe contare tutti i modi possibili per ottenere una corrispondenza per restituire il risultato corretto con quel metodo.

— mbomb007
fonte
1
Sembra dare il risultato sbagliato .R.R.R.anche se cambiare la prima riga in R.+Rpotrebbe aiutare?
— Neil,
@Neil Fixed. Grazie.
— mbomb007,
2

Gelatina , 6 byte

t1;ḟẠS

Provalo online!

Un collegamento monadico che prende un elenco di 0per torre e 1per spazio e restituisce un numero intero con il numero di mosse. Il collegamento TIO prende l'elenco incollato di possibili schede fornite nella domanda, converte nel formato corretto e quindi genera le risposte calcolate e corrette.

Spiegazione

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

C (clang) , 57 byte

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

Provalo online!

  • Salvato 1 grazie a @ceilingcat

Mi sono reso conto che non ha funzionato per liste vuote .. Ora funziona! Inoltre ha salvato alcuni byte!

1 = torre. 0 = spazio.

per (.. i + = n ++? - i: 1) // conta gli spazi o resetta le mosse extra => i = - ~ i ! * n ++ (@ceilingcat)

o + = * n r = 1, i:? r; // aggiunge all'output -i- (mosse extra) quando viene soddisfatta una torre più insiemi -r- (torre incontrate), -i- verrà cancellato per la frase di incremento.

aggiunge -r- per ogni spazio (rook incontrato garantito)

— AZTECCO
fonte
Rocce? Le tue rocce si muovono?
— Albero
1
@Mast lol mi dispiace! Modificato
— AZTECCO
2

Haskell , 36 byte

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

Provalo online!

Usa 1 per spazio vuoto, 0 per torre. Conta il numero di 1 non in un blocco iniziale di quelli e lo aggiunge al risultato per la stringa invertita.

— XNOR
fonte
2

Haskell , 33 byte

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

Provalo online!

Funzione anonima che accetta input come un elenco di 1s (spazi) e 0s (rooks). Ciò consente di tagliare gli spazi dall'inizio e dalla fine dell'elenco, quindi concatena le due versioni dell'elenco e le somma.

Questo utilizza GHC 8.4.1 o versioni successive per avere accesso <>all'operatore senza importarlo.

— Jo King
fonte
1

Java 11, 35 32 byte

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

La risposta di Python 3 di Port of @Joel .
-3 byte grazie anche a @Joel .

Utilizza NULL-bytes ( \0) per Rooks e tabs ( \t) per gli spazi.

Provalo online.

Ho provato a utilizzare s->(s+s).trim().chars().sum()/9inizialmente come 31 byte, ma questo non funziona perché l' String#trimintegrato non solo rimuove spazi / tab / newline iniziali e finali, ma anche tutti gli altri byte più piccoli o uguali U+0020(unicode 32; uno spazio) , quindi rimuoverà anche i byte NULL.
Grazie a Joel per avermi consigliato il nuovo String#stripbuilt-in Java 11+ (che ho dimenticato di aver aggiunto) in alternativa. Questo rimuove anche le porzioni finali / iniziali, ma in questo caso solo gli spazi bianchi , quindi i byte NULL vengono mantenuti.

Spiegazione:

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
fonte
1
Java 11+ consente l'utilizzo String.strip()per rimuovere solo gli spazi bianchi: 32 byte
— Joel
@Joel Ah, completamente dimenticato di quello! Grazie. :)
— Kevin Cruijssen,
1

C , 183 156 151 137 96 91 byte

Grazie a ceilingcat per 91 byte.

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 è una torre, tutto il resto è uno spazio.

TIO

— girobuz
fonte
Alcune cose: è consentita una funzione (anziché un programma completo), puoi fare affidamento su un comportamento indefinito (ad es. Azzeramento automatico) fintanto che il tuo programma funziona correttamente su almeno un compilatore, è 82invece più breve da usare o 'R'è più breve usa e+e*dthan e*(1+d), e=0,d=1;else e++; can be changed to e = -1, d = 1; e ++; , and b [a] `e b[++a]può essere sostituito con *be*++b
— solo ASCII il
0

Pyth , 7 byte

/r6*2Qd

Provalo online!

Prende una stringa di Rfor rooks, (spazio) per spazi vuoti

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

x86-64 - 26 byte

L'input è un array fino a 32 bit e un numero intero che rappresenta il numero di quadrati, 1 che rappresenta la torre, 0 che rappresenta il vuoto.

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

Copia i bit in modo che vengano aggiunti a sinistra e rimuove i bit zero finali. Quindi ottiene il numero di zero bit iniziali e lo sottrae dal numero totale di zero bit.

x86-64 Codice macchina - 22 byte - solo gradi di scacchi di lunghezza normale.

L'input è un numero intero a 32 bit con il byte meno significativo composto da 8 bit che rappresentano i rook. 1 è una torre, 0 è vuoto.

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

Copia i bit nel byte significativo successivo e rimuove i bit zero finali. Quindi ottiene il numero di zero bit iniziali e lo sottrae dal numero totale di zero bit.

— me'
fonte
Quindi questo funziona solo per file esattamente della lunghezza 8? Se sì, sembra un po 'troppo specifico per la sfida.
— ar4093,
Accidentalmente supponevo che fossero ranghi di torre regolari, risolti ora.
— L'
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.