Codice-Bowling

Sei stato assunto da Brunswick Bowling per creare un semplice programma per produrre il testo Code Bowlingsui loro monitor. Questa compagnia vale un bel soldo e pensi di poterli ingannare per un bel po ' di soldi.

La descrizione del lavoro afferma chiaramente che pagano in base al punteggio e sei abbastanza sicuro di poter manipolare il loro sistema di punteggio a tuo vantaggio e ottenere il più grande controllo di paga possibile da questi ragazzi. Per fare ciò dovrai impacchettare più codice possibile nel tuo programma / funzione, anche se il loro sistema di punteggio è progettato per impedirti di farlo.

Esci dai tuoi salvadanai, codifichiamo!

Sfida

La sfida è semplicemente produrre il testo Code Bowling, esattamente come è scritto qui, con il punteggio più alto possibile. (Vedi la sezione: Sistema di punteggio in basso)

Le nuove righe iniziali e finali (interruzioni di riga) sono accettabili.

Il tuo codice può essere un intero programma o solo una funzione eseguibile.

Regole

Obbligatorio: questa sfida consiste nell'utilizzare il bowling di codice: regole comuni, revisione 1.0.0 ; Vedi Meta per i dettagli.

1. Carattere: rapporto byte
   Nel bowling di codice è preferibile un conteggio di caratteri rispetto a un conteggio di byte. Il ragionamento ovvio per questo è che i caratteri unicode multi-byte (es. 🁴) possono essere usati al posto dei caratteri unicode single-byte per aumentare il numero di byte e renderanno il bowling più su chi rinomina la maggior parte delle variabili con caratteri unicode high-byte piuttosto di chi crea strategicamente un codice complesso significativo.

2. Nomi di variabili / funzioni / oggetti
   Tutti i nomi di variabili (o puntatori di oggetti, nomi di funzioni, ecc.) Devono avere una lunghezza di 1 carattere. L'unico tempo accettabile per utilizzare i nomi delle variabili a 2 caratteri è dopo che sono state utilizzate tutte le possibili variabili a 1 carattere. L'unico tempo accettabile per utilizzare i nomi delle variabili a 3 caratteri è dopo che sono state utilizzate tutte le possibili variabili a 2 caratteri. Eccetera.

3. Codice non utilizzato
   È necessario utilizzare tutto il codice. Ciò significa che il programma non deve riuscire a completare sempre correttamente l'attività se viene rimosso / rimosso qualsiasi singolo carattere (o serie variabile di caratteri). Naturalmente, un sottoinsieme del programma non dovrebbe essere in grado di completare l'attività da solo senza il resto del programma.

4. Commenti I
   commenti non sono consentiti per il conteggio dei caratteri, a meno che non siano utilizzati in qualche modo dal programma / funzione.

Sistema di punteggio:

  Pangram Challenge:

Un pangram è una frase che usa ogni lettera almeno una volta. (La rapida volpe marrone salta sopra il cane pigro).

Questo tipo di sfida ha un sistema di punteggio progettato in cui un pangram perfetto raggiungerebbe il punteggio massimo teorico (anche se non è necessario utilizzare ogni personaggio almeno una volta). Inoltre, l'utilizzo di qualsiasi personaggio più di una volta inizierà a incorrere in una penalità. Questa sfida si espande anche oltre i caratteri alfabetici.

  Punteggio metrico:

1. Ogni personaggio usato aumenta il tuo punteggio di 1.
2. L'uso ripetuto di qualsiasi carattere alfanumerico (az, AZ, 0-9) comporterà una detrazione di 3 punti per ripetizione (il primo utilizzo non comporta una detrazione).
3. L'uso ripetuto della punteggiatura di base ([!?.-,":';])- comprese le parentesi - comporterà una detrazione di 2 punti per ripetizione.
4. L'uso ripetuto di altri caratteri ASCII {`~@#$%^&*_+=|\/><}- comprese le parentesi graffe - comporterà una detrazione di 4 punti per ripetizione.
5. L'uso di spazi, tabulazioni e newline comporterà una detrazione di 1 punto per uso. Cioè, non contano ai fini del totale dei personaggi.
6. I personaggi non menzionati sopra (Personaggi esotici) comporteranno una detrazione di 1 punto per uso. Cioè, non contano ai fini del totale dei personaggi.

  Strumento per il punteggio:

È stato creato un widget di punteggio automatico che può essere trovato qui .

Questa è una variante di bowling . Vince il programma con il punteggio più alto! (Dato che c'è un punteggio massimo di 94, chiunque lo raggiunga per primo (se può essere raggiunto) verrà contrassegnato come risposta accettata, anche se altri sono liberi di continuare a rispondere per divertimento)

Glifo , 94

Il file di origine è codificato in 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{·|}·√ⁿⁿ√~²²²

Provalo online!

Spiegazione

Glypho è abbastanza utile per sfide come questa perché non gli interessa affatto i personaggi reali utilizzati. Invece osserva ogni blocco di 4 caratteri e il comando utilizzato è determinato dal modello creato da questi quattro caratteri:

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

Ciò significa che possiamo semplicemente risolvere il problema e quindi inserire caratteri unici in ogni quartetto con i caratteri stampabili e tutti quelli ripetuti con alcuni dei caratteri "esotici", che vengono ignorati dal punteggio. Glypho è sufficientemente dettagliato che una normale soluzione scritta a mano contiene abbastanza caratteri unici per adattarsi a tutti i 94 stampabili all'interno. In effetti, ho finito per giocare a golf fino a quando non aveva esattamente 94, solo per poter usare personaggi esotici unici per quelli ripetuti (si spera, per rendere più difficile ridurre il programma).

La forma abbreviata del programma sopra è questa:

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

Dove ogni riga stampa uno dei personaggi.

Ho usato questo script Retina per convertirlo in Glypho usando 0123. Successivamente, ho appena compilato i caratteri al posto delle cifre.

In teoria, potrebbe essere possibile ridurlo ulteriormente, se qualcuno riuscisse a giocare a golf nel programma abbreviato e poi riuscisse a ricombinare i personaggi in modo tale da mostrare i giusti schemi, ma non sono sicuro di come dimostrare o smentire che ciò sia possibile . Se qualcuno riesce a formare una soluzione valida da un sottoinsieme del mio programma, per favore fatemi sapere così posso eliminare la risposta fino a quando non viene risolto. Fino ad allora, dovrò supporre che questo sia valido.

Python 3, 82 87 88

Grazie a @JonathanAllan per il punteggio +1

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

Provalo online!

Niente di speciale, solo tagliare e saltare i personaggi. La stringa è invertita in modo da non poter rimuovere caratteri e stampare la stringa originale.

> <> , 92 94

YAY, LO HO FATTO!

␑è il carattere esotico\x11 con valore decimale 17. Il programma esce con un errore dopo aver stampato il risultato (è un underflow dello stack). Ho dovuto gestire con precisione i mirror e i comandi direzionali, poiché posso usarli solo una volta.

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

Provalo online

Il programma principale:

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

Spiegazione:

Spingere la stringa vCoUV␑3`h]Z_X >(wrapping di esecuzione). Muoviti verso il basso. Invertire la pila e rimuovere il file v.

Premere 9e c(12). Moltiplicare per ottenere 108( l). Push 7. Premere d(13), sottrarre 1, dividere 2per ottenere 6. Metti la (x, y) di (13,6), che è sotto il e. Avrei potuto farlo in modo più breve, ma questo è allungato, quindi ho spazio per inserire più caratteri ASCII.

Sposta su in un ciclo. Spingere la lunghezza della pila con l. Se maggiore di 14, carattere di output, altrimenti crea un nuovo stack con i primi 10 elementi, aggiungi 15 quindi rifletti sull'esecuzione, quindi su e verso l'alto. Questo viene usato per impedire che gli spazi extra >vengano stampati alla fine, oltre a trasformare la stringa dall'aspetto casuale in ciò che deve essere stampato. Continua il looping.

Se una delle linee è più corta (rimuovendo un carattere), il programma non funzionerà più, sia perché le parti verticali del programma non sono più allineate, sia perché la stringa da stampare non è più corretta. Il tentativo di rimuovere un personaggio davanti a ogni riga cambierà la profondità dello stack e il punto in cui lè posizionato, causando anche problemi.

^_Pesce

Ottava, 20 21 22 25 27 33

Il migliore che ho gestito finora è

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

Questo crea una funzione anonima fche non accetta input. Puoi chiamarlo f(). Direi che il punto e virgola alla fine è necessario, al fine di evitare la stampa del corpo della funzione.

È possibile che ciò possa essere migliorato combinando evale printf, ma ho provato e fallito più volte.

Questo utilizza tutte le cifre una volta, esplorando il fatto che Octave esegue mod(x,256)un'operazione durante la conversione implicita di numeri in caratteri. Ciò significa che possiamo usare numeri negativi, oltre a numeri al di fuori dell'intervallo normale 32-126. I seguenti numeri di tutto risultato nella lettera i, quando convertito in caratteri: ... -2455 -2199 -1943 ... 105 361 .... Invece di usare 'owling'alla fine, usiamo "nvkhmf"e aggiungiamo 1. Questo crea un vettore di numeri interi che vengono convertiti implicitamente in caratteri. Invece di 1, usiamo !0(o not(false). Inoltre, usiamo "invece di 'evitare due punti di penalità.

Dobbiamo trovare l'insieme di numeri che dà il punteggio più basso. La stringa Code Bowlingrisulta nella seguente matrice, quando sottraggiamo e aggiungiamo -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

Quindi, ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]risulta ans = Code Bowling. La sfida è quindi quella di trovare l'insieme di numeri e caratteri che riduce maggiormente il punteggio. L'uso di tutte le cifre è ovviamente buono, ma i duplicati sono cattivi. Poiché tutte le cifre vengono utilizzate e non vengono utilizzate due volte, questa è la migliore combinazione possibile. Inoltre, possiamo usare -, risultando in un punto.

Si potrebbe affermare che può essere ridotto alla riga sottostante (31 punti), ma non sarebbe più una "funzione eseguibile" e quindi avrebbe una funzionalità diversa.

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

QBasic, 34

Questo è un codice non formattato (yay per la distinzione tra maiuscole e minuscole). È possibile eseguirlo in QB64 o su archive.org (sebbene si noti che quest'ultimo formatterà il codice mentre lo si digita). Io penso che sono riuscito a rispettare tutte le regole.

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

Il CLSoccorre: senza di essa, il Cnon è garantito per stampare in alto a sinistra dello schermo, dove si allineeranno con ode Bowling. Il LOcatEoccorre: senza di essa, ode Bowlingsarà stampato sulla riga sotto C. Non credo che ci sia alcun sottoinsieme del programma (tranne gli spazi bianchi) che può essere eliminato e mantenere lo stesso output.

C, 27 29

+2 punti grazie a @ceilingcat!

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

Haskell , punteggio 21 38 46 47 21 70

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

Provalo online! L'idea è quella di ottenere il Ccomando costruendo una stringa di lunghezza 67 che contiene tutti i caratteri non utilizzati altrimenti e convertendo la lunghezza di questa stringa in un carattere. Ho iniziato con putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'è esadecimale per '\111'quale resa 'o') e ho calcolato tutti i caratteri ASCII stampabili non contenuti nel programma:

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

Per inciso, rimangono esattamente 67 caratteri ASCII stampabili che possono essere inseriti nella stringa e Cche non possono apparire nella stringa perché il programma sarebbe riducibile a solo putStr"Code B\x6Fwling".

Soluzione precedente: (punteggio 21)

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

Definisce una funzione fche non accetta input e stampa la stringa. Provalo online!

JavaScript, 19

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

Non è un punteggio molto alto.

Jelly , 94

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

Provalo online!

105 personaggi unici, 11 esotici ( “¹³⁵⁷°⁹⁻”ḄỌ).

Come?

Forma la stringa da ASCII invertita a 8 bit in cui ogni bit è codificato utilizzando LSB del valore Unicode di un carattere.

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

Provalo online!

Ho provato a seguire tutte le regole. Funziona spingendo prima la stringa ode Bowling!nello stream e quindi inserendo C= 3 * 4 + 57-2 nella parte anteriore.

Cardinale 20

23 caratteri non bianchi
% #> / NI "CodeB8 ^ o) wl, ing

-3 per "o" ripetute

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

Percorsi puntatore:

Passaggio 1:
puntatore creato su% andando a destra

Passaggio 2: il
puntatore si divide in # per andare su, destra e giù (P1, P2, P3)

Passaggio 3 :
P1 Inviato da>
P2 Vai a destra
P3 Impostare attendere 3 passaggi su 8

Passaggio 4:
P1 Riflesso da \. \ modificato in /
P2 Impostare sulla modalità di stampa da "
P3 Attendere 2 tick su 8

Passaggio 5:
P1 Verso il basso
P2 Stampa C
P3 Attendere 1 tick su 8

Passaggio 6:
P1 Inviato da ^
P2 Stampa o
P3 Fine attendere a continuare, raccogliere il valore ASCII di "" (32) da)

Passaggio 7: P1 verso l'alto
P2 Stampa d
P3 verso il basso

Passaggio 8: P1 Riflesso a destra da \ che è stato modificato in /
P2 Stampa e
P3 Stampa carattere con valore ASCII = 32 da, operazione

Passaggio 9:
P1 Riflesso da / che viene modificato in \
P2 Stampa B
P3 Raggiunta la fine del campo e si arresta

Step 10:
P1 Riflessa da I
P2 Raggiunta la fine del campo e si ferma

Passaggio 11:
P1 Riflesso a destra da / che è stato modificato in \. Torna a /

Step 12:
P1 Riflesso a sinistra da N

Passaggio 13:
P1 Riflessa verso il basso da /

Passaggio 14:
P1 Impostare sulla modalità di stampa per "

Passaggio 15:
Stampa P1 o

Passaggio 16:
Stampa P1 w

Passaggio 17:
Stampa P1 l

Passaggio 18:
Stampa P1 i

Passo 19:
P1 Stampa n

Passaggio 20:
Stampa P1 g

Step 21:
P1 Raggiunge la fine del campo e si ferma.

Provalo online

C, 73

Grazie a @Laikoni!

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

Provalo online!

C,  31   33  35

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

Grazie a @ceilingcat e @DLosc per altri due punti e grazie a @ Ørjan Johansen per altri due punti!

Provalo online!

Lotto, 19 caratteri

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

A partire da Windows Vista, TMPinizia con C:\Users\e quindi %TMP:~5,1%è un modo dettagliato di scrivere e, nonostante richieda una doppia %penalità di -4.

Brainfuck: -204

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

Beh, punteggio orribile, ma è stato divertente scrivere.

• Lunga 122 caratteri
• aln ripetuto: -0 ()
• punteggiatura ripetuta: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• ripetuto altro: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++ ++++)
• caratteri spazi bianchi: -0 ()
• personaggi esotici: -0 ()

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

+53 punteggio (24 → 77) grazie a @Laikoni .

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

Lunghezza 104 caratteri
- ripetizione di alnum: -15 ( helng)
- punteggiatura ripetuta: -10 ( "()"")
- ripetuta altra ASCII: nessuna
- spazi bianchi: -1
PUNTEGGIO: 78

Provalo online.

Vecchia risposta da 24 byte :

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

Lunghezza di 30 caratteri - ripetizione di alnum: -3 ( 1)
- punteggiatura ripetuta: -2 ( ")
- ripetuta altra ASCII: nessuna
- spazi bianchi: -1
PUNTEGGIO: 24

Provalo online.

impilato , 42

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

Provalo online!

Lascia l'output in pila. Ecco la ripartizione:

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

Probabilmente potrei farlo più in alto, ma è a 42 anni ...

Un altro contendente, 40:

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

Ho usato questo script per segnarlo.

male , -81

Meglio di Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Spiegazione

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'

Presentato perché nessuno fa nulla di male ma è divertente.

Punto:

Lunghezza = 63

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

Provalo online!

EDIT: TiO sembra gestire in modo errato la creazione e la cancellazione di nuove celle Wheel - Ho presentato una segnalazione di bug sull'argomento. Non funzionerà correttamente lì, ma l'ho eseguito sul mio interprete e funziona e puoi fidarti di me, quindi non me ne preoccuperei;)

Perl: 29 , 33

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

Punto:

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

Total score: 33

05AB1E , 94 punti

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

Provalo online!

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

Total score: 94

Fondamentalmente converte (The Binary ASCII of Code Bowling):

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

In una stringa di 1 e 0, quindi sostituisce ogni 1 con una lettera nell'alfabeto e ogni 0 con uno spazio o un simbolo o una cifra.

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

È la stringa, dove 1 sono lettere e 0 sono simboli, numeri o qualsiasi altra cosa. Quindi passiamo attraverso, vedendo quali sono alfabetici, spingendo 1 per 0 alfabetico per non alfabetico. Quindi dividiamo in gruppi di 7, riconvertiamo in ASCII e stampiamo ogni carattere.

T-SQL, 65 18 32! punti

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

Ispirato da un trucco nella risposta QBasic di Dlosc , ho trovato un modo per includere tutte e 10 le cifre e la maggior parte degli operatori matematici ( %è resto / modulo, mancante solo /), principalmente tramite tentativi ed errori. Non penso che ci sia modo di ottenere un 67 rimuovendo qualsiasi combinazione di cifre / simboli, ma sei il benvenuto.

Versione 2 (18 punti, banale):

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

Non è un ottimo punteggio, ma questo è ciò che la mia prima versione ha semplificato (grazie, MickyT). Tutto il resto che ho provato (codificare e decodificare hex64, estrarre singoli elementi da una stringa, convertire valori ASCII, ecc.) Tutti avevano troppi caratteri ripetuti (specialmente ECRe simboli (),@) che lo spingono in negativo.

Versione 1 (65 punti, non valida):

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

Ho usato la lunghezza della stringa per determinare quanti caratteri uso dal lato sinistro, quindi la rimozione di qualsiasi singolo carattere dalla stringa farà scendere il risultato della divisione intera fino a 11, producendo solo Code Bowlin.

; # , punteggio -1163, non competitivo

Non penso che questo sarebbe molto competitivo anche se potesse competere.

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

Provalo online! Nota: TIO non ha; # interprete, solo; # +.

CJam , punteggio 47

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

Eventualmente nessun problema con questo ...

Utilizza un carattere esotico (Separatore unità, ASCII 31, rappresentato da ␟) e un carattere ripetuto ( "). Penso che potrebbe essere ancora più lungo, ma lo lascerò com'è per ora.

Provalo online!

Il programma funziona prendendo quella lunga stringa e dividendola in sottostringhe di lunghezza 3. Ogni sottostringa viene quindi mappata sul blocco, che converte i suoi caratteri nei loro valori ASCII, scarica i valori nello stack, prende la differenza assoluta dei secondi due, aggiunge il risultato con il primo, quindi converte il risultato finale in ASCII carattere.

CJam, punteggio 93

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

Provalo online

Ispirato dalla risposta Python di TidB .
Non sono sicuro se c'è un modo per evitare la ripetizione delle doppie virgolette.

Spiegazione:

La stringa contiene "Cpde Bowling" al contrario, ogni 8 ° carattere.
7~%estrae "Cpde Bowling" ( 7~= -8)
2,.-decrementa il carattere p ( 2,= [0 1])

PHP, 33 punti

Questo è stato abbastanza difficile da inventare.

Il punteggio potrebbe essere approvato in futuro.

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

Si presume che la newline sia una newline in stile Linux! Stile Windows e stile Vecchio Mac non funzioneranno correttamente.

Ruby, 75 anni

Circa una porta della risposta di Python, ma Ruby non ha quella funzione di passaggio gradevole, quindi io uso gsubinvece. Inoltre ho deciso di divertirmi un po 'con i personaggi esotici lanciando frasi in Google Translate

Provalo online!

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

USML, 12 o 9 punti (non competitivi)

"Code\tBowling'

Provalo online!

Questa risposta tradisce un po 'abusando del rendering dell'HTML. La stringa effettivamente creata da questo è "Code\tBowling ". I punti vengono persi per la ripetizione del carattere "o".

Per una risposta non cheaty:

"Code Bowling

USML è ancora abbastanza presto in fase di sviluppo e non è ancora in grado di aumentare ulteriormente le dimensioni del programma.

Cubix , 85

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

Provalo online!

Cubificato con caratteri insignificanti sostituito con.

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

Penso di aver reso il percorso abbastanza fragile da rimuovere i personaggi abbastanza male.

Guarda correre

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

Un test rapido che sfrutta l'insensibilità del case di VB e la mancanza del "sistema" necessario.

Shell: punteggio 17

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

• 44 caratteri
• alnum ripetuto: -12 (bhoD)
• punteggiatura ripetuta: -4 ("-)
• ripetuto altro: -4 (/)
• caratteri spazi bianchi: -7 ()
• personaggi esotici: -0 ()

Punteggio totale: 17

Acc !! , 171 caratteri

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 _

Provalo online!

Acc !! funziona bene per questa sfida in quanto sono necessari spazi bianchi e i loop sono costosi. Ho usato l' umulatore Acc qui, ma male, per aumentare i caratteri. Ecco una breve panoramica dalla pagina:

AccumulatorQualsiasi espressione in piedi da sola viene valutata e assegnata all'accumulatore (che è accessibile come _). Pertanto, ad esempio, 3 è un'istruzione che imposta l'accumulatore su 3; _ + 1 incrementa l'accumulatore; e _ * N legge un carattere e moltiplica l'accumulatore per il suo codice. (N riceve input)

Write <charcode> Emette un singolo carattere con il dato valore ASCII / Unicode su stdout. Il charcode può essere qualsiasi espressione.

I circuiti ad Acc, almeno per il golf, sono un dolore. Richiedono parentesi graffe ed è necessario tutto lo spazio bianco. Altrimenti è piuttosto autoesplicativo.