Code-Bowling

Zostałeś zatrudniony przez Brunswick Bowling, aby stworzyć prosty program do wyświetlania tekstu Code Bowlingna swoich monitorach. Ta firma jest warta ładny grosz i czujesz można oszukać je wręcz odrobiną gotówki.

Opis stanowiska wyraźnie stwierdza, że ​​płacą na zasadzie punktacji, a ty jesteś całkiem pewny, że możesz manipulować ich systemem punktacji na swoją korzyść i uzyskać najwyższą możliwą kontrolę płac od tych facetów. Aby to zrobić, musisz zapakować jak najwięcej kodu do swojego programu / funkcji, nawet jeśli ich system oceniania został zaprojektowany tak, aby ci to uniemożliwić.

Wyciągnij skarbonki, kodujemy!

Wyzwanie

Wyzwaniem jest po prostu wydrukowanie tekstu Code Bowling, dokładnie tak, jak jest tutaj napisany, z możliwie najwyższym wynikiem. (Patrz sekcja: System punktacji poniżej)

Dopuszczalne są wiodące i końcowe znaki nowej linii (łamanie linii).

Kod może być całym programem lub tylko funkcją wykonywalną.

Zasady

Obowiązkowe: w tym wyzwaniu wykorzystuje się Code-Bowling: Common Rules, Revision 1.0.0 ; Zobacz Meta po szczegóły.

1. Znak: Stosunek bajtów
   W kręceniu kodu liczba znaków jest lepsza niż liczba bajtów. Oczywistym tego powodem jest to, że wielobajtowe znaki Unicode (np. 🁴) mogą być używane zamiast jednobajtowych znaków Unicode do puchnięcia liczby bajtów i sprawią, że kręgle będą bardziej dotyczyły tego, kto zmienia nazwy najbardziej zmiennych na znaki bajtowe o wysokim bajcie niż kto najbardziej strategicznie tworzy znaczący złożony kod.

2. Nazwy zmiennych / funkcji / obiektów
   Wszystkie nazwy zmiennych (lub wskaźniki obiektów, nazwy funkcji itp.) Powinny mieć długość 1 znaku. Jedynym dopuszczalnym czasem na użycie nazw zmiennych 2-znakowych jest użycie wszystkich możliwych zmiennych 1-znakowych. Jedynym dopuszczalnym czasem na użycie nazw zmiennych 3-znakowych jest użycie wszystkich możliwych zmiennych 2-znakowych. Itp.

3. Nieużywany
   kod Należy użyć całego kodu. Oznacza to, że program nie zawsze musi poprawnie wykonać zadania, jeśli jakikolwiek pojedynczy znak (lub inny zestaw znaków) zostanie / zostanie usunięty. Oczywiście podzbiór programu nie powinien być w stanie samodzielnie wykonać zadania bez reszty programu.

4. Komentarze
   Komentarze nie są dozwolone przy liczeniu znaków, chyba że w jakiś sposób zostaną wykorzystane przez twój program / funkcję.

System oceniania:

  Wyzwanie Pangram:

Pangram to zdanie, które używa każdej litery przynajmniej raz. (Szybki brązowy lis przeskakuje nad leniwym psem).

To wyzwanie typu posiada systemy punktacji zaprojektowane gdzie to idealne pangram by osiągnąć teoretyczną maksymalną liczbę punktów (choć nie są wymagane , aby wykorzystać każdą postacią co najmniej raz.) Dodatkowo, przy użyciu dowolnego znaku więcej niż raz zacznie poniesienia kary. Wyzwanie to obejmuje nie tylko znaki alfabetyczne.

  Metryka punktacji:

1. Każda użyta postać zwiększa Twój wynik o 1.
2. Wielokrotne użycie dowolnego znaku alfanumerycznego (az, AZ, 0-9) spowoduje odjęcie 3 punktów za powtórzenie (pierwsze użycie nie spowoduje odliczenia).
3. Powtarzające się stosowanie podstawowej interpunkcji ([!?.-,":';])- w tym nawiasów - spowoduje odjęcie 2 punktów za powtórzenie.
4. Wielokrotne użycie innych znaków ASCII {`~@#$%^&*_+=|\/><}- w tym nawiasów klamrowych - spowoduje odjęcie 4 punktów za powtórzenie.
5. Użycie spacji, tabulatorów i znaków nowej linii spowoduje odjęcie 1 punktu za użycie. Oznacza to, że nie liczą się one do sumy postaci.
6. Postacie niewymienione powyżej (Postacie egzotyczne) spowodują odjęcie 1 punktu za użycie. Oznacza to, że nie liczą się one do sumy postaci.

  Narzędzie punktacji:

Utworzono automatyczny widget oceniania, który można znaleźć tutaj .

To jest wariant gry w kręgle . Program z najwyższym wynikiem wygrywa! (Ponieważ istnieje maksymalny wynik tego 94, kto pierwszy go osiągnie (jeśli można go osiągnąć), zostanie oznaczony jako zaakceptowana odpowiedź, chociaż inni mogą swobodnie odpowiadać dla zabawy)

Glypho , 94

Plik źródłowy jest zakodowany w 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{·|}·√ⁿⁿ√~²²²

Wypróbuj online!

Wyjaśnienie

Glif jest bardzo przydatny w takich wyzwaniach, ponieważ w ogóle nie obchodzi go faktyczne użycie postaci. Zamiast tego patrzy na każdy fragment 4 znaków, a użyte polecenie jest określone przez wzorzec, który tworzą te cztery znaki:

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

Oznacza to, że możemy po prostu rozwiązać problem, a następnie wypełnić niepowtarzalne postacie w każdym kwartecie drukowanymi znakami, a wszystkie powtórzone niektórymi „egzotycznymi” postaciami, które są ignorowane przez punktację. Glif jest wystarczająco gadatliwy, aby zwykłe odręczne rozwiązanie zawierało wystarczająco dużo unikalnych znaków, aby zmieściły się w nim wszystkie 94 znaki do wydrukowania. W rzeczywistości skończyłem grać w golfa, aż miał dokładnie 94, tylko po to, aby móc używać unikatowych egzotycznych postaci dla powtarzających się (mam nadzieję, że trudniej będzie zmniejszyć program).

Skrócona forma powyższego programu jest następująca:

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

Gdzie każda linia wypisuje jeden ze znaków.

Użyłem tego skryptu Retina do przekonwertowania go na Glypho 0123. Następnie wprowadziłem znaki zamiast cyfr.

Teoretycznie można by to jeszcze bardziej zmniejszyć, gdyby komuś udało się zagrać w golfa w programie stenografii, a następnie udało się zrekombinować postacie w taki sposób, aby pojawiły się odpowiednie wzory, ale nie jestem pewien, jak udowodnić lub obalić, że jest to możliwe . Jeśli komuś uda się stworzyć prawidłowe rozwiązanie z podzbioru mojego programu, daj mi znać, żebym mógł usunąć odpowiedź, dopóki nie zostanie naprawiona. Do tego czasu będę musiał założyć, że jest to poprawne.

Python 3, 82 87 88

Dzięki @JonathanAllan za wynik +1

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

Wypróbuj online!

Nic specjalnego, tylko krojenie i pomijanie postaci. Ciąg jest odwrócony, więc nie można usunąć znaków i wydrukować oryginalny ciąg.

> <> , 92 94

Tak, zrobiłem to!

␑to egzotyczny znak \x11o wartości dziesiętnej 17. Program kończy pracę z błędem po wydrukowaniu wyniku (jest to niedopełnienie stosu). Musiałem ostrożnie zarządzać, których luster i poleceń kierunkowych używałem, ponieważ z każdego mogę korzystać tylko raz.

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

Wypróbuj online

Program podstawowy:

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

Wyjaśnienie:

Wciśnij ciąg vCoUV␑3`h]Z_X >(zawija wykonanie). Przejdź w dół. Odwróć stos i usuń v.

Naciśnij 9i c(12). Pomnóż, aby uzyskać 108( l). Push 7. Naciśnij d(13), odejmij 1, podziel przez, 2aby uzyskać 6. Ustaw lna (x, y) na (13,6), co jest poniżej e. Mógłbym zrobić w ten sposób krócej, ale jest to wydłużone, więc mam miejsce na umieszczenie większej liczby znaków ASCII.

Przejdź do pętli. Naciśnij długość stosu za pomocą l. Jeśli jest większy niż 14, znak wyjściowy, w przeciwnym razie utwórz nowy stos z 10 górnymi elementami, dodaj 15, a następnie odzwierciedl wykonanie, a następnie w górę i wyjmij. Służy to do zapobiegania dodatkowym spacjom i >drukowania na końcu, a także do zamiany losowo wyglądającego ciągu na to, co należy wydrukować. Kontynuuj zapętlanie.

Jeśli którykolwiek z wierszy jest krótszy (poprzez usunięcie znaku), program przestanie działać, albo dlatego, że pionowe części programu nie są już ustawione w linii, lub ponieważ ciąg do wydrukowania nie jest już poprawny. Próba usunięcia znaku z przodu każdej linii zmieni głębokość stosu i miejsce jego lumieszczenia, powodując również problemy.

^_Ryba

Oktawa, 20 21 22 25 27 33

Jak dotąd najlepiej sobie radziłem

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

Tworzy to anonimową funkcję, fktóra nie przyjmuje danych wejściowych. Możesz to nazwać f(). Powiedziałbym, że średnik na końcu jest konieczny, aby uniknąć drukowania treści funkcji.

Możliwe, że można to poprawić, łącząc evali printf, ale próbowałem i ciągle nie udawało mi się.

Wykorzystuje to wszystkie cyfry raz, wyjaśniając fakt, że Octave wykonuje mod(x,256)operację podczas niejawnej konwersji liczb na znaki. Oznacza to, że możemy używać liczb ujemnych, a także liczb spoza normalnego 32-126zakresu. Poniższe numery wszystkich doprowadzić listu ipo przekształceniu do postaci: ... -2455 -2199 -1943 ... 105 361 .... Zamiast używać 'owling'na końcu, używamy "nvkhmf"i dodajemy 1. Tworzy to wektor liczb całkowitych, które są domyślnie konwertowane na znaki. Zamiast tego 1używamy !0(lub not(false). Używamy "zamiast, 'aby uniknąć dwóch punktów karnych.

Musimy znaleźć zestaw liczb, który daje najniższy wynik. Code BowlingWynikiem ciągu jest następująca macierz, po odjęciu i dodaniu -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

Więc ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]wyniki w ans = Code Bowling. Wyzwanie polega na znalezieniu zestawu liczb i znaków, które najbardziej obniżą wynik. Używanie wszystkich cyfr jest oczywiście dobre, ale duplikaty są złe. Ponieważ wszystkie cyfry są używane, a nie są używane dwa razy, jest to najlepsza możliwa kombinacja. Możemy również użyć -, co daje jeden punkt.

Można twierdzić, że można go sprowadzić do linii poniżej (31 punktów), ale wtedy nie byłby on już „funkcją wykonywalną” , a zatem miałby inną funkcjonalność.

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

QBasic, 34

To jest niesformatowany kod (tak dla rozróżniania wielkości liter). Możesz go uruchomić w QB64 lub na archive.org (choć pamiętaj, że ten ostatni sformatuje kod podczas pisania). I pomyśleć , że udało się przestrzegać wszystkich zasad.

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

Jest CLSto konieczne: bez niego Cnie ma gwarancji, że wydrukuje się w lewym górnym rogu ekranu, w którym się zrówna ode Bowling. Jest LOcatEto konieczne: bez niego ode Bowlingzostanie wydrukowany w wierszu poniżej C. Nie sądzę, aby istniał jakikolwiek podzbiór programu (z wyjątkiem białych znaków), który można usunąć i zachować to samo wyjście.

C, 27 29

+2 punkty dzięki @ceilingcat!

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

Haskell , wynik 21 38 46 47 21 70

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

Wypróbuj online! Chodzi o to, aby uzyskać wiodącą pozycję Cprzez skonstruowanie ciągu o długości 67, który zawiera wszystkie nieużywane w inny sposób znaki i przekształcenie długości tego ciągu na znak. Zacząłem od putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'jest szesnastkowy, dla '\111'którego zwraca 'o') i obliczyłem wszystkie drukowalne znaki ASCII nie zawarte w programie:

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

Nawiasem mówiąc, pozostaje dokładnie 67 drukowalnych znaków ASCII, które można wstawić do łańcucha, i Csamo, które nie może pojawić się w ciągu, ponieważ wtedy program można by zredukować do justowania putStr"Code B\x6Fwling".

Poprzednie rozwiązanie: (ocena 21)

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

Definiuje funkcję, fktóra nie pobiera danych wejściowych i drukuje ciąg. Wypróbuj online!

JavaScript, 19

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

Niezbyt wysoki wynik.

Galaretka , 94

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

Wypróbuj online!

105 unikalnych znaków, 11 egzotycznych ( “¹³⁵⁷°⁹⁻”ḄỌ).

W jaki sposób?

Tworzy ciąg z 8-bitowego odwróconego ASCII, w którym każdy bit jest kodowany przy użyciu LSB wartości Unicode znaku.

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

Wypróbuj online!

Starałem się przestrzegać wszystkich zasad. Działa poprzez wpychanie łańcucha ode Bowling!do strumienia, a następnie wstawienie C= 3 * 4 + 57-2 do przodu.

Kardynał 20

23 znaki spacje
% #> / NI "CodeB8 ^ o) wl, ing

-3 dla powtarzającego się „o”

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

Ścieżki wskaźnika:

Krok 1:
Wskaźnik utworzony przy% idzie w prawo

Krok 2:
Wskaźnik dzieli się na #, aby przejść w górę, w prawo i w dół (P1, P2, P3)

Krok 3 :
P1 Wysłane przez>
P2 Idąc w prawo
P3 Ustaw czekaj na 3 kroki o 8

Krok 4:
P1 Odzwierciedlenie w dół przez \. \ zmieniono na /
P2 Ustaw tryb drukowania przez „
P3 Poczekaj na 2 tiki przy 8

Krok 5:
P1 Nagłówek w dół
P2 Drukuj C
P3 Poczekaj na 1 tik na 8

Krok 6:
P1 Wysłane przez ^
P2 Drukuj o
P3 Zakończ czekaj przy kontynuacji, wybierz wartość ASCII z „” (32) od)

Krok 7: P1 Nagłówek w górę
P2 Drukuj d
P3 Nagłówek w dół

Krok 8: P1 Odzwierciedlenie w prawo przez \, który został zmieniony na /
P2 Drukuj e
P3 Drukuj znak o wartości ASCII = 32 z, operacja

Krok 9:
P1 Odzwierciedlenie przez /, który jest zmieniony na \
P2 Drukuj B
P3 Osiągnięto koniec pola i zatrzymuje się

Krok 10:
P1 Odbicie przez I
P2 Dotarł do końca pola i zatrzymuje się

Krok 11:
P1 Odzwierciedlenie bezpośrednio przez / który został zmieniony na \. Zmienia się z powrotem na /

Krok 12:
P1 Odzwierciedlenie w lewo przez N.

Krok 13:
P1 odzwierciedlone przez /

Krok 14:
P1 Ustaw tryb drukowania przez „

Krok 15:
P1 Wydrukuj o

Krok 16:
Wydruk P1 w

Krok 17:
Wydruk P1 l

Krok 18:
P1 Wydrukuj i

Krok 19:
P1 Drukuj n

Krok 20:
P1 Wydrukuj g

Krok 21:
P1 Osiąga koniec pola i zatrzymuje się.

Wypróbuj online

C, 73

Dzięki @Laikoni!

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

Wypróbuj online!

C,  31   33  35

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

Dzięki @ceilingcat i @DLosc za dwa dodatkowe punkty i dzięki @ Ørjan Johansen za kolejne dwa punkty!

Wypróbuj online!

Partia, 19 znaków

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

Począwszy od systemu Windows Vista, TMPzaczyna się od C:\Users\i dlatego %TMP:~5,1%jest pełnym sposobem pisania e, mimo że wymaga podwójnej %kary w wysokości -4.

Brainfuck: -204

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

Cóż, okropny wynik, ale fajnie było pisać.

• 122 znaków
• powtórzone alnum: -0 ()
• powtarzana interpunkcja: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• powtórzone inne: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> ++++++++++++++ ++++)
• białe znaki: -0 ()
• znaki egzotyczne: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 punktów

+53 wynik (24 → 77) dzięki @Laikoni .

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

104 znaki długie
- powtarzane alnum: -15 ( helng)
- powtarzane znaki interpunkcyjne: -10 ( "()"")
- powtarzane inne ASCII: brak
- białe znaki: -1
WYNIK: 78

Wypróbuj online.

Odpowiedź na stare 24 bajty :

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

30 znaków
- powtarzane alnum: -3 ( 1)
- powtarzane znaki interpunkcyjne: -2 ( ")
- powtarzane inne ASCII: brak
- białe znaki: -1
WYNIK: 24

Wypróbuj online.

ułożone w stos , 42

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

Wypróbuj online!

Pozostawia dane wyjściowe na stosie. Oto podział:

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

Prawdopodobnie mógłbym to zwiększyć, ale ma 42 lata ...

Inny zawodnik, 40:

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

Użyłem tego skryptu do jego oceny.

zło , -81

Lepsze niż Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Wyjaśnienie

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'

Zgłoszony, ponieważ nikt nie robi nic złego, ale to rodzaj zabawy.

Wynik:

Długość = 63

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

Wypróbuj online!

EDYCJA: TiO wydaje się niepoprawnie obsługiwać tworzenie i usuwanie nowych komórek Koła - Złożyłem raport o błędzie na ten temat. Nie będzie tam działał poprawnie, ale uruchomiłem go na własnym tłumaczu i działa i możesz mi zaufać, żebym się tym nie martwił;)

Perl: 29 , 33

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

Wynik:

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

Total score: 33

05AB1E , 94 punkty

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

Wypróbuj online!

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

Total score: 94

Zasadniczo konwertuje (The Binary ASCII z Code Bowling):

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

Do ciągu 1 i 0, a następnie zastępuje każdy 1 literą w alfabecie, a każdy 0 znakiem spacji lub symbolem lub cyfrą.

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

Jest łańcuchem, w którym 1 to litery, a 0 to symbole, cyfry lub cokolwiek innego. Następnie iterujemy, sprawdzając, które są alfabetyczne, naciskając 1 dla alfabetycznego 0 dla niealfabetycznego. Następnie dzielimy na grupy po 7, przekształcamy z powrotem do ASCII i drukujemy każdy znak.

T-SQL, 65 18 32! zwrotnica

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

Zainspirowany sztuczką w odpowiedzi QBasic firmy Dlosc , znalazłem sposób na zawarcie wszystkich 10 cyfr i większości operatorów matematycznych ( %reszta / modulo, brak tylko /), głównie metodą prób i błędów. Nie sądzę, że istnieje sposób na uzyskanie 67 poprzez usunięcie dowolnej kombinacji cyfr / symboli, ale możesz spróbować.

Wersja 2 (18 punktów, trywialna):

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

Nie jest to świetny wynik, ale właśnie to uprościła moja pierwsza wersja (dzięki, MickyT). Wszystko, czego próbowałem (kodowanie i dekodowanie hex64, wybieranie pojedynczych elementów z łańcucha, konwertowanie wartości ASCII itp.) Zawierało zbyt wiele powtarzających się znaków (zwłaszcza ECRsymboli (),@), które powodują, że jest on przeczący.

Wersja 1 (65 punktów, nieważna):

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

Użyłem długości ciągu, aby określić, ile znaków używam z lewej strony, więc usunięcie dowolnego pojedynczego znaku z ciągu spowoduje zmniejszenie wyniku dzielenia liczb całkowitych do 11, wyświetlając tylko Code Bowlin.

; # , wynik -1163, niekonkurujący

Nie sądzę, że byłaby to duża konkurencja, nawet gdyby mogła konkurować.

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

Wypróbuj online! Uwaga: TIO nie ma; # tylko tłumacza; # +.

CJam , wynik 47

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

Mam nadzieję, że nie ma z tym problemów ...

Używa jednego egzotycznego znaku (Separator jednostek, ASCII 31, reprezentowany przez ␟) i jednego powtarzanego znaku ( "). Myślę, że można go jeszcze wydłużyć, ale zostawię to na razie.

Wypróbuj online!

Program działa poprzez pobranie tego długiego łańcucha i podzielenie go na podciągi o długości 3. Każdy podciąg jest następnie mapowany na blok, który konwertuje swoje znaki na ich wartości ASCII, zrzuca wartości ze stosu, bierze bezwzględną różnicę z dwóch drugich, dodaje wynik z pierwszym, a następnie konwertuje wynik końcowy z powrotem do ASCII postać.

CJam, wynik 93

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

Wypróbuj online

Inspirowany odpowiedzią TidB na Python .
Nie jestem pewien, czy jest jakiś sposób na uniknięcie powtarzania podwójnych cudzysłowów.

Wyjaśnienie:

Ciąg zawiera „Cpde Bowling” na odwrocie, co 8 znak.
7~%wyodrębnia „Cpde Bowling” ( 7~= -8)
2,.-zmniejsza znak p ( 2,= [0 1])

PHP, 33 punkty

To było dość trudne do wymyślenia.

Wynik może zostać ulepszony w przyszłości.

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

Zakłada się, że nowa linia to nowa linia w stylu Linux! Windows i Old-Mac-Style nie będą działać poprawnie.

Ruby, 75

W przybliżeniu port odpowiedzi w Pythonie, ale Ruby nie ma tej fajnej funkcji kroku, więc używam gsubzamiast tego. Postanowiłem też trochę zabawić się z egzotycznymi postaciami, wrzucając frazy do Tłumacza Google

Wypróbuj online!

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

USML, 12 lub 9 punktów (niekonkurencyjny)

"Code\tBowling'

Wypróbuj online!

Ta odpowiedź nieco oszukuje, nadużywając sposobu renderowania HTML. Ciąg utworzony przez to jest "Code\tBowling ". Punkty są tracone za powtórzenie znaku „o”.

Aby uzyskać nie cheatującą odpowiedź:

"Code Bowling

USML jest wciąż dość wcześnie opracowywany i nie jest jeszcze w stanie zwiększyć rozmiaru programu.

Cubix , 85

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

Wypróbuj online!

Cubified z nieznacznymi znakami zastąpionymi przez.

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

Wydaje mi się, że ścieżka była na tyle delikatna, że ​​usunięcie postaci bardzo ją złamie.

Zobacz, jak biegnie

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

Szybki test wykorzystujący niewrażliwość na wielkość liter w VB i brak potrzeby „systemu”.

Powłoka: wynik 17

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

• 44 znaki
• powtórzony alnum: -12 (bhoD)
• powtarzana interpunkcja: -4 („-)
• powtórzone inne: -4 (/)
• białe znaki: -7 ()
• znaki egzotyczne: -0 ()

Łączny wynik: 17

Acc !! , 171 znaków

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 _

Wypróbuj online!

Acc !! sprawdza się w przypadku tego wyzwania, ponieważ białe znaki są konieczne, a pętle są kosztowne. I korzystanie z Acc umulator tutaj, ale słabo, aby zwiększyć znaki. Oto krótki przegląd ze strony:

AccumulatorKażde wyrażenie stojące samo w sobie jest oceniane i przypisywane do akumulatora (który jest dostępny jako _). Zatem np. 3 jest instrukcją, która ustawia akumulator na 3; _ + 1 zwiększa akumulator; a _ * N odczytuje znak i mnoży akumulator przez jego kod znakowy. (N pobiera dane wejściowe)

Write <charcode> Wysyła pojedynczy znak o podanej wartości ASCII / Unicode na standardowe wyjście. Kod znaków może być dowolnym wyrażeniem.

Pętle w Acc, przynajmniej do gry w golfa, są uciążliwe. Wymagają nawiasów klamrowych, a wszystkie białe znaki są konieczne. W przeciwnym razie jest to dość oczywiste.