Dada una posición con una fila de torres y / o espacios vacíos, muestra cuántos movimientos de torre diferentes son posibles. Una torre puede moverse hacia la izquierda o hacia la derecha a un espacio vacío, pero no a uno que requiera pasar sobre otra torre. Cuando una torre se mueve, las otras torres permanecen en su lugar.

Por ejemplo, desde esta posición, son posibles 6 movimientos :

.R..RRR.

• La primera torre (más a la izquierda) puede moverse 1 espacio a la izquierda, o 1 o 2 espacios a la derecha (3 movimientos)
• La siguiente torre solo puede moverse 1 o 2 espacios a la izquierda (2 movimientos)
• La tercera torre no puede moverse en absoluto porque está apretada entre otras dos torres (0 movimientos)
• La última torre solo puede moverse 1 espacio a la derecha (1 movimiento)

Tenga en cuenta que una posición puede no tener torres o espacios vacíos.

Entrada: una lista no vacía (cadena, matriz, etc.) de torres y espacios vacíos. Puede representarlos como True/ False, 1/ 0, 'R'/ '.'o cualquiera de los dos caracteres consistentes de un solo byte o números de un dígito de su elección. Depende de usted cuál significa torre y cuál significa espacio vacío.

Salida: un entero no negativo. Los flotadores de números enteros también están bien.

Casos de prueba

La salida es el número a la izquierda.

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

Para más casos de prueba, aquí están todas las entradas hasta la longitud 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

Retina , 14 9 bytes

w`_+R|R_+

Pruébalo en línea! El enlace incluye casos de prueba. Se utiliza _para el espacio vacío, ya que es el personaje no agradable de expresiones regulares. Funciona contando el número de subcadenas que corresponden a un movimiento de Torre válido. Una subcadena es un movimiento de Torre válido si contiene al menos uno _más Runo al principio o al final.

Python 3 , 30 29 bytes

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

Pruébalo en línea!

-1 byte gracias a @JoKing

La función toma una cadena de bytes de Python como entrada. Cada espacio vacío se codifica como una pestaña y cada torre se codifica como un byte que b'\x00'tiene valor 0.

El cálculo es equivalente a lambda s:(s+s).strip().count(b'\t')tener un recuento de bytes más bajo.

JavaScript (ES6),  38  33 bytes

Guardado 5 bytes gracias a @JoKing

Toma la entrada como una cadena. Espera un espacio para un cuadrado vacío y cualquier otro personaje para una torre.

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

Pruébalo en línea!

Comentado

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

Guardado 7 bytes gracias a @Grimy

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

Pruébalo en línea!

Japt , 5 bytes

²x èS

Intentalo

²x èS        Implicit input string of U
²            U + U
 x           Remove trailing and leading whitespace
   èS        Number of spaces

Perl 6 , 16 bytes

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

Pruébalo en línea!

Una expresión regular que coincide con todas las instancias exhaustivas de torres seguidas de espacios, o espacios seguidos de una torre y devuelve el número de coincidencias.

05AB1E , 5 bytes

«ðÚð¢

Pruébalo en línea!

«       # concatenate the input with itself
 ðÚ     # remove leading and trailing spaces
   ð¢   # count spaces

Retina , 23 15 bytes

Duplique la cantidad de espacios entre torres, grep líneas con al menos una torre, luego cuente la cantidad de espacios.

R.+R
$0$0
G`R
 

Pruébalo en línea!

Aunque el programa usa espacios en lugar de puntos, agregué un código de prefijo para que los casos de prueba proporcionados se puedan pegar y usar fácilmente.

Esperaba poder usar coincidencias superpuestas (?<=R.*) | (?=.*R), pero las superposiciones no son tan agresivas. Tendría que contar todas las formas posibles de obtener una coincidencia para obtener el resultado correcto con ese método.

Jalea , 6 bytes

t1;ḟẠS

Pruébalo en línea!

Un enlace monádico que toma una lista de 0torre y 1espacio y devuelve un número entero con el número de movimientos. El enlace TIO toma la lista pegada de posibles tablas dadas en la pregunta, convierte al formato correcto y luego genera las respuestas calculadas y correctas.

Explicación

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

Japt , 6 bytes

Espacios para espacios, cualquier otro personaje para torres.

²x ¸ÊÉ

Intentalo

Caracoles, 7 bytes

Al menos supera a Retina :)

o
\.+\R

Pruébalo en línea!

Jalea , 5 bytes

ḲẈ+ƝS

Pruébalo en línea!

-1 gracias a Jonathan Allan .

0representa una torre, 1representa un espacio vacío.

Stax , 7 6 5 bytes

àσQ█ε

Ejecutar y depurarlo

Use la pestaña para el cuadrado vacío y cualquier otro personaje para la torre.

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

Pruébalo en línea!

• Guardado 1 gracias a @ceilingcat

Me di cuenta de que no funcionaba para listas vacías ... ¡Ahora funciona! Además guardado algunos bytes!

1 = torre. 0 = espacio.

for (.. i + = n ++? - i: 1) // cuenta espacios o reinicia movimientos adicionales => i = - ~ i ! * n ++ (@ceilingcat)

o + = * n? r = 1, i: r; // se agrega a la salida -i- (movimientos adicionales) cuando se cumple una torre más los conjuntos -r- (torre se cumple), -i- se borrará para la oración de incremento.

agrega -r- por cada espacio (torre reunida garantizada)

Haskell , 36 bytes

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

Pruébalo en línea!

Utiliza 1 para el espacio vacío, 0 para la torre. Cuenta el número de 1 que no está en un bloque inicial de unos y agrega eso al resultado para la cadena invertida.

Haskell , 33 bytes

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

Pruébalo en línea!

Función anónima que toma la entrada como una lista de 1s (espacios) y 0s (torres). Esto recorta los espacios desde el principio y el final de la lista, luego concatena las dos versiones de la lista y las suma.

Esto usa GHC 8.4.1 o posterior para tener acceso al <>operador sin importarlo.

Python 2 , 59 bytes

def f(r):S=map(len,r.split('R'));return sum(S)*2-S[0]-S[-1]

Pruébalo en línea!

Japt , 6 bytes

²x ¸ÊÉ

Pruébalo en línea

Wolfram Language (Mathematica) , 43 38 bytes

Count[Subsequences@#,{0,1..}|{1..,0}]&

Pruébalo en línea!

Solución Retina del Puerto de Neil . Utiliza 1 para espacios y 0 para torres.

Haskell , 68 58 54 bytes

(n#y)(a:x)|a<1=n+(0#1)x|m<-n+1=y+(m#y)x
(_#_)x=0
f=0#0

Pruébalo en línea!

Rojo , 46 bytes

func[s][length? next split trim append s s sp]

Pruébalo en línea!

Solo un puerto rojo de las soluciones JavaScript / Python de Arnauld . Toma un espacio como un cuadrado vacío.

Java 11, 35 32 bytes

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

Puerto de @ Joel Python 3 respuestas 's .
-3 bytes gracias a @Joel también.

Utiliza NULL-bytes ( \0) para Rooks y tabs ( \t) para espacios.

Pruébalo en línea.

Intenté usarlo s->(s+s).trim().chars().sum()/9al principio como 31 bytes, pero esto no funciona porque el String#trimincorporado no solo elimina los espacios iniciales / finales / tabuladores / líneas nuevas, sino también todos los demás bytes que son más pequeños o iguales a U+0020(unicode 32; un espacio) , por lo que también eliminará los bytes NULL.
Gracias a Joel por recomendarme la nueva versión String#stripincorporada de Java 11+ (que olvidé que agregaron) como alternativa. Este también elimina las partes finales / iniciales, pero en este caso solo espacios en blanco , por lo que se retienen los bytes NULL.

Explicación:

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

Perl 5 -MList::Util=sum -pF/R/ , 40 bytes

$\=2*sum map$_=y///c,@F}{$\-="@F"+$F[-1]

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 27 bytes

x=>(x+x).Trim().Sum(d=>d)/9

Guardado un byte gracias a @someone

Pruébalo en línea!

Stax , 7 6 bytes

-1 byte gracias a recursivo

╣ë|óêπ

Ejecutar y depurarlo

Befunge-98 (PyFunge) , 73 bytes

#;ep10fp#;>#v~:'.-#v_$1+0k
v0+ge0*gf0$_v#!-R':<
>ep20fp   v >0fg1-*0eg+.@

Pruébalo en línea!

C , 183 156 151 137 96 91 bytes

Gracias a ceilingcat por 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 es una torre, todo lo demás es un espacio.

TIO

Pyth , 7 bytes

/r6*2Qd

Pruébalo en línea!

Toma una cadena de Rpara torres, (espacio) para espacios vacíos

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

x86-64 - 26 bytes

La entrada es una matriz de hasta 32 bits y un número entero que representa el número de cuadrados, 1 representa la torre, 0 representa el vacío.

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 los bits para que se agregue a la izquierda y elimina los bits cero finales. Luego obtiene el número de cero bits iniciales y lo resta del número total de cero bits.

Código de máquina x86-64 - 22 bytes - rangos de ajedrez de longitud regular solamente.

La entrada es un número entero de 32 bits con el byte menos significativo compuesto de 8 bits que representan las torres. 1 es una torre, 0 está vacía.

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 los bits en el siguiente byte significativo y elimina los bits cero finales. Luego obtiene el número de cero bits iniciales y lo resta del número total de cero bits.