Ayuda a pannenkoek a contar las prensas A

28

pannenkoek2012 tiene como objetivo completar Super Mario 64 con tan pocas pulsaciones como sea posible del botón A, lo que hace que Mario salte. Cada "prensa A" consta de tres partes:

  • Presionando el botón
  • Sosteniéndolo por cualquier período de tiempo
  • Soltándolo

Partes de una prensa A, del video de Pannenkoek2012

Vea este video (1:15 - 3:23) para obtener una excelente explicación que incluye la imagen de arriba. (Sin embargo, este desafío no utilizará la terminología de media prensa y presentará obstáculos que requieren la liberación de A).

Tarea:

Dada una secuencia de obstáculos que requieren presionar (P), mantener presionado (H) o soltar (R) el botón A, genera la menor cantidad de presiones necesarias para superarlos en el orden dado. El botón A no se mantiene inicialmente.

Dicho formalmente: dada una cadena S de caracteres PHR, considere cadenas de forma (PH*R)*que contengan S como una subsecuencia, y genere el menor número posible de P's en dicha cadena. O, alternativamente, encuentre el menor número de fragmentos de la forma en P?H*R?que S se puede dividir.

Ejemplo

Veamos la entrada RHRPHHHR. El botón A no se mantiene presionado, por lo que para superar el obstáculo inicial es Rnecesario presionar el botón y luego soltarlo (presione # 1). A continuación, debemos mantener presionado el botón H, que nuevamente requiere que primero se presione (presione # 2). Luego, se puede liberar luego para satisfacer el Rposterior. Finalmente, el resto PHHHRpuede satisfacerse presionando una vez (presione # 3) seguido de mantener HHHy soltar R. Entonces, el recuento de salida es 3.

Otra forma de verlo es que podemos dividir la cadena de entrada en 3 partes de forma PHH..HHRdonde se pueden omitir las letras.

R
HR
PHHHR

Formato de entrada

La entrada será una lista o cadena de elementos que representan presionar, mantener y soltar como su elección de:

  • P, H, R
  • p, h, r
  • 1, 2, 3
  • 0, 1, 2

emparejado en el orden dado. La entrada no estará vacía.

Casos de prueba:

P 1
H 1
R 1
HP 2
RHP 3
HHR 1
PHRH 2
RHRPHHHR 3
HHHHHH 1
PPRRHHPP 6
HPPRHRPRHPPRHPPHRP 12
PRHRHPHHPRRRHPPRHHPPRRRHRHPRPHPRPRHHRPPPRHPRP 28

Tabla de clasificación:

Mostrar fragmento de código

code-golf  sequence  subsequence 
— xnor
fuente
1
¿Qué pasa con los obstáculos que requieren que el botón A no se mantenga? Hay cuatro estados de botones en el gráfico ( creo que estos también podrían existir en el juego)
— Random832
3
En realidad, hay 3 estados: prensa, retenido y no retenido. Ningún estado requiere la liberación de un botón A. El desafío es ligeramente erróneo en comparación con la realidad.
— user202729
1
@ 11684 "en cuanto al lanzamiento, bueno, actualmente no hay casos en los que eso sea útil o importante, así que no te preocupes por esa parte". (1:48 - 1:52)
— usuario202729
3
¿Alguien quiere hacer esto en el ensamblaje MIPS? (el lenguaje utilizado para programar Super Mario 64)
— user202729
1
@ user202729 Wow, ese es un panqueque completo. ¡Gracias!
— 11684

Respuestas:

3

Pyth , 13 bytes

tl:z"P?H*R?"3

Pruébalo aquí! o Verificar todos los casos de prueba.

Tenga en cuenta que 1también funciona en lugar de 3.

¿Cómo funciona?

tl: z "P? H * R?" 3 | Programa completo Toma entrada de STDIN, salidas a STDOUT.

  : z 3 | Dividir la cadena de entrada en coincidencias de ...
    "P? H * R?" El | La expresión regular "P? H * R?".
 l | Obtén la longitud.
t | Disminución (porque la división incluye la cadena vacía).

Más sobre la expresión regular:

¿PAGS? El | P: el carácter literal P, distingue entre mayúsculas y minúsculas.
       El | ? - Cuantificador. Coincide con uno o cero veces el carácter anterior.
  H * | H - El carácter literal H, distingue entre mayúsculas y minúsculas.
       El | * - Cuantificador. Coincide con cualquier número de ocurrencias del personaje anterior.
    R? El | R: el carácter literal R, distingue entre mayúsculas y minúsculas.
       El | ? - Cuantificador. Coincide con uno o cero veces el carácter anterior.
— Sr. Xcoder
fuente
Ah, diablos, ¡me ganaste!
— Shaggy
¡bonito! La penúltima línea de la descripción de expresiones regulares debería decir "Carácter literal R", ¿verdad?
— vidstige
@vidstige Sí, gracias. Solucionado
— Sr. Xcoder
2

Jalea , 10 bytes

o5ḄƝ%⁵>4S‘

Una cadena monádica que toma una lista (la P,H,R : 0,1,2opción) y devuelve un número entero, el recuento.

Pruébalo en línea! o ver el conjunto de pruebas

¿Cómo?

Efectivamente trabaja por conseguir todos los pares adyacentes luego contar cualquier que no son "pares de continuación" ( PR, PH, HR, o HH) y la adición de uno.

o5ḄƝ%⁵>4S‘ - Link: list of integers (in [0,1,2])  e.g.: [0,0,1,0,2,1,1,2,2,0] (representing PPHPRHHRRP)
o5         - logical OR with 5                          [5,5,1,5,2,1,1,2,2,5]
   Ɲ       - for all adjacent pairs:              i.e.: [5,5],[5,1],[1,5],[5,2],[2,1],[1,1],[1,2],[2,2],[2,5]
  Ḅ        -   convert from binary                      [ 15 ,  11 ,  7  ,  12 ,  5  ,  3  ,  4  ,  6  ,  9 ]
     ⁵     - literal ten
    %      - modulo                                     [  5 ,   1 ,  7  ,   2,   5  ,  3  ,  4  ,  6  ,  9 ]
      >4   - greater than four?                         [  1 ,   0 ,  1  ,   0,   1  ,  0  ,  0  ,  1  ,  1 ]
        S  - sum                                        5
         ‘ - increment                                  6

Solución anterior de 11 bytes:

ḅ3Ɲạ3ḟ1,2L‘

Pruébalo en línea! o ver el conjunto de pruebas

¿Cómo?

Funciona como lo anterior, pero de una manera completamente diferente ...

ḅ3Ɲạ3ḟ1,2L‘ - Link: list of integers (in [0,1,2])  e.g.: [0,0,1,0,2,1,1,2,2,0] (representing PPHPRHHRRP)
  Ɲ         - for all adjacent pairs:              i.e.: [0,0],[0,1],[1,0],[0,2],[2,1],[1,1],[1,2],[2,2],[2,0]
ḅ3          -   convert from base three                  [ 0  ,  1  ,  3  ,  2  ,  7  ,  4  ,  5  ,  8  ,  6 ]
   ạ3       - absolute difference with three             [ 3  ,  2  ,  0  ,  1  ,  4  ,  1  ,  2  ,  5  ,  3 ]
     ḟ1,2   - filter discard if in [1,2]                 [ 3        ,  0        ,  4              ,  5  ,  3 ]
         L  - length                                     5
          ‘ - increment                                  6

y otro, nuevamente bastante diferente:

+19*Ɲ%13ḂS‘

(agregue 19 a cada uno, luego para los pares adyacentes realice la exponenciación, módulo por 13, módulo por 2, suma y agregue uno).

— Jonathan Allan
fuente
New Jelly rápido!
— user202729
2

Lote, 69 bytes

@set/ab=2,n=0
@for %%b in (%*)do @set/an+=b/2^|!%%b,b=%%b
@echo %n%

Toma la entrada como una lista de parámetros de línea de comando indexados en 0, pero puede usar una lista de letras p, h, ren mayúsculas o minúsculas si escribe set /a p=0, h=1, r=2primero. Explicación: bmantiene la última entrada (predeterminada 2para liberado) y nel recuento de prensas. Cada entrada agrega una prensa si la última entrada fue una liberación o la entrada actual es una prensa.

— Neil
fuente
Oh, ¿ setpuedo establecer múltiples variables a la vez? Útil para saber.
— user202729
1
@ user202729 set /aes una evaluación aritmética, por lo que siempre que todas las variables que desee establecer sean numéricas, simplemente puede usar el operador de coma para concatenar las expresiones de asignación.
— Neil
2

Python 2, 44 bytes

Utiliza P-> 1 H-> 2 R-> 3

lambda a:sum(1/y|x/3for x,y in zip([3]+a,a))
— Feersum
fuente
1

Casco , 6 5 bytes

Lġo&ε

Pruébalo en línea! La entrada es una lista 0,1,2(el enlace TIO usa letras para facilitar el copiado de los casos de prueba).

Explicación

Utilizo la misma idea general que la respuesta Jelly de Jonathan Allan : dividir las apariciones de los "pares de discontinuidad" PP, HP, RH, RR y RP, y contar los bloques resultantes. En la codificación 0,1,2, estos pares son exactamente aquellos cuyo elemento izquierdo es 2 o el elemento derecho es 0.

Lġo&ε  Input is a list.
 ġ     Split between pairs that do not satisfy:
    ε  the left element is at most 1
  o&   and the right element is truthy.
L      Length.
— Zgarb
fuente
1

Javascript (ES6), 30 bytes

f=s=>s.match(/P?H*R?/g).length-1
<input id=i oninput="o.innerText=f(i.value)" value="PHHR"><pre id=o>l
Expandir fragmento

— Herman L
fuente
1

Jalea , 10 bytes

Pn1></µƝS‘

Pruébalo en línea! o Test suite! ( Robado prestado de Jonathan.)

Alternativa:

P=1=</µƝS‘

Pruébalo en línea!

Pn1></µƝS‘ | Monadic chain.

      µƝ   | Map over each pair of "neighbours" (x, y) in the list.
P          | And check whether their product...
 n1        | ... 1 if it doesn't equal 1, 0 otherwise...
   >       | Is higher than?
    </     | The pair reduced by "Smaller than?". 1 if x < y, else 0.
        S  | Sum.
         ‘ | Add 1.

Jalea , 11 bytes

Guardado 1 byte con ayuda de caird coinheringaahing.

ḅ3Ɲf⁽vḲD¤L‘

Pruébalo en línea!

— Sr. Xcoder
fuente
Aww, perdí la oportunidad de ser el primero en usar a los vecinos rápidamente :(
— caird coinheringaahing
Puede eliminar el μdel tercero
— caird coinheringaahing
1

Kotlin , 36 bytes

Regex("P?H*R?").findAll(i).count()-1

Embellecido

Regex("P?H*R?").findAll(i).count()-1

Prueba

fun f(i:String) =
Regex("P?H*R?").findAll(i).count()-1
data class Test(val input: String, val output: Int)

val TESTS = listOf(
        Test("P", 1),
        Test("H", 1),
        Test("R", 1),
        Test("HP", 2),
        Test("RHP", 3),
        Test("HHR", 1),
        Test("PHRH", 2),
        Test("RHRPHHHR", 3),
        Test("HHHHHH", 1),
        Test("PPRRHHPP", 6),
        Test("HPPRHRPRHPPRHPPHRP", 12),
        Test("PRHRHPHHPRRRHPPRHHPPRRRHRHPRPHPRPRHHRPPPRHPRP", 28)
)

fun main(args: Array<String>) {
    for ((input, expectded) in TESTS) {
        val actual = f(input)
        if (actual != expectded) {
            throw AssertionError("$input $expectded $actual")
        }
    }
}

TIO

TryItOnline

— jrtapsell
fuente
0

J , 18 17 bytes

-1 Gracias a @FrownyFrog

1+1#.}:(<+:1=*)}.

Toma entrada en forma de 0,1,2. La función auxiliar en TIO convierte los casos de prueba a este formulario.

Pruébalo en línea!

La lógica de las comparaciones aún puede ser golfable. Estoy retorciendo mi cerebro en nudos tratando de pensar en declaraciones más equivalentes y más cortas.

Explicación (solución previa)

1+1#.2(</+:1=*/)\]

La única diferencia entre la solución actual y la anterior es cómo se generan las comparaciones. La solución actual compara explícitamente los elementos adyacentes al compensar la matriz y la solución anterior compara los elementos adyacentes al observar infijos de 2.

1 + 1 #. 2 (</ +: 1 = */)\ ]
         2               \ ]  On infixes of 2 on the input
                  1 = */        Is the infix 1 1 (two holds)?
            </                  Is the infix x y such that x < y?
               +:               These results NORed
    1 #.                       Add all of the results together (debase to base 1)
1 +                            Add one

Esto sería mucho más limpio si dos retenciones no hicieran nada. El código toma infijos de dos y verifica si no son ascendentes y no dos retenciones. Si este es el caso, entonces agregamos uno a nuestra cuenta final. Tenemos que agregar 1 al final ya que de lo contrario estamos apagados (o podría anteponer un _valor o cualquier valor mayor que 2).

La forma en que comprueba si el infijo es dos retenciones es multiplicando los dos valores y viendo si es uno (dos retenciones son 1 1).

— col
fuente
1
1+1#.}:(<+:1=*)}.Es uno más corto.
— FrownyFrog
@FrownyFrog inteligente, lo editaré en.
— cole
1
14:1+1#.0=}.*2-}:
— FrownyFrog
0

Vim + wc, 25 bytes

:s/P\?H*R\?/a/g␊V!wc -c␊␘

␊es la tecla de retorno y ␘es Ctrl+X

Pruébalo en línea!

Explicación

:s/P\?H*R\?/a/g␊    Replace all button presses with the character a
V!wc -c␊␘          Count the characters using the wc command
— Herman L
fuente
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.