Code-Bowling

Sie wurden von Brunswick Bowling beauftragt, ein einfaches Programm zu erstellen, um den Text Code Bowlingauf ihren Monitoren auszugeben . Dieses Unternehmen lohnt sich ein hübsches Sümmchen und Sie denken , Sie können sie für ganz die beschwindeln Bit Geld .

Aus der Stellenbeschreibung geht eindeutig hervor, dass sie auf der Grundlage von Bewertungen zahlen, und Sie sind ziemlich sicher, dass Sie ihr Bewertungssystem zu Ihrem Vorteil manipulieren und von diesen Mitarbeitern den größtmöglichen Gehaltsscheck erhalten können. Dazu müssen Sie so viel Code packen wie möglich in Ihr Programm / Ihre Funktion , auch wenn das Bewertungssystem so konzipiert ist, dass Sie dies nicht tun können.

Holen Sie Ihre Sparschweine raus, lassen Sie uns Code!

Herausforderung

Die Herausforderung besteht darin, den Text einfach so auszugeben Code Bowling, wie er hier geschrieben ist, mit der höchstmöglichen Punktzahl. (Siehe Abschnitt: Punktesystem unten)

Führende und nachfolgende neue Zeilen (Zeilenumbrüche) sind zulässig.

Ihr Code kann ein gesamtes Programm oder nur eine ausführbare Funktion sein.

Regeln

Obligatorisch: Bei dieser Herausforderung wird Code-Bowling verwendet: Common Rules, Revision 1.0.0 ; Siehe Meta für Details.

1. Zeichen: Byte-Verhältnis
   Beim Code-Bowling wird die Anzahl der Zeichen der Anzahl der Bytes vorgezogen. Der offensichtliche Grund dafür ist, dass Mehrbyte-Unicode-Zeichen (z. B. 🁴) anstelle von Einzelbyte-Unicode-Zeichen verwendet werden können, um die Byteanzahl zu erhöhen, und um zu klären, wer die meisten Variablen mit Hochbyte-Unicode-Zeichen umbenennt als wer am strategischsten sinnvollen komplexen Code erstellt.

2. Variablen- / Funktions- / Objektnamen
   Alle Variablennamen (oder Objektzeiger, Funktionsnamen usw.) sollten 1 Zeichen lang sein. Die einzige akzeptable Zeit, um zweistellige Variablennamen zu verwenden, ist, nachdem alle möglichen zweistelligen Variablen verwendet wurden. Die einzige akzeptable Zeit für die Verwendung von 3-stelligen Variablennamen ist, nachdem alle möglichen 2-stelligen Variablen verwendet wurden. Usw.

3. Nicht verwendeter Code Der
   gesamte Code muss verwendet werden. Dies bedeutet, dass das Programm die Aufgabe nicht immer ordnungsgemäß ausführen kann, wenn einzelne Zeichen (oder unterschiedliche Zeichensätze) entfernt werden. Natürlich sollte eine Teilmenge des Programms die Aufgabe nicht alleine ohne den Rest des Programms erledigen können.

4. Kommentare
   Kommentare sind für die Anzahl der Zeichen nicht zulässig, es sei denn, sie werden von Ihrem Programm / Ihrer Funktion auf irgendeine Weise verwendet.

Punktesystem:

  Pangram Challenge:

Ein Pangram ist ein Satz, der jeden Buchstaben mindestens einmal verwendet. (Der schnelle braune Fuchs springt über den faulen Hund).

Diese Herausforderung Typ wurde entwickelt ein Scoring - Systeme , bei denen eine perfekte pangram die theoretische maximale Punktzahl erreichen würde (auch wenn Sie nicht benötigt jedes Zeichen mindestens einmal zu verwenden.) Zusätzlich mit einem beliebigen Zeichen mehr als einmal wird beginnt eine Vertragsstrafe zahlen. Diese Herausforderung erstreckt sich auch auf mehr als nur die alphabetischen Zeichen.

  Bewertungsmetrik:

1. Jeder benutzte Charakter erhöht deine Punktzahl um 1.
2. Die wiederholte Verwendung eines beliebigen alphanumerischen Zeichens (az, AZ, 0-9) führt zu einem Abzug von 3 Punkten pro Wiederholung (die erste Verwendung führt nicht zu einem Abzug).
3. Die wiederholte Verwendung der grundlegenden Interpunktion ([!?.-,":';])- einschließlich der Klammern - führt zu einem Abzug von 2 Punkten pro Wiederholung.
4. Die wiederholte Verwendung anderer ASCII-Zeichen {`~@#$%^&*_+=|\/><}- einschließlich der geschweiften Klammern - führt zu einem Abzug von 4 Punkten pro Wiederholung.
5. Die Verwendung von Leerzeichen, Tabulatoren und Zeilenumbrüchen führt zu einem Abzug von 1 Punkt pro Verwendung. Das heißt, sie zählen nicht zur Charaktersumme.
6. Charaktere, die oben nicht erwähnt wurden (exotische Charaktere), werden mit 1 Punkt abgezogen. Das heißt, sie zählen nicht zur Charaktersumme.

  Bewertungswerkzeug:

Ein automatisiertes Bewertungs-Widget wurde erstellt und kann hier gefunden werden .

Dies ist eine Code-Bowling- Variante. Das Programm mit der höchsten Punktzahl gewinnt! (Da es eine maximale Punktzahl von gibt 94, wird derjenige als die akzeptierte Antwort markiert, der sie zuerst erreicht (wenn sie erreicht werden kann), obwohl es anderen freisteht, zum Spaß weiter zu antworten.)

Glypho , 94

Die Quelldatei ist in CP437 codiert .

␀␀!"☺☺#$☻♥♥☻♦♣♦♣%♠♠&•◘•◘'○○(◙♂◙♂♀♪♪♀♫☼♫☼►◄◄►↕↕)*‼¶¶‼§§+,▬↨↨▬↑↓↑↓→←→←∟∟-.↔▲▲↔/▼▼▼⌂Ç⌂Çüééüââ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{·|}·√ⁿⁿ√~²²²

Probieren Sie es online!

Erläuterung

Glypho ist für solche Herausforderungen sehr nützlich, da es sich überhaupt nicht um die tatsächlich verwendeten Charaktere handelt. Stattdessen wird jeder Block mit 4 Zeichen betrachtet und der verwendete Befehl wird durch das Muster bestimmt, das diese vier Zeichen bilden:

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

Das heißt, wir können das Problem einfach lösen und dann in jedem Quartett eindeutige Zeichen mit den druckbaren Zeichen und alle wiederholten Zeichen mit einigen der "exotischen" Zeichen einfügen, die von der Wertung ignoriert werden. Glypho ist so ausführlich, dass eine normale handschriftliche Lösung genug eindeutige Zeichen enthält, um alle 94 druckbaren Zeichen darin unterzubringen. Tatsächlich habe ich es bis auf 94 herunter gespielt, damit ich für die Wiederholungen einzigartige exotische Charaktere verwenden konnte (hoffentlich, um es schwieriger zu machen, das Programm zu reduzieren).

Die Kurzform des obigen Programms lautet wie folgt:

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

Wo jede Zeile eines der Zeichen druckt.

Ich habe dieses Retina-Skript verwendet , um es mit Glypho zu konvertieren 0123. Danach habe ich nur die Zeichen anstelle der Ziffern eingegeben.

Theoretisch ist es möglich, dies weiter zu reduzieren, wenn es jemandem gelungen ist, das Shorthand-Programm herunterzuspielen und dann die Zeichen so zu kombinieren, dass die richtigen Muster angezeigt werden. Ich bin mir jedoch nicht sicher, wie ich beweisen oder widerlegen kann, dass dies möglich ist . Wenn es jemandem gelingt, aus einer Teilmenge meines Programms eine gültige Lösung zu bilden, lassen Sie es mich bitte wissen, damit ich die Antwort löschen kann, bis sie behoben ist. Bis dahin muss ich davon ausgehen, dass dies gültig ist.

Python 3, 82 87 88

Vielen Dank an @ JonathanAllan für +1 Punktzahl

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

Probieren Sie es online!

Nichts Besonderes, nur das Aufteilen und Überspringen von Zeichen. Die Zeichenfolge ist umgekehrt, sodass Sie keine Zeichen entfernen können und die ursprüngliche Zeichenfolge gedruckt wird.

> <> , 92 94

Ja, ich habe es getan!

␑ist das exotische Zeichen \x11mit dem Dezimalwert 17. Das Programm wird mit einem Fehler beendet, nachdem das Ergebnis gedruckt wurde (es ist ein Stapel-Unterlauf). Ich musste verwalten, welche Spiegel und Richtungsbefehle ich sorgfältig verwendete, da ich jeden nur einmal verwenden kann.

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

Probieren Sie es online aus

Das Kernprogramm:

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

Erläuterung:

Schieben Sie die Zeichenfolge vCoUV␑3`h]Z_X >(Ausführungs Wraps). Gehe nach unten. Kehre den Stapel um und entferne den v.

Drücken Sie 9und c(12). Multipliziere, um 108( l) zu erhalten. Drücken 7. Drücken Sie d(13), subtrahieren Sie 1, dividieren Sie durch 2, um zu erhalten 6. Setzen Sie lbei (x, y) von (13,6), die unter dem iste . Ich hätte es auch kürzer machen können, aber das ist länger, so dass ich mehr Platz für ASCII-Zeichen habe.

Gehe in eine Schleife. Schieben Sie die Länge des Stapels mit l. Wenn größer als 14, wird das Zeichen ausgegeben. Andernfalls wird ein neuer Stapel mit den Top-10-Elementen erstellt. Fügen Sie 15 hinzu, und geben Sie die Ausführung sofort wieder. Dies wird verwendet, um zu verhindern, dass die zusätzlichen Leerzeichen und >am Ende gedruckt werden, und um die zufällig aussehende Zeichenfolge in die zu druckende Zeichenfolge umzuwandeln. Wiederholen Sie die Schleife.

Wenn eine der Zeilen kürzer ist (durch Entfernen eines Zeichens), funktioniert das Programm nicht mehr, entweder weil die vertikalen Teile des Programms nicht mehr ausgerichtet sind oder weil die zu druckende Zeichenfolge nicht mehr korrekt ist. Wenn Sie versuchen, ein Zeichen vor jeder Zeile zu entfernen, ändert sich die Stapeltiefe und die lPosition des Zeichens , was ebenfalls zu Problemen führt.

^_Fisch

Oktave, 20 21 22 25 27 33

Das Beste, was ich bisher geschafft habe, ist

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

Dadurch wird eine anonyme Funktion erstellt f, für die keine Eingabe erforderlich ist. Du kannst es nennen f(). Ich würde sagen, dass das Semikolon am Ende notwendig ist, um das Drucken des Funktionskörpers zu vermeiden.

Es ist möglich, dass dies durch Kombinieren von evalund verbessert werden kann printf, aber ich habe es immer wieder versucht und bin immer wieder gescheitert.

Hierbei werden alle Ziffern einmal verwendet, indem die Tatsache erklärt wird, dass Octave eine mod(x,256)Operation ausführt, wenn implizit Zahlen in Zeichen konvertiert werden. Dies bedeutet, dass wir negative Zahlen sowie Zahlen außerhalb des normalen 32-126Bereichs verwenden können. Die folgenden Zahlen alle in dem Schreiben zur Folge hat, iwenn in Zeichen umgewandelt: ... -2455 -2199 -1943 ... 105 361 .... Anstatt 'owling'am Ende zu verwenden, wird 1 verwendet "nvkhmf"und hinzugefügt. Dadurch wird ein Vektor von Ganzzahlen erstellt, die implizit in Zeichen konvertiert werden. Stattdessen verwenden 1wir !0(oder not(false). Auch verwenden wir "statt ', um zwei Strafpunkte zu vermeiden.

Wir müssen den Satz von Zahlen finden, der die niedrigste Punktzahl ergibt. Die Zeichenfolge Code Bowlingergibt die folgende Matrix, wenn wir -10 * 256 - 10 * 256 subtrahieren und addieren.

  -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

So ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]ergibt sich ans = Code Bowling. Die Herausforderung besteht dann darin, die Zahlen und Zeichen zu finden, die die Punktzahl am meisten reduzieren. Die Verwendung aller Ziffern ist natürlich gut, aber Duplikate sind schlecht. Da alle Ziffern verwendet werden und nicht zweimal verwendet werden, ist dies die bestmögliche Mischung. Auch wir bekommen zu verwenden -, was zu einem Punkt führt.

Man könnte behaupten, dass es auf die unterste Zeile (31 Punkte) reduziert werden kann, aber dann wäre es keine "ausführbare Funktion" mehr und hätte daher eine andere Funktionalität.

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

QBasic, 34

Dies ist unformatierter Code (yay für Groß- und Kleinschreibung). Sie können es in QB64 oder auf archive.org ausführen (wobei letztere den Code während der Eingabe formatieren). Ich glaube, ich habe es geschafft, alle Regeln einzuhalten.

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

Das CLSist notwendig: Ohne es Cwird nicht garantiert, dass es in der oberen linken Ecke des Bildschirms gedruckt wird, in der es sich ausrichtet ode Bowling. Das LOcatEist notwendig: ohne es ode Bowlingwird in der Zeile unten gedruckt C. Ich glaube nicht, dass es eine Untermenge des Programms gibt (außer Whitespace), die gelöscht werden kann und die gleiche Ausgabe behält.

C 27, 29

+2 Punkte dank @ceilingcat!

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

Haskell , Kerbe 21 38 46 47 21 70

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

Probieren Sie es online! Die Idee ist, den Anfang zu erhalten, Cindem eine Zeichenfolge der Länge 67 konstruiert wird, die alle nicht anderweitig verwendeten Zeichen enthält, und die Länge dieser Zeichenfolge in ein Zeichen konvertiert wird. Ich habe mit putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'ist hexadezimal, '\111'wofür ergibt 'o') begonnen und alle druckbaren ASCII-Zeichen berechnet, die nicht im Programm enthalten sind:

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

Übrigens bleiben genau 67 druckbare ASCII-Zeichen übrig, die in die Zeichenfolge eingefügt werden können, und Cselbst, die nicht in der Zeichenfolge enthalten sind, da das Programm dann auf nur reduziert werden kann putStr"Code B\x6Fwling".

Vorherige Lösung: (21 Punkte)

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

Definiert eine Funktion, fdie keine Eingabe akzeptiert und die Zeichenfolge druckt. Probieren Sie es online!

JavaScript, 19

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

Keine sehr hohe Punktzahl.

Jelly , 94

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

Probieren Sie es online!

105 einzigartige Charaktere, 11 Exoten ( “¹³⁵⁷°⁹⁻”ḄỌ).

Wie?

Bildet die Zeichenfolge aus umgekehrtem 8-Bit-ASCII, wobei jedes Bit mit dem LSB des Unicode-Werts eines Zeichens codiert wird.

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

Probieren Sie es online!

Ich habe versucht, alle Regeln zu befolgen. Es funktioniert, indem Sie zuerst die Zeichenfolge ode Bowling!in den Stream schieben und dann C= 3 * 4 + 57-2 nach vorne einfügen .

Kardinal 20

23 Zeichen ohne Leerzeichen
% #> / NI "CodeB8 ^ o) wl, ing

-3 für wiederholtes "o"

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

Zeigerpfade:

Schritt 1:
Zeiger erstellt bei% nach rechts

Schritt 2:
Zeiger teilt sich bei # auf, um nach oben, rechts und unten zu gehen (P1, P2, P3)

Schritt 3 :
P1 Rechts gesendet von>
P2 Rechts gehen
P3 Bei 8 auf 3 Schritte warten einstellen

Schritt 4:
P1 Nach unten reflektiert von \. \ geändert in /
P2 In den Druckmodus setzen von "
P3 Warten Sie 2 Ticks um 8

Schritt 5:
P1 Richtung unten
P2 Drucken C
P3 Warten Sie 1 Tick bei 8

Schritt 6:
P1 gesendet von ^
P2 drucken o
P3 beenden warten um fortzufahren, ASCII-Wert von "" (32) abholen von

Schritt 7: P1 Richtung oben
P2 Drucken d
P3 Richtung unten

Schritt 8: P1 Nach rechts reflektiert von \, das in /
P2 geändert wurde. Drucken e
P3 Zeichen mit ASCII-Wert = 32 aus der Operation drucken

Schritt 9:
P1 Wird reflektiert von / und wird geändert zu \
P2 Drucken B
P3 Feldende erreicht und stoppt

Schritt 10:
P1 von I nach unten reflektiert
P2 Erreicht das Feldende und stoppt

Schritt 11:
P1 Reflektiert rechts von /, das zu \ geändert wurde. Änderungen zurück zu /

Schritt 12:
P1 links von N reflektiert

Schritt 13:
P1 nach unten reflektiert von /

Schritt 14:
P1 Stellen Sie den Druckmodus auf "

Schritt 15:
P1 Drucken Sie o

Schritt 16:
P1 Drucken w

Schritt 17:
P1 Drucken l

Schritt 18:
P1 Drucken i

Schritt 19:
P1 Drucken Sie n

Schritt 20:
P1 Drucken g

Schritt 21:
P1 Erreicht das Feldende und stoppt.

Probieren Sie es online

C 73

Vielen Dank an @Laikoni!

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

Probieren Sie es online!

C  31   33  35

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

Danke an @ceilingcat und @DLosc für zwei weitere Punkte und danke an @ Ørjan Johansen für zwei weitere Punkte!

Probieren Sie es online!

Batch, 19 Zeichen

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

Beginnend mit Windows Vista TMPbeginnt mit C:\Users\und ist daher %TMP:~5,1%eine ausführliche Schreibweise e, obwohl eine doppelte %Strafe bei -4 erforderlich ist .

Gehirnfick: -204

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

Naja, schreckliche Punktzahl, aber es hat Spaß gemacht zu schreiben.

• 122 Zeichen lang
• wiederholtes Album: -0 ()
• wiederholte Zeichensetzung: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• wiederholte andere: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> ++++++++++++++ ++++)
• Leerzeichen: -0 ()
• exotische Zeichen: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 Punkte

+53 Punkte (24 → 77) dank @Laikoni .

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

104 Zeichen lang
- wiederholtes ALNUM: -15 ( helng)
- wiederholte Interpunktion: -10 ( "()"")
- wiederholte andere ASCII-Zeichen: keine
- Whitespace-Zeichen: -1
SCORE: 78

Probieren Sie es online aus.

Alte 24-Byte- Antwort:

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

30 Zeichen lang
- wiederholtes ALNUM: -3 ( 1)
- wiederholte Interpunktion: -2 ( ")
- wiederholte andere ASCII-Zeichen: keine
- Leerzeichen: -1
SCORE: 24

Probieren Sie es online aus.

gestapelt , 42

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

Probieren Sie es online!

Lässt die Ausgabe auf dem Stapel. Hier ist die Aufteilung:

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

Ich könnte es wahrscheinlich höher machen, aber es ist bei 42 soo ....

Ein anderer Anwärter, 40:

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

Ich habe dieses Skript verwendet, um es zu bewerten.

böse , -81

Besser als Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Erläuterung

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'

Eingereicht, weil niemand etwas im Bösen tut, aber es macht Spaß.

Ergebnis:

Länge = 63

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

Probieren Sie es online!

BEARBEITEN: TiO scheint falsch mit dem Erstellen und Löschen neuer Radzellen umzugehen - ich habe einen Fehlerbericht zu diesem Thema eingereicht. Es wird dort nicht richtig funktionieren, aber ich habe es mit meinem eigenen Dolmetscher ausgeführt und es funktioniert und Sie können mir vertrauen, damit ich mir keine Sorgen machen kann;)

Perl: 29 , 33

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

Ergebnis:

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

Total score: 33

05AB1E , 94 Punkte

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

Probieren Sie es online!

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

Total score: 94

Grundsätzlich konvertiert (das binäre ASCII von Code Bowling):

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

In eine Zeichenfolge aus 1 und 0 wird jeweils 1 durch einen Buchstaben im Alphabet und 0 durch ein Leerzeichen oder ein Symbol oder eine Ziffer ersetzt.

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

Ist die Zeichenfolge, bei der Einsen Buchstaben und Nullen Symbole, Zahlen oder etwas anderes sind. Wir iterieren dann durch, sehen, welche alphabetisch sind, und drücken 1 für alphabetisch 0 für nichtalphabetisch. Wir teilen uns dann in 7er-Gruppen auf, konvertieren zurück in ASCII und drucken jedes Zeichen.

T-SQL, 65 18 32! Punkte

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

Inspiriert von einem Trick in Dloscs QBasic-Antwort , habe ich einen Weg gefunden, alle 10 Stellen und die meisten mathematischen Operatoren ( %ist Rest / Modulo, fehlt nur /) einzuschließen , meistens durch Ausprobieren. Ich glaube nicht, dass es eine Möglichkeit gibt, eine 67 zu erhalten, indem eine beliebige Kombination von Ziffern / Symbolen entfernt wird, aber Sie können es gerne versuchen.

Version 2 (18 Punkte, trivial):

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

Keine gute Punktzahl, aber das ist, was meine erste Version vereinfacht hat (danke, MickyT). Alles andere, was ich versuchte (hex64 codieren und decodieren, einzelne Elemente aus einer Zeichenkette auswählen, ASCII-Werte konvertieren usw.), hatte zu viele wiederholte Zeichen (insbesondere ECRund Symbole (),@), die es in das Negativ treiben.

Version 1 (65 Punkte, ungültig):

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

Ich habe die Länge der Zeichenfolge verwendet, um zu bestimmen, wie viele Zeichen ich auf der linken Seite verwende. Wenn Sie also ein einzelnes Zeichen aus der Zeichenfolge entfernen, wird das Ergebnis der Ganzzahldivision auf 11 reduziert und nur ausgegeben Code Bowlin.

; # , Punktzahl -1163, nicht konkurrierend

Ich denke nicht, dass dies viel Konkurrenz wäre, selbst wenn es konkurrieren könnte.

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

Probieren Sie es online! Hinweis: TIO hat nur keinen; # Interpreter; # +.

CJam , Punktzahl 47

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

Hoffentlich keine Probleme damit ...

Verwendet ein exotisches Zeichen (Einheitentrennzeichen, ASCII 31, dargestellt durch ␟) und ein wiederholtes Zeichen ( "). Ich denke es könnte noch länger gemacht werden, aber ich lasse es so wie es ist.

Probieren Sie es online!

Das Programm verwendet diese lange Zeichenfolge und teilt sie in Teilzeichenfolgen der Länge 3 auf. Jede Teilzeichenfolge wird dann dem Block zugeordnet, der seine Zeichen in ihre ASCII-Werte umwandelt, die Werte auf dem Stapel ausgibt, die absolute Differenz der beiden zweiten berechnet, das Ergebnis mit dem ersten addiert und dann das Endergebnis wieder in ein ASCII-Ergebnis umwandelt Charakter.

CJam, Score 93

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

Probieren Sie es online aus

Inspiriert von der Python-Antwort von TidB .
Nicht sicher, ob es eine Möglichkeit gibt, die Wiederholung der doppelten Anführungszeichen zu vermeiden.

Erläuterung:

Die Zeichenfolge enthält umgekehrt "Cpde Bowling", jedes achte Zeichen.
7~%extrahiert "Cpde Bowling" ( 7~= -8)
2,.-dekrementiert das Zeichen p ( 2,= [0 1])

PHP, 33 Punkte

Das war ziemlich schwer zu finden.

Die Punktzahl kann in Zukunft verbessert werden.

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

Es wird davon ausgegangen, dass die Newline eine Newline im Linux-Stil ist! Windows-Style und Old-Mac-Style funktionieren nicht richtig.

Rubin, 75

Ungefähr ein Port der Python-Antwort, aber Ruby hat diese coole Step-Funktion nicht, also benutze ich gsubstattdessen. Außerdem habe ich beschlossen, ein bisschen Spaß mit den exotischen Charakteren zu haben, indem ich Phrasen in Google Translate warf

Probieren Sie es online!

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

USML, 12 oder 9 Punkte (nicht konkurrierend)

"Code\tBowling'

Probieren Sie es online!

Diese Antwort betrügt ein bisschen, indem sie missbraucht, wie HTML gerendert wird. Die tatsächlich dadurch erzeugte Zeichenfolge ist"Code\tBowling " . Bei der Wiederholung des Zeichens "o" gehen Punkte verloren.

Für eine nicht betrügerische Antwort:

"Code Bowling

USML befindet sich noch in einem relativ frühen Entwicklungsstadium und ist noch nicht in der Lage, das Programm weiter zu vergrößern.

Cubix , 85

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

Probieren Sie es online!

Cubified mit unbedeutenden Zeichen ersetzt durch.

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

Ich glaube, ich habe den Pfad so zerbrechlich gemacht, dass das Entfernen von Zeichen ihn ziemlich stark beschädigen wird.

Schau es dir an

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

Ein schneller Test, der die Fallunempfindlichkeit von VB und das Fehlen eines "Systems" nutzt.

Shell: Punktzahl 17

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

• 44 Zeichen lang
• wiederholtes Album: -12 (bhoD)
• wiederholte Zeichensetzung: -4 ("-)
• wiederholte andere: -4 (/)
• Leerzeichen: -7 ()
• exotische Zeichen: -0 ()

Gesamtpunktzahl: 17

Acc !! 171 Zeichen

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 _

Probieren Sie es online!

Acc !! eignet sich gut für diese Herausforderung, da Leerzeichen erforderlich und Schleifen teuer sind. Ich habe das Acc umulator hier, aber schlecht, Zeichen zu erhöhen. Hier ist eine kurze Übersicht von der Seite:

AccumulatorJeder Ausdruck, der für sich steht, wird ausgewertet und dem Akkumulator zugeordnet (der zugänglich ist als _). So ist zB 3 eine Aussage, die den Akkumulator auf 3 setzt; _ + 1 erhöht den Akku; und _ * N liest ein Zeichen und multipliziert den Akkumulator mit seinem Zeichencode. (N wird eingegeben)

Write <charcode> Gibt ein einzelnes Zeichen mit dem angegebenen ASCII / Unicode-Wert an stdout aus. Der Zeichencode kann ein beliebiger Ausdruck sein.

Loops in Acc, zumindest zum Golfen, sind ein Schmerz. Sie benötigen geschweifte Klammern und alle Leerzeichen sind erforderlich. Ansonsten ist es ziemlich selbsterklärend.