รหัสโบว์ลิ่ง

คุณได้รับการว่าจ้างจาก Brunswick Bowling เพื่อสร้างโปรแกรมง่าย ๆ ในการแสดงผลข้อความCode Bowlingบนหน้าจอ บริษัท นี้มีมูลค่าเงินสวยและคุณรู้สึกว่าคุณสามารถโกงพวกเขาสำหรับค่อนข้างบิตของเงินสด

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

ออกกระปุกออมสินของคุณกันเถอะรหัส!

ท้าทาย

ความท้าทายคือการส่งออกข้อความCode Bowlingอย่างที่เขียนไว้ที่นี่ด้วยคะแนนสูงสุดเท่าที่จะเป็นไปได้ (ดูหัวข้อ: ระบบการให้คะแนนด้านล่าง)

บรรทัดใหม่และนำหน้า (ขึ้นบรรทัดใหม่) เป็นที่ยอมรับ

รหัสของคุณอาจเป็นโปรแกรมทั้งหมดหรือเพียงแค่ฟังก์ชั่นที่ปฏิบัติการได้

กฎระเบียบ

ข้อผูกมัด: ความท้าทายนี้ใช้Code-Bowling: กฎทั่วไป, การแก้ไข 1.0.0 ; ดู Meta สำหรับรายละเอียด

1. ตัวละคร: Byte Ratio
   ใน Code-Bowling จะต้องนับจำนวนตัวอักษรมากกว่า byte-count เหตุผลที่ชัดเจนสำหรับเรื่องนี้ก็คือตัวอักษร Unicode แบบหลายไบต์ (เช่น🁴) สามารถใช้แทนอักขระแบบ Unicode ไบต์เดียวเพื่อการนับจำนวนไบต์และจะทำให้โบว์ลิ่งมากขึ้นเกี่ยวกับผู้ที่เปลี่ยนชื่อตัวแปรส่วนใหญ่ด้วยอักขระแบบ Unicode แบบไบต์สูง กว่าใครส่วนใหญ่สร้างรหัสที่ซับซ้อนมีความหมาย

2. ชื่อตัวแปร / ฟังก์ชัน / วัตถุชื่อ
   ตัวแปรทั้งหมด (หรือตัวชี้วัตถุชื่อฟังก์ชัน ฯลฯ ) ควรมีความยาว 1 อักขระ เวลาที่ยอมรับได้เฉพาะการใช้ชื่อตัวแปร 2 ตัวคือหลังจากใช้ตัวแปร 1 ตัวที่เป็นไปได้ทั้งหมดแล้ว เวลาที่ยอมรับได้เฉพาะในการใช้ชื่อตัวแปร 3 ตัวคือหลังจากใช้ตัวแปร 2 ตัวที่เป็นไปได้ทั้งหมดแล้ว เป็นต้น

3. 
   รหัสที่ไม่ได้ใช้จะต้องใช้รหัสทั้งหมด ความหมายของโปรแกรมจะต้องล้มเหลวในการทำงานให้เสร็จสมบูรณ์หากตัวละครใด ๆ (หรือชุดอักขระที่แตกต่างกัน) ถูกลบออก โดยธรรมชาติแล้วเซตย่อยของโปรแกรมไม่ควรทำงานให้เสร็จสมบูรณ์ได้เองหากไม่มีโปรแกรมอื่นที่เหลืออยู่

4. ความ
   คิดเห็นไม่ได้รับอนุญาตความคิดเห็นที่มีต่อการนับจำนวนตัวละครยกเว้นว่าโปรแกรม / ฟังก์ชั่นของคุณจะถูกใช้อย่างใด

ระบบการให้คะแนน:

  Pangram Challenge:

pangramเป็นประโยคที่ใช้ตัวอักษรทุกตัวอย่างน้อยหนึ่งครั้ง (สุนัขจิ้งจอกสีน้ำตาลอย่างรวดเร็วกระโดดข้ามสุนัขขี้เกียจ)

ประเภทความท้าทายนี้มีระบบการให้คะแนนที่ออกแบบมาซึ่ง pangram ที่สมบูรณ์แบบจะได้คะแนนสูงสุดทางทฤษฎี(แม้ว่าคุณจะไม่จำเป็นต้องใช้ตัวละครทุกตัวอย่างน้อยหนึ่งครั้ง)นอกจากนี้การใช้ตัวละครมากกว่าหนึ่งครั้งจะเริ่มทำให้เกิดการลงโทษ ความท้าทายนี้ยังขยายไปมากกว่าตัวละครที่เป็นตัวอักษร

  เกณฑ์การให้คะแนน:

1. ตัวละครแต่ละตัวที่ใช้เพิ่มคะแนนของคุณ 1
2. การใช้ตัวอักษรและตัวเลขซ้ำ ๆ (az, AZ, 0-9) จะส่งผลให้มีการหัก 3 คะแนนต่อการทำซ้ำ (การใช้ครั้งแรกไม่ส่งผลให้มีการหัก)
3. การใช้เครื่องหมายวรรคตอนพื้นฐานซ้ำ ๆ([!?.-,":';])รวมถึงเครื่องหมายวงเล็บจะทำให้มีการหัก 2 คะแนนต่อการทำซ้ำ
4. การใช้อักขระ ASCII อื่น ๆ ซ้ำ ๆ{`~@#$%^&*_+=|\/><}รวมถึงวงเล็บปีกกาจะทำให้มีการหัก 4 คะแนนต่อการทำซ้ำ
5. การใช้ช่องว่างแท็บและการขึ้นบรรทัดใหม่จะส่งผลให้ลด 1 จุดต่อการใช้งาน นั่นคือพวกเขาจะไม่นับรวมตัวละคร
6. อักขระที่ไม่ได้กล่าวถึงข้างต้น(อักขระที่แปลกใหม่)จะส่งผลให้ลด 1 จุดต่อการใช้งาน นั่นคือพวกเขาจะไม่นับรวมตัวละคร

  เครื่องมือให้คะแนน:

อัตโนมัติเครื่องมือการให้คะแนนได้ถูกสร้างขึ้นและสามารถพบได้ที่นี่

นี่เป็นตัวแปรรหัสโบลิ่ง โปรแกรมที่มีคะแนนสูงสุดจะเป็นผู้ชนะ! (เนื่องจากมีคะแนนสูงสุด94ใครก็ตามที่มาถึงก่อน (หากสามารถเข้าถึงได้) จะถูกทำเครื่องหมายเป็นคำตอบที่ยอมรับแม้ว่าคนอื่น ๆ จะมีอิสระในการตอบเพื่อความสนุก)

Glypho , 94

แฟ้มแหล่งที่มีการเข้ารหัสในCP437

␀␀!"☺☺#$☻♥♥☻♦♣♦♣%♠♠&•◘•◘'○○(◙♂◙♂♀♪♪♀♫☼♫☼►◄◄►↕↕)*‼¶¶‼§§+,▬↨↨▬↑↓↑↓→←→←∟∟-.↔▲▲↔/▼▼▼⌂Ç⌂Çüééüââ01ää23àååàçêçê4ëë5èïèïîî67ìÄÄì8ÅÅ9ÉÉ:;æÆÆæô<=ôöòòöûùûù>ÿÿÿÖÖ?@ÜÜAB¢££¢¥₧¥₧CƒƒDáíáíóóEFúññúѪѪGººHI¿¿J⌐¬⌐¬K½½½¼¼LM¡««¡N»»»░░OP▒▒QR▓││▓┤╡┤╡S╢╢T╖╕╖╕U╣╣V║╗║╗╝╜╜╝W╛╛╛┐X┐┐Y└└└┴┬┴┬├─├─Z┼┼┼╞╞[\╟╟]^╚╔╔╚╩╦╩╦_╠╠`═╬═╬╧╨╨╧╤╥╥╤a╙╙╙╘╘bc╒╒de╓╓fg╫╪╪╫┘┌┌┘█▄█▄▌hi▌▐j▐▐▀αα▀ßΓßΓπΣπΣkσσσµlµµτmnτΦΘΘΦΩδΩδo∞∞∞φpφφεεqr∩≡≡∩±±st≥≤≤≥u⌠⌠⌠⌡⌡vw÷xy÷≈°°≈∙∙z{·|}·√ⁿⁿ√~²²²

ลองออนไลน์!

คำอธิบาย

Glypho ค่อนข้างมีประโยชน์สำหรับความท้าทายเช่นนี้เพราะมันไม่สนใจว่าตัวละครที่แท้จริงจะถูกใช้งานอย่างไร แต่มันจะดูที่กลุ่มของอักขระ 4 ตัวและคำสั่งที่ใช้จะถูกกำหนดโดยรูปแบบที่อักขระสี่ตัวเหล่านี้สร้าง:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

นั่นหมายความว่าเราสามารถแก้ปัญหาได้จากนั้นกรอกอักขระที่ไม่ซ้ำกันในแต่ละควอเตตด้วยอักขระที่พิมพ์ได้และอักขระที่ทำซ้ำทั้งหมดด้วยอักขระ "แปลกใหม่" บางตัวซึ่งไม่สนใจในการให้คะแนน Glypho มีคำอธิบายที่เพียงพอว่าโซลูชันที่เขียนด้วยลายมือปกติมีอักขระที่ไม่ซ้ำกันมากพอที่จะใส่ลงใน 94 ที่สามารถพิมพ์ได้ ในความเป็นจริงฉันลงเอยด้วยการเล่นกอล์ฟจนมี 94 อย่างแท้จริงเพื่อที่ฉันจะได้ใช้ตัวละครแปลกใหม่สำหรับตัวละครซ้ำ (หวังว่าจะทำให้การลดโปรแกรมยากขึ้น)

รูปแบบย่อของโปรแกรมด้านบนคือ:

11+d*d*d+d+1+1+dd1+o
d+11+d*d1+*1+-+do
11+d*d1+d**do
1+o
11+d*d*d+o
<o
ddo
11+d*d++o
111++d-<+ddo
<-+do
<1+1+o
1-+1-+o

ที่แต่ละบรรทัดพิมพ์หนึ่งในตัวละคร

ผมเคยใช้สคริปต์ Retina นี้เพื่อแปลงเป็น Glypho 0123ใช้ หลังจากนั้นฉันเพิ่งกรอกตัวอักขระแทนตัวเลข

ในทางทฤษฎีอาจเป็นไปได้ที่จะลดสิ่งนี้ลงอีกถ้ามีคนจัดการโปรแกรมย่อชวเลขแล้วจัดการรวมตัวอักขระที่รูปแบบที่ถูกต้องปรากฏขึ้นอีกครั้ง แต่ฉันไม่แน่ใจว่าจะพิสูจน์หรือพิสูจน์ว่านี่เป็นไปได้ . หากใครก็ตามจัดการเพื่อสร้างโซลูชันที่ถูกต้องจากส่วนย่อยของโปรแกรมของฉันโปรดแจ้งให้เราทราบเพื่อให้ฉันสามารถลบคำตอบจนกว่าจะได้รับการแก้ไข ก่อนหน้านั้นฉันจะต้องสมมติว่ามันใช้ได้

Python 3, 82 87 88

ขอบคุณ @JonathanAllan สำหรับคะแนน +1

print("g!#$%&'*n+,./012i34579;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ ^_`abchejkmqsuvdyz{|}~ \x6f       C"[::-8])

ลองออนไลน์!

ไม่มีอะไรพิเศษเพียงแค่หั่นและข้ามตัวอักษร สายอักขระถูกย้อนกลับดังนั้นคุณไม่สามารถลบอักขระและมีการพิมพ์สายอักขระดั้งเดิม

> <> , 92 94

ใช่ฉันไม่ได้!

␑เป็นอักขระแปลกใหม่ที่\x11มีค่าทศนิยม 17 โปรแกรมออกจากพร้อมข้อผิดพลาดหลังจากพิมพ์ผลลัพธ์ ฉันต้องจัดการที่กระจกและคำสั่งทิศทางที่ฉันใช้อย่างระมัดระวังเนื่องจากฉันสามารถใช้แต่ละครั้ง

   >"vCoUV␑3`h]Z_X
       /a[f+
#$%&'r(!
.0456~8?
:;<=@9l)
ABDEFcGe
HIJKL*
MNOPQ7
RSTWYd
bgijk1
mnqst-
uwxyz2
{|}  ,
     \p^

ลองออนไลน์

โปรแกรมหลัก:

   >"vCoUV␑3`h]Z_X
       /a[f+
     r !
     ~ ?
     9 )
     c e
     *
     7
     d
     1
     -
     2
     ,
     \p^

คำอธิบาย:

กดสตริงvCoUV␑3`h]Z_X >(การดำเนินการ wraps) เลื่อนลง vย้อนกลับสแต็คและลบ

กด9และc(12) ทวีคูณเพื่อรับ108( l) 7ดัน ผลักดันd(13), ลบ1, หารด้วยที่จะได้รับ2 6ใส่lที่ (x, y) ของ (13,6) eซึ่งอยู่ด้านล่าง ฉันทำแบบนี้ให้สั้นลงได้ แต่มันยาวขึ้นดังนั้นฉันจึงมีที่ว่างที่จะใส่อักขระ ASCII ให้มากขึ้น

เลื่อนขึ้นเป็นวง lความยาวของสแต็คผลักดันด้วย ถ้ามากกว่า 14 ตัวอักษรเอาท์พุทมิฉะนั้นสร้างกองใหม่ที่มีองค์ประกอบ 10 อันดับแรกเพิ่ม 15 จากนั้นสะท้อนให้เห็นถึงการดำเนินการแล้วขึ้นและออก สิ่งนี้ใช้เพื่อป้องกันช่องว่างเพิ่มเติมและ>จากการพิมพ์ที่ส่วนท้ายเช่นเดียวกับการเปลี่ยนสตริงการค้นหาแบบสุ่มเป็นสิ่งที่จำเป็นต้องพิมพ์ ทำการวนซ้ำต่อไป

หากมีเส้นใดเส้นหนึ่งสั้นลง (โดยการลบอักขระ) โปรแกรมจะไม่ทำงานอีกต่อไปเนื่องจากส่วนแนวตั้งของโปรแกรมไม่ได้อยู่อีกต่อไปหรือเนื่องจากสตริงที่จะพิมพ์ไม่ถูกต้องอีกต่อไป ความพยายามที่จะลบอักขระออกจากด้านหน้าของแต่ละบรรทัดจะเปลี่ยนความลึกของสแต็กและตำแหน่งที่lวางอยู่ซึ่งทำให้เกิดปัญหาเช่นกัน

^_ปลา

Octave, 20 21 22 25 27 33

สิ่งที่ดีที่สุดที่ฉันเคยจัดการมาคือ

g=@()disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0));

สิ่งนี้จะสร้างฟังก์ชั่นนิรนามfที่ไม่มีการป้อนข้อมูล f()คุณสามารถเรียกมันว่า ฉันจะบอกว่าเครื่องหมายอัฒภาคท้ายมีความจำเป็นเพื่อหลีกเลี่ยงการพิมพ์ของฟังก์ชันร่างกาย

เป็นไปได้ที่จะสามารถปรับปรุงได้โดยการรวมevalและprintfแต่ฉันได้ลองและล้มเหลวซ้ำแล้วซ้ำอีก

สิ่งนี้ใช้ตัวเลขทั้งหมดเพียงครั้งเดียวโดยการอธิบายข้อเท็จจริงที่ว่าอ็อกเทฟทำการmod(x,256)ดำเนินการเมื่อแปลงตัวเลขเป็นอักขระ ซึ่งหมายความว่าเราสามารถใช้ตัวเลขติดลบเช่นเดียวกับตัวเลขนอกปกติ32-126-range ตัวเลขดังต่อไปนี้ผลทั้งหมดในจดหมายเมื่อแปลงเป็นตัวอักษร:i ... -2455 -2199 -1943 ... 105 361 ...แทนที่จะใช้'owling'ในท้ายที่สุดเราใช้"nvkhmf"และเพิ่ม 1 สิ่งนี้จะสร้างเวกเตอร์ของจำนวนเต็มที่แปลงเป็นอักขระโดยปริยาย แทนที่จะ1ใช้เราใช้!0(หรือnot(false)นอกจากนี้เราใช้"แทน'เพื่อหลีกเลี่ยงจุดโทษสองจุด

เราจำเป็นต้องค้นหาชุดของตัวเลขที่ให้คะแนนต่ำสุด สตริงCode Bowlingส่งผลให้เมทริกซ์ต่อไปนี้เมื่อเราลบและเพิ่ม -10 * 256 - 10 * 256

  -2493  -2449  -2460  -2459  -2528  -2494  -2449  -2441  -2452  -2455  -2450  -2457
  -2237  -2193  -2204  -2203  -2272  -2238  -2193  -2185  -2196  -2199  -2194  -2201
  -1981  -1937  -1948  -1947  -2016  -1982  -1937  -1929  -1940  -1943  -1938  -1945
  -1725  -1681  -1692  -1691  -1760  -1726  -1681  -1673  -1684  -1687  -1682  -1689
  -1469  -1425  -1436  -1435  -1504  -1470  -1425  -1417  -1428  -1431  -1426  -1433
  -1213  -1169  -1180  -1179  -1248  -1214  -1169  -1161  -1172  -1175  -1170  -1177
   -957   -913   -924   -923   -992   -958   -913   -905   -916   -919   -914   -921
   -701   -657   -668   -667   -736   -702   -657   -649   -660   -663   -658   -665
   -445   -401   -412   -411   -480   -446   -401   -393   -404   -407   -402   -409
   -189   -145   -156   -155   -224   -190   -145   -137   -148   -151   -146   -153
     67    111    100    101     32     66    111    119    108    105    110    103
    323    367    356    357    288    322    367    375    364    361    366    359
    579    623    612    613    544    578    623    631    620    617    622    615
    835    879    868    869    800    834    879    887    876    873    878    871
   1091   1135   1124   1125   1056   1090   1135   1143   1132   1129   1134   1127
   1347   1391   1380   1381   1312   1346   1391   1399   1388   1385   1390   1383
   1603   1647   1636   1637   1568   1602   1647   1655   1644   1641   1646   1639
   1859   1903   1892   1893   1824   1858   1903   1911   1900   1897   1902   1895
   2115   2159   2148   2149   2080   2114   2159   2167   2156   2153   2158   2151
   2371   2415   2404   2405   2336   2370   2415   2423   2412   2409   2414   2407
   2627   2671   2660   2661   2592   2626   2671   2679   2668   2665   2670   2663

ดังนั้นจะส่งผลใน['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103] ans = Code Bowlingความท้าทายคือการหาชุดของตัวเลขและตัวละครที่ช่วยลดคะแนนมากที่สุด การใช้ตัวเลขทั้งหมดเป็นสิ่งที่ดีแน่นอน แต่ข้อมูลซ้ำซ้อนนั้นไม่ดี เนื่องจากมีการใช้ตัวเลขทั้งหมดและไม่ได้ใช้สองครั้งจึงเป็นการผสมผสานที่ดีที่สุด นอกจากนี้เรายังได้ใช้งาน-ซึ่งส่งผลให้ในจุดหนึ่ง

หนึ่งสามารถอ้างว่ามันสามารถลดลงไปยังบรรทัดด้านล่าง (31 คะแนน) แต่แล้วมันจะไม่เป็น"ฟังก์ชันปฏิบัติการ"อีกต่อไปและจะมีฟังก์ชั่นที่แตกต่างกัน

disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0))

QBasic, 34

นี่คือรหัสที่ยังไม่ฟอร์แมต (ใช่สำหรับการพิจารณาตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) คุณสามารถเรียกใช้งานได้ในQB64หรือที่archive.org (โปรดทราบว่าส่วนหลังจะจัดรูปแบบรหัสตามที่คุณพิมพ์) ฉันคิดว่าฉันสามารถปฏิบัติตามกฎทั้งหมดได้แล้ว

CLS
PrINT "C
LOcatE 1, 2 : ? CHR$(957-846); "de Bowling

CLSเป็นสิ่งที่จำเป็น: โดยไม่ได้ที่จะไม่รับประกันในการพิมพ์ที่มุมซ้ายบนของหน้าจอที่มันจะสอดคล้องกับC เป็นสิ่งที่จำเป็น: ไม่ว่าจะพิมพ์ในบรรทัดด้านล่าง ฉันไม่เชื่อว่ามีส่วนย่อยของโปรแกรม (ยกเว้นช่องว่าง) ที่สามารถลบและเก็บผลลัพธ์เดียวกันode BowlingLOcatEode BowlingC

C, 27 29

+2 คะแนนขอบคุณ @ceilingcat!

f(){char q<:]="Code B\157wling";puts(q);%>

Haskellคะแนน21 38 46 47 21 70

putStr$toEnum(length"!#%&'*+,-./012345789;<=>?@ADGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~"):"ode B\x6Fwling"

ลองออนไลน์! ความคิดคือการได้รับความเป็นผู้นำCโดยการสร้างสตริงที่มีความยาว 67 ซึ่งมีตัวละครที่ไม่ได้ใช้ทั้งหมดและการแปลงความยาวของสตริงนี้เป็นตัวละคร ฉันเริ่มต้นด้วยputStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'เป็นเลขฐานสิบหก'\111'ที่ให้ผลตอบแทน'o') และคำนวณอักขระ ASCII ที่พิมพ์ได้ทั้งหมดที่ไม่มีอยู่ในโปรแกรม:

!#%&'*+,-./012345789;<=>?@ACDGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~

อนึ่งมีอักขระ ASCII ที่พิมพ์ได้ 67 ตัวที่สามารถใส่ลงในสตริงได้และCตัวเองที่ไม่สามารถปรากฏในสตริงได้เพราะโปรแกรมจะสามารถย่อให้เหลือเพียงputStr"Code B\x6Fwling"ได้

วิธีแก้ปัญหาก่อนหน้า: (คะแนน 21)

f|x<-'C'=mapM putStr[(:)x"ode Bowling"]

กำหนดฟังก์ชั่นfที่ไม่มีการป้อนข้อมูลและพิมพ์สตริง ลองออนไลน์!

JavaScript, 19

prompt('C\157de B\x6fwlin'+"g")

ไม่ใช่คะแนนที่สูงมาก

เยลลี่ , 94

“!#"$&('*)+-/,13.0456:79<;>=@B?ADFHJLNCPRTEVXZ\G^IKMQ`SWbY[]d_acfhjegliknmprotquvxwy{z}¹|³⁵⁷~°⁹⁻”O%2s8UḄỌ

ลองออนไลน์!

105 ตัวละครที่ไม่ซ้ำกัน 11 exotics ( “¹³⁵⁷°⁹⁻”ḄỌ)

อย่างไร?

จัดรูปแบบสตริงจาก ASCII แบบย้อนกลับ 8 บิตโดยที่แต่ละบิตถูกเข้ารหัสโดยใช้ LSB ของค่า Unicode ของอักขระ

“...”O%2s8UḄỌ - Main link: no arguments
“...”         - the string enclosed            !  #  "  $  &  (  '  *  )  +  -  /  ,  1  3  .  0  4  5  6  :  7  9  <  ;  >  =  @  B  ?  A  D  F  H  J  L  N  C  P  R  T  E  V  X  Z  \  G  ^  I  K  M  Q  `  S  W  b  Y  [  ]   d  _  a  c   f   h   j   e   g   l   i   k   n   m   p   r   o   t   q   u   v   x   w   y   {   z   }   ¹   |   ³    ⁵    ⁷   ~   °    ⁹    ⁻
     O        - cast to ordinal (vectorises) [33,35,34,36,38,40,39,42,41,43,45,47,44,49,51,46,48,52,53,54,58,55,57,60,59,62,61,64,66,63,65,68,70,72,74,76,78,67,80,82,84,69,86,88,90,92,71,94,73,75,77,81,96,83,87,98,89,91,93,100,95,97,99,102,104,106,101,103,108,105,107,110,109,112,114,111,116,113,117,118,120,119,121,123,122,125,185,124,179,8309,8311,126,176,8313,8315]
      %2      - mod 2 (vectorises)           [ 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,  0, 1, 1, 1,  0,  0,  0,  1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  1,  0,  1,  1,  0,  1,   1,   1,  0,  0,   1,   1]
        s8    - split into chunks of 8       [[1,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [0,0,1,0,0,1,1,0], [1,0,1,0,0,1,1,0], [0,0,0,0,0,1,0,0], [0,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [1,1,1,0,1,1,1,0], [0,0,1,1,0,1,1,0], [1,0,0,1,0,1,1,0], [0,1,1,1,0,1,1,0], [1,1,1,0,0,1,1]]
          U   - upend (vectorises)           [[0,1,0,0,0,0,1,1], [0,1,1,0,1,1,1,1], [0,1,1,0,0,1,0,0], [0,1,1,0,0,1,0,1], [0,0,1,0,0,0,0,0], [0,1,0,0,0,0,1,0], [0,1,1,0,1,1,1,1], [0,1,1,1,0,1,1,1], [0,1,1,0,1,1,0,0], [0,1,1,0,1,0,0,1], [0,1,1,0,1,1,1,0], [1,1,0,0,1,1,1]]
           Ḅ  - binary to int (vectorises)   [67, 111, 100, 101, 32, 66, 111, 119, 108, 105, 110, 103]
            Ọ - to character (vectorises)    ['C', 'o', 'd', 'e', ' ', 'B', 'o', 'w', 'l', 'i', 'n', 'g']
              - implicit print               Code Bowling

Röda , 33

{["ode B\x6fwling"]|push chr(3*4+57-2).._}

ลองออนไลน์!

ฉันพยายามทำตามกฎทั้งหมด มันทำงานโดยการกดสตริงode Bowling!ไปที่กระแสก่อนแล้วจึงใส่C= 3 * 4 + 57-2 ที่ด้านหน้า

คาร์ดินัล 20

23 อักขระที่ไม่ใช่ช่องว่าง
% #> / NI "CodeB8 ^ o) wl, ing

-3 สำหรับการทำซ้ำ "o"

   I
 >\/N
%# "CodeB
 8^o
 ) w
   l
 , i
   n
   g

เส้นทางตัวชี้:

ขั้นตอนที่ 1:
ตัวชี้สร้างขึ้นที่% ไปทางขวา

ขั้นตอนที่ 2:
ตัวชี้แยกที่ # เพื่อขึ้นไปทางขวาและลง (P1, P2, P3)

ขั้นตอนที่ 3 :
P1 ส่งไปทางขวา>
P2 ไปทางขวา
P3 ตั้งค่ารอ 3 ขั้นตอนที่ 8

ขั้นตอนที่ 4:
P1 สะท้อนลงโดย \ \ เปลี่ยนเป็น /
P2 ตั้งเป็นโหมดการพิมพ์โดย "
P3 รอ 2 เห็บที่ 8

ขั้นตอนที่ 5:
P1 มุ่งหน้าลง
P2 พิมพ์ C
P3 รอ 1 ขีดที่ 8

ขั้นตอนที่ 6:
P1 ส่งโดย ^
P2 พิมพ์ o
P3 เสร็จสิ้นรอต่อไปรับค่า ASCII ของ "" (32) จาก)

ขั้นตอนที่ 7: P1 มุ่งหน้าขึ้น
P2 พิมพ์ d
P3 มุ่งหน้าลง

ขั้นตอนที่ 8: P1 ถูกสะท้อนโดย \ ซึ่งเปลี่ยนเป็น /
P2 Print e
P3 Print อักขระที่มีค่า ASCII = 32 จากการดำเนินการ

ขั้นตอนที่ 9:
P1 สะท้อนโดย / ซึ่งเปลี่ยนเป็น \
P2 พิมพ์ B
P3 ถึงจุดสิ้นสุดของฟิลด์แล้วและหยุด

ขั้นตอนที่ 10:
P1 สะท้อนโดย I
P2 ถึงจุดสิ้นสุดของฟิลด์แล้วหยุด

ขั้นตอนที่ 11:
P1 ถูกสะท้อนโดย / ซึ่งเปลี่ยนเป็น \ เปลี่ยนกลับเป็น /

ขั้นตอนที่ 12:
P1 สะท้อนซ้ายโดย N

ขั้นตอนที่ 13:
P1 สะท้อนลงโดย /

ขั้นตอนที่ 14:
P1 ตั้งค่าเป็นโหมดการพิมพ์โดย "

ขั้นตอนที่ 15:
P1 พิมพ์ o

ขั้นตอนที่ 16:
P1 พิมพ์ w

ขั้นตอนที่ 17:
P1 พิมพ์ l

ขั้นตอนที่ 18:
P1 พิมพ์ i

ขั้นตอนที่ 19:
P1 พิมพ์ n

ขั้นตอนที่ 20:
P1 พิมพ์ g

ขั้นตอนที่ 21:
P1 ถึงจุดสิ้นสุดของฟิลด์และหยุด

ลองออนไลน์

C, 73

ขอบคุณ @Laikoni!

F(){printf("Code B\157wli%cg",48+strlen("!#$&'*-../2369:<=>?@ADEGHIJKLMNOPQRSTUVWXYZ[]^_`abhjkmquvxyz|~"));}

ลองออนไลน์!

C,  31   33  35

F(){printf("Code B\157wli%cg",96|0xD+3*4/8);}

ขอบคุณ @ceilingcat และ @DLosc สำหรับอีกสองคะแนนและขอบคุณ @ Ørjan Johansen อีกสองคะแนน!

ลองออนไลน์!

แบตช์ 19 ตัวอักษร

@echO(Cod%TMP:~5,1% Bowling

การเริ่มต้นด้วย Windows Vista TMPเริ่มต้นด้วยC:\Users\ดังนั้นจึง%TMP:~5,1%เป็นวิธีการเขียนeอย่างละเอียดแม้ว่าจะต้องได้รับ%โทษคู่ที่ -4

Brainfuck: -204

++++[++++>---<]>.+[--->+<]>+++.-----------.+.--[--->+<]>-.+[->++<]>.-[--->+<]>++++.++++++++.-----------.---.+++++.-------.

คะแนนแย่มาก แต่ก็สนุกดีที่ได้เขียน

• ความยาว 122 ตัวอักษร
• ซ้ำ alnum: -0 ()
• เครื่องหมายวรรคตอนซ้ำแล้วซ้ำอีก: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] .. - ---------. --- ..-------.)
• ทำซ้ำอื่น ๆ : -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++++ ++++)
• อักขระช่องว่าง: -0 ()
• ตัวละครแปลกใหม่: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 คะแนน

53 คะแนน (24 → 77) ขอบคุณที่@Laikoni

v->(char)"!#$%&'*,/0234689:;<=?@ADEFGHIJKLMNOPQRSTUVWXYZ[]^_`bfjkmpqsuxyz{|}~".length()+"\157de Bowling"

ความยาว 104 อักขระ
- alnum ซ้ำ: -15 ( helng)
- เครื่องหมายวรรคตอนซ้ำ: -10 ( "()"")
- ทำซ้ำ ASCII อื่น ๆ : ไม่มี
- ตัวอักษรช่องว่าง: -1
คะแนน: 78

ลองออนไลน์

คำตอบเก่า24 ไบต์ :

v->"C\157de Bowlin"+(char)103;

30 ตัวอักษร
- alnum ซ้ำ: -3 ( 1)
- เครื่องหมายวรรคตอนซ้ำ: -2 ( ")
- ทำซ้ำ ASCII อื่น ๆ : ไม่มี
- ตัวอักษรช่องว่าง: -1
คะแนน: 24

ลองออนไลน์

ซ้อนกัน , 42

(67:43,1 ab)2 9*pf sum 8/0\|>+chr'de Bowling',EPS#`

ลองออนไลน์!

ปล่อยเอาต์พุตบนสแต็ก นี่คือรายละเอียด:

length: 51
repeated alnum:        -0 ()
repeated punct:        -4 (',)
repeated other:        -0 ()
whitespace characters: -5 (     )
exotic characters:     -0 ()
total score: 42

ฉันอาจจะทำให้มันสูงขึ้น แต่มันอยู่ที่ 42 soo ....

ผู้เข้าแข่งขันคนอื่น 40:

(67:43,sum)9 pf 2%MIN 0\|>+chr'de Bowling',EPS#`

ฉันใช้สคริปต์นี้เพื่อให้คะแนน

ชั่วร้าย -81

ดีกว่า Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

คำอธิบาย

aeeaeuw //Write 'C'
k       //Set P[0] to 'C'
aaeeuw  //Write 'O'
y       //Set W[0] to 'O'
gaeae   //Set Accumulator to 'D'
claa    //Create new Wheel cell at index 0, swap with Accumulator, add 2
xj      //Set alternate marker mode and drop marker
lwa     //Write value of W[0], add 1
lu      //Put it back, subtract 1 from Accumulator
sb      //Go to 'j' if Accumulator != 0
d       //Delete W[0]
        //The above loop writes 'D' and 'E'
gueuew  //Write ' '
guw     //Write 'B'
pw      //Write 'o'
eew     //Write 'w'
puuuw   //Write 'l'
uuuw    //Write 'i'
puw     //Write 'n'
eew     //Write 'g'

ส่งเพราะไม่มีใครทำอะไรชั่วร้าย แต่มันสนุก

คะแนน:

ความยาว = 63

a*8  = -24
e*12 = -36
g*2  = -6
l*2  = -6
p*2  = -6
u*12  = -36
w*10  = -30

ลองออนไลน์!

แก้ไข: TiO ดูเหมือนว่าจะจัดการการสร้างและการลบเซลล์ล้อใหม่อย่างไม่ถูกต้อง - ฉันได้ยื่นรายงานข้อผิดพลาดเกี่ยวกับเรื่องนี้แล้ว มันทำงานไม่ถูกต้อง แต่ฉันใช้มันเป็นล่ามของฉันเองและใช้งานได้และคุณสามารถไว้ใจฉันได้ดังนั้นฉันจะไม่ต้องกังวลกับมัน)

Perl: 29 , 33

$_=OWLING;printf%s,"C\157de".chr(30+8/4).B.lc

คะแนน:

- 46 characters long
- repeated alnum:       -6 (rc)
- repeated punctuation: -6 ("..)
- repeated other:       -0 ()
- whitespace characters:  -1 (
)
- exotic characters:  -0 ()

Total score: 33

05AB1E , 94 คะแนน

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”€a7ôJCç€?

ลองออนไลน์!

- 100 characters long
- repeated alnum:       -0 ()
- repeated punctuation: -0 ()
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -6 (””€ôç€)

Total score: 94

โดยทั่วไปจะแปลง (ASCII ไบนารีของ Code Bowling):

['1000011', '1101111', '1100100', '1100101', '0100000', '1000010', '1101111', '1110111', '1101100', '1101001', '1101110', '1100111']

เป็นสตริงของ 1 และ 0 จากนั้นจะแทนที่แต่ละ 1 ด้วยตัวอักษรในตัวอักษรและแต่ละ 0 มีอักขระเว้นวรรคหรือสัญลักษณ์หรือตัวเลข

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”

เป็นสตริงโดยที่ 1 คือตัวอักษรและ 0 คือสัญลักษณ์ตัวเลขหรือสิ่งอื่นใด จากนั้นเราก็วนซ้ำไปเรื่อย ๆ โดยดูว่าตัวอักษรใดเป็นตัวผลัก 1 สำหรับตัวอักษร 0 สำหรับ nonalphabetical จากนั้นเราแบ่งออกเป็นกลุ่ม 7 แปลงกลับเป็น ASCII และพิมพ์อักขระแต่ละตัว

T-SQL, 65 18 32! จุด

PRINT char(78-9605*43%12) + 'ode Bowling'

แรงบันดาลใจจากเล่ห์เหลี่ยมในคำตอบ QBasic ของ Dloscฉันพบวิธีที่จะรวมตัวเลข 10 หลักและตัวดำเนินการทางคณิตศาสตร์ทั้งหมด ( %ส่วนที่เหลือ / โมดูโลหายไปเท่านั้น/) ส่วนใหญ่ผ่านการลองผิดลองถูก ฉันไม่คิดว่าจะมีวิธีใดในการรับ 67 โดยการลบตัวเลข / สัญลักษณ์ใด ๆ แต่คุณสามารถลองได้

รุ่น 2 (18 คะแนนเล็กน้อย):

DECLARE @ char(12)='Code Bowling'PRINT @

ไม่ใช่คะแนนที่ยอดเยี่ยม แต่นี่เป็นสิ่งที่รุ่นแรกของฉันทำให้ง่ายขึ้น (ขอบคุณ MickyT) ทุกสิ่งทุกอย่างที่ฉันพยายาม (เข้ารหัสและถอดรหัส hex64, เลือกแต่ละองค์ประกอบจากสตริง, แปลงค่า ASCII, ฯลฯ ) ทั้งหมดมีอักขระซ้ำ ๆ กันจำนวนมากเกินไป (โดยเฉพาะECRและสัญลักษณ์(),@) ที่ขับเข้าไปในค่าลบ

รุ่น 1 (65 คะแนนไม่ถูกต้อง):

DECLARE @ char(123)=
'Code Bowling FGHJKMOQSUVWXYZbjkmpqsuvxyz045789 [!?.-":;]{`~#$%^&*_+|\><}'
PRINT left(@,LEN(@)/6)

ผมใช้ความยาวของสตริงเพื่อตรวจสอบจำนวนตัวอักษรที่ผมใช้จากด้านซ้ายดังนั้นการลบใด ๆเดียวตัวละครจากสตริงจะลดลงผลแบ่งจำนวนเต็มลงไปที่ 11 Code Bowlinการแสดงผลเท่านั้น

; # , คะแนน -1163, ไม่ใช่การแข่งขัน

ฉันไม่คิดว่ามันจะเป็นการแข่งขันที่ยิ่งใหญ่แม้ว่ามันจะสามารถแข่งขันได้

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

ลองออนไลน์! หมายเหตุ: TIO ไม่มี; # interpreter เท่านั้น; # +

CJam , คะแนน 47

"'#?GyQ2wE(s6&␟JI!gF$u*Aq;0p4BvOKkHLhM"3/{:i~-z+c}%

หวังว่าจะไม่มีปัญหากับสิ่งนี้ ...

ใช้อักขระแปลกใหม่หนึ่งตัว (หน่วยคั่น, ASCII 31, แสดงโดย␟) และอักขระซ้ำหนึ่งตัว ( ") ฉันคิดว่ามันน่าจะยังใช้งานได้อีกต่อไป แต่ฉันจะทิ้งไว้อย่างนั้นตอนนี้

ลองออนไลน์!

โปรแกรมทำงานโดยนำสตริงยาวนั้นและแยกออกเป็นสตริงย่อยความยาว 3 แต่ละสตริงย่อยจะถูกแมปกับบล็อกซึ่งแปลงอักขระเป็นค่า ASCII ของพวกเขาทิ้งค่าบนสแต็กใช้ความแตกต่างที่แน่นอนของสองที่สองเพิ่มผลลัพธ์ด้วยครั้งแรกแล้วแปลงผลลัพธ์สุดท้ายกลับเป็น ASCII ตัวละคร

CJam, 93 คะแนน

"g!#$&'()n*+/0134i5689:;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ [\]^_`aebcfhjkmdqrstuvxpyz{|}  C"7~%2,.-

ลองออนไลน์

แรงบันดาลใจจากTidB คำตอบของงูหลาม
ไม่แน่ใจว่ามีวิธีใดที่จะหลีกเลี่ยงการซ้ำซ้อนของคำพูดคู่

คำอธิบาย:

สตริงมี "Cpde Bowling" ในทางกลับกันทุกตัวละครที่ 8
7~%แยก "Cpde Bowling" ( 7~= -8)
2,.-ลดจำนวนอักขระ p ( 2,= [0 1])

PHP, 33 คะแนน

มันค่อนข้างยากที่จะเกิดขึ้นกับ

คะแนนอาจได้รับการพิสูจน์ในอนาคต

<?echo IHASZODECG9F^"
'%6z\r+2/.W!";

การขึ้นบรรทัดใหม่ถือว่าเป็นบรรทัดใหม่ของ Linux! สไตล์ Windows และ Old-Mac-Style ทำงานไม่ถูกต้อง

ทับทิม, 75

ประมาณพอร์ตของคำตอบ Python แต่ Ruby ไม่มีฟังก์ชั่น cool step ดังนั้นฉันจึงใช้gsubแทน ฉันตัดสินใจที่จะสนุกกับตัวละครแปลก ๆ โดยการใส่วลีลงใน Google Translate

ลองออนไลน์!

print"Cachjkmq\x6fvyzADEFdGHIJKLMeNOPQRST UVWXYZ0B234589[o!?-:;]`w~@\#$%^&l*_+=|><i コードゴルフn 代碼保齡球 gκωδικός".gsub /(.).{7}/,'\1'

USML, 12 หรือ 9 คะแนน (ไม่ใช่การแข่งขัน)

"Code\tBowling'

ลองออนไลน์!

คำตอบนี้โกงกลโกงเล็กน้อยโดยใช้วิธีการแสดงผล HTML "Code\tBowling "สตริงที่สร้างขึ้นจริงตามนี้คือ คะแนนจะหายไปสำหรับการทำซ้ำอักขระ "o"

สำหรับคำตอบที่ไม่โกง:

"Code Bowling

USML ยังค่อนข้างเร็วในการพัฒนาและยังไม่สามารถเพิ่มขนาดของโปรแกรมได้อีก

Cubix , 85

Codeha1spqumtr;$"gnilwoB"Sv"ADEFH%IJK2f!OPUzQ0V3XY&*[-|L:]\T`~#x>MR56cGk'?W<()b4j}.{Z_^/978@

ลองออนไลน์!

ถูกตัดเป็นอักขระที่ไม่มีนัยสำคัญแทนที่ด้วย

        C o d e
        . . . .
        . . u . 
        . . ; . 
" g n i l w o B " S v " . . . .
. . . . . . . ! . . U . . . . .
. . . . . . . L . . \ . . . . .
> . R . . . . . . . W < . . . .
        . . . {
        . . ^ /
        . . . @
        . . . .

ฉันคิดว่าฉันได้ทำให้เส้นทางมีความเปราะบางพอที่การลบตัวละครจะทำลายมันได้ค่อนข้างแย่

ดูมันทำงาน

- 92 characters long
- repeated alnum:       -3 (o)
- repeated punctuation: -4 ("")
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -0 ()

Total score: 85

VB.net, 68

cONSOLE.WRITE("Code BowlingADEFGHJKQUVXYZfhjkmpqyz`!@#$%^&*9876543~][{}\|';:<>?+=-_".subStrinG(0,12))

การทดสอบอย่างรวดเร็วใช้ประโยชน์จากกรณีตายตัวของ VB และการขาดความต้องการ "ระบบ"

เชลล์: คะแนน 17

#!/bin/bash
echo "CODE BoWLING" | tr D-X d-x

• ความยาว 44 อักขระ
• ซ้ำแล้วซ้ำอีก: -12 (bhoD)
• เครื่องหมายวรรคตอนซ้ำแล้วซ้ำอีก: -4 ("-)
• ทำซ้ำอื่น ๆ : -4 (/)
• อักขระช่องว่าง: -7 ()
• ตัวละครแปลกใหม่: -0 ()

คะแนนรวม: 17

Acc !! , 171 ตัวอักษร

119
Write _-52
Write _-8
Count i while i-2 {
	Write _-19+i
}
32
Write _
_+34
Write _
_+45
Write _
_+8
Write _
_-11
Write _
Count i while i-2 {
	Write 105+i*5
}
_-5
Write _

ลองออนไลน์!

ตามมาตรฐาน !! ทำงานได้ดีสำหรับความท้าทายนี้เนื่องจากช่องว่างจำเป็นและมีค่าใช้จ่ายสูง ฉันใช้Acc umulator ที่นี่ แต่ไม่ดีเพื่อเพิ่มตัวอักษร นี่เป็นภาพรวมคร่าวๆจากหน้า:

Accumulatorนิพจน์ที่ยืนด้วยตัวเองจะถูกประเมินและกำหนดให้แอคคูมูเลเตอร์ (ซึ่งสามารถเข้าถึงได้_) ดังนั้นเช่น 3 เป็นคำสั่งที่กำหนดตัวสะสมเป็น 3; _ + 1 เพิ่มการสะสม; และ _ * N อ่านตัวอักษรและคูณตัวสะสมด้วยรหัสของมัน (N รับอินพุต)

Write <charcode> เอาต์พุตอักขระเดี่ยวที่มีค่า ASCII / Unicode ที่กำหนดเป็น stdout รหัสสามารถเป็นนิพจน์ใด ๆ

ลูปใน Acc อย่างน้อยสำหรับการเล่นกอล์ฟนั้นเป็นความเจ็บปวด พวกเขาต้องการวงเล็บปีกกาและช่องว่างทั้งหมดเป็นสิ่งที่จำเป็น มิฉะนั้นมันจะอธิบายได้ด้วยตนเอง