Salida del texto "Código Bowling"

54

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

Albert Renshaw
fuente
37
Logré obtener una puntuación de -75k. Si este fuera el puntaje más bajo, lo estaría haciendo increíblemente.
ATaco
1
@carusocomputing Pruebe los headsecks. El puntaje probablemente seguirá siendo horrible. Además, realmente no podría usar BF, ya que los que no son comandos son comentarios y podrían eliminarse.
mbomb007
1
Delimit sería bueno para esto, porque realmente no le importa qué caracteres uses, solo el ASCII combinado de un conjunto de caracteres
MildlyMilquetoast
2
¡El código más corto sería un buen desempate en este desafío!
Stewie Griffin
2
Tal vez alguien pueda resolver eso otorgando recompensas a los otros 94 años
masterX244

Respuestas:

36

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.

Martin Ender
fuente
¡Buena cosa! Estoy aceptando esto por ahora ya que 94es el puntaje máximo. Sin embargo, todos los demás son libres de seguir enviando respuestas por diversión .
Albert Renshaw
¡Buen trabajo, Martin! Si solo hubiera sido unas horas más rápido ...: D
mbomb007
@AlbertRenshaw ¿Quizás el desempate debería ser un conteo de bytes? : D
mbomb007
49

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.

TidB
fuente
2
Woah eso es bueno
Matthew Roh
1
Muy buena respuesta, pero ¿por qué el orden barajado? ¿No sería más simple (para usted) tenerlo en el orden en que están naturalmente ( HIJKLMN...) excepto por cada 8vo carácter, por supuesto?
Stewie Griffin
@StewieGriffin Hubiera sido más fácil, sí. Simplemente recorrí los conjuntos y realmente no me importó la clasificación.
TidB
¿Hay alguna razón por la que llenaste a los otros personajes en un orden tan extraño?
mbomb007
2
Eres como la inspiración TidB! Mi nueva pregunta :)
Stewie Griffin
17

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

mbomb007
fuente
94! ¡Agradable! No pensé que llegarías allí jaja
Albert Renshaw
2
Cuando comencé a hacer la primera versión, sabía que podía reutilizar algunas. Luego me deshice del "y lcon bastante trabajo. Una vez que llegué a 92, estaba seguro de que debía haber una forma de eliminar el último o. Sin embargo, tomó un poco de esfuerzo. Puedes verlo por el historial de revisiones.
mbomb007
16

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))
Stewie Griffin
fuente
¿Lo intentaste function q();disp(...)también? Excepto por el i(), están muy bien sin superposición.
Sanchises
@Sanchises Puedo verlo. Pero cotdentro horzcaty nfdentro de la cadena bajará el puntaje de manera drástica. Sin embargo, podría ser mejor si elimino horzcaty creo la cadena de otra manera, pero tampoco puedo usar +!0ninguno. Para ser honesto, me sorprendería si aumenta el puntaje ... Es solo 7 caracteres más largo que la respuesta actual, y obtendré una penalización de 7 bytes, además de los que mencioné.
Stewie Griffin
1
Sí, trivialmente no podría obtener un puntaje más alto function, pero luego pensé que ya lo habrías intentado y estaría perdiendo mi tiempo (en lugar de, ya sabes, pasar mi tiempo útilmente en PPCG)
Sanchises
12

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.

DLosc
fuente
1
¿Puedes compartir un enlace a un intérprete en línea? No puedo ejecutar esto en repl.it. Me saleParse failed: Syntax error at 3:36: Token(Bowling)
Stewie Griffin
1
@StewieGriffin Editado en un par de opciones.
DLosc
1
@StewieGriffin, esto aprovecha una peculiaridad en las implementaciones de Microsoft de Basic donde la cita de cierre de una cadena es opcional si esa cadena se extiende hasta el final de la línea. Espero que la mayoría de los intérpretes que no son de Microsoft se opondrán a las citas que faltan.
Mark
Aparentemente, QBasic tiene una fuerte asociación de olores para mí.
No es que Charles
1
@DLosc Huele como el libro del que lo aprendí, y como la sala de computadoras en mi casa mientras crecía. No tenía ni idea. Era LOCATE 1, 2el que lo hizo
No es que Charles
12

C, 27 29

¡+2 puntos gracias a @ceilingcat!

f(){char q<:]="Code B\157wling";puts(q);%>
Betseg
fuente
2
Sugerir en char q<:]lugar de char q[]y en puts(q);%>lugar deputs(q);}
ceilingcat
Sugerencia: 1.utilizando funciones separadas para generar cada segmento de la cadena y luego ejecutarlas todas en la función f 2. La magia de usar estructuras para hacer que el código sea irrazonablemente más largo
Matthew Roh
1
@MatthewRoh Creo que es posible que el sistema de puntuación lo castigue bastante fuerte
Albert Renshaw
1
@AlbertRenshaw Esos son dígrafos
ceilingcat
15
Jaja, la primera vez que veo un+2 points thanks to ...
Kritixi Lithos
9

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!

Laikoni
fuente
1
Esto se puede reducir
Leo
@Leo buena captura! ¿Este enfoque también funciona para mi versión actualizada con 95la cadena y restando 4621? (No tengo tiempo para comprobarlo ahora mismo, pero lo investigaré más adelante)
Laikoni
1
Gotcha . Me tomó más tiempo del que debería, viendo lo simple que es el resultado :)
Leo
8

JavaScript, 19

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

No es un puntaje muy alto.

Solo ASCII
fuente
z(){var x=alert('Code \nBowling');}
sagiksp
@AlbertRenshaw, el punto y coma se puede eliminar
solo ASCII
1
@sagiksp no funciona, no lo ha hecho functionantesf
solo ASCII
1
Damnit ono se usó
solo ASCII
1
19:prompt('C\157de B\x6fwlin'+"g")
Albert Renshaw
8

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
Jonathan Allan
fuente
1
Jelly es más larga que otras ¿cómo es esto posible?
Christopher
1
@DownChristopher En realidad es más corto que la respuesta de Python. Sin embargo, la respuesta de Python tiene repetición.
fəˈnɛtɪk
@DownChristopher ¿detecto el sarcasmo?
Jonathan Allan
@JonathanAllan no Sí, todavía me parece divertido que la gelatina sea bastante larga aquí
Christopher
6

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.

fergusq
fuente
6

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

fəˈnɛtɪk
fuente
5

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!

Steadybox
fuente
1
@ceilingcat Entonces uno podría eliminar el 8-código válido y todavía. 0xA-4+8Sin embargo, debería funcionar.
DLosc
1
Funcionaria 0xA+32/8? (Sin que algo sea removible, eso es)
Ørjan Johansen
@ ØrjanJohansen, creo que sí. Ninguno de +32, +3, +2, +3/8, +2/8, /8o +8produce la salida derecha. ¡Gracias!
Steadybox
Oh, o 0xD+4*8/32. No, espera, eso se acortaría, 0xD+4/3¿no?
Ørjan Johansen
1
Usar el mismo enfoque que mi respuesta de Haskell da un puntaje de 74, si no es reducible de ninguna manera: ¡ Pruébelo en línea!
Laikoni
3

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.

Neil
fuente
3

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 ()
Haydn Dias
fuente
¿Brainfuck gana algún desafío PPCG? ; P
Draco18s
@ Draco18s probablemente no jajaja llore.
Haydn Dias
1
"Divertido de escribir", ¿quiere decir "Code Bowling" en un generador de texto ?
Jo King
3

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.

Kevin Cruijssen
fuente
El uso de un escape octal en el texto aumentaría su puntaje en 6 en lugar de los 2 que obtiene para su escape Unicode (aunque tener ambos es peor). Además, concatenar el primer o el último carácter aumentará su puntaje en 1. Finalmente, piense que podría estar mejor con una lambda en lugar de una función con nombre.
Neil
@Neil Weird, ya se me ocurrió Object x(){return"C\157de Bowling";}hace unas horas por 17 puntos ... Aparentemente, no lo he editado / guardado en mi envío, aunque ...: S En cuanto a la lambda, uso Java 7 que no tengo lambdas todavía. Sin embargo, podría agregar una respuesta Java 8 con lambda.
Kevin Cruijssen
Vaya, lo siento, no me di cuenta 7. (Pero no olvide la concatenación.)
Neil
1
Usar el mismo enfoque que mi respuesta de Haskell le da a esta versión un puntaje de 77: ¡ Pruébelo en línea! .
Laikoni
@Laikoni ¡Gracias! +53 puntaje gracias a ti. Y dado que las respuestas de Java 8 generalmente se responden sin el punto y coma final, podría eliminar ese punto y reemplazar el repetido ,,con ,;otro +1. Es curioso cómo la cadena que usa todos los ASCII imprimibles disponibles que quedaron EXACTAMENTE 97 caracteres para el código de caracteres C. :)
Kevin Cruijssen
2

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.

Conor O'Brien
fuente
2

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

charliefox2
fuente
2

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
Toto
fuente
2

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.

Urna de pulpo mágico
fuente
2

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.

BradC
fuente
No estoy seguro, pero creo que esto se puede reducir a DECLARE @ char(12)='Code Bowling'PRINT @las reglas.
MickyT
@MickyT Puede, ¿eso invalida mi respuesta? Alguien en el chat dijo que solo tenía que resistir la eliminación de caracteres aleatorios individuales, no porciones arbitrarias largas, ¿eran incorrectos?
BradC
Lo dejaría aquí por el momento, siempre es bueno ver una respuesta t-SQL
MickyT
@MickyT Lo dejaré pero tacharé el puntaje. Lo mejor que podría hacer de otra manera es un mísero 18 puntos: P
BradC
2

; # , 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; # +.

Khuldraeseth na'Barya
fuente
1

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.

Gato de negocios
fuente
1

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

aditsu
fuente
@Laikoni, si quisiste decir que violé la regla de código no utilizada, debería arreglarse ahora
aditsu
@Laikoni, sí, pero si elimina cualquier carácter individual en su código, no funciona correctamente, por lo tanto, porque se usa todo el código, es válido.
Urna mágica del pulpo
@carusocomputing Las reglas mencionan claramente que el código no debería funcionar "si algún carácter individual (o conjunto (s) variable) de caracteres) es / son eliminados", por lo que no creo que su interpretación se mantenga. De todos modos, aditsu ya solucionó el problema, así que todo está bien ahora.
Laikoni
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.

Ismael Miguel
fuente
1

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'
Tinta de valor
fuente
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.

MarkSill
fuente
" USML todavía está bastante temprano en el desarrollo y todavía no es capaz de aumentar el tamaño del programa ". ¿Qué pasa con esto por 10 puntos "Code&'Bowling(* Nota: Reemplazar &con un salto de línea, no me deja escribirlos en los comentarios)
Albert Renshaw
También puede agregar una barra invertida `` delante de cualquiera de las letras y aún generará la misma cadena ya que el compilador lo ignora o escapa del carácter en sí mismo. ¡Esto obtiene el puntaje (en competencia) hasta 11 ahora!
Albert Renshaw
Luego puede agregar un salto de línea y una minúscula sa la siguiente línea (obteniendo una subcadena de nada, sin cambiar la salida) para obtener su puntaje competitivo hasta 12, lo mismo que su puntaje no competitivo, excepto un real presentación válida: D
Albert Renshaw
De hecho, aquí hay una respuesta de 16 puntos en USML, publicaré el hastebin ya que es difícil escribir código de varias líneas en los comentarios: hastebin.com/icuguviyax.tex
Albert Renshaw
Soy un idiota y olvidé las reglas de mi propio desafío jajaja, un subconjunto del código anterior aún completaría el desafío, descalificando mi respuesta; whoops!
Albert Renshaw
1

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
MickyT
fuente
0

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".

chrixbittinx
fuente
1
No conozco VB.net, pero ¿no se puede reducir esto a cONSOLE.WRITE("Code Bowling")?
Laikoni
1
Si puede. Según la publicación, 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. "Puntuación debería ser 17, creo.
charliefox2
@ charliefox2 Gracias. No leí eso, ¡debe haber estado demasiado emocionado para usar VB nuevamente!
chrixbittinx
1
¡Hola, 17 todavía aplasta mi puntaje de -81!
charliefox2
0

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

Perette
fuente
0

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.

FantaC
fuente
Este es un desafío de bolos, no de golf, por lo que se supone que debes maximizar el puntaje. Además, su puntuación es de otra manera inusual. Usando la herramienta de puntuación anterior, su código obtiene una puntuación negativa.
Ørjan Johansen
1
@ ØrjanJohansen Parece que están intentando maximizar el puntaje (debido a que " utilicé el umulator Acc aquí, pero mal, para aumentar los caracteres"), pero simplemente no lo están anotando correctamente.
LyricLy
@ ØrjanJohansen Ah, sí, parece que me perdí por completo la sección de puntuación. Actualizaré
FantaC