Đếm que diêm


20

Hầu hết mọi người ở đây đều quen thuộc với bảy màn hình phân đoạn, cũng được sử dụng trong các câu đố que diêm. Dưới đây là các chữ số 0thông qua 9và các chữ cái athông qua z, ngoại trừ k,m,t,v,w, được viết theo định dạng này.

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

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

Thử thách ở đây rất đơn giản. Đưa ra một chuỗi đầu vào, xuất số lượng que diêm cần thiết để thể hiện chuỗi đó. Nếu chuỗi chứa một ký tự bên ngoài biểu diễn trên, hãy bỏ qua nó (tính nó là 0).

Ví dụ, đối với đầu vào 53, cần có tổng số 10que diêm, 5cho 55cho 3, vì vậy đầu ra là 10.

Đối với đầu vào, cần hellocó tổng số 19que diêm h (4), e (5), l (3), l (3), o (4), vì vậy đầu ra là 19.

Để rõ ràng, đây là các que diêm cần thiết để xây dựng mỗi nhân vật:

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

Bây giờ cho các twist, và có hai trong số họ.

  • Đầu tiên là đầu vào được coi đựng pin- trong nhạy cảm. Đó là, Aacả hai nên tính cho 6que diêm, mặc dù biểu diễn trực quan trông giống như chữ hoa A.
  • Điểm của bạn là mã nguồn của bạn chạy qua thuật toán này, cộng với độ dài của mã nguồn tính theo byte, thấp hơn là tốt hơn. Ví dụ: nếu mã nguồn của bạn là abc123, điểm của bạn sẽ là 6+5+4+2+5+5 = 27 + 6 = 33. Nếu mã nguồn của bạn là #&@()*, điểm số của bạn sẽ là 0 + 6 = 6.

Ví dụ đầu vào / đầu ra

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

Quy tắc

  • Nếu có thể, bạn có thể giả sử rằng đầu vào / đầu ra sẽ phù hợp với loại Số nguyên gốc của ngôn ngữ của bạn.
  • Đầu vào và đầu ra có thể được cung cấp bởi bất kỳ phương pháp thuận tiện .
  • Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
  • Sơ hở tiêu chuẩn bị cấm.

2
T thường được viết là |_\n|_(chữ thường t)
12Me21

@ 12Me21 Tôi đã dự tính làm một cái gì đó như thế, nhưng tôi không cảm thấy nó trông đủ gần với bức thư, vì vậy tôi đã bỏ nó ra.
admBorkBork 23/03/18

Thư X (H) của bạn thì sao? (
vâng,

Đối với ký tự bên ngoài [0-9a-z], chúng ta có nên đếm 0 que diêm không? Đó là những gì tôi hiểu từ Điểm của bạn là mã nguồn của bạn chạy qua thuật toán này , cộng với độ dài của mã nguồn tính bằng byte .
Erik the Outgolfer 23/03/18

@EriktheOutgolfer Vâng, điều đó đúng.
admBorkBork 23/03/18

Câu trả lời:


8

Python 2 , 97 byte + 237 trùng khớp = 334

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

Hãy thử trực tuyến!

Điều này hoạt động bằng cách tạo một chuỗi trong đó mỗi ký tự có thể xây dựng xuất hiện cùng một lượng que diêm cần thiết để xây dựng ký tự đó


Một nhân vật có thể được lưu với +'069a8'*6+'8')thay vì +'069a'*6+'8'*7).
xbarbie

@xbarbie thực sự, nhưng điều đó sẽ tăng số trận đấu, dẫn đến +3 điểm
Rod

6

Perl 5 với -pF, 95 byte + 14, 109

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

Điều này tương đương với:

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

nhưng bằng cách sử dụng ~toán tử, chúng ta có thể sử dụng các ký tự byte cao và tránh rất nhiều ký tự mà không thực sự hy sinh byte.

Vẫn còn khá nhiều cách để ghi điểm của Ton, ngay cả với sự trợ giúp!

Hãy thử trực tuyến!

Giải pháp này chứa các dấu vết không thể in được, vì vậy đây là kết xuất hex có thể đảo ngược để xác minh số đếm byte:

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

Tại sao }{? Thả nó và -ntùy chọn. Ngoài ra, bạn tiếp tục quên +lcthay vì lc():-)
TonMedel 23/03/18

@TonHeach Goddammit! Tôi thậm chí đã xem qua cả hai bài đăng của chúng tôi và tôi không thể nhớ bài đăng nào tôi đã xem và +không ngay lập tức nảy ra trong đầu! Tôi cần ntrên máy của tôi và quên tôi có thể thả nó!
Dom Hastings

Xin lỗi, tôi sai chính tả. Tôi có nghĩa là "bỏ }{-p" (và thay thế nó bằng cách -nnếu perl của bạn vẫn cần nó. Ngày nay nó không được tính nữa)
TonMedel 23/03/18

@TonHeach Tôi chưa cập nhật mã của mình lên bản mới nhất, ôi ...
Dom Hastings

6

JavaScript (ES6), 198 (102 byte + 96 que diêm)

Lưu được 5 điểm nhờ @ l4m2

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi sử dụng mã ASCII modulo 9 ký tự không thêm bất kỳ hình phạt nào để mã hóa số lượng que diêm.

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

Chúng tôi không phải lo lắng về trường hợp này vì parseInt()không phân biệt chữ hoa chữ thường.

Đối với các ký tự không khớp với [0-9A-Za-z] , parseInt()trả về NaNvà kết quả tra cứu chuỗi kết quả undefined. Sau khi được ép buộc thành một chuỗi, "undefined".charCodeAt()trả về mã ASCII "u"117 . Thuận tiện, 117 modulo 9 cho 0 như mong đợi.


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

5

Jelly , 42 byte + 0 que diêm = 42 điểm

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

Cảm ơn @Jonathan ALLan cho -2 điểm!

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Các chữ bắt đầu bằng và kết thúc bằng phân tách , thay thế các ký tự còn lại bằng các chỉ số dựa trên 1 của chúng trong trang mã của Jelly, sau đó chuyển đổi từ cơ sở phỏng đoán 250 sang số nguyên.

Mã hóa đặc biệt này

[3096734725226860846495, 211369264881118657055472842435156679693648].

×/ giảm bằng cách nhân, năng suất

654554542403034552503005456545545424030345525030054562554563760

(Mã hóa số nguyên này trực tiếp sẽ tiết kiệm 6 byte, nhưng tốn 28 que diêm.)

ṚṚđảo ngược hai lần; cuộc gọi đầu tiên thúc đẩy một số nguyên cho mảng chữ số của nó. Sản lượng này

[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$đếm ( ċ) số lần xuất hiện của mỗi ( Ѐ) ký tự của "A ... Za ... z0 ... 9_" ( ØW) trong chuỗi đầu vào.

Cuối cùng æ.lấy sản phẩm chấm, nhân mỗi số ký tự với chi phí tương ứng trong que diêm, sau đó lấy tổng.


Sử dụng hệ số của số lớn để lưu một byte và giải nén cơ sở và modulo thay vì Dlưu một số khác. Dùng thử trực tuyến
Jonathan Allan

byte ... điểm sai lầm :)
Jonathan Allan

1
Và một cái nữa với Ɗ. Cảm ơn!
Dennis

3

Perl 5 -p , 90 64 mã + 9 khai thác eval + 14 que diêm = 87

Thay thế các mã hex bằng biến thể 1 byte theo nghĩa đen của chúng ( không phải UTF-8 như TIO cố gắng) cho điểm số được yêu cầu

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

Hãy thử trực tuyến!

Mã bên trong chuỗi bổ sung:

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

3

Jelly , 34 byte + 3 trận đấu = 37

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

Một liên kết đơn âm chấp nhận một danh sách các ký tự và trả về một số nguyên.

Hãy thử trực tuyến!

Làm sao?

Hoạt động theo cách tương tự như câu trả lời của Dennis 'Jelly nhưng đã nỗ lực đủ để tôi cảm thấy nó đảm bảo một câu trả lời khác. Sự khác biệt cốt lõi là nó viết thường các đầu vào với chi phí là ba kết quả khớp ( Œlchứa một l), sau đó cho phép sử dụng một số lượng nhỏ hơn nhiều để tạo ra mảng chi phí. Một mẹo nhỏ là tìm cách xây dựng con số đó mà không khớp trong khi vẫn súc tích.

ØWnăng suất "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"vì vậy việc đếm các lần xuất hiện đầu vào thấp hơn luôn bắt đầu bằng 26 số không. Chúng ta có thể đảo ngược điều này và thực hiện một sản phẩm chấm với một mảng có chiều dài 37 thay vì một chiều dài 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 byte = 397 điểm

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

Hãy thử trực tuyến!


1
Chào mừng đến với PPCG!
admBorkBork



1

Ruby , 125 byte + 87 que diêm = 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}

Hãy thử trực tuyến!

Lấy cảm hứng mạnh mẽ từ câu trả lời Javascript của Arnauld .

Thông thường, chi phí khai báo lambda chỉ được sử dụng hai lần là không đáng, nhưng trọng lượng que diêm của " scanap" .scan(/./).mapđã thay đổi điều đó. Đây là một thử thách thú vị!

->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 byte + 319 kết quả = 431 điểm

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

Hãy thử trực tuyến!

Kudos cho Giuseppe , người đã đưa ra cải tiến này.

Phiên bản cũ, 143 byte + 454 trận đấu = 597 điểm

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

Để làm cho el()chức năng hoạt động trên TIO, bạn cần sử dụng library(methods).

Trời ạ, là R verbose!


TIO, vì bất kỳ lý do gì, không tự động tải methodsgói, nhưng vì là basegói, tôi đã luôn đưa nó vào tiêu đề và không tính nó cho số đếm byte. readlinecũng sẽ không hoạt động trên TIO vì đây không phải là phiên tương tác. Điều này chắc chắn là golf, mặc dù.
Giuseppe


^ cần báo giá xung quanh đầu vào có chứa không gian.
Giuseppe

Ngoài ra, tôi mới bắt đầu một phòng chat cho R golfing! ! Gần đây tôi đã thấy rất nhiều câu trả lời trong R bởi rất nhiều người dùng khác nhau, điều này khá đáng khích lệ :)
Giuseppe

@Giuseppe Tôi nghĩ bạn nên đăng câu trả lời của bạn một cách riêng biệt. Nó khác về nguyên tắc và vượt trội hơn nhiều so với của tôi.
Andreï Kostyrka 23/03/18

1

Perl 6 , 87 byte + 26 que diêm = 113

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

Hãy thử trực tuyến!

Sử dụng một số ký tự Unicode không phải ASCII. Bảng tra cứu được mã hóa theo chuỗi Unicode:

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

Các ký tự được chuyển đổi thành các chỉ mục với chuyển đổi cơ sở 36 bằng cách sử dụng các chữ số Ả Rập:

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

1

sed, 367 (byte mã nguồn) + 535 (số lượng que diêm cho mã nguồn) = 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

Dùng thử trực tuyến

Phiên bản nhiều dòng:

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

Giải trình:

Kịch bản trên đọc dòng đầu vào tiêu chuẩn theo dòng (vào không gian mẫu - "cách thức thông thường") và, đối với mỗi dòng, nó xuất ra số lượng que diêm cần thiết để thể hiện tất cả các ký tự đại diện cho que diêm trong dòng đó. Việc tính toán cho từng dòng đầu vào xảy ra như sau:


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

Đầu tiên, chúng tôi xóa mọi ký tự mà chúng tôi không có biểu diễn que diêm tương ứng (như được nêu trong câu hỏi) khỏi không gian mẫu. Đó là, chúng tôi xóa mọi ký tự không phải là một chữ số từ "0" đến "9", một chữ cái từ "a" đến "j", "n" thành "s", "l", "u", "x", "y" hoặc "z". Chữ in hoa và chữ thường được xử lý như nhau.

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

Nếu chúng ta kết thúc với một không gian mẫu trống, chúng ta sẽ in 0 (tự động theo dòng mới, giống như sed luôn làm trừ khi bạn chuyển một cờ đặc biệt cho nó), bỏ qua tất cả các dòng sau của tập lệnh và chuyển sang "chu kỳ sed" tiếp theo ( tức là đọc dòng tiếp theo của đầu vào và lặp lại xử lý lại từ lệnh đầu tiên cho đến khi không còn dòng đầu vào nào được xử lý nữa).

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

Mặt khác, nếu không gian mẫu không trống, bây giờ chúng ta chia nó thành hai "không gian con" được phân tách bằng dấu chấm phẩy: đầu tiên là không gian đầu vào , ban đầu được hình thành bởi tất cả các ký tự không được xóa khỏi không gian mẫu sau thực hiện dòng 1; tiếp đến là dấu chấm phẩy và sau đó là không gian bản đồ .

Không gian bản đồ cho chúng ta biết cần bao nhiêu que diêm bên cạnh 1 để thể hiện mỗi ký tự chữ và số có liên quan. Nếu chúng ta muốn biết có bao nhiêu que diêm cần thiết để đại diện cho bất kỳ ký tự chữ và số nào trong không gian bản đồ, chúng ta sẽ tìm chuỗi đầu tiên của %% liền kề bên trái ký tự đó và câu trả lời sẽ là số% của chuỗi đó cộng với 1. Vì vậy, ví dụ, số lượng que diêm cần thiết để biểu thị "b" là 4 + 1 = 5; để đại diện cho "4", 3 + 1 = 4, để đại diện cho "y", 3 + 1 = 4; vân vân

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

Đây là một vòng lặp. Bây giờ chúng ta sẽ thay thế mọi ký tự trong không gian đầu vào bằng chuỗi (hoàn thành) của% có số cho biết số lượng que diêm cần thiết để thể hiện ký tự đó và theo dõi chuỗi đó bằng ký tự khoảng trắng (một lần nữa, chữ hoa và chữ thường là đưa ra cách xử lý tương tự). Tiêu chí để xác định xem vòng lặp có nên kết thúc hay không là kiểm tra xem có ký tự khoảng trắng ở bên trái dấu chấm phẩy trong không gian mẫu hay không: nếu điều kiện đó giữ, chúng ta chấm dứt vòng lặp và tiếp tục vào dòng tiếp theo.

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

Hai dòng đó loại bỏ dấu chấm phẩy và mọi thứ sau nó từ không gian mẫu và sau đó chèn dấu phẩy và dấu chấm phẩy vào đầu không gian mẫu. Bây giờ chúng ta có không gian mẫu được chia một lần nữa thành hai không gian con mới: không gian kết quả tương tự trước dấu chấm phẩy và không gian đầu vào tương tự sau nó.

Không gian đầu vào tương tự chỉ là cái mà trước đây chúng ta gọi là "không gian đầu vào", nhưng ở một dạng khác: giờ đây nó chứa các chuỗi% được phân tách bằng khoảng trắng. Tổng số% như vậy trong không gian đầu vào tương tự là cùng số lượng que diêm cần thiết để biểu diễn chuỗi ký tự đầu vào ban đầu, nghĩa là số đó là kết quả. Nhưng chúng ta phải in kết quả đó bằng ký hiệu thập phân, không phải là một chuỗi các dấu phần trăm. Mục đích của không gian kết quả tương tự là giữ một biểu diễn tương tự của từng chữ số của kết quả trong khi chúng tôi tính kết quả đó bằng cách tính tổng từng chuỗi tiếp giáp của% trong từng không gian đầu vào tương tự. Vòng lặp tiếp theo thực hiện tổng đó:

:2
s/(;[^%]*)(%+)/\2\1/
    :3
    s/,%{10}/%,/
    s/^%/,&/
    /%{10}/b3
/;.*%/b2
  1. Đầu tiên, sau nhãn 2 , chúng tôi di chuyển chuỗi tiếp theo của% sau dấu chấm phẩy từ không gian đầu vào tương tự sang bên trái của dấu chấm phẩy, trong không gian kết quả tương tự;

  2. Tiếp theo, chúng tôi bước vào một vòng lặp phụ (nhãn 3 ) để thực hiện các tính toán sau:

    • Nếu có một chuỗi mười% liền kề sau dấu phẩy trong không gian kết quả tương tự, chúng tôi sẽ xóa các% đó và đặt một% ngay lập tức ở bên trái dấu phẩy. Nói một cách đơn giản, điều này chỉ ra rằng một trong những vị trí thập phân trong kết quả đã thu được hơn 9 đơn vị, vì vậy chúng tôi lấy 10 đơn vị từ vị trí thập phân đó và thêm 1 đơn vị vào vị trí thập phân lớn hơn tiếp theo;

    • Nếu "%" là ký tự đầu tiên trong không gian mẫu, chúng tôi sẽ chèn một dấu phẩy mới ngay trước nó. Điều này chỉ ra rằng tổng đã đạt đến một giá trị có biểu diễn thập phân có thêm một vị trí thập phân ở bên trái so với giá trị trước đó;

    • Nếu vẫn còn bất kỳ chuỗi mười% tiếp giáp nào trong không gian kết quả tương tự, chúng tôi quay lại nhãn 3 và lặp lại quy trình này. Nếu không, chúng ta thoát khỏi vòng lặp phụ này và bước vào dòng tiếp theo.

  3. Bây giờ, nếu vẫn còn bất kỳ "%" nào trong không gian đầu vào tương tự (nghĩa là sau dấu chấm phẩy), điều đó có nghĩa là vẫn còn một số lượng que diêm được thêm vào tổng số - vì vậy chúng tôi quay lại nhãn 2 .

Khi tổng đã hoàn thành, chúng tôi bước vào vòng lặp cuối cùng của mã:

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

Ở đây, chúng tôi kiểm tra từng cặp ký tự được hình thành bởi dấu phẩy bên trái và dấu chấm phẩy hoặc dấu phẩy bên phải. Chúng tôi thay thế tất cả các cặp ký tự như vậy bằng "0" bên trong hai dấu phẩy.

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

Đoạn mã trên khá đơn giản: chúng tôi thay thế từng chuỗi tiếp giáp của% trong không gian kết quả tương tự bằng một ký tự chữ số thập phân tương ứng với số% của mỗi chuỗi cụ thể.

s/[^0-9]//g

Cuối cùng, chúng tôi xóa mọi ký tự không số khỏi không gian mẫu và phần còn lại là kết quả cuối cùng trong ký hiệu thập phân quen thuộc. Giá trị đó được in trên đầu ra tiêu chuẩn và chu kỳ sed tiếp theo bắt đầu, nếu có thêm bất kỳ dòng đầu vào nào được xử lý.




1

Điểm số Java 10, 452 432 416 404 (145 byte + 259 trận đấu)

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

Giải trình:

Hãy thử trực tuyến.

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
  • Tên biến $ραετđược sử dụng thay vì chữ cái. EDIT: Tên biến kmtvwhiện được sử dụng thay thế, bởi vì chúng không thể được tạo bởi các trận đấu theo mô tả thách thức.
  • ''(không thể in) được sử dụng thay vì 6.
  • m-mt-tđược sử dụng thay vì 0.
  • (char)(w|32)+""với đầu vào mảng ký tự được sử dụng thay vì w.toLowerCase()đầu vào mảng Chuỗi.

0

AutoHotkey , 148 byte + 345 que diêm = 493

Điều này là một chút thách thức để rút ngắn.

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 byte + 65 trận đấu = 188

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

Hàm không tên chấp nhận một chuỗi và trả về một số nguyên.

Chứa nhiều ký tự không in được (cụ thể là byte từ một đến tám).

Hãy thử trực tuyến!


0

Than , 48 byte + 3 = 51

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

IΣEθ

Lặp lại các ký tự của đầu vào, tính toán số lượng que diêm của mỗi đầu vào, sau đó tổng hợp kết quả, chuyển đổi thành chuỗi và in ngầm.

⎇№α↥ι

Nếu đó là một bức thư ...

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

Tra cứu số lượng que diêm trong chuỗi nén 65455454240303455250300545.

∧№IX²φι

Khác nếu nó xuất hiện trong giá trị của 2 ** 1000...

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

Tra cứu số lượng que diêm trong chuỗi nén 6255456376.


0

PHP, 98 + 253 = 351

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

Chạy như ống với -nrhoặc thử trực tuyến .

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.