Code-Bowling

Brunswick Bowling lo contrató para crear un programa simple para generar el texto Code Bowlingen sus monitores. Esta empresa vale un centavo y cree que puede estafarlos por un poco de dinero.

La descripción del trabajo establece claramente que pagan en base a puntajes y usted está bastante seguro de que puede manipular su sistema de puntaje para su ventaja y obtener el mayor cheque de pago posible de estos tipos. Para hacerlo, será necesario que empaque todo el código que pueda en su programa / función, a pesar de que su sistema de puntuación está diseñado para evitar que lo haga.

¡Saca tus huchas, codifiquemos!

Desafío

El desafío es simplemente generar el texto Code Bowling, exactamente como está escrito aquí, con el puntaje más alto posible. (Consulte la sección: Sistema de puntuación a continuación)

Las nuevas líneas iniciales y finales (saltos de línea) son aceptables.

Su código puede ser un programa completo o simplemente una función ejecutable.

Reglas

Obligatorio: este desafío está utilizando Code-Bowling: Reglas comunes, Revisión 1.0.0 ; Ver Meta para más detalles.

1. Carácter: Relación de bytes
   En Code-Bowling se prefiere un conteo de caracteres sobre un conteo de bytes. El razonamiento obvio para esto es que los caracteres unicode de varios bytes (p. Ej. que quien más estratégicamente crea un código complejo significativo.

2. Nombres de variables / funciones / objetos
   Todos los nombres de variables (o punteros de objetos, nombres de funciones, etc.) deben tener 1 carácter. El único momento aceptable para usar nombres de variables de 2 caracteres es después de que se hayan utilizado todas las posibles variables de 1 carácter. El único momento aceptable para usar nombres de variables de 3 caracteres es después de que se hayan utilizado todas las variables de 2 caracteres posibles. Etc.

3. Código no utilizado Se
   debe usar todo el código. Lo que significa que el programa debe fallar para completar siempre la tarea correctamente si se elimina / elimina cualquier carácter individual (o conjunto (s) variable (s) de caracteres). Naturalmente, un subconjunto del programa no debería poder completar la tarea por sí solo sin el resto del programa.

4. Comentarios
   No se permiten comentarios sobre el recuento de caracteres, a menos que su programa / función lo utilice de alguna manera.

Sistema de puntuación:

  Pangram Challenge:

Un pangrama es una oración que usa cada letra al menos una vez. (El rápido zorro marrón salta sobre el perro perezoso).

Este tipo de desafío tiene un sistema de puntuación diseñado en el que un pangrama perfecto alcanzaría la puntuación máxima teórica (aunque no es necesario que uses todos los personajes al menos una vez). Además, usar cualquier personaje más de una vez comenzará a incurrir en una penalización. Este desafío también se expande a más que solo los caracteres alfabéticos.

  Métrica de puntuación:

1. Cada personaje utilizado aumenta tu puntuación en 1.
2. El uso repetido de cualquier carácter alfanumérico (az, AZ, 0-9) dará como resultado una deducción de 3 puntos por repetición (el primer uso no resulta en una deducción).
3. El uso repetido de la puntuación básica ([!?.-,":';]), incluidos los corchetes, dará como resultado una deducción de 2 puntos por repetición.
4. El uso repetido de otros caracteres ASCII {`~@#$%^&*_+=|\/><}, incluidos los corchetes, dará como resultado una deducción de 4 puntos por repetición.
5. El uso de espacios, pestañas y líneas nuevas dará como resultado una deducción de 1 punto por uso. Es decir, no cuentan para el carácter total.
6. Los caracteres no mencionados anteriormente (Caracteres exóticos) resultarán en una deducción de 1 punto por uso. Es decir, no cuentan para el carácter total.

  Herramienta de puntuación:

Se ha creado un widget de puntuación automatizado y se puede encontrar aquí .

Esta es una variante de código de boliche . ¡El programa con la puntuación más alta gana! (Dado que hay un puntaje máximo de 94, quien lo alcance primero (si se puede alcanzar) se marcará como la respuesta aceptada, aunque otros son libres de seguir respondiendo por diversión)

Glifo , 94

El archivo fuente está codificado en 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{·|}·√ⁿⁿ√~²²²

Pruébalo en línea!

Explicación

Glypho es bastante útil para desafíos como este porque no le importan los personajes reales que se utilizan en absoluto. En cambio, analiza cada fragmento de 4 caracteres y el comando que se utiliza está determinado por el patrón que forman estos cuatro caracteres:

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

Eso significa que podemos resolver el problema y luego completar caracteres únicos en cada cuarteto con los caracteres imprimibles y todos los repetidos con algunos de los caracteres "exóticos", que la puntuación ignora. Glypho es lo suficientemente detallado como para que una solución manuscrita normal contenga suficientes caracteres únicos para que quepan dentro de los 94 imprimibles. De hecho, terminé jugando golf hasta que tenía exactamente 94, solo para poder usar personajes exóticos únicos para los repetidos (con suerte, para que sea más difícil reducir el programa).

La forma abreviada del programa anterior es esta:

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

Donde cada línea imprime uno de los caracteres.

He usado este script Retina para convertirlo a Glypho usando 0123. Después, acabo de completar los caracteres en lugar de los dígitos.

En teoría, podría ser posible reducir esto aún más, si alguien lograra jugar golf en el programa abreviado y luego lograra recombinar los caracteres de manera que aparezcan los patrones correctos, pero no estoy seguro de cómo demostrar o refutar que esto es posible . Si alguien logra formar una solución válida desde un subconjunto de mi programa, avíseme para que pueda eliminar la respuesta hasta que se solucione. Hasta entonces, tendré que suponer que esto es válido.

Pitón 3, 82 87 88

Gracias a @JonathanAllan por +1 puntaje

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

Pruébalo en línea!

Nada especial, solo rebanar y saltar caracteres. La cadena se invierte para que no pueda eliminar caracteres y se imprima la cadena original.

> <> , 92 94

¡YAY, LO HICE!

␑es el carácter exótico\x11 con valor decimal 17. El programa sale con un error después de imprimir el resultado (es un desbordamiento de pila). Tuve que administrar qué espejos y comandos direccionales usé con cuidado, ya que solo puedo usar cada uno una vez.

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

Pruébalo en línea

El programa central:

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

Explicación:

Empuje la cadena vCoUV␑3`h]Z_X >(envolturas de ejecución). Moverse hacia abajo Invierta la pila y retire el v.

Empujar 9y c(12). Multiplica para obtener 108( l). Empujar 7. Presione d(13), reste 1, divida entre 2para obtener 6. Poner len (x, y) de (13,6), que está debajo de e. Podría haber hecho esto de manera más corta, pero esto se alarga, así que tengo espacio para poner más caracteres ASCII.

Mover hacia arriba en un bucle. Empuje la longitud de la pila con l. Si es mayor que 14, el carácter de salida, de lo contrario, cree una nueva pila con los 10 elementos principales, agregue 15 y luego refleje la ejecución, luego hacia arriba y la salida. Esto se usa para evitar que >se impriman los espacios adicionales al final, así como para convertir la cadena de aspecto aleatorio en lo que debe imprimirse. Continuar en bucle.

Si alguna de las líneas es más corta (al eliminar un carácter), el programa ya no funcionará, ya sea porque las partes verticales del programa ya no se alinean o porque la cadena para imprimir ya no es correcta. Intentar eliminar un personaje delante de cada línea cambiará la profundidad de la pila y el lugar donde lse coloca, lo que también causará problemas.

^_Pescado

Octava, 20 21 22 25 27 33

Lo mejor que he logrado hasta ahora es

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

Esto crea una función anónima fque no toma entrada. Puedes llamarlo f(). Yo diría que el punto y coma al final es necesario, para evitar la impresión del cuerpo de la función.

Es posible que esto pueda mejorarse combinando evaly printf, pero lo he intentado y he fallado una y otra vez.

Esto usa todos los dígitos una vez, explotando el hecho de que Octave realiza una mod(x,256)operación cuando convierte implícitamente números a caracteres. Esto significa que podemos usar números negativos, así como números fuera del 32-126rango normal . Los siguientes números de todo el resultado en la letra icuando se convierte a caracteres: ... -2455 -2199 -1943 ... 105 361 .... En lugar de usar 'owling'al final, usamos "nvkhmf"y agregamos 1. Esto crea un vector de enteros que se convierten implícitamente en caracteres. En lugar de 1, usamos !0(o not(false). Además, usamos en "lugar de 'para evitar dos puntos de penalización.

Necesitamos encontrar el conjunto de números que da la puntuación más baja. El Code Bowlingresultado de la cadena en la siguiente matriz, cuando restamos y sumamos -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

Entonces, los ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]resultados en ans = Code Bowling. El desafío es encontrar el conjunto de números y caracteres que reduzca más la puntuación. Por supuesto, usar todos los dígitos es bueno, pero los duplicados son malos. Como se usan todos los dígitos, y los que no se usan dos veces, esta es la mejor combinación posible. Además, podemos usar -, lo que resulta en un punto.

Se podría afirmar que se puede reducir a la línea de abajo (31 puntos), pero que ya no sería una "función ejecutable" y, por lo tanto, tendría una funcionalidad diferente.

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

QBasic, 34

Este es un código sin formato (yay para la mayúsculas y minúsculas). Puede ejecutarlo en QB64 o en archive.org (aunque tenga en cuenta que este último formateará el código a medida que lo escriba). Yo creo que he logrado cumplir con todas las reglas.

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

El CLSes necesaria: sin ella, el Cno está garantizado para imprimir en la esquina superior izquierda de la pantalla, donde se alineará con ode Bowling. El LOcatEes necesaria: sin ella, ode Bowlingse imprimirá en la línea de abajo C. No creo que haya ningún subconjunto del programa (excepto los espacios en blanco) que se pueda eliminar y mantener el mismo resultado.

C, 27 29

¡+2 puntos gracias a @ceilingcat!

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

Haskell , puntaje 21 38 46 47 21 70

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

Pruébalo en línea! La idea es obtener el liderazgo Cconstruyendo una cadena de longitud 67 que contenga todos los caracteres no utilizados de otra manera y convirtiendo la longitud de esta cadena en un carácter. Comencé con putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'es hexadecimal para el '\111'que produce 'o') y calculé todos los caracteres ASCII imprimibles que no figuran en el programa:

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

Por cierto, quedan exactamente 67 caracteres ASCII imprimibles que pueden colocarse en la cadena, y en Csí mismos que no pueden aparecer en la cadena porque entonces el programa sería reducible a solo putStr"Code B\x6Fwling".

Solución anterior: (puntaje 21)

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

Define una función fque no toma entrada e imprime la cadena. Pruébalo en línea!

JavaScript, 19

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

No es un puntaje muy alto.

Gelatina , 94

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

Pruébalo en línea!

105 personajes únicos, 11 exóticos ( “¹³⁵⁷°⁹⁻”ḄỌ).

¿Cómo?

Forma la cadena de ASCII invertido de 8 bits donde cada bit se codifica utilizando el LSB del valor Unicode de un carácter.

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

Pruébalo en línea!

Traté de seguir todas las reglas. Funciona empujando primero la cadena ode Bowling!a la secuencia y luego insertando C= 3 * 4 + 57-2 al frente.

Cardenal 20

23 caracteres que no son espacios en blanco
% #> / NI "CodeB8 ^ o) wl, ing

-3 por "o" repetido

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

Trayectorias de puntero:

Paso 1:
puntero creado en% a la derecha

Paso 2: el
puntero se divide en # para subir, derecha y abajo (P1, P2, P3)

Paso 3 :
P1 Enviado directamente por>
P2 Ir a la derecha
P3 Establecer esperar 3 pasos a las 8

Paso 4:
P1 Reflejado hacia abajo por \. \ cambiado a /
P2 Establecido en modo de impresión por "
P3 Espere 2 tics a las 8

Paso 5:
P1 Encabezado hacia abajo
P2 Imprimir C
P3 Esperar 1 marca a 8

Paso 6:
P1 enviado por ^
P2 Imprimir o
P3 Finalizar esperar al continuar, recoger el valor ASCII de "" (32) de)

Paso 7: P1 Encabezado hacia arriba
P2 Imprimir d
P3 Encabezado hacia abajo

Paso 8: P1 Reflejado a la derecha por \ que se cambió a /
P2 Imprimir e
P3 Imprimir carácter con valor ASCII = 32 desde, operación

Paso 9:
P1 Reflejado hacia arriba por / que se cambia a \
P2 Imprimir B
P3 Al final del campo alcanzado y se detiene

Paso 10:
P1 Reflejado hacia abajo por I
P2 Alcanzado el final del campo y se detiene

Paso 11:
P1 Reflejado a la derecha por / que se cambió a \. Los cambios vuelven a /

Paso 12:
P1 Reflejado a la izquierda por N

Paso 13:
P1 Reflejado hacia abajo por /

Paso 14:
P1 Configure el modo de impresión con "

Paso 15:
P1 Imprimir o

Paso 16:
P1 Imprimir w

Paso 17:
P1 Imprimir l

Paso 18:
P1 Imprimir i

Paso 19:
P1 Imprimir n

Paso 20:
P1 Imprimir g

Paso 21:
P1 llega al final del campo y se detiene.

Pruébalo en línea

C, 73

Gracias a @Laikoni!

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

Pruébalo en línea!

C,  31   33  35

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

¡Gracias a @ceilingcat y @DLosc por dos puntos más y gracias a @ Ørjan Johansen por otros dos puntos más!

Pruébalo en línea!

Lote, 19 caracteres.

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

Comenzando con Windows Vista, TMPcomienza con C:\Users\y, por %TMP:~5,1%lo tanto, es una forma detallada de escribir e, a pesar de requerir una %penalización doble de -4.

Brainfuck: -204

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

Bueno, puntaje horrible, pero fue divertido de escribir.

• 122 caracteres de largo
• alnum repetido: -0 ()
• puntuación repetida: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• otro repetido: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++ ++++)
• caracteres de espacio en blanco: -0 ()
• personajes exóticos: -0 ()

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

Puntuación +53 (24 → 77) gracias a @Laikoni .

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

104 caracteres de largo
- alnum repetido: -15 ( helng)
- puntuación repetida: -10 ( "()"")
- otros caracteres ASCII repetidos: ninguno
- caracteres de espacio en blanco: -1
PUNTUACIÓN: 78

Pruébalo en línea.

Antigua respuesta de 24 bytes :

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

30 caracteres de largo
- alnum repetido: -3 ( 1)
- puntuación repetida: -2 ( ")
- otros ASCII repetidos: ninguno
- caracteres de espacio en blanco: -1
PUNTUACIÓN: 24

Pruébalo en línea.

apilados , 42

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

Pruébalo en línea!

Deja la salida en la pila. Aquí está el desglose:

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

Probablemente podría hacerlo más alto, pero está en 42 soo ...

Otro contendiente, 40:

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

Usé este script para calificarlo.

mal , -81

¡Mejor que Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Explicación

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'

Enviado porque nadie hace nada malo, pero es divertido.

Puntuación:

Longitud = 63

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

Pruébalo en línea!

EDITAR: TiO parece manejar incorrectamente la creación y eliminación de nuevas celdas de Wheel: he presentado un informe de error sobre el tema. No funcionará correctamente allí, pero lo ejecuté en mi propio intérprete y funciona y puedes confiar en mí para que no me preocupe por eso;)

Perl: 29 , 33

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

Puntuació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 puntos

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

Pruébalo en línea!

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

Total score: 94

Básicamente convierte (El ASCII binario de Bowling de código):

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

En una cadena de 1 y 0, reemplaza cada 1 con una letra en el alfabeto y cada 0 con un carácter de espacio o un símbolo o un dígito.

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

Es la cadena, donde los 1 son letras y los 0 son símbolos, números o cualquier otra cosa. Luego iteramos, viendo cuáles son alfabéticos, presionando 1 para alfabético 0 para no alfabético. Luego nos dividimos en grupos de 7, convertimos nuevamente a ASCII e imprimimos cada carácter.

T-SQL, 65 18 32! puntos

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

Inspirado por un truco en la respuesta QBasic de Dlosc , encontré una manera de incluir los 10 dígitos y la mayoría de los operadores matemáticos ( %es el resto / módulo, solo falta /), principalmente a través de prueba y error. No creo que haya ninguna forma de obtener un 67 eliminando cualquier combinación de dígitos / símbolos, pero puede intentarlo.

Versión 2 (18 puntos, trivial):

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

No es un gran puntaje, pero esto es lo que simplificó mi primera versión (gracias, MickyT). Todo lo demás que intenté (codificar y decodificar hex64, seleccionar elementos individuales de una cadena, convertir valores ASCII, etc.) tenía demasiados caracteres repetidos (especialmente ECRy símbolos (),@) que lo llevan a lo negativo.

Versión 1 (65 puntos, inválido):

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

Usé la longitud de la cadena para determinar cuántos caracteres uso desde el lado izquierdo, por lo que eliminar cualquier carácter individual de la cadena reducirá el resultado de la división entera a 11, produciendo solo Code Bowlin.

; # , puntaje -1163, no competitivo

No creo que esto sea mucha competencia, incluso si pudiera competir.

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

Pruébalo en línea! Nota: TIO no tiene; # intérprete, solo; # +.

CJam , puntaje 47

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

Esperemos que no haya problemas con esto ...

Utiliza un carácter exótico (Separador de unidades, ASCII 31, representado por ␟) y un carácter repetido ( "). Creo que podría alargarse aún más, pero lo dejaré como está por ahora.

Pruébalo en línea!

El programa funciona tomando esa cadena larga y dividiéndola en subcadenas de longitud 3. Cada subcadena se asigna al bloque, que convierte sus caracteres a sus valores ASCII, volca los valores en la pila, toma la diferencia absoluta de los segundos dos, agrega el resultado con el primero y luego convierte el resultado final de nuevo en un ASCII personaje.

CJam, puntaje 93

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

Pruébalo en línea

Inspirado en la respuesta Python de TidB .
No estoy seguro de si hay alguna forma de evitar la repetición de las comillas dobles.

Explicación:

La cadena contiene "Cpde Bowling" en reversa, cada 8 caracteres.
7~%extrae "Cpde Bowling" ( 7~= -8)
2,.-disminuye el carácter p ( 2,= [0 1])

PHP, 33 puntos

Esto fue bastante difícil de resolver.

El puntaje puede ser mejorado en el futuro.

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

¡Se supone que la nueva línea es una nueva línea de estilo Linux! El estilo Windows y el estilo Old-Mac no funcionarán correctamente.

Rubí, 75

Aproximadamente un puerto de la respuesta de Python, pero Ruby no tiene esa función de paso genial, así que la uso gsuben su lugar. También decidí divertirme un poco con los personajes exóticos lanzando frases en el Traductor de Google

Pruébalo en línea!

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

USML, 12 o 9 puntos (no competidor)

"Code\tBowling'

Pruébalo en línea!

Esta respuesta engaña un poco al abusar de cómo se representa HTML. La cadena realmente creada por esto es "Code\tBowling ". Se pierden puntos por repetir el carácter "o".

Para una respuesta no engañosa:

"Code Bowling

USML todavía está bastante temprano en el desarrollo y aún no es capaz de aumentar el tamaño del programa.

Cubix , 85

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

Pruébalo en línea!

Cubicado con caracteres insignificantes reemplazados por.

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

Creo que he hecho el camino lo suficientemente frágil como para que eliminar personajes lo rompa bastante mal.

Míralo correr

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

Una prueba rápida que aprovecha la insensibilidad de mayúsculas y minúsculas de VB y la falta de necesidad de "sistema".

Shell: puntaje 17

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

• 44 caracteres de largo
• alnum repetido: -12 (bhoD)
• puntuación repetida: -4 ("-)
• otro repetido: -4 (/)
• caracteres de espacio en blanco: -7 ()
• personajes exóticos: -0 ()

Puntuación total: 17

Acc !! 171 caracteres

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 _

Pruébalo en línea!

Acc !! funciona bien para este desafío ya que los espacios en blanco son necesarios y los bucles son costosos. Hice uso del Acc umulator aquí, pero mal, para aumentar los caracteres. Aquí hay una breve descripción de la página:

AccumulatorCualquier expresión que se encuentre sola se evalúa y se asigna al acumulador (al que se puede acceder como _). Por lo tanto, por ejemplo, 3 es una declaración que establece el acumulador en 3; _ + 1 incrementa el acumulador; y _ * N lee un carácter y multiplica el acumulador por su código de char. (N recibe entrada)

Write <charcode> Emite un solo carácter con el valor ASCII / Unicode dado a stdout. El código de char puede ser cualquier expresión.

Los bucles en Acc, al menos para jugar al golf, son un dolor. Requieren llaves, y todo el espacio en blanco es necesario. De lo contrario, se explica por sí mismo.