Aidez pannenkoek à compter les presses A

28

pannenkoek2012 vise à compléter Super Mario 64 en appuyant le moins possible sur le bouton A, ce qui fait sauter Mario. Chaque "Une presse" se compose de trois parties:

  • En appuyant sur le bouton
  • Le tenir pendant n'importe quelle durée
  • Le libérer

Parties d'une presse A, d'après une vidéo de Pannenkoek2012

Voir cette vidéo (1:15 - 3:23) pour une excellente explication qui inclut l'image ci-dessus. (Cependant, ce défi n'utilisera pas la terminologie de la demi-presse et posera des obstacles qui nécessitent la publication de A.)

Tâche:

Étant donné une séquence d'obstacles nécessitant d'appuyer sur (P), de maintenir (H) ou de relâcher (R) le bouton A, émettez le plus petit nombre de pressions nécessaires pour les surmonter dans l'ordre indiqué. Le bouton A n'est initialement pas maintenu.

Formulé formellement: étant donné une chaîne S de caractères PHR, considérez les chaînes de forme (PH*R)*qui contiennent S comme sous-séquence, et sortez le plus petit nombre possible de Pdans une telle chaîne. Ou, alternativement, trouvez le plus petit nombre de morceaux de la forme dans P?H*R?laquelle S peut être divisé.

Exemple

Regardons l'entrée RHRPHHHR. Le bouton A ne démarre pas, donc pour surmonter l'obstacle initial, il Rfaut appuyer sur le bouton puis le relâcher (appuyez sur # 1). Ensuite, nous sommes tenus de maintenir le bouton H, ce qui nécessite encore une fois qu'il soit pressé (appuyez sur # 2). Ensuite, il peut ensuite être libéré après pour le satisfaire R. Enfin, le reste PHHHRpeut être satisfait par une seule pression (appuyez sur # 3) suivie d'un maintien HHHet d'un relâchement R. Ainsi, le nombre de sorties est de 3.

Une autre façon de le voir, c'est que nous pouvons diviser la chaîne d'entrée en 3 parties de formulaire PHH..HHRoù les lettres peuvent être omises.

R
HR
PHHHR

Format d'entrée

L'entrée sera une liste ou une chaîne d'éléments représentant appuyer, maintenir et relâcher comme votre choix de:

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

correspondant dans l'ordre donné. L'entrée ne sera pas vide.

Cas de 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

Classement:

Afficher l'extrait de code

code-golf sequence subsequence xnor
la source
1
Qu'en est-il des obstacles nécessitant de ne pas tenir le bouton A? Il y a quatre états de bouton dans le graphique (je pense que ceux-ci pourraient également exister dans le jeu)
Random832
3
En réalité, il y a 3 états: Presse, En attente et Non détenu. Aucun état ne nécessite une libération du bouton A. Le défi est légèrement faux par rapport à la réalité.
user202729
1
@ 11684 "en ce qui concerne la version, eh bien, il n'y a actuellement aucun cas où c'est utile ou important, alors ne vous inquiétez pas pour cette partie." (1:48 - 1:52)
user202729
3
Quelqu'un veut-il le faire dans l'assemblage MIPS? (la langue utilisée pour programmer Super Mario 64)
user202729
1
@ user202729 Wow, c'est une crêpe complète. Merci!
11684

Réponses:

3

Pyth , 13 octets

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

Essayez-le ici! ou Vérifiez tous les cas de test.

Notez que cela 1fonctionne également à la place de 3.

Comment ça marche?

tl: z "P? H * R?" 3 | Programme complet. Prend les entrées de STDIN, les sorties vers STDOUT.

  : z 3 | Fractionner la chaîne d'entrée sur les correspondances de ...
    "P? H * R?" | L'expression régulière "P? H * R?".
 l | Obtenez la longueur.
t | Décrémenter (car le fractionnement inclut la chaîne vide).

En savoir plus sur l'expression régulière:

P? | P - Le caractère littéral P, sensible à la casse.
       | ? - Quantificateur. Correspond à une ou zéro fois le caractère précédent.
  H * | H - Le caractère littéral H, sensible à la casse.
       | * - Quantificateur. Correspond à n'importe quel nombre d'occurrences du caractère précédent.
    R? | R - Le caractère littéral R, sensible à la casse.
       | ? - Quantificateur. Correspond à une ou zéro fois le caractère précédent.
M. Xcoder
la source
Ah, feck, tu m'as battu!
Shaggy
agréable! L'avant-dernière ligne de la description de l'expression rationnelle devrait indiquer "Caractère littéral R", n'est-ce pas?
vidstige
@vidstige Oui, merci. Corrigé
M. Xcoder
2

Gelée , 10 octets

o5ḄƝ%⁵>4S‘

Une chaîne monadique prenant une liste (l' P,H,R : 0,1,2option) et renvoyant un entier, le nombre.

Essayez-le en ligne! ou voir la suite de tests

Comment?

Fonctionne de manière efficace en obtenant toutes les paires adjacentes de comptage alors que tout ne sont pas des « paires de continuation » ( PR, PH, HR, ou HH) et en ajoutant une.

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

Solution précédente de 11 octets:

ḅ3Ɲạ3ḟ1,2L‘

Essayez-le en ligne! ou voir la suite de tests

Comment?

Fonctionne comme ci-dessus, mais d'une manière complètement différente ...

ḅ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

et un autre, encore très différent:

+19*Ɲ%13ḂS‘

(ajouter 19 à chacun, puis pour les paires adjacentes effectuer l'exponentiation, modulo par 13, modulo par 2, additionner et ajouter un).

Jonathan Allan
la source
Nouvelle gelée rapide!
user202729
2

Lot, 69 octets

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

Prend l'entrée comme une liste de paramètres de ligne de commande indexés sur 0, mais vous pouvez utiliser une liste de lettres p, h, ren majuscules ou en minuscules si vous tapez d' set /a p=0, h=1, r=2abord. Explication: bconserve la dernière entrée (par défaut à 2pour relâché) et nle nombre de pressions. Chaque entrée ajoute une presse si la dernière entrée était un communiqué ou si l'entrée actuelle est une presse.

Neil
la source
Oh, setpeut définir plusieurs variables à la fois? Utile à savoir.
user202729
1
@ user202729 set /aest une évaluation arithmétique, donc tant que toutes les variables que vous souhaitez définir sont numériques, vous pouvez simplement utiliser l'opérateur virgule pour concaténer les expressions d'affectation.
Neil
2

Python 2, 44 octets

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

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

Husk , 6 5 octets

Lġo&ε

Essayez-le en ligne! L'entrée est une liste 0,1,2(le lien TIO utilise des lettres pour un copier-coller plus facile des cas de test).

Explication

J'utilise la même idée générale que la réponse Jelly de Jonathan Allan : diviser sur les occurrences des "paires de discontinuités" PP, HP, RH, RR et RP, et compter les blocs résultants. Dans le codage 0,1,2, ces paires sont exactement celles dont l'élément gauche est 2 ou l'élément droit est 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
la source
1

Javascript (ES6), 30 octets

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
Développer l'extrait

Herman L
la source
1

Gelée , 10 octets

Pn1></µƝS‘

Essayez-le en ligne! ou Suite de tests! ( Volé emprunté à Jonathan.)

Alternative:

P=1=</µƝS‘

Essayez-le en ligne!

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.

Gelée , 11 octets

1 octet enregistré avec l'aide de caird coinheringaahing.

ḅ3Ɲf⁽vḲD¤L‘

Essayez-le en ligne!

M. Xcoder
la source
Aww, j'ai raté la chance d'être le premier à utiliser les voisins rapidement :(
caird coinheringaahing
Vous pouvez retirer le μdu troisième
caird coinheringaahing
1

Kotlin , 36 octets

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

Embellie

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

Tester

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
la source
0

J , 18 17 octets

-1 Merci à @FrownyFrog

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

Prend entrée sous la forme de 0,1,2. La fonction d'assistance sur TIO convertit les cas de test dans ce formulaire.

Essayez-le en ligne!

La logique des comparaisons peut encore être jouable. Je tord mon cerveau en nœuds en essayant de penser à des déclarations plus équivalentes et plus courtes.

Explication (solution précédente)

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

La seule différence entre la solution actuelle et la précédente est la façon dont les comparaisons sont générées. La solution actuelle compare explicitement les éléments adjacents en décalant le tableau et la solution précédente compare les éléments adjacents en examinant les infixes 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

Ce serait beaucoup plus propre si deux prises ne faisaient rien. Le code prend des infixes de deux et vérifie s'ils ne sont pas ascendants et non deux fois. Si tel est le cas, nous en ajoutons un à notre décompte final. Nous devons ajouter 1 à la fin car nous sommes hors de l'un sinon (ou vous pouvez ajouter une _ou toute valeur supérieure à 2).

La façon dont il vérifie si l'infixe est deux prises consiste à multiplier les deux valeurs ensemble et à voir s'il s'agit d'une seule (deux prises le sont 1 1).

cole
la source
1
1+1#.}:(<+:1=*)}.est un plus court.
FrownyFrog
@FrownyFrog intelligent, je vais le modifier.
cole
1
14:1+1#.0=}.*2-}:
FrownyFrog
0

Vim + wc, 25 octets

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

␊est la touche de retour et ␘est Ctrl+X

Essayez-le en ligne!

Explication

: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
la source