Aiuta pannenkoek a contare le presse

28

pannenkoek2012 mira a completare Super Mario 64 con il minor numero di pressioni possibili del pulsante A, che fa saltare Mario. Ogni "una stampa" è composta da tre parti:

  • Premendo il tasto
  • Tenendolo per un certo periodo di tempo
  • Rilasciandolo

Parti di una stampa A, dal video di Pannenkoek2012

Guarda questo video (1:15 - 3:23) per una grande spiegazione che include l'immagine sopra. (Tuttavia, questa sfida non utilizzerà la terminologia della mezza stampa e metterà in evidenza gli ostacoli che richiedono il rilascio di A.)

Compito:

Data una sequenza di ostacoli che richiedono di premere (P), tenere premuto (H) o rilasciare (R) il pulsante A, emettere il minor numero di pressioni necessarie per superarli nell'ordine indicato. Il pulsante A inizialmente non viene tenuto.

Dichiarato formalmente: data una stringa S di caratteri PHR, considera le stringhe di forma (PH*R)*che contengono S come sottosequenza e genera il minor numero possibile di P's in tale stringa. Oppure, in alternativa, trova il numero più piccolo di blocchi della forma in P?H*R?cui S può essere suddiviso.

Esempio

Diamo un'occhiata all'input RHRPHHHR. Il pulsante A non viene tenuto premuto, quindi per superare l'ostacolo iniziale è Rnecessario premere e rilasciare il pulsante (premere # 1). Successivamente ci viene richiesto di tenere premuto il pulsante H, che richiede nuovamente che venga prima premuto (premere # 2). Quindi, può essere rilasciato successivamente per soddisfare il Rdopo. Infine, il resto PHHHRpuò essere soddisfatto con una sola pressione (premere # 3) seguita da mantenimento HHHe rilascio R. Quindi, il conteggio delle uscite è 3.

Un altro modo per vederlo è che possiamo dividere la stringa di input in 3 parti del modulo in PHH..HHRcui le lettere possono essere omesse.

R
HR
PHHHR

Formato di input

L'input sarà un elenco o una stringa di elementi che rappresentano premere, tenere premuto e rilasciare come scelta di:

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

abbinato nell'ordine indicato. L'input non sarà vuoto.

Casi test:

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

Classifica:

Mostra snippet di codice

code-golf  sequence  subsequence 
— XNOR
fonte
1
Che dire degli ostacoli che richiedono di non tenere premuto il pulsante A? Ci sono quattro stati dei pulsanti nel grafico ( penso che potrebbero esistere anche nel gioco)
— Random832
3
In realtà, ci sono 3 stati: Press, Held e Not-hold. Nessuno stato richiede un rilascio del pulsante A. La sfida è leggermente sbagliata rispetto alla realtà.
— user202729
1
@ 11684 "per quanto riguarda il rilascio, beh, al momento non ci sono casi in cui ciò sia utile o importante, quindi non preoccuparti di quella parte." (1:48 - 1:52)
— user202729
3
Qualcuno vuole farlo nell'assemblaggio MIPS? (la lingua utilizzata per programmare Super Mario 64)
— user202729
1
@ user202729 Wow, questo è un pancake completo. Grazie!
— 11684

Risposte:

3

Pyth , 13 byte

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

Provalo qui! oppure Verifica tutti i casi di test.

Si noti che 1funziona anche al posto di 3.

Come funziona?

tl: z "P? H * R?" 3 | Programma completo. Riceve input da STDIN, output su STDOUT.

  : z 3 | Dividi la stringa di input in corrispondenza di ...
    "P? H * R?" | L'espressione regolare "P? H * R?".
 l | Prendi la lunghezza.
t | Decremento (perché la divisione include la stringa vuota).

Maggiori informazioni su regex:

P? | P - Il carattere letterale P, maiuscolo / minuscolo.
       | ? - Quantificatore. Corrisponde a una o zero volte il carattere precedente.
  H * | H - Il carattere letterale H, maiuscolo / minuscolo.
       | * - Quantificatore. Corrisponde a qualsiasi numero di occorrenze del personaggio precedente.
    R? | R - Il carattere letterale R, maiuscolo / minuscolo.
       | ? - Quantificatore. Corrisponde a una o zero volte il carattere precedente.
— Mr. Xcoder
fonte
Ah, cavolo, mi hai battuto!
— Shaggy,
simpatico! La penultima riga nella descrizione di regexp dovrebbe dire "Personaggio letterale R", giusto?
— Vidstige,
@vidstige Sì, grazie. Risolto
— Mr. Xcoder
2

Gelatina , 10 byte

o5ḄƝ%⁵>4S‘

Una catena monadica che prende un elenco (l' P,H,R : 0,1,2opzione) e restituisce un numero intero, il conteggio.

Provalo online! o vedi la suite di test

Come?

Funziona in modo efficace per ottenere tutte le coppie adiacenti quindi contando qualsiasi che non sono "coppie continuazione" ( PR, PH, HR, o HH) e aggiungendo una.

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

Precedente soluzione a 11 byte:

ḅ3Ɲạ3ḟ1,2L‘

Provalo online! o vedi la suite di test

Come?

Funziona come sopra, ma in un modo completamente diverso ...

ḅ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

e un altro, ancora abbastanza diverso:

+19*Ɲ%13ḂS‘

(aggiungi 19 a ciascuno, quindi per le coppie adiacenti esegui esponenziazione, modulo per 13, modulo per 2, somma e aggiungi uno).

— Jonathan Allan
fonte
Nuova gelatina veloce!
— user202729
2

Lotto, 69 byte

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

Prende l'input come un elenco di parametri della riga di comando indicizzati 0, ma è possibile utilizzare un elenco di lettere p, h, rin maiuscolo o minuscolo se si digita per set /a p=0, h=1, r=2primo. Spiegazione: bmantiene l'ultimo input (impostazione predefinita per 2per rilasciato) e nil conteggio delle presse. Ogni input aggiunge una stampa se l'ultimo input è stato un rilascio o l'input corrente è una stampa.

— Neil
fonte
Oh, setpuoi impostare più variabili contemporaneamente? Utile da sapere.
— user202729
1
@ user202729 set /aè una valutazione aritmetica, quindi finché tutte le variabili che si desidera impostare sono numeriche, è possibile utilizzare semplicemente l'operatore virgola per concatenare le espressioni di assegnazione.
— Neil
2

Python 2, 44 byte

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

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

Buccia , 6 5 byte

Lġo&ε

Provalo online! L'input è un elenco 0,1,2(il collegamento TIO utilizza le lettere per un più semplice incollaggio dei casi di test).

Spiegazione

Uso la stessa idea generale della risposta Jelly di Jonathan Allan : dividere le occorrenze delle "coppie di discontinuità" PP, HP, RH, RR e RP e contare i blocchi risultanti. Nella codifica 0,1,2, queste coppie sono esattamente quelle il cui elemento sinistro è 2 o l'elemento destro è 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
fonte
1

Javascript (ES6), 30 byte

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
Espandi frammento

— Herman L
fonte
1

Gelatina , 10 byte

Pn1></µƝS‘

Provalo online! o suite di test! ( Rubato in prestito da Jonathan.)

Alternativa:

P=1=</µƝS‘

Provalo online!

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.

Gelatina , 11 byte

Salvato 1 byte con l'aiuto di caird coinheringaahing.

ḅ3Ɲf⁽vḲD¤L‘

Provalo online!

— Mr. Xcoder
fonte
Ah, ho perso l'occasione di essere il primo a usare i vicini in fretta :(
— caird coinheringaahing
Puoi rimuoverlo μdal terzo
— caird coinheringaahing
1

Kotlin , 36 byte

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

Abbellire

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

Test

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
fonte
0

J , 18 17 byte

-1 Grazie a @FrownyFrog

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

Accetta input sotto forma di 0,1,2. La funzione di supporto su TIO converte i casi di test in questo modulo.

Provalo online!

La logica dei confronti può essere ancora golfabile. Sto torcendo il mio cervello in nodi cercando di pensare a dichiarazioni più equivalenti e più brevi.

Spiegazione (soluzione precedente)

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

L'unica differenza tra la soluzione attuale e quella precedente è come vengono generati i confronti. La soluzione corrente confronta esplicitamente gli elementi adiacenti compensando l'array e la soluzione precedente confronta gli elementi adiacenti osservando gli infissi di 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

Sarebbe molto più pulito se due prese non facessero nulla. Il codice accetta due di due e controlla se non sono ascendenti e non due prese. In questo caso, ne aggiungiamo uno al nostro conteggio finale. Dobbiamo aggiungere 1 alla fine poiché siamo spenti di uno altrimenti (o potresti anteporre uno _o qualsiasi valore maggiore di 2).

Il modo in cui controlla se l'infix è due hold è moltiplicando i due valori insieme e vedendo se è uno (due hold sono 1 1).

— ravizzone
fonte
1
1+1#.}:(<+:1=*)}.è uno più corto.
— FrownyFrog
@FrownyFrog intelligente, lo modificherò in.
— Cole
1
14:1+1#.0=}.*2-}:
— FrownyFrog
0

Vim + wc, 25 byte

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

␊è la chiave di ritorno ed ␘è Ctrl+X

Provalo online!

Spiegazione

: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
fonte
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.