Mã-Bowling

Bạn đã được Brunswick Bowling thuê để tạo ra một chương trình đơn giản để xuất văn bản Code Bowlingtrên màn hình của họ. Công ty này là đáng một xu khá và bạn cảm thấy bạn có thể lừa đảo họ cho khá chút tiền mặt.

Mô tả công việc nêu rõ rằng họ trả tiền trên cơ sở tính điểm và bạn khá tự tin rằng bạn có thể điều khiển hệ thống tính điểm của họ thành lợi thế của bạn và nhận được kiểm tra lương lớn nhất có thể từ những người này. Để làm như vậy sẽ yêu cầu bạn đóng gói càng nhiều mã càng tốt vào chương trình / chức năng của bạn, mặc dù hệ thống tính điểm của họ được thiết kế để ngăn bạn làm như vậy.

Nhận ra con heo đất của bạn, hãy để mã!

Thử thách

Thách thức là chỉ đơn giản là xuất văn bản Code Bowling, chính xác như nó được viết ở đây, với số điểm cao nhất có thể. (Xem phần: Hệ thống chấm điểm bên dưới)

Hàng đầu và cuối dòng mới (ngắt dòng) được chấp nhận.

Mã của bạn có thể là toàn bộ chương trình hoặc chỉ là một chức năng thực thi.

Quy tắc

Bắt buộc: Thử thách này là sử dụng Code-Bowling: Common Rules, Revision 1.0.0 ; Xem Meta để biết chi tiết.

1. Ký tự: Tỷ lệ byte
   trong Code-Bowling, số đếm ký tự được ưu tiên hơn số đếm byte. Lý do rõ ràng cho điều này là các ký tự unicode nhiều byte (ví dụ) có thể được sử dụng thay cho các ký tự unicode một byte để tăng số lượng byte và sẽ làm cho bowling biết nhiều hơn về việc ai đổi tên hầu hết các biến bằng các ký tự unicode byte cao hơn ai là chiến lược tạo ra mã phức tạp có ý nghĩa.

2. Tên biến / Hàm / Đối tượng
   Tất cả các tên biến (hoặc con trỏ đối tượng, tên hàm, v.v.) phải dài 1 ký tự. Thời gian duy nhất được chấp nhận để sử dụng tên biến 2 ký tự là sau khi tất cả các biến 1 ký tự có thể đã được sử dụng. Thời gian duy nhất được chấp nhận để sử dụng tên biến 3 ký tự là sau khi tất cả các biến 2 ký tự có thể đã được sử dụng. Vân vân.

3. Mã không sử dụng
   Tất cả mã phải được sử dụng. Có nghĩa là chương trình phải không luôn luôn hoàn thành đúng nhiệm vụ nếu bất kỳ ký tự riêng lẻ (hoặc bộ (các) ký tự khác nhau) bị / bị xóa. Đương nhiên, một tập hợp con của chương trình sẽ không thể tự hoàn thành nhiệm vụ mà không có phần còn lại của chương trình.

4. Nhận xét Nhận
   xét không được phép đối với số lượng ký tự, trừ khi được chương trình / chức năng của bạn sử dụng bằng cách nào đó.

Hệ thống chấm điểm:

  Thử thách Pangram:

Một pangram là một câu sử dụng mỗi chữ cái ít nhất một lần. (The quick brown fox jumps over the lazy dog).

Loại thử thách này có một hệ thống tính điểm được thiết kế trong đó một pangram hoàn hảo sẽ đạt được điểm tối đa theo lý thuyết (mặc dù bạn không bắt buộc phải sử dụng mọi ký tự ít nhất một lần.) Ngoài ra, sử dụng bất kỳ ký tự nào nhiều hơn một lần sẽ bắt đầu bị phạt. Thách thức này cũng mở rộng ra nhiều hơn là chỉ các ký tự chữ cái.

  Ghi điểm:

1. Mỗi nhân vật được sử dụng sẽ tăng điểm của bạn lên 1.
2. Việc sử dụng lặp lại bất kỳ ký tự chữ và số nào (az, AZ, 0-9) sẽ dẫn đến việc bị trừ 3 điểm mỗi lần lặp lại (lần sử dụng đầu tiên không dẫn đến việc khấu trừ).
3. Việc sử dụng lặp lại các dấu câu cơ bản ([!?.-,":';])- bao gồm cả dấu ngoặc - sẽ dẫn đến việc trừ 2 điểm mỗi lần lặp lại.
4. Việc sử dụng lặp lại các ký tự ASCII khác {`~@#$%^&*_+=|\/><}- bao gồm cả dấu ngoặc nhọn - sẽ dẫn đến việc trừ 4 điểm mỗi lần lặp lại.
5. Việc sử dụng khoảng trắng, tab và dòng mới sẽ dẫn đến việc bị trừ 1 điểm cho mỗi lần sử dụng. Đó là, họ không tính vào tổng số nhân vật.
6. Các ký tự không được đề cập ở trên (Nhân vật kỳ lạ) sẽ bị trừ 1 điểm cho mỗi lần sử dụng. Đó là, họ không tính vào tổng số nhân vật.

  Công cụ chấm điểm:

Một tiện ích chấm điểm tự động đã được tạo và có thể được tìm thấy ở đây .

Đây là một biến thể mã-bowling . Chương trình có số điểm cao nhất sẽ chiến thắng! (Vì có số điểm tối đa 94, bất cứ ai đạt được trước (nếu có thể đạt được) sẽ được đánh dấu là câu trả lời được chấp nhận, mặc dù những người khác có thể tiếp tục trả lời cho vui)

Glypho , 94

Tệp nguồn được mã hóa trong 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{·|}·√ⁿⁿ√~²²²

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

Giải trình

Glypho khá hữu ích cho các thử thách như thế này vì nó không quan tâm đến các nhân vật thực tế đang được sử dụng. Thay vào đó, nó nhìn vào từng đoạn gồm 4 ký tự và lệnh được sử dụng được xác định theo mẫu mà bốn ký tự này tạo ra:

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

Điều đó có nghĩa là chúng ta chỉ có thể giải quyết vấn đề và sau đó điền vào các ký tự duy nhất trong mỗi bộ tứ với các ký tự có thể in và tất cả các ký tự được lặp lại với một số ký tự "kỳ lạ", bị bỏ qua khi tính điểm. Glypho đủ dài dòng rằng một giải pháp viết tay thông thường chứa đủ các ký tự duy nhất để phù hợp với tất cả 94 ký tự có thể in bên trong. Trên thực tế, tôi đã kết thúc việc chơi golf cho đến khi nó có đúng 94, để tôi có thể sử dụng các ký tự kỳ lạ độc đáo cho các ký tự lặp lại (hy vọng, để làm giảm chương trình khó hơn).

Hình thức tốc ký của chương trình trên là:

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

Trong đó mỗi dòng in một trong các ký tự.

Tôi đã sử dụng tập lệnh Retina này để chuyển đổi nó thành Glypho bằng cách sử dụng 0123. Sau đó, tôi chỉ điền vào các ký tự thay cho các chữ số.

Về lý thuyết, có thể giảm điều này hơn nữa, nếu ai đó quản lý chương trình tốc ký và sau đó quản lý để kết hợp lại các ký tự sao cho các mẫu phù hợp xuất hiện, nhưng tôi không chắc làm thế nào để chứng minh hoặc từ chối rằng điều này là có thể . Nếu bất cứ ai quản lý để tạo thành một giải pháp hợp lệ từ một tập hợp con của chương trình của tôi, vui lòng cho tôi biết để tôi có thể xóa câu trả lời cho đến khi nó được sửa. Cho đến lúc đó, tôi sẽ phải cho rằng điều này là hợp lệ.

Trăn 3, 82 87 88

Cảm ơn @Jonathan ALLan cho số điểm +1

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

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

Không có gì đặc biệt, chỉ cắt và bỏ qua các nhân vật. Chuỗi được đảo ngược để bạn không thể xóa các ký tự và có chuỗi gốc được in.

> <> , 92 94

YAY, TÔI ĐÃ NÓ!

␑là ký tự kỳ lạ\x11 có giá trị thập phân 17. Chương trình thoát với lỗi sau khi in kết quả (đó là một ngăn xếp ngăn xếp). Tôi đã phải quản lý các gương và các lệnh định hướng mà tôi đã sử dụng cẩn thận, vì tôi chỉ có thể sử dụng mỗi một lần.

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

Dùng thử trực tuyến

Chương trình cốt lõi:

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

Giải trình:

Đẩy chuỗi vCoUV␑3`h]Z_X >(kết thúc thực hiện). Di chuyển xuống dưới. Đảo ngược ngăn xếp và loại bỏ v.

Đẩy 9và c(12). Nhân lên để có được 108( l). Đẩy 7. Đẩy d(13), trừ 1, chia 2cho để có được 6. Đặt ltại (x, y) của (13,6), nằm dưới e. Tôi có thể thực hiện theo cách này ngắn hơn, nhưng điều này được kéo dài để tôi có chỗ để đặt nhiều ký tự ASCII hơn.

Di chuyển lên thành một vòng lặp. Đẩy chiều dài của ngăn xếp với l. Nếu lớn hơn 14, ký tự đầu ra, nếu không, tạo một ngăn xếp mới với 10 phần tử hàng đầu, thêm 15 rồi phản ánh thực hiện ngay sau đó lên và xuất. Điều này được sử dụng để ngăn không gian thừa và >không được in ở cuối, cũng như biến chuỗi tìm kiếm ngẫu nhiên thành những gì cần được in. Tiếp tục lặp.

Nếu bất kỳ dòng nào ngắn hơn (bằng cách xóa một ký tự), chương trình sẽ không còn hoạt động nữa, vì các phần dọc của chương trình không còn xếp hàng hoặc do chuỗi để in không còn đúng nữa. Cố gắng loại bỏ một ký tự từ phía trước mỗi dòng sẽ thay đổi độ sâu ngăn xếp và lvị trí được đặt, cũng gây ra vấn đề.

^_Cá

Octave, 20 21 22 25 27 33

Điều tốt nhất tôi đã quản lý cho đến nay là

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

Điều này tạo ra một chức năng ẩn danh fkhông có đầu vào. Bạn có thể gọi nó f(). Tôi muốn nói dấu chấm phẩy ở cuối là cần thiết, để tránh in cơ thể chức năng.

Có thể điều này có thể được cải thiện bằng cách kết hợp evalvà printf, nhưng tôi đã thử và thất bại nhiều lần.

Điều này sử dụng tất cả các chữ số một lần, bằng cách khám phá thực tế rằng Octave thực hiện một mod(x,256)thao tác khi hoàn toàn chuyển đổi số thành ký tự. Điều này có nghĩa là chúng ta có thể sử dụng các số âm, cũng như các số ngoài phạm vi bình thường 32-126. Tất cả các số sau đây đều dẫn đến chữ cái ikhi được chuyển đổi thành ký tự : ... -2455 -2199 -1943 ... 105 361 .... Thay vì sử dụng 'owling'cuối cùng, chúng tôi sử dụng "nvkhmf"và thêm 1. Điều này tạo ra một vectơ các số nguyên được chuyển đổi hoàn toàn thành các ký tự. Thay vì 1, chúng tôi sử dụng !0(hoặc not(false). Ngoài ra, chúng tôi sử dụng "thay vì 'để tránh hai điểm phạt.

Chúng ta cần tìm tập hợp các số cho điểm thấp nhất. Chuỗi Code Bowlingkết quả trong ma trận sau, khi chúng ta trừ và thêm -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

Vì vậy, ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]kết quả trong ans = Code Bowling. Thử thách sau đó là tìm ra bộ số và ký tự làm giảm điểm nhiều nhất. Sử dụng tất cả các chữ số là tất nhiên tốt, nhưng trùng lặp là xấu. Vì tất cả các chữ số được sử dụng và không được sử dụng hai lần, đây là hỗn hợp tốt nhất có thể. Ngoài ra, chúng tôi có thể sử dụng -, dẫn đến một điểm.

Người ta có thể tuyên bố rằng nó có thể được giảm xuống dòng bên dưới (31 điểm), nhưng sau đó nó sẽ không còn là "chức năng thực thi" , và do đó sẽ có chức năng khác.

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

QBasic, 34

Đây là mã không được định dạng (yay cho trường hợp không nhạy cảm). Bạn có thể chạy nó trong QB64 hoặc tại archive.org (mặc dù lưu ý rằng cái sau sẽ định dạng mã khi bạn nhập mã). Tôi nghĩ rằng tôi đã xoay sở để tuân thủ tất cả các quy tắc.

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

Điều CLScần thiết là: không có nó, Ckhông được đảm bảo để in ở góc trên cùng bên trái của màn hình, nơi nó sẽ xếp hàng ode Bowling. Điều LOcatEcần thiết: không có nó, ode Bowlingsẽ được in trên dòng dưới đây C. Tôi không tin có bất kỳ tập hợp con nào của chương trình (trừ khoảng trắng) có thể bị xóa và giữ nguyên đầu ra.

C, 27 29

+2 điểm nhờ @ceilingcat!

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

Haskell , điểm 21 38 46 47 21 70

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

Hãy thử trực tuyến! Ý tưởng là để dẫn đầu Cbằng cách xây dựng một chuỗi có độ dài 67 chứa tất cả các ký tự không được sử dụng và chuyển đổi độ dài của chuỗi này thành một ký tự. Tôi đã bắt đầu với putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'là thập lục phân cho '\111'năng suất 'o') và tính toán tất cả các ký tự ASCII có thể in không có trong chương trình:

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

Ngẫu nhiên vẫn còn chính xác 67 ký tự ASCII có thể in được có thể đặt vào chuỗi và Cchính nó không thể xuất hiện trong chuỗi vì khi đó chương trình sẽ có thể rút gọn thành chỉ putStr"Code B\x6Fwling".

Giải pháp trước: (điểm 21)

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

Xác định hàm fkhông có đầu vào và in chuỗi. Hãy thử trực tuyến!

JavaScript, 19

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

Không phải là một điểm số rất cao.

Thạch , 94

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

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

105 ký tự độc đáo, 11 exotics ( “¹³⁵⁷°⁹⁻”ḄỌ).

Làm sao?

Hình thành chuỗi từ ASCII đảo ngược 8 bit trong đó mỗi bit được mã hóa bằng LSB của giá trị Unicode của một ký tự.

“...”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).._}

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

Tôi đã cố gắng tuân theo tất cả các quy tắc. Nó hoạt động bằng cách trước tiên đẩy chuỗi ode Bowling!vào luồng và sau đó chèn C= 3 * 4 + 57-2 lên phía trước.

Hồng y 20

23 ký tự không phải khoảng trắng
% #> / NI "CodeB8 ^ o) wl, ing

-3 cho "o" lặp lại

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

Đường dẫn con trỏ:

Bước 1:
Con trỏ được tạo ở% đi đúng

Bước 2:
Con trỏ chia tách tại # để đi lên, phải và xuống (P1, P2, P3)

Bước 3 :
P1 Đã gửi đúng bởi>
P2 Đi đúng
P3 Đặt chờ 3 bước ở 8

Bước 4:
P1 Phản xạ xuống bởi \. \ đã thay đổi thành /
P2 Đặt thành chế độ in bằng "
P3 Đợi 2 tích tắc ở 8

Bước 5:
P1 Heading xuống
P2 In C
P3 Đợi 1 tick ở 8

Bước 6:
P1 Đã gửi lên bởi ^
P2 In o
P3 Kết thúc chờ tiếp tục, chọn giá trị ASCII của "" (32) từ)

Bước 7: P1 Heading up
P2 In d
P3 Heading down

Bước 8: P1 Được phản ánh đúng bởi \ đã được thay đổi thành /
P2 In e
P3 In ký tự có giá trị ASCII = 32 từ, thao tác

Bước 9:
P1 Được phản chiếu lên bởi / được thay đổi thành \
P2 In B
P3 Đã đến cuối trường và dừng lại

Bước 10:
P1 Phản xạ xuống bởi I
P2 Đã đến cuối trường và dừng lại

Bước 11:
P1 Phản ánh đúng bởi / đã được thay đổi thành \. Thay đổi trở lại /

Bước 12:
P1 Phản xạ trái bởi N

Bước 13:
P1 Phản chiếu xuống bởi /

Bước 14:
P1 Đặt thành chế độ in bằng "

Bước 15:
In P1

Bước 16:
In P1

Bước 17:
In P1

Bước 18:
In i

Bước 19:
In P1

Bước 20:
In g

Bước 21:
P1 Đến cuối trường và dừng lại.

Dùng thử trực tuyến

C, 73

Cảm ơn @Laikoni!

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

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

C,  31   33  35

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

Cảm ơn @ceilingcat và @DLosc để có thêm hai điểm và cảm ơn @ rjan Johansen để có thêm hai điểm nữa!

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

Mẻ, 19 ký tự

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

Bắt đầu với Windows Vista, TMPbắt đầu bằng C:\Users\và do đó %TMP:~5,1%là một cách viết dài dòng e, mặc dù yêu cầu một %hình phạt gấp đôi ở mức -4.

Brainfuck: -204

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

Vâng, điểm số khủng khiếp, nhưng là niềm vui để viết.

• Dài 122 ký tự
• lặp lại alnum: -0 ()
• dấu câu lặp đi lặp lại: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• lặp lại khác: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++ ++++)
• ký tự khoảng trắng: -0 ()
• nhân vật kỳ lạ: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 điểm

+53 điểm (24 → 77) nhờ @Laikoni .

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

Dài 104 ký tự
- alnum lặp lại: -15 ( helng)
- dấu chấm lặp lại: -10 ( "()"")
- lặp lại ASCII khác: none
- ký tự khoảng trắng: -1
SCORE: 78

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

Câu trả lời cũ 24 byte :

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

Dài 30 ký tự
- lặp lại alnum: -3 ( 1)
- dấu chấm lặp lại: -2 ( ")
- lặp lại ASCII khác: none
- ký tự khoảng trắng: -1
SCORE: 24

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

xếp chồng lên nhau , 42

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

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

Lá đầu ra trên ngăn xếp. Đây là sự cố:

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

Tôi có thể có thể làm cho nó cao hơn, nhưng nó ở mức 42 giây ....

Một ứng cử viên khác, 40:

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

Tôi đã sử dụng kịch bản này để ghi điểm.

ác , -81

Tốt hơn Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Giải trình

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'

Gửi vì không ai làm bất cứ điều gì xấu xa nhưng đó là loại niềm vui.

Ghi bàn:

Chiều dài = 63

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

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

EDIT: TiO dường như xử lý không chính xác việc tạo và xóa các ô Wheel mới - Tôi đã gửi báo cáo lỗi về chủ đề này. Nó sẽ không hoạt động đúng ở đó, nhưng tôi đã chạy nó trên trình thông dịch của riêng tôi và nó hoạt động và bạn có thể tin tưởng tôi vì vậy tôi sẽ không lo lắng về điều đó;)

Perl: 29 , 33

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

Ghi bàn:

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

Total score: 33

05AB1E , 94 điểm

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

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

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

Total score: 94

Về cơ bản chuyển đổi (ASCII nhị phân của Code Bowling):

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

Trong một chuỗi 1 và 0, sau đó nó thay thế mỗi 1 bằng một chữ cái trong bảng chữ cái và mỗi 0 bằng một ký tự khoảng trắng hoặc ký hiệu hoặc chữ số.

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

Là chuỗi, trong đó 1 là chữ cái và 0 là ký hiệu, số hoặc bất cứ thứ gì khác. Sau đó, chúng tôi lặp đi lặp lại, xem đó là bảng chữ cái, đẩy 1 cho bảng chữ cái 0 cho phi ngôn ngữ. Sau đó chúng tôi chia thành các nhóm 7, chuyển đổi lại thành ASCII và in từng ký tự.

T-SQL, 65 18 32! điểm

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

Lấy cảm hứng từ một mẹo trong câu trả lời QBasic của Dlosc , tôi đã tìm ra cách bao gồm tất cả 10 chữ số và hầu hết các toán tử toán học ( %chỉ còn lại / modulo, chỉ thiếu /), chủ yếu thông qua thử và sai. Tôi không nghĩ có bất kỳ cách nào để có được 67 bằng cách xóa bất kỳ tổ hợp chữ số / ký hiệu nào, nhưng bạn có thể thử.

Phiên bản 2 (18 điểm, tầm thường):

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

Không phải là một điểm số tuyệt vời, nhưng đây là những gì phiên bản đầu tiên của tôi đơn giản hóa (cảm ơn, MickyT). Mọi thứ khác tôi đã thử (mã hóa và giải mã hex64, chọn các phần tử riêng lẻ ra khỏi chuỗi, chuyển đổi giá trị ASCII, v.v.) đều có quá nhiều ký tự lặp lại (đặc biệt ECRvà ký hiệu (),@) khiến nó bị âm.

Phiên bản 1 (65 điểm, không hợp lệ):

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

Tôi đã sử dụng độ dài của chuỗi để xác định có bao nhiêu ký tự tôi sử dụng từ phía bên trái, do đó, việc xóa bất kỳ ký tự đơn nào khỏi chuỗi sẽ giảm kết quả phân chia số nguyên xuống còn 11, chỉ xuất ra Code Bowlin.

; # , điểm -1163, không lọc

Tôi không nghĩ rằng điều này sẽ cạnh tranh nhiều ngay cả khi nó có thể cạnh tranh.

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

Hãy thử trực tuyến! Lưu ý: TIO không có; # trình thông dịch, chỉ; # +.

CJam , điểm 47

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

Hy vọng không có vấn đề gì với ...

Sử dụng một ký tự kỳ lạ (Dấu phân cách đơn vị, ASCII 31, được đại diện bởi ␟) và một ký tự lặp lại ( "). Tôi nghĩ rằng nó có thể được thực hiện lâu hơn nữa, nhưng tôi sẽ để nó như bây giờ.

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

Chương trình hoạt động bằng cách lấy chuỗi dài đó và tách nó thành chuỗi con dài 3. Mỗi chuỗi con sau đó được ánh xạ vào khối, chuyển đổi các ký tự của nó thành các giá trị ASCII của chúng, bỏ các giá trị trên ngăn xếp, lấy sự khác biệt tuyệt đối của hai chuỗi thứ hai, thêm kết quả với đầu tiên, sau đó chuyển kết quả cuối cùng trở lại thành ASCII tính cách.

CJam, điểm 93

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

Dùng thử trực tuyến

Lấy cảm hứng từ câu trả lời Python của TidB .
Không chắc chắn nếu có cách nào để tránh sự lặp lại của dấu ngoặc kép.

Giải trình:

Chuỗi chứa "Cpde Bowling" ngược lại, cứ sau 8 ký tự.
7~%trích xuất "Cpde Bowling" ( 7~= -8) làm
2,.-giảm ký tự p ( 2,= [0 1])

PHP, 33 điểm

Điều này là khá khó khăn để đưa ra.

Điểm số có thể được chứng minh trong tương lai.

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

Dòng mới được coi là một dòng mới theo phong cách Linux! Kiểu Windows và Kiểu Mac cũ sẽ không hoạt động chính xác.

Ruby, 75

Khoảng một cổng của câu trả lời Python, nhưng Ruby không có chức năng bước tuyệt vời đó nên tôi sử dụng gsubthay thế. Ngoài ra, tôi quyết định vui vẻ một chút với các nhân vật kỳ lạ bằng cách ném các cụm từ vào Google Dịch

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

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

USML, 12 hoặc 9 điểm (không cạnh tranh)

"Code\tBowling'

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

Câu trả lời này gian lận một chút bằng cách lạm dụng cách hiển thị HTML. Chuỗi thực sự được tạo ra bởi điều này là "Code\tBowling ". Điểm bị mất khi lặp lại ký tự "o".

Đối với một câu trả lời không gian lận:

"Code Bowling

USML vẫn còn khá sớm trong quá trình phát triển và chưa có khả năng tăng quy mô của chương trình thêm nữa.

Đàn con , 85

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

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

Được thay thế bằng các ký tự không đáng kể được thay thế bằng.

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

Tôi nghĩ rằng tôi đã làm cho con đường đủ mỏng manh để loại bỏ các nhân vật sẽ phá vỡ nó khá tồi tệ.

Xem nó chạy

- 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))

Một thử nghiệm nhanh chóng viết hoa trên trường hợp vô cảm và thiếu "hệ thống" của VB.

Shell: điểm 17

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

• Dài 44 ký tự
• lặp lại alnum: -12 (bhoD)
• dấu câu lặp lại: -4 ("-)
• lặp lại khác: -4 (/)
• ký tự khoảng trắng: -7 ()
• nhân vật kỳ lạ: -0 ()

Tổng số điểm: 17

Acc !! , 171 ký tự

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 _

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

Acc !! hoạt động tốt cho thử thách này vì khoảng trắng là cần thiết và các vòng lặp tốn kém. Tôi đã sử dụng bộ giải mã Acc ở đây, nhưng rất kém, để tăng ký tự. Dưới đây là một tổng quan ngắn gọn từ trang:

AccumulatorBất kỳ biểu thức nào đứng một mình được đánh giá và gán cho bộ tích lũy (có thể truy cập dưới dạng _). Do đó, ví dụ 3 là một câu lệnh đặt bộ tích lũy thành 3; _ + 1 tăng bộ tích lũy; và _ * N đọc một ký tự và nhân số tích lũy bằng mã số của nó. (N nhận đầu vào)

Write <charcode> Xuất một ký tự đơn có giá trị ASCII / Unicode đã cho thành thiết bị xuất chuẩn. Mã có thể là bất kỳ biểu thức.

Vòng lặp trong Acc, ít nhất là để chơi golf, là một nỗi đau. Họ yêu cầu niềng răng, và tất cả khoảng trắng là cần thiết. Nếu không, nó khá tự giải thích.