这里的大多数人都熟悉七段式显示器，它们也用于火柴拼图。下面是数字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

规则

• 如果适用，您可以假定输入/输出将适合您语言的本机Integer类型。
• 输入和输出可以通过任何方便的方法给出。
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 禁止出现标准漏洞。

Python 2，97个字节+ 237个匹配项= 334

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

在线尝试！

这通过生成一个字符串来起作用，在该字符串中，每个可构建字符都显示与构建该字符所需的火柴棍数量相同的量

Perl 5 with -pF，95 bytes + 14，109

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

这等效于：

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

但是使用~运算符，我们可以使用高字节字符，并避免很多字符而不会真正牺牲字节。

即使有协助，距离Ton的成绩还有很大距离！

在线尝试！

该解决方案包含不可打印的内容，因此这里是一个可逆的十六进制转储，用于验证字节数：

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字节+ 96个火柴）

@ l4m2节省了5分

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

在线尝试！

怎么样？

我们使用字符的模数为9的ASCII码，这些字符不增加任何代价来编码火柴棍的数量。

 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。

果冻，42个字节+ 0个火柴= 42分

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

感谢@JonathanAllan -2分！

在线尝试！

怎么运行的

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

“以’split on 开头和结尾“的文字，在Jelly的代码页中将剩余字符替换为基于1的索引，然后从双射基数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$计算输入字符串中“ A ... Za ... z0 ... 9 _”（）中ċ每个（Ѐ）字符的出现（）个。ØW

最后æ.求出点​​积，将每个字符数乘以火柴棍中的相应成本，然后求和。

Perl 5中 -p，90 64个码+ 9的eval线束+ 14根火柴= 87

将十六进制代码替换为其原义的1字节变体（不是 TIO尝试使用的UTF-8），以换取要求的分数

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

果冻，34个字节+ 3个匹配项= 37

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

接受字符列表并返回整数的单子链接。

在线尝试！

怎么样？

工作方式与丹尼斯（Dennis）的果冻（Jelly）答案相似，但付出了足够的努力，我认为它值得另一个答案。核心区别在于，它为三个匹配项的成本（Œ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

PHP 176字节= 397分

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

在线尝试！

SOGL V0.12，34 字节 + 18 = 52

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

在这里尝试！

打高尔夫球，但得分不高：

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

Python 3，138 + 265 = 403字节

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

在线尝试！

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

在线尝试！

受Arnauld的Javascript答案的启发。

通常，声明只使用两次的lambda的成本不值得，但是火柴杆重量“ 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
}

MATL，总分166 156

代码长度41 +输出的代码用作输入115。

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

在线尝试！

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冗长！

Perl 6、87个字节+ 26个火柴= 113

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

在线尝试！

使用一些非ASCII Unicode字符。查找表以Unicode字符串编码：

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

使用阿拉伯数字将数字转换为以36为基数的索引：

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

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”的数字，也不是从“ a”到“ j”，“ n”到“ s”，“ l”，“ u”的字母的每个字符， “ x”，“ y”或“ z”。大写字母和小写字母被视为相同。

/^$/{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/^/,;/

这两行从模式空间中删除分号及其后的所有内容，然后在模式空间的开头插入逗号和分号。现在，我们将模式空间再次划分为两个新的子空间：分号之前的模拟结果空间和其后的模拟输入空间。

模拟输入空间就是我们以前称为“输入空间”的形式，但是形式不同：它现在包含％的序列，用空格隔开。模拟输入空间中此类％的总数与表示初始输入字符串所需的火柴数相同，即，该数字就是结果。但是我们必须将结果打印为十进制符号，而不是百分号的序列。模拟结果空间的目的是保存结果的每个数字的模拟表示，同时我们通过将模拟输入空间中％的每个连续序列一一求和来计算结果。下一个循环执行该总和：

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

1. 首先，在标签2之后，我们将分号后的下一个％连续序列从模拟输入空间移至模拟结果空间中分号的最左端；

2. 接下来，我们进入执行以下计算的子循环（标签3）：

   • 如果在模拟结果空间中的逗号后面有一个连续的10％序列，我们将删除这些％并将单个％立即放在逗号的左边。简而言之，这表明结果中的一个小数位已获取9个以上的单位，因此我们从该小数位减去10个单位，并将1个单位加到下一个较大的小数位；

   • 如果“％”是模式空间中的第一个字符，我们将在其前面插入一个新逗号。这表示总和已达到一个值，该值的小数点表示比前一个值的左数小一位。

   • 如果模拟结果空间中仍然有任何连续的10％序列，则返回标签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周期开始。

C（gcc），134个字节+ 38个火柴= 172

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

在线尝试！

05AB1E，30个字节+ 70个匹配项= 100分

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

在线尝试！

-5感谢Emgina

爪哇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()字符串数组输入。

自动热键，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

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)

一个未命名的函数，它接受一个字符串并返回一个整数。

包含许多不可打印的字符（特别是字节1到8）。

在线尝试！

木炭，48字节+ 3 = 51

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

在线尝试！链接是详细版本的代码。说明：

ＩΣＥθ

循环输入的字符，计算每个火柴的数目，然后将结果求和，转换为字符串，然后隐式打印。

⎇№α↥ι

如果是字母...

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

在压缩的字符串中查找火柴的数量65455454240303455250300545。

∧№ＩＸ²φι

否则，如果它出现在2 ** 1000... 的值中

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

在压缩的字符串中查找火柴的数量6255456376。

PHP，98 + 253 = 351

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

与管道一起运行-nr或在线尝试。