นับไม้ขีด

20

คนส่วนใหญ่ที่นี่คุ้นเคยกับการแสดงเซกเมนต์เจ็ดส่วนซึ่งใช้ในการจับคู่ปริศนา ด้านล่างนี้เป็นตัวเลข0ผ่าน9และตัวอักษรaผ่านzยกเว้นk,m,t,v,wเขียนในรูปแบบนี้

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

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

ความท้าทายที่นี่เป็นเรื่องง่าย รับสตริงอินพุตเอาต์พุตจำนวน matchsticks ที่ต้องการเพื่อแสดงสตริงนั้น หากสตริงมีอักขระที่อยู่นอกการแสดงด้านบนให้ข้ามมัน (นับเป็น 0)

ตัวอย่างเช่นสำหรับการป้อนข้อมูล53ทั้งหมด10ไม้ขีดไฟที่จำเป็น5สำหรับ5และ5สำหรับเพื่อส่งออกเป็น310

สำหรับการป้อนข้อมูล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

ทีนี้สำหรับการบิดและมีสองอย่าง

  • แรกคือการป้อนข้อมูลที่ถือว่า CASE- ในความละเอียดอ่อน นั่นคือ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
  • อินพุตและเอาต์พุตจะได้รับโดยวิธีการที่สะดวกใด ๆ
  • ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
  • ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
code-challenge  counting 
— AdmBorkBork
แหล่งที่มา
2
T เขียนโดยทั่วไปว่าเป็น|_\n|_(ตัวพิมพ์เล็กt)
— 12Me21
@ 12Me21 ฉันคิดว่าจะทำอะไรแบบนั้น แต่ฉันไม่รู้สึกว่ามันใกล้กับจดหมายมากพอดังนั้นฉันจึงออกไป
— AdmBorkBork
ตัวอักษร X (H) ของคุณล่ะ? (ดีฉันไม่สำคัญว่าตอนนี้จะมีคำตอบ)
— 12Me21
สำหรับตัวอักษรภายนอก[0-9a-z]เราควรนับไม้ขีดไฟ 0 อัน? นั่นคือสิ่งที่ผมเข้าใจจากคะแนนของคุณเป็นรหัสที่มาของคุณทำงานได้ผ่านขั้นตอนวิธีนี้บวกกับความยาวของรหัสต้นฉบับของคุณในไบต์
— Erik the 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
— Rod
6

Perl 5กับ-pF, 95 ไบต์ +14, 109

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

นี่เทียบเท่ากับ:

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

แต่การใช้~โอเปอเรเตอร์เราสามารถใช้อักขระไบต์สูงและหลีกเลี่ยงอักขระจำนวนมากโดยไม่ต้องเสียสละไบต์

ยังค่อนข้างเป็นวิธีปิดคะแนนของ Ton แม้จะมีความช่วยเหลือ!

ลองออนไลน์!

โซลูชันนี้มี unprintables ดังนั้นนี่คือการถ่ายโอนข้อมูล hex ที่ย้อนกลับได้เพื่อตรวจสอบการนับไบต์:

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    ............"}{
— เฮสติ้งส์ Dom
แหล่งที่มา
ทำไม}{? วางและ-nตัวเลือก นอกจากนี้คุณยังลืม+lcแทนlc():-)
— Ton Hospel
@TonHospel Goddammit! ฉันดูทั้งโพสต์ของเราและจำไม่ได้ว่าโพสต์อะไรที่ฉันเคยเห็นและ+ไม่คิดทันที! ฉันต้องการnเครื่องของฉันและลืมฉันสามารถวางมัน!
— Dom Hastings
ขอโทษฉันพลาด ฉันหมายถึง "ปล่อย}{และ-p" (และแทนที่ด้วย-nถ้า perl ของคุณยังคงต้องการมันทุกวันนี้จะไม่นับอะไรเลย)
— Ton Hospel
@TonHospel ฉันไม่ได้อัปเดตโค้ดเป็นโอ๊ะโอ ...
— Dom Hastings
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 modulo 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อย่างที่คาดไว้

— Arnauld
แหล่งที่มา
v=>[...v].map(w=>t+='~{w__^_{]|{{_^__^_^w^~]~]^__w_~]~~_^_'.charCodeAt(1+parseInt(w,36))%9,t=+[])|t1 น้อยกว่า
— l4m2
5

Jelly , 42 ไบต์ + 0 matchsticks = 42 คะแนน

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

ขอบคุณ @JonathanAllan สำหรับ -2 คะแนน!

ลองออนไลน์!

มันทำงานอย่างไร

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

ตัวอักษรที่เริ่มต้นด้วย“และจบด้วยการ’แยก“แทนอักขระที่เหลือด้วยดัชนี 1 รายการในหน้ารหัสของ Jelly จากนั้นแปลงจากฐาน bijective 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) ในสตริงอินพุต

ในที่สุดก็æ.นำผลิตภัณฑ์ dot มาคูณจำนวนตัวละครแต่ละตัวด้วยราคาที่ตรงกันใน matchsticks จากนั้นจึงนำผลรวม

— เดนนิส
แหล่งที่มา
ใช้การแยกตัวเป็นจำนวนมากเพื่อบันทึกหนึ่งไบต์และคลายการบีบอัดฐานและโมดูโลแทนDการบันทึกอีกอันหนึ่ง ลองออนไลน์
— โจนาธานอัลลัน
บาย ... จุดผิดพลาด :)
— Jonathan Allan
1
Ɗและอีกหนึ่งด้วย ขอบคุณ!
— Dennis
3

Perl 5 -p , 90 64 code + 9 eval harness + 14 matchsticks = 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ṚƊ

ลิงก์ monadic ยอมรับรายการของอักขระและส่งคืนจำนวนเต็ม

ลองออนไลน์!

อย่างไร?

ทำงานในลักษณะเดียวกันกับคำตอบของ Jelly Dennisแต่ใช้ความพยายามมากพอที่ฉันรู้สึกว่ามันรับประกันคำตอบอื่น ความแตกต่างหลักคือมันเป็นตัวพิมพ์เล็กสำหรับอินพุตสำหรับค่าใช้จ่ายของการจับคู่สามรายการ ( Œ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
— Jonathan Allan
แหล่งที่มา
1

Ruby , 125 ไบต์ + 87 matchsticks = 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 คำตอบของ

โดยปกติค่าใช้จ่ายในการประกาศแลมบ์ดาที่จะใช้เพียงสองครั้งนั้นไม่คุ้มค่า แต่น้ำหนักของไม้ขีดไฟที่เปลี่ยนไป" 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
}
— benj2240
แหล่งที่มา
1

R, 112 bytes + 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 verbose!

— Andreï Kostyrka
แหล่งที่มา
TIO ไม่ว่าด้วยเหตุผลใดก็ตามจะไม่โหลดmethodsแพ็กเกจโดยอัตโนมัติแต่เนื่องจากเป็นbaseแพ็กเกจฉันจึงผลักมันไว้ในส่วนหัวเสมอและไม่นับเป็นจำนวนไบต์ readlineยังไม่ทำงานบน TIO เนื่องจากไม่ใช่เซสชันแบบโต้ตอบ แม้ว่านี่จะสามารถตีกอล์ฟได้แน่นอน
— Giuseppe
— จูเซปเป้
^ ต้องการเครื่องหมายคำพูดรอบอินพุตที่มีช่องว่าง
— Giuseppe
นอกจากนี้ฉันเพิ่งเริ่มห้องแชทสำหรับเล่นกอล์ฟ R! ! ผมเคยเห็นมากคำตอบในการวิจัยเมื่อเร็ว ๆ นี้โดยผู้ใช้จำนวนมากที่แตกต่างกันซึ่งเป็นที่ค่อนข้างให้กำลังใจ :)
— จูเซปเป้
@Giuseppe ฉันคิดว่าคุณควรโพสต์คำตอบแยกต่างหาก มันแตกต่างกันในหลักการและเหนือกว่าของฉันมาก
— Andreï Kostyrka
1

Perl 6 , 87 bytes + 26 matchsticks = 113

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

ลองออนไลน์!

ใช้อักขระ Unicode ที่ไม่ใช่ ASCII บางตัว ตารางการค้นหาถูกเข้ารหัสในสายอักขระ Unicode:

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

อักขระจะถูกแปลงเป็นดัชนีที่มีการแปลงฐาน -36 โดยใช้ตัวเลขอารบิก - อินดิก:

:٣٦('z'); # is equivalent to
:36('z');
— nwellnhof
แหล่งที่มา
1

sed, 367 (ไบต์ซอร์สโค้ด) + 532 (จำนวน matchsticks สำหรับซอร์สโค้ด) = 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

คำอธิบาย:

สคริปต์ด้านบนจะอ่านบรรทัดอินพุตมาตรฐานทีละบรรทัด (ในพื้นที่รูปแบบ - "วิธีการทั่วไป") และสำหรับแต่ละบรรทัดมันจะส่งออกจำนวนของไม้ขีดไฟที่จำเป็นในการเป็นตัวแทนของตัวอักษรที่จับต้องได้ทั้งหมดในบรรทัดนั้น การคำนวณสำหรับอินพุตแต่ละบรรทัดเกิดขึ้นดังนี้:

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

ก่อนอื่นเราจะลบตัวละครทุกตัวที่เราไม่มีการจับคู่ไม้ขีดไฟที่สอดคล้องกัน (ตามที่กำหนดในคำถาม) ออกจากพื้นที่รูปแบบ นั่นคือเราลบอักขระทุกตัวที่ไม่ใช่ตัวเลขจาก "0" ถึง "9" จดหมายจาก "a" ถึง "j", "n" ถึง "s", "l", "u", "x", "y" หรือ "z" ตัวพิมพ์ใหญ่และตัวพิมพ์เล็กจะถือว่าเหมือนกัน

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

หากเราลงท้ายด้วยช่องว่างรูปแบบที่ว่างเปล่าเราจะพิมพ์ 0 (ตามด้วยการขึ้นบรรทัดใหม่โดยอัตโนมัติเช่นเดียวกับ 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/^/,;/

เส้นสองเส้นนั้นจะลบเครื่องหมายอัฒภาคและทุกอย่างที่อยู่หลังจากช่องว่างรูปแบบแล้วใส่เครื่องหมายจุลภาคและเครื่องหมายอัฒภาคลงในจุดเริ่มต้นของช่องว่างรูปแบบ ตอนนี้เราได้แบ่งพื้นที่รูปแบบอีกครั้งเป็นสองส่วนย่อยใหม่: พื้นที่ผลลัพธ์อะนาล็อกก่อนเซมิโคลอนและพื้นที่อินพุตอะนาล็อกหลังจากนั้น

พื้นที่อินพุตแบบอะนาล็อกเป็นสิ่งที่เราเคยเรียกว่า "พื้นที่อินพุต" ก่อนหน้านี้ แต่ในรูปแบบที่แตกต่าง: ตอนนี้มันมีลำดับของ% คั่นด้วยช่องว่างสีขาว จำนวนรวมของ% เช่นนี้ในพื้นที่อินพุตแบบอะนาล็อกคือจำนวน matchsticks เท่ากันที่จำเป็นในการแสดงสตริงอักขระเริ่มต้นที่ป้อนเข้ามานั่นคือตัวเลขนั้นเป็นผลลัพธ์ แต่เราต้องพิมพ์ผลลัพธ์นั้นเป็นสัญกรณ์ทศนิยมไม่ใช่ลำดับของเครื่องหมายเปอร์เซ็นต์ จุดประสงค์ของพื้นที่ผลลัพธ์แบบอะนาล็อกคือเพื่อเก็บการแทนแบบอะนาล็อกของแต่ละหลักของผลลัพธ์ในขณะที่เราคำนวณผลลัพธ์นั้นโดยการหาผลรวมของลำดับ% ต่อเนื่องของ% ในพื้นที่อินพุตแบบอะนาล็อกทีละหนึ่ง ลูปถัดไปจะทำการรวม:

: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 ในพื้นที่ผลลัพธ์แบบอะนาล็อกด้วยอักขระทศนิยมซึ่งสอดคล้องกับจำนวน% ของแต่ละลำดับเฉพาะ

s/[^0-9]//g

ในที่สุดเราจะลบอักขระที่ไม่ใช่ตัวเลขทั้งหมดออกจากพื้นที่รูปแบบและสิ่งที่เหลืออยู่คือผลลัพธ์สุดท้ายในรูปแบบทศนิยมที่คุ้นเคย ค่านั้นจะถูกพิมพ์ลงในเอาต์พุตมาตรฐานและรอบการประมวลผลรอบถัดไปจะเริ่มขึ้นหากมีสายอินพุตที่ต้องดำเนินการเพิ่มเติม

— lucasb
แหล่งที่มา
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-t0
  • (char)(w|32)+""ด้วยอินพุตอักขระอาเรย์ที่ใช้แทนw.toLowerCase()กับอินพุตสตริงอาเรย์
— Kevin Cruijssen
แหล่งที่มา
0

AutoHotkey , 148 bytes + 345 matchsticks = 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
— nelsontruran
แหล่งที่มา
0

Python 3 , 123 bytes + 65 ตรงกัน = 188

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

ฟังก์ชั่นที่ไม่มีชื่อยอมรับสตริงและส่งกลับจำนวนเต็ม

มีอักขระที่ไม่สามารถพิมพ์ได้จำนวนมาก (โดยเฉพาะหนึ่งถึงแปด)

ลองออนไลน์!

— Jonathan Allan
แหล่งที่มา
0

Charcoal , 48 ไบต์ +3 = 51

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

ＩΣＥθ

วนรอบตัวอักขระของอินพุตคำนวณจำนวนไม้ขีดไฟของแต่ละอันจากนั้นหาผลรวมแปลงเป็นสตริงและพิมพ์โดยปริยาย

⎇№α↥ι

ถ้ามันเป็นจดหมาย ...

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

ค้นหาจำนวนไม้ขีดไฟในสตริงที่บีบอัด 65455454240303455250300545เงยหน้าขึ้นมองจำนวนไม้ขีดไฟในสตริงบีบอัด

∧№ＩＸ²φι

ถ้ามันปรากฏในค่าของ2 ** 1000...

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

6255456376เงยหน้าขึ้นมองจำนวนไม้ขีดไฟในสตริงบีบอัด

— นีล
แหล่งที่มา
0

PHP, 98 + 253 = 351

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

ทำงานเป็นท่อที่มี-nrหรือลองออนไลน์

— ติตัส
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.