Count rook mueve 1D

31

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
code-golf  counting  chess 
— xnor
fuente

Respuestas:

9

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.

— Neil
fuente
Oh, básicamente descubriste cómo hacer lo que mencioné en mi respuesta. No sé por qué no pensé en eso.
— mbomb007
9

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.

— Joel
fuente
6

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!

— Arnauld
fuente
1
La versión de Python debería usar en countlugar de split( TIO )
— Grimmy
@ Grimy Gracias. :)
— Arnauld
4

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.

— Jo King
fuente
3

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.

— mbomb007
fuente
1
¿Parece dar el resultado incorrecto .R.R.R.aunque cambiar la primera línea R.+Rpodría ayudar?
— Neil
@Neil Fixed. Gracias.
— mbomb007
2

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
— Nick Kennedy
fuente
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;}

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)

— AZTECCO
fuente
Rocas? ¿Se mueven tus rocas?
— Mástil el
1
@Mast jajaja lo siento! Editado
— AZTECCO
2

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.

— xnor
fuente
2

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.

— Jo King
fuente
1

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
— Kevin Cruijssen
fuente
1
Java 11+ permite usar String.strip()para eliminar solo espacios en blanco: 32 bytes
— Joel
@ Joel Ah, ¡me olvidé por completo de eso! Gracias. :)
— Kevin Cruijssen
1

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

— girobuz
fuente
Algunas cosas: se permite una función (en lugar de un programa completo), puede confiar en un comportamiento indefinido (por ejemplo, poner a cero automáticamente) siempre que su programa funcione correctamente en al menos un compilador, sea más corto de usar 82o 'R'sea ​​más corto de uso e+e*dque e*(1+d), e=0,d=1;else e++; can be changed to e = -1, d = 1; e ++; , and b [a] `y b[++a]puede ser reemplazado con *by*++b
— solo ASCII
0

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)
— ar4093
fuente
0

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.

— yo'
fuente
Entonces, ¿esto solo funciona para filas de exactamente 8? En caso afirmativo, eso parece demasiado específico para el desafío.
— ar4093
Accidentalmente asumí que eran rangos regulares de torre, arreglados ahora.
— yo
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.