Подсчитать спички


20

Большинство людей здесь знакомы с семью сегментами дисплеев, которые также используются в головоломках спичек. Ниже приведены цифры 0через 9и письма aчерез z, за исключением того k,m,t,v,w, написанные в этом формате.

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

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

Задача здесь проста. Учитывая входную строку, выведите количество спичек, необходимых для представления этой строки. Если строка содержит символ вне вышеприведенного представления, игнорируйте его (считайте 0).

Например, для ввода 53требуется общее количество 10совпадений, 5для 5и 5для 3, поэтому вывод 10.

Для ввода helloтребуется общее количество 19спичек, h (4), e (5), l (3), l (3), o (4)поэтому вывод есть 19.

Для ясности вот спички, необходимые для построения каждого персонажа:

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

Теперь для поворота, и есть два из них.

  • Во - первых, что вход считается к регистру в чувствительной. То есть Aи aоба должны учитывать 6спички, хотя визуальное представление выглядит как заглавные A.
  • Ваша оценка - ваш исходный код, выполненный по этому алгоритму, плюс длина исходного кода в байтах, чем меньше, тем лучше. Например, если ваш исходный код был abc123, ваш счет будет 6+5+4+2+5+5 = 27 + 6 = 33. Если ваш исходный код был #&@()*, ваш счет будет 0 + 6 = 6.

Примеры ввода / вывода

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

правила

  • Если применимо, вы можете предположить, что ввод / вывод будет соответствовать целочисленному типу вашего языка.
  • Вход и выход могут быть заданы любым удобным способом .
  • Допустимы либо полная программа, либо функция. Если функция, вы можете вернуть вывод, а не распечатать его.
  • Стандартные лазейки запрещены.

2
T обычно пишется как |_\n|_(строчные буквы t)
12Me21

@ 12Me21 Я думал о том, чтобы сделать что-то подобное, но я не чувствовал, что это выглядело достаточно близко к письму, поэтому я пропустил это.
AdmBorkBork

Как насчет вашего письма X (H)? (ну, это не имеет значения сейчас, когда есть ответ.)
12Me21

Для символов снаружи [0-9a-z]мы должны считать 0 спичек? Вот что я понимаю из вашей оценки - ваш исходный код проходит по этому алгоритму плюс длина исходного кода в байтах .
Эрик Outgolfer

@EriktheOutgolfer Да, это правильно.
AdmBorkBork

Ответы:


8

Python 2 , 97 байт + 237 совпадений = 334

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

Попробуйте онлайн!

Это работает путем генерации строки, в которой каждый строимый символ содержит одинаковое количество спичек, необходимых для построения этого символа.


Один символ может быть сохранен с +'069a8'*6+'8')вместо +'069a'*6+'8'*7).
xbarbie

@xbarbie действительно, но это увеличило бы количество матчей, в результате чего +3 очка
Род

6

Perl 5 с -pF, 95 байт + 14, 109

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

Это эквивалентно:

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

но используя ~оператор, мы можем использовать старшие байты и избегать большого количества символов, не жертвуя байтами.

Все еще довольно далеко от счета Тони, даже с помощью!

Попробуйте онлайн!

Это решение содержит непечатаемые таблицы, поэтому вот обратимый шестнадцатеричный дамп для проверки количества байтов:

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

Почему то }{? Брось и -nвариант. Кроме того, вы продолжаете подделывать +lcвместо lc():-)
Тон Хоспел

@TonHospel Черт возьми! Я даже просмотрел оба наших поста, и я не мог вспомнить, на каком посте я его видел, и +не сразу приходит на ум! Мне нужно nна моей машине и забыть, что я могу уронить ее!
Дом Гастингс

Извините, я оговорился. Я имел в виду «отбросьте }{и -p» (и замените его на, -nесли ваш perl все еще нуждается в нем. В настоящее время он все равно не считается)
Тон Хоспел

@TonHospel Я не обновил свой код до последней, упс ...
Дом Гастингс,

6

JavaScript (ES6), 198 (102 байта + 96 спичек)

Сохранено 5 баллов благодаря @ l4m2

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

Попробуйте онлайн!

Как?

Мы используем код ASCII по модулю 9 символов, который не добавляет штрафов для кодирования количества спичек.

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

Нам не нужно беспокоиться о случае, потому что он parseInt()не учитывает регистр.

Для символов, которые не соответствуют [0-9A-Za-z] , parseInt()возвращается, NaNи поиск строки приводит к undefined. После приведения к строке "undefined".charCodeAt()возвращает код ASCII "u", равный 117 . Удобно, 117 по модулю 9 дает 0, как и ожидалось.


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

5

Желе , 42 байта + 0 спичек = 42 балла

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

Спасибо @JonathanAllan за -2 балла!

Попробуйте онлайн!

Как это устроено

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

Литералы, которые начинаются с и заканчиваются разделением на , заменяют оставшиеся символы их основанными на 1 индексами на кодовой странице Jelly, затем преобразуются из биективного основания 250 в целое число.

Этот конкретный буквальный кодирует

[3096734725226860846495, 211369264881118657055472842435156679693648].

×/ уменьшает умножением, давая

654554542403034552503005456545545424030345525030054562554563760

(Кодирование этого целого числа напрямую сэкономило бы 6 байтов, но стоило 28 спичек.)

ṚṚдважды переворачивается; первый вызов переводит целое число в свой массив цифр. Это дает

[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$count ( ċ) вхождения каждого ( Ѐ) символа «A ... Za ... z0 ... 9_» ( ØW) во входной строке.

Наконец, æ.берется скалярное произведение, умножая количество каждого символа на соответствующую стоимость в спичках, а затем беря сумму.


Используйте факторизацию большого числа, чтобы сохранить один байт и базовую декомпрессию и по модулю вместо того, Dчтобы сохранить другой. Попробуй онлайн
Джонатан Аллан

байт ... точка ошибки :)
Джонатан Аллан

1
И еще один с Ɗ. Благодарность!
Деннис

3

Perl 5 -p , код 90 64 + 9 жгутов Eval + 14 спичек = 87

Замените шестнадцатеричные коды их буквальным 1-байтовым вариантом ( не UTF-8, как пытается TIO) для заявленной оценки

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

Попробуйте онлайн!

Код внутри дополненной строки:

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

3

Желе , 34 байта + 3 совпадения = 37

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

Монадическая ссылка, принимающая список символов и возвращающая целое число.

Попробуйте онлайн!

Как?

Работает аналогично ответу на желе Денниса, но потребовал достаточно усилий, чтобы я чувствовал, что это оправдывает другой ответ. Основное отличие состоит в том, что в нижнем регистре вводится стоимость трех совпадений ( Œlсодержит l), что позволяет использовать гораздо меньшее число для создания массива затрат. Сложнее было найти способ построить это число без совпадений, оставаясь при этом кратким.

ØWТаким "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"образом, подсчет входных значений в нижнем регистре всегда начинается с 26 нулей. Мы можем изменить это и выполнить точечное произведение с массивом длиной 37 вместо одного с длиной 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




1

Рубин , 125 байт + 87 спичек = 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}

Попробуйте онлайн!

Сильно вдохновлен ответом Арнаулда на Javascript .

Обычно стоимость объявления лямбды для использования только дважды не стоит этого, но вес спички " scanap" .scan(/./).mapизменил это. Это было весело!

->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 байт + 319 совпадений = 431 счет

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

Попробуйте онлайн!

Слава Джузеппе который придумал это улучшение.

Старая версия, 143 байта + 454 совпадения = 597 баллов

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

Чтобы el()функция работала на TIO, вам нужно использоватьlibrary(methods) .

Черт возьми, это R многословно!


TIO по какой-либо причине не загружает methodsпакет автоматически , но, поскольку это baseпакет, я всегда помещаю его в заголовок и не считаю его для подсчета байтов. readlineтакже не будет работать на TIO, поскольку это не интерактивный сеанс. Это, безусловно, игра в гольф, хотя.
Джузеппе


^ нужны кавычки вокруг ввода, содержащего пробелы, хотя.
Джузеппе

Кроме того, я только начал чат для игры в гольф R! ! Я видел много ответов в R в последнее время от множества разных пользователей, что довольно обнадеживает :)
Джузеппе

@ Giuseppe Я думаю, вы должны опубликовать свой ответ отдельно. Это отличается в принципе и намного превосходит мое.
Андрей Костырка

1

Perl 6 , 87 байт + 26 спичек = 113

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

Попробуйте онлайн!

Использует некоторые не-ASCII символы Unicode. Таблица поиска закодирована в строке Unicode:

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

Символы преобразуются в индексы с помощью преобразования base-36 с использованием арабско-индийских цифр:

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

1

sed, 367 (байты исходного кода) + 532 (количество спичек для исходного кода) = 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

Попробуйте онлайн

Многострочная версия:

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

Объяснение:

Вышеуказанный скрипт построчно считывает стандартный ввод (в пространство шаблона - обычный «способ sed») и для каждой строки выводит количество спичек, необходимых для представления всех представляемых спичками символов в этой строке. Вычисления для каждой строки ввода выполняются следующим образом:


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

Сначала мы удаляем каждый символ, для которого у нас нет соответствующего представления спички (как указано в вопросе) из пространства образца. То есть мы удаляем каждый символ, который не является ни цифрой от «0» до «9», ни буквой от «а» до «j», от «n» до «s», «l», «u», «х», «у» или «г». Прописные и строчные буквы обрабатываются одинаково.

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

Если мы получим пустое пространство шаблона, мы печатаем 0 (автоматически следует новая строка, как всегда делает sed, если вы не передаете ему специальный флаг), пропускаете все задние строки сценария и переходите к следующему «циклу sed» ( т. е. читать следующую строку ввода и повторять обработку заново, начиная с первой команды, пока не останется больше строк ввода для обработки).

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

В противном случае, если пространство шаблона не является пустым, мы теперь разделяем его на два «подпространства», разделенных точкой с запятой: сначала идет пространство ввода , которое первоначально формируется всеми символами, которые не были удалены из пространства шаблона после исполнение строки 1; Далее следует точка с запятой, а после нее - пространство карты .

Пространство карты говорит нам, сколько спичек рядом с 1 необходимо для представления каждого соответствующего буквенно-цифрового символа. Если мы хотим узнать, сколько совпадений необходимо для представления любого алфавитно-цифрового символа в пространстве карты, мы ищем первую последовательность смежных% слева от этого символа, и ответом будет число% в эта последовательность плюс 1. Так, например, количество спичек, необходимых для представления «b», равно 4 + 1 = 5; представлять «4», 3 + 1 = 4, представлять «y», 3 + 1 = 4; и так далее.

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

Это петля. Теперь мы заменим каждый символ во входном пространстве на (завершенную) последовательность%, число которой указывает необходимое количество спичек для представления этого символа, и последуем за этой последовательностью символом пробела (опять же, заглавные и строчные буквы дано такое же лечение). Критерий определения того, должен ли цикл завершиться, заключается в проверке наличия символа пробела в левой части точки с запятой в пространстве шаблона: если это условие выполняется, мы завершаем цикл и переходим к следующей строке.

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

Эти две строки удаляют точку с запятой и все после нее из пространства шаблона, а затем вставляют запятую и точку с запятой в начало пространства шаблона. Теперь у нас есть пространство шаблонов, разделенное еще раз на два новых подпространства: пространство аналоговых результатов перед точкой с запятой и пространство аналоговых входов после него.

Пространство аналогового ввода - это то, что мы ранее называли «пространством ввода», но в другой форме: теперь оно содержит последовательности%, разделенных пробелом. Общее количество таких% в пространстве аналогового ввода равно количеству спичек, необходимых для представления исходной строки входных символов, т. Е. Это число является результатом. Но мы должны напечатать этот результат в десятичной записи, а не как последовательность знаков процента. Цель аналогового результата пространства , чтобы провести аналоговое представление каждой цифры результата , пока мы вычислить , что результат путем суммирования каждой непрерывной последовательности% 'S в пространстве аналогового входа по одному. Следующий цикл выполняет эту сумму:

:2
s/(;[^%]*)(%+)/\2\1/
    :3
    s/,%{10}/%,/
    s/^%/,&/
    /%{10}/b3
/;.*%/b2
  1. Сначала после ярлыка 2 мы перемещаем следующую смежную последовательность% после точки с запятой из пространства аналогового ввода в непосредственную левую точку с запятой в пространстве аналоговых результатов;

  2. Далее, мы вступаем в под-цикл (метка 3 ), который выполняет следующие вычисления:

    • Если в аналоговой области результатов есть непрерывная последовательность из десяти% после запятой, мы удаляем эти% и помещаем один% непосредственно слева от запятой. Проще говоря, это означает, что одно из десятичных разрядов в результате получило более 9 единиц, поэтому мы убираем 10 единиц из этого десятичного разряда и добавляем 1 единицу к следующему большему десятичному разряду;

    • Если «%» является первым символом в пространстве шаблона, мы вставляем новую запятую непосредственно перед ним. Это указывает на то, что сумма достигла значения, у которого десятичное представление имеет еще один десятичный знак слева от предыдущего значения;

    • Если в аналоговом результирующем пространстве все еще есть какая-то непрерывная последовательность из десяти%, мы возвращаемся к метке 3 и повторяем этот процесс. В противном случае мы выходим из этого под-цикла и переходим на следующую строку.

  3. Теперь, если все еще есть «%» в пространстве аналогового ввода (то есть после точки с запятой), это означает, что к общей сумме еще нужно добавить некоторое количество спичек - поэтому мы возвращаемся к метке 2 .

Как только сумма будет завершена, мы переходим к последнему циклу кода:

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

Здесь мы проверяем каждую пару символов, образованную запятой слева и точкой с запятой или запятой справа. Мы заменяем все такие пары символов на «0» внутри двух запятых.

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

Наконец, мы удаляем каждый нечисловой символ из пространства образца, и остается только конечный результат в знакомой десятичной записи. Это значение печатается на стандартном выводе, и начинается следующий цикл sed, если есть еще входные строки для обработки.




1

Java 10, 452 432 416 404 (145 байтов + 259 соответствий)

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

Объяснение:

Попробуйте онлайн.

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
  • Имена переменных $ραετиспользуются вместо букв. РЕДАКТИРОВАТЬ: kmtvwвместо этого теперь используются имена переменных , потому что они не могут быть сформированы совпадениями в соответствии с описанием задачи.
  • ''(непечатный) используется вместо 6.
  • m-mи t-tиспользуются вместо 0.
  • (char)(w|32)+""с вводом символьного массива, используемого вместо ввода w.toLowerCase()строкового массива.

0

AutoHotkey , 148 байт + 345 спичек = 493

Этот был немного сложным для сокращения.

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 байта + 65 совпадений = 188

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

Безымянная функция, принимающая строку и возвращающая целое число.

Содержит много непечатаемых символов (в частности, байтов от одного до восьми).

Попробуйте онлайн!


0

Древесный уголь , 48 байтов + 3 = 51

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

IΣEθ

Переберите символы входных данных, рассчитайте количество спичек каждого из них, затем сложите результат, преобразуйте в строку и неявно напечатайте.

⎇№α↥ι

Если это письмо ...

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

Посмотрите количество спичек в сжатой строке 65455454240303455250300545.

∧№IX²φι

Иначе, если это появляется в значении 2 ** 1000...

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

Посмотрите количество спичек в сжатой строке 6255456376.


Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.