Comptez les allumettes


20

La plupart des gens ici connaissent les affichages à sept segments, qui sont également utilisés dans les puzzles à allumettes. Voici les chiffres 0par 9lettres et apar z, à l' exception k,m,t,v,w, écrites dans ce format.

 _        _   _         _    _    _    _    _
| |   |   _|  _|  |_|  |_   |_     |  |_|  |_|
|_|   |  |_   _|    |   _|  |_|    |  |_|   _|

 _       _      _  _  _                        _   _      _               _
|_| |_  |   _| |_ |_ |   |_  |   | |   _   _  |_| |_|  _ |_      |_| |_|  _|
| | |_| |_ |_| |_ |  |_| | | | |_| |_ | | |_| |     | |   _| |_| | |   | |_

Le défi ici est simple. Étant donné une chaîne d'entrée, affichez le nombre d'allumettes nécessaires pour représenter cette chaîne. Si la chaîne contient un caractère en dehors de la représentation ci-dessus, ignorez-le (comptez-le comme 0).

Par exemple, pour l'entrée 53, un total d' 10allumettes sont nécessaires, 5pour le 5et 5pour le 3, donc la sortie l'est 10.

Pour l'entrée, helloun total d' 19allumettes sont nécessaires h (4), e (5), l (3), l (3), o (4), donc la sortie l'est 19.

Pour plus de clarté, voici les allumettes nécessaires pour construire chaque personnage:

0 -> 6
1 -> 2
2 -> 5
3 -> 5
4 -> 4
5 -> 5
6 -> 6
7 -> 3
8 -> 7
9 -> 6
a -> 6
b -> 5
c -> 4
d -> 5
e -> 5
f -> 4
g -> 5
h -> 4
i -> 2
j -> 4
l -> 3
n -> 3
o -> 4
p -> 5
q -> 5
r -> 2
s -> 5
u -> 3
x -> 5
y -> 4
z -> 5

Maintenant, pour la torsion, et il y en a deux.

  • La première est que l'entrée est considérée comme sensible à la casse. Autrement dit, Aet adevraient tous deux compter pour les 6allumettes, même si la représentation visuelle ressemble à une majuscule A.
  • Votre score est votre code source exécuté à travers cet algorithme, plus la longueur de votre code source en octets, plus c'est bas, mieux c'est. Par exemple, si votre code source était abc123, votre score serait 6+5+4+2+5+5 = 27 + 6 = 33. Si votre code source l'était #&@()*, votre score serait 0 + 6 = 6.

Exemples d'entrées / sorties

0    -> 6
53   -> 10
111  -> 6
112  -> 9
8888 -> 28
hello -> 19
PPCG  -> 19
Programming Puzzles & Code Golf -> 99
#&()mt!!~ -> 0
*DḌƤÆE%Ḅċ0 -> 16

Règles

  • Le cas échéant, vous pouvez supposer que l'entrée / sortie s'adaptera au type Integer natif de votre langue.
  • L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
  • Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
  • Les failles standard sont interdites.

2
T s'écrit couramment |_\n|_(en minuscules t)
12Me21

@ 12Me21 J'avais envisagé de faire quelque chose comme ça, mais je ne pensais pas que cela semblait assez proche de la lettre, alors je l'ai laissé de côté.
AdmBorkBork du

Et votre lettre X (H)? (eh bien, je n'a plus d'importance maintenant qu'il y a une réponse.)
12Me21

Pour les caractères extérieurs [0-9a-z], faut-il compter 0 allumettes? C'est ce que je comprends de votre score est votre code source exécuté à travers cet algorithme , plus la longueur de votre code source en octets .
Erik the Outgolfer

@EriktheOutgolfer Oui, c'est exact.
AdmBorkBork

Réponses:


8

Python 2 , 97 octets + 237 correspondances = 334

lambda w:sum(map(('1ir'*2+'7lnu'*3+'4cfhjoy'*4+'235bdegpqsxz'*5+'069a'*6+'8'*7).count,w.lower()))

Essayez-le en ligne!

Cela fonctionne en générant une chaîne où chaque personnage à construire apparaît la même quantité d'allumettes nécessaires pour construire ce personnage


Un caractère peut être enregistré avec +'069a8'*6+'8')au lieu de +'069a'*6+'8'*7).
xbarbie

@xbarbie en effet, mais cela augmenterait le nombre de matchs, ce qui donnerait +3 points
Rod

6

Perl 5 avec -pF, 95 octets + 14, 109

eval~"Û£Ô„…ÊÏÉÎÍÍÊÌÊËËÊÊÉÉÈÌÇÈÆÉžÉʜ˛ʚʙ˘ʗ˖͕˓̑ÌËÊŽÊ͌ʊ̇ʆËÂÐÑИ‚ÒÁ„Ô“œ‚™¿¹"}{

Cela équivaut à:

$\+={z506122535445566738796a6b5c4d5e5f4g5h4i2j4l3n3o4p5q5r2s5u3x5y4=~/./g}->{+lc}for@F

mais en utilisant l' ~opérateur, nous pouvons utiliser des caractères à octets élevés et éviter beaucoup de caractères sans vraiment sacrifier les octets.

Encore loin du score de Ton, même avec de l'aide!

Essayez-le en ligne!

Cette solution contient des non imprimables, voici donc un vidage hexadécimal réversible pour vérifier le nombre d'octets:

00000000: 6576 616c 7e22 dba3 d4c2 8485 cacf c9ce  eval~"..........
00000010: cdcd cacc cacb cbca cac9 c9c8 ccc7 c8c6  ................
00000020: c99e c99d ca9c cb9b ca9a ca99 cb98 ca97  ................
00000030: cb96 cd95 cb93 cc91 cc90 cb8f ca8e ca8d  ................
00000040: cd8c ca8a cc87 ca86 cbc2 81d0 d1d0 9882  ................
00000050: d2c1 84d4 939c 8299 908d bfb9 227d 7b    ............"}{

Pourquoi }{? Déposez-le et l' -noption. Vous oubliez aussi +lcau lieu de lc():-)
Ton Hospel

@TonHospel Goddammit! J'ai même regardé nos deux articles et je ne me souvenais pas sur quel article je l'avais vu et cela +ne me vient pas immédiatement à l'esprit! J'ai besoin nsur ma machine et oublie que je peux la laisser tomber!
Dom Hastings

Désolé, j'ai mal parlé. Je voulais dire "laisser tomber le }{et -p" (et le remplacer par -nsi votre perl en a toujours besoin. De nos jours, cela ne compte pas de toute façon)
Ton Hospel

@TonHospel Je n'avais pas mis à jour mon code au plus tard, oups ...
Dom Hastings

6

JavaScript (ES6), 198 (102 octets + 96 allumettes)

5 points économisés grâce à @ l4m2

v=>[...v].map(w=>t+=('{w__^_{]|{{_^__^_^w^~]~]^__w_~]~~_^_'[parseInt(w,36)]+v).charCodeAt()%9,t=+[])|t

Essayez-le en ligne!

Comment?

Nous utilisons le code ASCII modulo 9 de caractères qui n'ajoutent aucune pénalité pour encoder le nombre d'allumettes.

 char. | code | modulo 9
-------+------+-----------------
   ~   |  126 |   0
   v   |  118 |   1  (not used)
   w   |  119 |   2
   ]   |   93 |   3
   ^   |   94 |   4
   _   |   95 |   5
   {   |  123 |   6
   |   |  124 |   7

Nous n'avons pas à nous soucier du cas car il parseInt()est insensible à la casse.

Pour les caractères qui ne correspondent pas à [0-9A-Za-z] , parseInt()renvoie NaNet la recherche de chaîne se traduit par undefined. Une fois contraint à une chaîne, "undefined".charCodeAt()retourne le code ASCII de "u", qui est 117 . Idéalement, 117 modulo 9 donne 0 comme prévu.


v=>[...v].map(w=>t+='~{w__^_{]|{{_^__^_^w^~]~]^__w_~]~~_^_'.charCodeAt(1+parseInt(w,36))%9,t=+[])|t1 de moins
l4m2

5

Gelée , 42 octets + 0 allumettes = 42 points

“ṄḟṭkɗØæ⁶ṡ“£ƈṠ¤żȥṬ}ė$t¿ƬⱮȷ|çƓ’×/ṚṚæ.ċЀØW$

Merci à @JonathanAllan pour -2 points!

Essayez-le en ligne!

Comment ça fonctionne

“ṄḟṭkɗØæ⁶ṡ“£ƈṠ¤żȥṬ}ė$t¿ƬⱮȷ|çƓ’

Les littéraux qui commencent et se terminent par split on , remplacent les caractères restants par leurs index basés sur 1 dans la page de codes de Jelly, puis convertissent de la base bijective 250 en entier.

Ce littéral particulier code

[3096734725226860846495, 211369264881118657055472842435156679693648].

×/ réduit par multiplication, donnant

654554542403034552503005456545545424030345525030054562554563760

(L'encodage direct de cet entier économiserait 6 octets, mais coûterait 28 allumettes.)

ṚṚinverse deux fois; le premier appel promeut un entier dans son tableau de chiffres. Cela donne

[6, 5, 4, 5, 5, 4, 5, 4, 2, 4, 0, 3, 0, 3, 4, 5, 5, 2, 5, 0, 3, 0, 0, 5, 4, 5, 6, 5, 4, 5, 5, 4, 5, 4, 2, 4, 0, 3, 0, 3, 4, 5, 5, 2, 5, 0, 3, 0, 0, 5, 4, 5, 6, 2, 5, 5, 4, 5, 6, 3, 7, 6, 0]

ċЀØW$compte ( ċ) les occurrences de chaque ( Ѐ) caractère de "A ... Za ... z0 ... 9_" ( ØW) dans la chaîne d'entrée.

Prend enfin æ.le produit scalaire, multipliant chaque nombre de caractères par le coût correspondant en allumettes, puis en prenant la somme.


Utilisez une factorisation du grand nombre pour enregistrer un octet et une décompression de base et modulo au lieu d' Den enregistrer un autre. Essayez-le en ligne
Jonathan Allan

octet ... point d'erreur :)
Jonathan Allan

1
Et un de plus avec Ɗ. Merci!
Dennis

3

Perl 5 -p , 90 64 code + 9 harnais d'évaluation + 14 allumettes = 87

Remplacez les codes hexadécimaux par leur variante littérale de 1 octet ( pas UTF-8 comme TIO essaie de le faire) pour le score revendiqué

eval~"\xdb\xa3\xd4\xc2\x86\xd0\xcf\xd2\xc6\x9e\xd2\x85\xd0\xc9\xcd\xca\xca\xcb\xca\xc9\xcc\xc8\xc9\xc9\xca\xcb\xca\xca\xcb\xca\xcb\xcd\xcb\xcf\xcc\xcf\xcc\xcb\xca\xca\xcd\xca\xcf\xcc\xcf\xcf\xca\xcb\xca\xd0\x8d\x99\x90\x8d\xdf\x93\x9c\xc2\x81\xd0\xd1\xc0\xd0\x98"}{

Essayez-le en ligne!

Code À l'intérieur de la chaîne complétée:

$\+=y/0-9a-z/625545637665455454240303455250300545/rfor lc=~/.?/g

3

Gelée , 34 octets + 3 correspondances = 37

⁽[ɱד®-&]Ṙṙ£⁺ÐĊṂⱮɼ ’‘ḤṚæ.ŒlċЀØWṚƊ

Un lien monadique acceptant une liste de caractères et renvoyant un entier.

Essayez-le en ligne!

Comment?

Fonctionne de manière similaire à la réponse de Dennis 'Jelly mais a pris suffisamment d'efforts pour que je pense que cela mérite une autre réponse. La principale différence est qu'elle met en minuscules l'entrée pour un coût de trois correspondances ( Œlcontient un l), ce qui permet ensuite d'utiliser un nombre beaucoup plus petit pour créer le tableau des coûts. La difficulté était de trouver un moyen de construire ce nombre sans correspondance tout en restant concis.

ØWdonne "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"donc que le comptage des occurrences d'entrée en minuscules commence toujours par 26 zéros. Nous pouvons inverser cela et effectuer un produit scalaire avec un tableau de longueur 37 au lieu de l'un de longueur 63.

⁽[ɱד®-&]Ṙṙ£⁺ÐĊṂⱮɼ ’‘ḤṚæ.ŒlċЀØWṚƊ - Link: list of characters
⁽[ɱ                                - literal                                     23913
    “®-&]Ṙṙ£⁺ÐĊṂⱮɼ ’               - literal         136861653160003879166772353166783
   ×                               - multiply  = 3272772712015172762515027281277281879
                    ‘              - increment = 3272772712015172762515027281277281880
                     Ḥ             - double    = 6545545424030345525030054562554563760
                      Ṛ            - reverse (implicit decimal list) -> [0,6,7,3,6,5,4,5,5,2,6,5,4,5,0,0,3,0,5,2,5,5,4,3,0,3,0,4,2,4,5,4,5,5,4,5,6]
                                   -                     (to align with: _ 9 8 7 6 5 4 3 2 1 0 z y x w v u t s r q p o n m l k j i h g f e d c b a)
                                 Ɗ - last four links as a monad:
                         Œl        -   lower-case (the input)
                              ØW   -   word -> "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"
                            Ѐ     -   map across right:
                           ċ       -     count (right character in lower-cased input)
                                Ṛ  -   reverse (to align with the values as shown above)
                       æ.          - dot-product

2

PHP 176 octets = 397 score

<?$n="6255456376";$l="065455454240303455250300545";$a=strtolower($argv[1]);for($i=0;$i<strlen($a);$i++)$t+=(is_numeric($a[$i])?$n[$a[$i]]:$l[max((ord($a[$i])-96),0)]);echo$t;

Essayez-le en ligne!


1
Bienvenue chez PPCG!
AdmBorkBork



1

Rubis , 125 octets + 87 allumettes = 212

->m{v=->w,k{w.scan(/./).map &k};v[m,->t{v["!#&&;&=$(==&;&&;&;#;!$!$;&&#&!$!!&;&",->k{k.ord%11}][t.to_i 36].to_i+(t==?0?6:0)}].sum}

Essayez-le en ligne!

Fortement inspiré par la réponse Javascript Arnauld .

Normalement, le coût de déclarer un lambda à utiliser seulement deux fois ne vaut pas la peine, mais le poids de l'allumette " scanap" en a .scan(/./).mapchangé cela. C'était un défi amusant!

->m{
  v=->w,k{w.scan(/./).map &k};                # v is a lambda taking a string and a block
  v[m,->t{                                    # Transform each char t of the input:
    v["!#&&;&=$(==&;&&;&;#;!$!$;&&#&!$!!&;&", # Transform each char of this magic string
      ->k{k.ord%11}                           #  into a matchstick count ([0,2,5,5,4,5...])
    ][t.to_i 36]+                             # Parse t as a base 36 index into the counts
    (t==?0?6:0)                               # If t was "0", add 6 matchsticks
  }].sum                                      # Add the counts for all characters
}


1

R, 112 octets + 319 correspondances = 431 points

sum(strtoi(el(strsplit(chartr("0-9a-z","625545637665455454240303455250300545",tolower(scan(,""))),""))),na.rm=T)

Essayez-le en ligne!

Bravo à Giuseppe qui a proposé cette amélioration.

Ancienne version, 143 octets + 454 correspondances = 597 points

b=el(strsplit(chartr("0123456789abcdefghijlnopqrsuxyz","6255456376654554542433455253545",tolower(readline())),""))
sum(as.numeric(b[b%in%0:9]))

Pour faire le el() fonction fonctionne sur TIO, vous devez utiliser library(methods).

Mon Dieu, c'est R verbeux!


TIO, pour une raison quelconque, ne charge pas automatiquement le methodspackage, mais comme il s'agit d'un basepackage, je l'ai toujours inséré dans l'en-tête et ne le compte pas pour le nombre d'octets. readlinene fonctionnera pas non plus sur TIO car ce n'est pas une session interactive. C'est définitivement golfable, cependant.
Giuseppe


^ a cependant besoin de guillemets autour des entrées contenant des espaces.
Giuseppe

De plus, je viens de commencer un salon de discussion pour le golf R! ! J'ai vu beaucoup de réponses dans R récemment par beaucoup d'utilisateurs différents, ce qui est assez encourageant :)
Giuseppe

@Giuseppe Je pense que vous devriez publier votre réponse séparément. Il est différent en principe et bien supérieur au mien.
Andreï Kostyrka

1

Perl 6 , 87 octets + 26 allumettes = 113

{+[+] (~'򘮉򛫡񯌞𺪯񯉒񉘁'.ords~~m:g/\w/)[m:g/<[/..{]-[\W_]>/>>.&{:٣٦(~$_)}]}

Essayez-le en ligne!

Utilise certains caractères Unicode non ASCII. La table de recherche est codée dans une chaîne Unicode:

say '򘮉򛫡񯌞𺪯񯉒񉘁'.ords;
# (625545 637665 455454 240303 455250 300545)

Les caractères sont convertis en indices avec une conversion en base 36 à l'aide de chiffres arabes:

:٣٦('z'); # is equivalent to
:36('z');

1

sed, 367 (octets de code source) + 532 (quantité d'allumettes pour le code source) = 899

s/[^0-9a-jln-suxyz]//Ig;/^$/{s/.*/0/;b};s/.+/&; %1ir %%7lnu %%%4cfhjoy %%%%235bdegpqsxz %%%%%069a %%%%%%8/;:1;s/([^% ])(.+ (%+)[^ ]*\1)/%\3 \2/I;/ ;/!b1;s/;.+//;s/^/,;/;:2;s/(;[^%]*)(%+)/\2\1/;:3;s/,%{10}/%,/;s/^%/,&/;/%{10}/b3;/;.*%/b2;:4;s/,[;,]/,0,/;/,[;,]/b4;s/%{9}/9/g;s/%{8}/8/g;s/%{7}/7/g;s/%{6}/6/g;s/%{5}/5/g;s/%%%%/4/g;s/%%%/3/g;s/%%/2/g;s/%/1/g;s/[^0-9]//g

Essayez-le en ligne

Version multiligne:

s/[^0-9a-jln-suxyz]//Ig
/^$/{s/.*/0/;b}
s/.+/&; %1ir %%7lnu %%%4cfhjoy %%%%235bdegpqsxz %%%%%069a %%%%%%8/
:1
s/([^% ])(.+ (%+)[^ ]*\1)/%\3 \2/I
/ ;/!b1
s/;.+//
s/^/,;/
:2
s/(;[^%]*)(%+)/\2\1/
:3
s/,%{10}/%,/
s/^%/,&/
/%{10}/b3
/;.*%/b2
:4
s/,[;,]/,0,/
/,[;,]/b4
s/%{9}/9/g
s/%{8}/8/g
s/%{7}/7/g
s/%{6}/6/g
s/%{5}/5/g
s/%%%%/4/g
s/%%%/3/g
s/%%/2/g
s/%/1/g
s/[^0-9]//g

Explication:

Le script ci-dessus lit l'entrée ligne par ligne standard (dans l'espace de motif - la "voie sed" habituelle) et, pour chaque ligne, il génère le nombre d'allumettes nécessaires pour représenter tous les caractères représentables par les allumettes de cette ligne. Les calculs pour chaque ligne d'entrée se produisent comme suit:


s/[^0-9a-jln-suxyz]//Ig

Tout d'abord, nous supprimons tous les caractères pour lesquels nous n'avons pas de représentation de matchstick correspondante (comme indiqué sur la question) de l'espace de motif. Autrement dit, nous supprimons chaque caractère qui n'est pas non plus un chiffre de "0" à "9", une lettre de "a" à "j", "n" à "s", "l", "u", "x", "y" ou "z". Les lettres majuscules et minuscules sont traitées de la même manière.

/^$/{s/.*/0/;b}

Si nous nous retrouvons avec un espace de motif vide, nous imprimons 0 (automatiquement suivi d'une nouvelle ligne, comme sed le fait toujours sauf si vous lui passez un drapeau spécial), sautez toutes les lignes postérieures du script et passez au prochain "cycle sed" ( c'est-à-dire, lisez la ligne d'entrée suivante et répétez le traitement à nouveau depuis la première commande jusqu'à ce qu'il n'y ait plus de lignes d'entrée à traiter).

s/.+/&; %1ir %%7lnu %%%4cfhjoy %%%%235bdegpqsxz %%%%%069a %%%%%%8/

Sinon, si l'espace de motif n'est pas vide, nous le divisons maintenant en deux "sous-espaces" séparés par un point-virgule: vient d'abord l' espace d'entrée , qui est initialement formé par tous les caractères qui n'ont pas été supprimés de l'espace de motif après la exécution de la ligne 1; vient ensuite le point-virgule, puis l' espace de carte .

L'espace de la carte nous indique combien d'allumettes à côté de 1 sont nécessaires pour représenter chaque caractère alphanumérique pertinent. Si nous voulons savoir combien d'allumettes sont nécessaires pour représenter un caractère alphanumérique dans l'espace de la carte, nous recherchons la première séquence de% contigus à gauche de ce caractère, et la réponse sera le nombre de% dans cette séquence plus 1. Ainsi, par exemple, le nombre d'allumettes nécessaires pour représenter un "b" est 4 + 1 = 5; pour représenter un "4", 3 + 1 = 4, pour représenter un "y", 3 + 1 = 4; etc.

:1
s/([^% ])(.+ (%+)[^ ]*\1)/%\3 \2/I
/ ;/!b1

Ceci est une boucle. Maintenant, nous allons remplacer chaque caractère dans l'espace d'entrée par la séquence (complète) de% dont le nombre indique la quantité nécessaire de correspondances pour représenter ce caractère, et suivre cette séquence par un caractère d'espace blanc (encore une fois, les lettres majuscules et minuscules sont le même traitement). Le critère pour déterminer si la boucle doit se terminer est de vérifier s'il y a un caractère d'espace blanc immédiatement à gauche du point-virgule dans l'espace de motif: si cette condition est remplie, nous terminons la boucle et continuons dans la ligne suivante.

s/;.+//
s/^/,;/

Ces deux lignes suppriment le point-virgule et tout ce qui se trouve après de l'espace de motif, puis insèrent une virgule et un point-virgule au début de l'espace de motif. Nous avons maintenant l'espace de motif divisé à nouveau en deux nouveaux sous-espaces: l' espace de résultat analogique avant le point-virgule et l' espace d'entrée analogique après celui-ci.

L'espace d'entrée analogique est exactement ce que nous avons appelé précédemment «l'espace d'entrée», mais sous une forme différente: il contient maintenant des séquences de% séparées par un espace blanc. Le nombre total de ces% dans l'espace d'entrée analogique est le même nombre d'allumettes nécessaires pour représenter la chaîne de caractères d'entrée initiale, c'est-à-dire que ce nombre est le résultat. Mais nous devons imprimer ce résultat en notation décimale, pas comme une séquence de signes de pourcentage. Le but de l' espace de résultat analogique est de contenir une représentation analogique de chaque chiffre du résultat pendant que nous calculons ce résultat en sommant une à une chaque séquence contiguë de% dans l'espace d'entrée analogique. La boucle suivante effectue cette somme:

:2
s/(;[^%]*)(%+)/\2\1/
    :3
    s/,%{10}/%,/
    s/^%/,&/
    /%{10}/b3
/;.*%/b2
  1. Tout d'abord, après l'étiquette 2 , nous déplaçons la prochaine séquence contiguë de% après le point-virgule de l'espace d'entrée analogique vers la gauche immédiate du point-virgule, dans l'espace de résultat analogique;

  2. Ensuite, nous entrons dans une sous-boucle (étiquette 3 ) qui effectue les calculs suivants:

    • S'il y a une séquence contiguë de dix% après une virgule dans l'espace de résultat analogique, nous supprimons ces% et mettons un seul% immédiatement à gauche de la virgule. Pour dire les choses simplement, cela indique que l'une des décimales dans le résultat a acquis plus de 9 unités, donc nous enlevons 10 unités de cette décimale et ajoutons 1 unité à la décimale suivante la plus grande;

    • Si un "%" est le premier caractère de l'espace de motif, nous insérons une nouvelle virgule juste avant. Cela indique que la somme a atteint une valeur dont la représentation décimale a une décimale de plus à gauche que la valeur précédente;

    • S'il y a encore une séquence contiguë de dix% dans l'espace de résultat analogique, nous revenons à l'étiquette 3 et répétons ce processus. Sinon, nous quittons cette sous-boucle et passons à la ligne suivante.

  3. Maintenant, s'il y a encore un "%" dans l'espace d'entrée analogique (c'est-à-dire après le point-virgule), cela signifie qu'il y a encore un certain nombre d'allumettes à ajouter à la somme totale - nous revenons donc à l'étiquette 2 .

Une fois la somme terminée, nous entrons dans la boucle finale du code:

:4
s/,[;,]/,0,/
/,[;,]/b4

Ici, nous vérifions chaque paire de caractères formée d'une virgule à gauche et d'un point-virgule ou d'une virgule à droite. Nous remplaçons toutes ces paires de caractères par un "0" à l'intérieur de deux virgules.

s/%{9}/9/g
s/%{8}/8/g
s/%{7}/7/g
s/%{6}/6/g
s/%{5}/5/g
s/%%%%/4/g
s/%%%/3/g
s/%%/2/g
s/%/1/g

Le morceau de code ci-dessus est assez simple: nous remplaçons chaque séquence contiguë de% dans l'espace de résultat analogique par un caractère décimal qui correspond au nombre de% dans chaque séquence particulière.

s/[^0-9]//g

Enfin, nous supprimons tous les caractères non numériques de l'espace de motif et ce qui reste est le résultat final dans la notation décimale familière. Cette valeur est imprimée sur la sortie standard et le cycle sed suivant commence, s'il reste d'autres lignes d'entrée à traiter.




1

Java 10, 452 432 416 404 (145 octets + 259 correspondances)

k->{int m=0,t;for(var w:k)for(t=m-m;t<'';)m+="1ir 7lnu 4cfhjoy 235bdegpqsxz 069a 8".split(" ")[t++].contains((char)(w|32)+"")?-~t:t-t;return m;}

Explication:

Essayez-le en ligne.

k->{                   // Method with character-array parameter and int return-type
  int m=0,             //  Result-integer, starting at 0
      t;               //  Index-integer
  for(var w:k)         //  Loop over the input String-array
    for(t=m-m;t<'';)   //   Inner loop over the parts array with index [0,6)
      m+="1ir 7lnu 4cfhjoy 235bdegpqsxz 069a 8".split(" ")[t++]
                       //     If the current part ordered by amount of matches (2-8)
         .contains((char)(w|32)+"")?
                       //     contains the current (lowercase) letter
          -~t          //      Increase the result by the index + 2
         :             //     Else:
          t-t;         //      The result remains the same by adding 0
  return m;}           //  Return the result
  • Les noms de variables $ραετsont utilisés à la place des lettres. EDIT: noms de variableskmtvw sont désormais utilisés à la place, car ils ne peuvent pas être formés par des correspondances selon la description du défi.
  • ''(non imprimable) est utilisé à la place de 6.
  • m-met t-tsont utilisés à la place de 0.
  • (char)(w|32)+""avec une entrée de tableau de caractères utilisée au lieu d'une entrée de tableau de w.toLowerCase()chaînes.

0

AutoHotkey , 148 octets + 345 allumettes = 493

Celui-ci était un peu difficile à raccourcir.

n:=["1ir","7lnu","4cfhjoy","235bdegpqsxz","09a5",7+1]
Loop Parse,i
{r:=A_LoopField
Loop % n.Length()
{l:=A_Index
if InStr(n[l],r)
u+=l+1
}}
send % u

0

Python 3 , 123 octets + 65 correspondances = 188

lambda w,m='',t='',k=ord:sum(~-k((m+t+m+''+t)[k(v)%77])*('/'<v<'{')for v in w)

Une fonction sans nom acceptant une chaîne et renvoyant un entier.

Contient de nombreux caractères non imprimables (en particulier les octets un à huit).

Essayez-le en ligne!


0

Fusain , 48 octets + 3 = 51

IΣEθ⎇№α↥ιI§”)➙⊞←!Σw➙⊙↘⁴↘”⌕α↥ι∧№IX²φιI§”)⧴u↑$◨”Iι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

IΣEθ

Parcourez les caractères de l'entrée, calculez le nombre de correspondances de chacun, puis additionnez le résultat, convertissez-le en chaîne et imprimez implicitement.

⎇№α↥ι

Si c'est une lettre ...

I§”)➙⊞←!Σw➙⊙↘⁴↘”⌕α↥ι

Recherchez le nombre d'allumettes dans la chaîne compressée 65455454240303455250300545.

∧№IX²φι

Sinon s'il apparaît dans la valeur de 2 ** 1000...

I§”)⧴u↑$◨”Iι

Recherchez le nombre d'allumettes dans la chaîne compressée 6255456376.


0

PHP, 98 + 253 = 351

for(;$k=ord($argn[$v++]);)$m+=$k>64?_65455454240303455250300545[$k&31]:_6255456376[$k-47];print$m;

Exécuter en tant que pipe avec -nrou l' essayer en ligne .

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.