Większość ludzi zna tu siedmiosegmentowe wyświetlacze, które są również używane w puzzlach. Poniżej znajdują się cyfry 0przez 9i litery apoprzez z, z wyjątkiem k,m,t,v,w, napisane w tym formacie.

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

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

Wyzwanie jest tutaj proste. Biorąc pod uwagę ciąg wejściowy, wypisz liczbę zapałek wymaganych do reprezentacji tego ciągu. Jeśli ciąg zawiera znak spoza powyższej reprezentacji, zignoruj ​​go (policz jako 0).

Na przykład, dla danych wejściowych 53, 10wymagana jest suma zapałek, 5dla 5i 5dla 3, więc wyjście jest 10.

Do wprowadzenia wymagane są hellowszystkie 19zapałki h (4), e (5), l (3), l (3), o (4), więc wynik jest 19.

Dla jasności, oto zapałki potrzebne do zbudowania każdej postaci:

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

Teraz coś dziwnego, a są ich dwa.

• Pierwszym jest to, że wejście jest uważany CASE- w czuły. To znaczy, Ai aoba powinny liczyć się z 6zapałkami, mimo że reprezentacja wizualna wygląda jak duża litera A.
• Twój wynik to kod źródłowy przebiegający przez ten algorytm, plus długość kodu źródłowego w bajtach, im niższa, tym lepiej. Na przykład, jeśli kod źródłowy był abc123, wynik byłby 6+5+4+2+5+5 = 27 + 6 = 33. Jeśli kod źródłowy był #&@()*, wynik byłby 0 + 6 = 6.

Przykłady wejścia / wyjścia

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

Zasady

• Jeśli ma to zastosowanie, możesz założyć, że wejście / wyjście będzie pasować do rodzimego typu Integer w twoim języku.
• Dane wejściowe i wyjściowe można podać dowolną dogodną metodą .
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Standardowe luki są zabronione.

Python 2 , 97 bajtów + 237 dopasowań = 334

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

Wypróbuj online!

Działa to poprzez generowanie ciągu, w którym każda postać do zbudowania wydaje taką samą ilość zapałek potrzebnych do zbudowania tej postaci

Perl 5 z -pF, 95 bajtów + 14, 109

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

Jest to równoważne z:

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

ale za pomocą ~operatora możemy używać znaków bajtowych i unikać wielu znaków bez poświęcania bajtów.

Nadal całkiem daleko od wyniku Tona, nawet z pomocą!

Wypróbuj online!

To rozwiązanie zawiera niedrukowalne, dlatego oto odwracalny zrzut heksadecymalny w celu weryfikacji liczby bajtów:

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    ............"}{

JavaScript (ES6), 198 (102 bajty + 96 zapałek)

Zaoszczędź 5 punktów dzięki @ l4m2

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

Wypróbuj online!

W jaki sposób?

Używamy kodu ASCII modulo 9 znaków, które nie dodają żadnej kary do kodowania liczby zapałek.

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

Nie musimy się martwić o sprawę, ponieważ parseInt()nie uwzględnia ona wielkości liter.

W przypadku znaków, które nie pasują do [0-9A-Za-z] , parseInt()zwracane są wyniki, NaNa wynikiem wyszukiwania łańcucha jest undefined. Po przymuszeniu do ciągu "undefined".charCodeAt()zwraca kod ASCII "u", który ma wartość 117 . Dogodnie 117 modulo 9 daje 0 zgodnie z oczekiwaniami.

Galaretka , 42 bajty + 0 zapałek = 42 punkty

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

Dzięki @JonathanAllan za -2 punkty!

Wypróbuj online!

Jak to działa

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

Literały, które zaczynają się “i kończą z ’podziałem na “, zastępują pozostałe znaki ich indeksami opartymi na 1 na stronie kodowej Jelly, a następnie konwertują z bazy bijective 250 na liczbę całkowitą.

Ten konkretny dosłowny kod

[3096734725226860846495, 211369264881118657055472842435156679693648].

×/ zmniejsza przez pomnożenie, dając

654554542403034552503005456545545424030345525030054562554563760

(Bezpośrednie kodowanie tej liczby całkowitej pozwoliłoby zaoszczędzić 6 bajtów, ale kosztowało 28 zapałek.)

ṚṚcofa się dwukrotnie; pierwsze wywołanie promuje liczbę całkowitą w swojej tablicy cyfr. To daje

[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$zlicza ( ċ) wystąpienia każdego ( Ѐ) znaku „A ... Za ... z0 ... 9_” ( ØW) w ciągu wejściowym.

Wreszcie æ.bierze iloczyn iloczynu, mnożąc liczbę znaków przez odpowiedni koszt w zapałkach, a następnie biorąc sumę.

Perl 5 -p , 90 64 code + 9 eval harness + 14 zapałek = 87

Zamień kody szesnastkowe na ich dosłowny wariant 1-bajtowy ( nie UTF-8, jak TIO próbuje) dla zadeklarowanego wyniku

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"}{

Wypróbuj online!

Kod Wewnątrz uzupełnionego łańcucha:

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

Galaretka , 34 bajty + 3 mecze = 37

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

Monadyczny link akceptujący listę znaków i zwracający liczbę całkowitą.

Wypróbuj online!

W jaki sposób?

Działa w podobny sposób, jak odpowiedź Jelly'ego na Jelly, ale dołożyła wystarczającego wysiłku, aby moim zdaniem uzasadnić inną odpowiedź. Zasadnicza różnica polega na tym, że nakłady na małe litery kosztują trzy dopasowania ( Œlzawiera an l), co następnie pozwala na użycie znacznie mniejszej liczby do utworzenia tablicy kosztów. Problem polegał na znalezieniu sposobu na skonstruowanie tej liczby bez dopasowań, pozostając zwięzłym.

ØWdaje wynik, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"więc liczenie wystąpień małych liter zawsze zaczyna się od 26 zer. Możemy to odwrócić i wykonać iloczyn skalarny o tablicy o długości 37 zamiast o długości 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

PHP 176 bajtów = 397 punktów

<?$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;

Wypróbuj online!

SOGL V0.12 , 34 bajty + 18 = 52

ā⁄,u{²²z+;W"⁾o∫k9÷│>Γ{σ¬μ┼“'=υ─wι+

Wypróbuj tutaj!

Grał w golfa, ale nie zdobył tyle punktów :

0,u{²²z+;W"⁾o∫k9÷│>Γ{σ¬μ┼“8─wι+

Python 3 , 138 + 265 = 403 bajtów

k='0123456789abcdefghijlnopqrsuxyz'
m=lambda t:sum([ord(''[k.index(v)])if v in k else 0for v in t.lower()])

Wypróbuj online!

Rubinowy , 125 bajtów + 87 zapałek = 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}

Wypróbuj online!

Mocno zainspirowany odpowiedzią Arnaulda na Javascript .

Zwykle koszt deklarowania użycia lambda tylko dwa razy nie jest tego wart, ale waga zapałki „ scanap” .scan(/./).mapzmieniła to. To było zabawne wyzwanie!

->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
}

MATL , wynik 166 156

Długość kodu 41 + wyjście dla kodu używanego jako dane wejściowe 115.

'%p#21jgyDT7o?pe}['TIW:qZajk4Y22Y2h&mXz)s

Wypróbuj online!

R, 112 bajtów + 319 dopasowań = 431 punktów

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

Wypróbuj online!

Uznanie dla Giuseppe który wymyślił tę poprawę.

Stara wersja, 143 bajty + 454 dopasowania = 597 punktów

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

Aby el()funkcja działała w TIO, musisz użyćlibrary(methods) .

Kurwa, do cholery, jest pełny R !

Perl 6 , 87 bajtów + 26 zapałek = 113

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

Wypróbuj online!

Wykorzystuje niektóre znaki Unicode spoza ASCII. Tabela odnośników jest zakodowana w ciągu znaków Unicode:

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

Znaki są konwertowane na indeksy z konwersją base-36 za pomocą cyfr arabskich:

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

sed, 367 (bajty kodu źródłowego) + 532 (ilość zapałek dla kodu źródłowego) = 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

Wypróbuj online

Wersja wieloliniowa:

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

Wyjaśnienie:

Powyższy skrypt odczytuje standardowy wiersz po wierszu (do przestrzeni wzorów - zwykły „sposób sed”) i dla każdego wiersza wypisuje ilość zapałek potrzebnych do reprezentacji wszystkich znaków reprezentujących zapałki w tym wierszu. Obliczenia dla każdego wiersza danych wejściowych następują w następujący sposób:

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

Najpierw usuwamy każdą przestrzeń, dla której nie mamy odpowiadającej reprezentacji zapałek (jak podano w pytaniu) z obszaru wzorów. Oznacza to, że usuwamy każdy znak, który nie jest ani cyfrą od „0” do „9”, literą od „a” do „j”, „n” do „s”, „l”, „u”, „x”, „y” lub „z”. Wielkie i małe litery są traktowane tak samo.

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

Jeśli skończymy z pustą przestrzenią wzorów, wypisujemy 0 (automatycznie następuje nowa linia, jak zawsze sed, chyba że przekażesz specjalną flagę), pomiń wszystkie tylne linie skryptu i przejdź do następnego „cyklu sed” tj. przeczytaj następny wiersz danych wejściowych i powtórz przetwarzanie od początku od pierwszego polecenia, aż nie będzie już więcej wierszy danych wejściowych do przetworzenia).

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

W przeciwnym razie, jeśli przestrzeń wzorcowa nie jest pusta, dzielimy ją na dwie „podprzestrzenie” oddzielone średnikiem: najpierw pojawia się przestrzeń wejściowa , która początkowo jest utworzona przez wszystkie znaki, które nie zostały usunięte z przestrzeni wzorcowej po wykonanie linii 1; następnie jest średnik, a po nim przestrzeń na mapie .

Obszar mapy mówi nam, ile pasujących puzzli obok 1 jest potrzebnych do przedstawienia każdego odpowiedniego znaku alfanumerycznego. Jeśli chcemy wiedzieć, ile pasujących pasków jest wymaganych do reprezentacji dowolnego znaku alfanumerycznego w obszarze mapy, szukamy pierwszej sekwencji ciągłych% po lewej stronie tego znaku, a odpowiedzią będzie liczba% w ta sekwencja plus 1. Tak więc na przykład liczba zapałek potrzebnych do przedstawienia „b” wynosi 4 + 1 = 5; reprezentować „4”, 3 + 1 = 4, reprezentować „y”, 3 + 1 = 4; i tak dalej.

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

To jest pętla. Teraz zastąpimy każdy znak w przestrzeni wejściowej (pełną) sekwencją%, której liczba wskazuje niezbędną liczbę zapałek do reprezentowania tego znaku, i podążymy za tą sekwencją spacją (ponownie wielkie i małe litery są poddane temu samemu leczeniu). Kryterium ustalenia, czy pętla powinna się kończyć, jest sprawdzenie, czy w bezpośrednim lewym rogu średnika w przestrzeni wzorca znajduje się biały znak: jeśli ten warunek się utrzymuje, przerywamy pętlę i przechodzimy do następnej linii.

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

Te dwie linie usuwają średnik i wszystko po nim z obszaru wzorców, a następnie wstawiają przecinek i średnik na początku obszaru wzorców. Mamy teraz przestrzeń wzorcową ponownie podzieloną na dwie nowe podprzestrzenie: analogową przestrzeń wynikową przed średnikiem i analogową przestrzeń wejściową po niej.

Analogowa przestrzeń wejściowa jest dokładnie tym, co wcześniej nazywaliśmy „przestrzenią wejściową”, ale w innej formie: teraz zawiera sekwencje% oddzielone białą spacją. Łączna liczba takich% w analogowej przestrzeni wejściowej to ta sama liczba zapałek potrzebnych do przedstawienia początkowego ciągu znaków wejściowych, tzn. Liczba ta jest wynikiem. Ale musimy wydrukować te wyniki w notacji dziesiętnej, a nie jako ciąg znaków procentu. Celem analogowej przestrzeni wyników jest przechowywanie analogowej reprezentacji każdej cyfry wyniku, podczas gdy my obliczamy ten wynik, sumując każdą ciągłą sekwencję% w analogicznej przestrzeni wejściowej jeden po drugim. Następna pętla wykonuje tę sumę:

:2
s/(;[^%]*)(%+)/\2\1/
    :3
    s/,%{10}/%,/
    s/^%/,&/
    /%{10}/b3
/;.*%/b2

1. Najpierw, po etykiecie 2 , przenosimy kolejną ciągłą sekwencję% za średnikiem z analogowej przestrzeni wejściowej do bezpośredniego lewego średnika, w analogicznej przestrzeni wyników;

2. Następnie wchodzimy w pętlę podrzędną (etykieta 3 ), która wykonuje następujące obliczenia:

   • Jeśli istnieje ciągła sekwencja dziesięciu% po przecinku w analogicznej przestrzeni wyników, usuwamy te% i umieszczamy pojedynczy% natychmiast po lewej stronie przecinka. Mówiąc prościej, oznacza to, że jedno z miejsc po przecinku w wyniku uzyskało więcej niż 9 jednostek, więc odejmujemy 10 jednostek od tego miejsca po przecinku i dodajemy 1 jednostkę do następnego większego miejsca po przecinku;

   • Jeśli „%” jest pierwszym znakiem w obszarze wzorów, wstawiamy nowy przecinek bezpośrednio przed nim. Wskazuje to, że suma osiągnęła wartość, której reprezentacja dziesiętna ma o jedno miejsce dziesiętne po lewej stronie niż poprzednia wartość;

   • Jeśli nadal istnieje ciągła sekwencja dziesięciu% w analogicznej przestrzeni wyników, wrócimy do etykiety 3 i powtórzymy ten proces. W przeciwnym razie wychodzimy z tej pod-pętli i przechodzimy do następnej linii.

3. Teraz, jeśli w analogicznym obszarze wejściowym jest jeszcze „%” (tj. Po średniku), oznacza to, że do sumy całkowitej należy dodać jeszcze pewną liczbę zapałek - wracamy do etykiety 2 .

Po zakończeniu sumowania wchodzimy do ostatniej pętli kodu:

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

Tutaj sprawdzamy każdą parę znaków utworzoną przez przecinek po lewej stronie oraz średnik lub przecinek po prawej stronie. Wszystkie takie pary znaków zastępujemy „0” w dwóch przecinkach.

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

Powyższy fragment kodu jest dość prosty: zamieniamy każdą ciągłą sekwencję% w analogicznej przestrzeni wyników na znak dziesiętny, który odpowiada liczbie% w każdej określonej sekwencji.

s/[^0-9]//g

Na koniec usuwamy wszystkie znaki nieliczbowe z obszaru wzorców, a tym, co pozostaje, jest końcowy wynik znanego zapisu dziesiętnego. Ta wartość jest drukowana na standardowym wyjściu i rozpoczyna się następny cykl sed, jeśli jest więcej linii wejściowych do przetworzenia.

C (gcc) , 134 bajty + 38 zapałek = 172

v(t,w)char*t;{t=(w=*t++)?v(t)+(isalnum(w|=w>'@'&w<'['?' ':!w)?")%(('()&*))('(('('%'#&#&'((%(#&##('("[w-=w>'`'?'W':'_'-'/']-'#':!w):w;}

Wypróbuj online!

05AB1E , 30 bajtów + 70 dopasowań = 100 punktów

žLÃlv•Ƶγ¤и©X´≠Ø&c3Íεç•žhA«ykèO

Wypróbuj online!

-5 dzięki Emginie

Java 10 452 432 416 404 wynik (145 bajtów + 259 wyników)

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;}

Wyjaśnienie:

Wypróbuj online.

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

• Zmienne nazwy $ραετsą używane zamiast liter. EDYCJA: Nazwy zmiennychkmtvw Zamiast tego używane są teraz , ponieważ nie można ich tworzyć z dopasowań zgodnych z opisem wyzwania.
• ''(niedrukowalne) jest używane zamiast 6.
• m-mi t-tsą używane zamiast0 .
• (char)(w|32)+""z wejściem tablicy znaków używanym zamiast w.toLowerCase()z wejściem tablicy znaków.

AutoHotkey , 148 bajtów + 345 zapałek = 493

To było trochę trudne do skrócenia.

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

Python 3 , 123 bajty + 65 dopasowań = 188

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

Nienazwana funkcja akceptująca ciąg znaków i zwracająca liczbę całkowitą.

Zawiera wiele niedrukowalnych znaków (w szczególności bajty od jednego do ośmiu).

Wypróbuj online!

Węgiel drzewny , 48 bajtów + 3 = 51

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

ＩΣＥθ

Zapętlaj znaki wejściowe, obliczając liczbę zapałek każdego z nich, a następnie zsumuj wynik, przekonwertuj na ciąg i niejawnie wydrukuj.

⎇№α↥ι

Jeśli to list ...

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

Sprawdź liczbę zapałek w skompresowanym ciągu 65455454240303455250300545.

∧№ＩＸ²φι

W przeciwnym razie pojawi się w wartości 2 ** 1000...

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

Sprawdź liczbę zapałek w skompresowanym ciągu 6255456376.

PHP, 98 + 253 = 351

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

Uruchom jako potok z -nrlub spróbuj online .