Su compañía recientemente contrató a un nuevo grupo de administradores de sistemas extremadamente dedicados . Sienten que solo mirar las pantallas de la computadora es bastante limitante (quiero decir, una frecuencia de actualización de 60Hz NO es suficiente), por lo que conectaron el bus de datos de la CPU a un DAC y lo reprodujeron en un altavoz a través de la sala del servidor para que puedan escuchar a 20kHz. Un problema: son administradores de sistemas, no ingenieros eléctricos, y la configuración de sus altavoces se sigue rompiendo. Pensaron que esto es causado por cambios demasiado abruptos en los valores de bytes en el código que los ingenieros de software compilan en el mainframe. Los administradores del sistema ahora están organizando una pequeña competencia para ver quién puede hacer el código más suave para la configuración de sus altavoces.

Reto

Su misión es crear un programa o función en un idioma de elección que tenga la menor diferencia posible entre bytes consecutivos (consulte la sección Cálculo). Este programa tendrá la tarea de calcular su propio puntaje.

Entrada

Una cadena ASCII stdino el equivalente más cercano de su idioma, o como una entrada de función si está creando una función. Dado que su programa tendrá que tomarse como entrada para calcular su puntaje, su programa debe admitir Unicode si contiene algún Unicode. De lo contrario, ASCII es suficiente. Se puede suponer que la entrada tiene al menos 2 bytes de longitud.

Cálculo

Cada carácter de la cadena se convertirá a su equivalente numérico, utilizando el estándar ASCII. Luego, la diferencia entre todos los personajes se cuadrará primero y luego se sumará . Por ejemplo, la cadena abdobtendrá una puntuación de 1²+2²=5.

Salida

La salida será el título de su entrada. Esto significa que debe estar precedido por a #o anexado por una nueva línea y un -(guión). Luego, debe mostrar el nombre de su lenguaje de programación, seguido de una coma, un espacio y luego un número entero que representa el resultado del cálculo. Por ejemplo

#C++, 98

Sería una salida válida. La salida se debe proporcionar en stdoutsu idioma o el equivalente más cercano, o como un valor de retorno para su función.

Tanteo

Su puntaje será el valor calculado por su programa, con el programa como entrada.

Editar: debería manejar nuevas líneas ahora, lo siento por antes, amigos

Aquí hay un script Pyth para verificar el cálculo del puntaje.

CJam, 1051 827 643 569 545 407 327 279 235 233 229

''"','#'C'J'a'm',' qYew::-Yf#:+e#'''''''''"
f{-ci'(*''2*\}'^,40>"*/:N"-"][ZZ[\^__`bcdgimpstsz{}~~~"

El programa anterior genera el código fuente real, que tiene una longitud de 1,179,112 bytes.

Pruebas

Usando el intérprete de Java , el código fuente puede generarse y probarse así:

$ alias cjam='java -jar cjam-0.6.5.jar'
$ cjam gen.cjam > diff.cjam
$ cksum diff.cjam 
896860245 1179112 diff.cjam
$ cjam diff.cjam < diff.cjam
#CJam, 229

Versión alternativa

Con un costo de 36 puntos, para un puntaje final de 265 , podemos hacer que el código fuente sea 99.92% más corto:

'''()))))(''''(((('''())))))))))))))))))))))))))))('''()))))))))))))))))))))))))))))))))))('''())))))))))))))))))))))))))))))))))))))))))))))))))))))))))('''())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('''()))))(''''((((((('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('())))))))))))))))))))))))))))))))))))))))))))))))))('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('()))))))))))))))))))('()))))))))))))))))))('())))))('())))))))))))))))))))))))))))))))))))))))))))))))))('()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(''(((('()))))))))))))))))))('())))('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(''((((''''''''''''''''''()+,-.0123456789;<=>?@ABCDEFGHIJKLMOPQRSTUVWXYZ[\]][ZZ[\^__`bcdgimpstsz{}~~~

Puede probar esta versión en línea en el intérprete de CJam .

Idea

Queremos ejecutar el código

'#'C'J'a'm',' qYew::-Yf#:+

manteniendo el puntaje lo más bajo posible. Para lograr esto, vamos a construir esa cadena carácter por carácter (con algunas operaciones no antes y después) y evaluar el resultado.

Afortunadamente, '(empujar caracteres literales), ((decremento) e )(incremento) son caracteres ASCII consecutivos, por lo que empujar caracteres arbitrarios es relativamente económico.

• Los caracteres ASCII después 'se pueden insertar como '()…)(, donde el número )depende del punto de código.

  Por ejemplo, +se puede empujar como '())))(. La distancia entre 'y (, y (y )es 1. El final se )(cancela entre sí; su única función es allanar el camino para lo siguiente '(correspondiente al siguiente carácter) con caracteres consecutivos.

  Los personajes empujados de esta manera aumentarán la puntuación en 4 puntos.

• Los caracteres ASCII anteriores 'se pueden insertar como ''(…(, donde el número (depende del punto de código.

  Por ejemplo, #se puede empujar como ''((((. La distancia entre 'y (es 1.

  Los personajes empujados de esta manera aumentarán la puntuación en 2 puntos.

• ''(…(en realidad funciona para todos los caracteres ASCII, ya que el carácter tiene 16 bits de ancho y se ajusta. Por ejemplo, +se puede empujar como '', seguido de 65.532 (s.

  Esta técnica se usa en la versión de 1,2 megabytes del código.

• El personaje 'puede ser empujado como '', dejando la puntuación no afectada.

Código

e# Push these characters on the stack: ','#'C'J'a'm',' qYew::-Yf#:+e#'''''''''

''
'()))))(
''
''((((
''
'())))))))))))))))))))))))))))(
''
'()))))))))))))))))))))))))))))))))))(
''
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''
'()))))(
''
''(((((((
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
'()))))))))))))))))))(
'()))))))))))))))))))(
'())))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))(
'()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''((((
'()))))))))))))))))))(
'())))(
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''((((
''
''
''
''
''
''
''
''
''()

+                         e# Concatenate the two topmost single quotes.
,                         e# Push the length of the resulting string (2).
-.0123456789              e# Push that number.
;                         e# Discard it from the stack.
<                         e# Compare a single quote with 2. Pushes 0.
=                         e# Compare a single quote with 0. Pushes 0.
>                         e# Compare a single quote with 0. Pushes 1.
?                         e# Ternary if. Discards a single quote and 1.
@                         e# Rotate the remaining three single quotes.
ABCDEFGHIJKLMOPQRSTUVWXYZ e# Push 25 items on the stack.
[\]                       e# Swap the last two and wrap them in an array.

e# So far, we've pushed the elements of "','#'C'J'a'm',' qYew::-Yf#:+e#'''"
e# followed by the elements of [10 11 12 13 14 15 16 17 18 19 20]
e# and ["" "" "" 3.141592653589793 "" "" " " 0 0 0 -1 1 [3 2]].

]    e# Wrap the entire stack in an array.
[    e# Begin an array. Does nothing.
ZZ   e# Push 3 twice.
[    e# Begin an array. Does nothing.
\^   e# Swap both 3s and push the bitwise XOR. Pushes 0.
__   e# Push two copies.
`    e# Inspect the last copy. Pushes the string "0".
b    e# Convert "0" from base 0 to integer. Pushes 48.
cd   e# Cast 48 to Character, then Double. Pushes 48.0.
gi   e# Apply the sign function, then cast to integer. Pushes 1.
mp   e# Check 1 for primality. Pushes 0.
s    e# Cast the result to string. Pushes the string "0".

e# We now have three elements on the stack: an array, 0, and "0"

t    e# Set the element at index 0 of the array to the string "0".
s    e# Cast the array to string.

e# This pushes the string consisting of the characters
e#     0,'#'C'J'a'm',' qYew::-Yf#:+
e# and
e#     e#'''10111213141516171819203.141592653589793 000-1132
e#
e# When evaluated this does the following:
e#   0,                Push an empty array. Does not affect output.
e#   '#'C'J'a'm','     Push the characters of "#CJam, ".
e#   q                 Read all input from STDIN.
e#   Yew               Push the overlapping slices of length 2.
e#   ::-               Reduce each pair of characters to their difference.
e#   Yf#               Square each difference.
e#   :+                Add the results.
e#   e#…               Comment. Does nothing.

z    e# Zip. This wraps the string on the stack in an array.
{}~  e# Execute an empty block.
~    e# Unwrap the array.
~    e# Evaluate the string.

Haskell, 152827 95742 91196 83921 77447 71742

a=(.);_ZYXWVUTSRQPONMLKJIHGFEDCBA=("#Haskell, "++)`a`show`a`sum`a`fmap(^2)`a`(tail>>=zipWith(-))`a`fmap fromEnum`a`(""++)

Uso (nota: "tiene que escapar):

_ZYXWVUTSRQPONMLKJIHGFEDCBA   "a=(.);_ZYXWVUTSRQPONMLKJIHGFEDCBA=(\"#Haskell, \"++)`a`show`a`sum`a`fmap(^2)`a`(tail>>=zipWith(-))`a`fmap fromEnum`a`(\"\"++)"

"#Haskell, 71742"

Antepongo la cadena vacía ""a la cadena de entrada para ayudar al intérprete de Haskell a descubrir los tipos. Sin la inferencia de tipo falla, el código es demasiado polimórfico. El resto es lo de siempre: asigna cada carácter a ascii, haz una lista de las diferencias de vecinos, el cuadrado, la suma y el nombre del idioma.

> <>, 30227

0&ii:0(?v:@-:*&+&20.
'#><>, '<;n&oooooo

Gah, el título duplicó mi puntaje; en palabras de mi propio programa, n & oooooo! Me tomaré un tiempo más tarde para mejorar esto. También sé que este puntaje puede estar desactivado ya que realmente no puedo ingresar nuevas líneas en el intérprete en línea y no estoy seguro de que haya una manera de llenar una pila de entrada en el oficial.

De ninguna manera está completamente optimizado, pero aprovecha al máximo la relativa proximidad (al menos en términos de caracteres ASCII) de los comandos en> <>. No podía enviar fácilmente la nueva línea como entrada, así que utilicé el verificador de puntuación Pyth, pero coincide con un montón de casos de prueba aleatorios que utilicé, por lo que debería estar bien con respecto a eso.

Aquí hay uno con una puntuación de 30353 (que debería ser correcto ya que es una línea):

0&l1=66+*77++0.$:@-:*&+&10.' ,><>#'oooooo&n;

Java, 66465 65506 62434

Sorprendentemente corto. Acepta una matriz de caracteres en lugar de una cadena.

ABCD->{int A98=0,GFEDCBA=1,A987;for(;GFEDCBA<ABCD.length;A98=A98+(A987=ABCD[GFEDCBA]-ABCD[GFEDCBA++-1])*A987-0);return"#Java, "+A98;}

Usé un programa para generar los mejores nombres de variables.

K5, 25478

"#K5, ",$+/1_{x*x}'-':

Solución bastante simple. Esta es una función que toma su entrada a través de una cadena.

Windows PowerShell ISE anfitrión, 62978 63894 67960 77050

PARAM($4)($4.LENGTH-2)..0|foreach{$9=+$4[$_]-$4[$_+1];$0+=$9*$9};'#'+$HOST.NAME+', '+$0

_{Editar: ahorró algunos puntos al deshacerse de la $Avariable y en lugar de contar hacia atrás a través de la cadena, y también al convertir algunas palabras clave a MAYÚSCULAS}

_{Edit2: ahorró algunos puntos más en $($HOST.NAME)lugar dePowerShell}

_{Edit3: guardó algunos puntos más al intercambiar nombres de variables y cambió la forma en que se genera la salida.}

Utiliza variables nombradas con números, ya que están "más cerca" de $modo que nuestra penalización es menor.

Es interesante no utilizar técnicas regulares de golf. Por ejemplo, |%{$es 22534, mientras |foreach{$que solo es 8718.

Esto probablemente sea casi óptimo sin cambiar las técnicas.

MATLAB, 19214 39748 39444 38785 37593

@(A9876543210)sprintf('#MATLAB, %d',diff(A9876543210)*diff(A9876543210'))

¡Gracias a Luis Mendo por reducir aún más la diferencia!

¡Gracias a NumberOne por reducir el recuento de ruido cambiando el nombre de la variable de entrada!

Como funciona esto

1. Declara una función anónima que se almacena en la ansvariable predeterminada en MATLAB
2. La función toma una cadena almacenada A9876543210e imprime la suma de las diferencias vecinas al cuadrado de la cadena.
3. diffencuentra diferencias vecinas por pares en una matriz y produce una matriz de length(A9876543210)-1. Al usar diffuna matriz de cadenas, esto se convierte en una doublematriz donde se generan los códigos ASCII de cada carácter y las diferencias de los pares consecutivos resultan en otra matriz.
4. Para encontrar la suma de las diferencias al cuadrado, simplemente tome el producto de puntos de esta matriz de diferencias consigo mismo transpuesto. Hacerlo en diff(A9876543210)'realidad produjo más ruido que con A9876543210.'(¡gracias Luis Mendo!)
5. El resultado se imprime en la pantalla.

QBasic, 38140

YAY PARA LA SINTAXIS SHOUTY

LINE INPUT A9876543210$:AAA=ASC(A9876543210$):WHILE A<LEN(A9876543210$):AA9876543210=AAA:A=1+A:AAA=ASC(MID$(A9876543210$,A)):A98765432100=A98765432100+(AA9876543210-AAA)*(AA9876543210-AAA):WEND:?"QBasic,";A98765432100

(Probado con QB64 .)

Este es un programa completo que ingresa la cadena y genera la respuesta. La única limitación aquí es que el programa no puede tomar entradas de varias LINE INPUTlíneas ( puede manejar cualquier cosa siempre que sea una sola línea).

Desobuscado:

LINE INPUT line$
b=ASC(line$)
WHILE i<LEN(line$)
    a=b
    i=i+1
    b=ASC(MID$(line$,i))
    score=score+(a-b)*(a-b)
WEND
PRINT "#QBasic,"; score

Convenientemente, pasar una cadena de caracteres múltiples para ASCobtener el valor ASCII del primer carácter. También convenientemente, las variables numéricas se inicializan automáticamente a cero.

Python 2, 91026

lambda A:"#Python 2, "+`sum((ord(A9876543210)-ord(A98765432100))**2for A9876543210,A98765432100 in zip(A,A[1:]))`

Define una función anónima que toma una cadena y devuelve la puntuación. Pruébalo en línea .

La mayor parte de esta es una aplicación funcional bastante sencillo: zip Acon A[1:]para obtener una lista de pares de letras, luego restar sus ords, cuadrado y suma con una expresión generador.

Observe que las dos variables dentro de la expresión generador están solamente siempre seguidos por los siguientes caracteres: ), ,, y el espacio. Los tres tienen valores ASCII muy bajos, por lo que nos corresponde terminar cada variable con un carácter con un valor ASCII tan bajo como sea posible. El carácter más bajo que puede terminar una variable en Python es 0. Además, cada oportunidad que tengamos para dividir un solo salto grande en dos saltos más pequeños reducirá la puntuación: A0cuesta 289, pero A90es solo 145 y A9876543210es un miserable 73.

(Este enfoque no ayudó a la variable lambda A, probablemente porque es seguida de [una sola vez).

JSFuck, 144420642

Construirlo desde:

t=arguments[0];n=0;for(u=1;u<t.length;++u)n+=(f=t.charCodeAt(u)-t.charCodeAt(u-1))*f;return'#JSFuck, '+n

Pega esto en JSFuck.com cuadro de entrada pequeña 's compilarlo a JSFuck. El resultado es un script largo de 112701 caracteres, por lo que no puedo ponerlo aquí. Los dos últimos caracteres de este script son paréntesis, coloque la entrada entre ellos.

...)[+!+[]])('abd')

El programa tarda casi 20 segundos en mi computadora para evaluarse a sí mismo.

Explicación

Tuve más tiempo para trabajar en esto, así que me senté e intenté optimizar los nombres de las variables. Aquí están los nombres de variables que vale la pena usar, en orden de puntuación.

u     ([][[]]+[])[+[]]                    17237
n     ([][[]]+[])[+!+[]]                  17437
f     (![]+[])[+[]]                       18041
t     (!![]+[])[+[]]                      18041
a     (![]+[])[+!+[]]                     18241
r     (!![]+[])[+!+[]]                    18241
d     ([][[]]+[])[!+[]+!+[]]              23405
N     (+[![]]+[])[+[]]                    23669
e     (!![]+[])[!+[]+!+[]+!+[]]           29217
i     ([![]]+[][[]])[+!+[]+[+[]]]         33581
l     (![]+[])[!+[]+!+[]]                 24209
s     (![]+[])[!+[]+!+[]+!+[]]            29217
uu    ([][[]]+[])[+[]]+([][[]]+[])[+[]]   36983

Aquí está el JavaScript que he traducido a JSFuck:

score = 0;
for (u = 1; u < input.length; ++u)
  score += (difference = input.charCodeAt(u) - input.charCodeAt(u-1)) * difference;
return '#JSFuck, ' + score;

Le eché un vistazo más de cerca al traductor de JSFuck.com y descubrí cómo funciona su función de evaluación. Con "Fuente de evaluación" marcada, el código se convertirá en una función JSFuck de ejecución automática. Sin embargo, para obtener la entrada, necesitamos acceder a los argumentos [0] desde la función. Esto trae nuestro código JS final a ...

t=arguments[0];n=0;for(u=1;u<t.length;++u)n+=(f=t.charCodeAt(u)-t.charCodeAt(u-1))*f;return'#JSFuck, '+n

(Si se pregunta por qué mi versión anterior tuvo una puntuación más baja que esta, es porque fue un programa JSFuck que devolvió una cadena que necesitaba ser evaluada como JS. Esta es también la razón por la que no la dejé en la publicación)

CJam, 23663 19389 11547

"#CJam,"32A;clYew[]ULC;;;;::- 0$.*:+

Pruébalo en línea

Está empezando a parecer que esto se puede empujar casi infinitamente al agregar estratégicamente más personajes. Pero creo que estoy comenzando a alcanzar un punto de rendimientos decrecientes aquí, así que me detendré por ahora. Por ejemplo, donde tengo ULC;;;, podría usar todo el alfabeto al revés seguido de 26 ;, pero las ganancias se hacen cada vez más pequeñas.

Con mucho, la brecha más grande que me queda es entre el my el ,en la cadena inicial. No he encontrado nada razonable para deshacerme de él. Estoy seguro de que hay maneras. Pero si lo llevo al límite, podría comenzar a parecerse a la solución de Dennis ...

JAVASCRIPT, 33911

$0123456789ABCDEFGHIJKLMNOPQRS=>/**/('#')+('JAVASCRIPT,')+(" ")+(($)/**/=0,($0123456789ABCDEFGHIJKLMNOPQRS[`split`]``[`map`]/**/(($$,$$$)/**/=>/**/($)/**/=Math[`pow`]/**/($0123456789ABCDEFGHIJKLMNOPQRS[T=`charCodeAt`]/**/($$$)+-($0123456789ABCDEFGHIJKLMNOPQRS[T]/**/(($$$)/**/>=6-5?/**/($$$)+-1:0.)),2)+($))),($))

Esta es, con mucho, una de las optimizaciones más tontas que he hecho en un código de golf ...

Apoyos a Neil para la sugerencia de "comentario no deseado" = P

JAVASCRIPT, 31520

Esta solución era significativamente más ridícula, muy diferente de la otra, y sentí que merecía su propia respuesta.

A=>/**/(($)/**/=/**/(''),('000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000100000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000000010000000000000000000000000000000000000000000100000000000000000000000000000000000000100000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000010000000000000000000000000000000100000000000000000000000000000000000000100000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000010/-,+*)(')/**/[`split`]``[`reduce`]/**/(($$,$$$,$$$$)/**/=>/**/($$$)/**/>7.-07?/**/(($)+=/**/((/**/String[`fromCharCode`]/**/)(($$$$)+-($$))),($$$$))/**/:/**/($$)),/**/eval/**/($))

Son 7306 caracteres, la mayoría de los cuales es el programa real codificado en esa cadena 0/1, y el resto simplemente para decodificarlo. Funciona al obtener el índice de cada '1' menos el índice del '1' anterior para obtener el valor de carácter necesario. Luego evalúa la cadena resultante en la función real, que es esencialmente un programa de golf estándar para resolver el problema (que solo tiene unos 105 caracteres).

R, 68911 57183 53816 52224

Toma una cadena de STDIN y la convierte en un entero a través de raw. Difunde, cuadra y suma el vector resultante. El resultado se devuelve como una cadena. Gracias a @nimi por el consejo de nombre variable.

'&&'=sum;'&&&'=diff;'&&&&'=as.integer;'&&&&&'=charToRaw;'&&&&&&'=readline;'&&&&&&&'=paste;'&&&&&&&'('#R,','&&'((A='&&&'('&&&&'('&&&&&'('&&&&&&'()))))*A))

Mathematica, 33552

A=ToExpression;A@ExportString[A@Characters@(**)"001000100010001101001101011000010111010001101000011001010110110101100001011101000110100101100011011000010010110000100000001000100011110000111110010101000110111101010011011101000111001001101001011011100110011101011011001000110010111000100011001001100100000001000100011010010110011001100110011001010111001001100101011011100110001101100101011100110100000001010100011011110100001101101000011000010111001001100001011000110111010001100101011100100100001101101111011001000110010101000000001000110101110100100110"(**),(**)"Bit"(**)]

Este código se evalúa como una función sin nombre, que calcula el "ruido" de una cadena de entrada. Hace uso del hecho de que la representación ASCII de datos binarios es esencialmente "silenciosa". Los datos binarios que ves son la cadena

"#Mathematica, "<>ToString[#.#&@Differences@ToCharacterCode@#]&

lo que habría sido una respuesta válida por sí sola, con un puntaje de 37848.

Todo lo demas

A=ToExpression;A@ExportString[A@Characters@(**)"001..110"(**),(**)"Bit"(**)]

simplemente decodifica la cadena binaria y la interpreta como código de Mathematica. Tenga en cuenta que el comentario vacío de Mathematica (**)es muy "silencioso" y en realidad elimina el ruido del "s.

Java8: 117170 100508 99062 98890

Con la ayuda de la expresión lambada y la asignación en línea de la variable puede acortar un poco este código.

A->{int B=0,D=0,E=0;char[] C=A.toCharArray();for(;D<C.length-1;)B+=(E=C[D]-C[++D])*E;return"#java, "+B;}

Java, 129300 128400 110930 106581 105101

B->{int A=0,C=A;char[]Z=B.toCharArray();for(;++C<Z.length;A=A+(Z[C]-Z[C-1])*(Z[C]-Z[C-1]));return\"#Java, \"+A;}

Este desafío realmente me hizo pensar más en los personajes que usaría y en la optimización más que en encontrar la solución más corta. Seguiré trabajando para bajar el número.

Esta es una función lambda, Bsiendo la cadena la que representa la función. No olvide escapar de las comillas ( ") al pasar esto como una cadena.

Pyth, 16391

++C38828542027820dsm^-ChdCed2,Vztz

El único truco de nota utilizado aquí es la codificación de base 256 #Pyth,, que cuesta mucho menos que la cadena en sí.

++C38828542027820dsm^-ChdCed2,Vztz    Implicit: d=' ', z=input()
                             ,Vztz    Pair each char in the input with its neighbour
                   m                  Map d in the above to:
                      Chd               ASCII code of 1st char
                         Ced            ASCII code of 2nd char
                     -                  Difference between the two
                    ^       2           Squared
                  s                   Take the sum
  C38828542027820                     '#Pyth,'
++               d                    '#Pyth,' + ' ' + result, implicit print

M, 47033 52798

A9876543210(A9876543210) F AA9876543210=2:1:$L(A9876543210) S AAA9876543210=$A($E(A9876543210,AA9876543210-1))-$A($E(A9876543210,AA9876543210))**2+AAA9876543210
    Q "#M, "_AAA9876543210

Para usar esto, tenemos que escapar de las comillas y los caracteres de espacio en blanco "escapar" (¡que son significativos en MUMPS!) Así:

>$$A9876543210^MYROUTINE("A9876543210(A9876543210)"_$C(9)_"F AA9876543210=2:1:$L(A9876543210) S AAA9876543210=$A($E(A9876543210,AA9876543210-1))-$A($E(A9876543210,AA9876543210))**2+AAA9876543210"_$C(10,9)_"Q ""#M, ""_AAA9876543210")
#M, 47033

Tenga en cuenta que "M" es un nombre alternativo para "MUMPS": existe un desacuerdo entre los profesionales acerca de cuál es el correcto. Naturalmente, he elegido la opción más corta aquí.

Rubí, 118402

puts "#Ruby, #{a=0;aa=nil;File.read(ARGV[0]).each_byte{|aaa| aa||=aaa;a+=(aaa-aa)**2;aa=aaa};a}"

Se lee en un archivo a través de la línea de comandos, como ruby diff.rb /path/to/file . Hay espacio para mejorar, y eso es algo en lo que estoy trabajando en este momento.

C ++ 166345

void n(){int b=0,c,d;string a;cin >>a;for(c=1;c<a.length();++c){d=(a[c]-a[c-1]);b+=d*d;}cout<<"#C++, "<<b;}

Perl, 93556

chomp($A=<>);$AAA=$AAAA=0;foreach$AAAAA(split'',$A){$AA=ord($AAAAA);$AAA+=($AAAA-$AA)**2 if($AAAA!=0);$AAAA=$AA}print'#Perl, '.$AAA

Trataré de reducir esto un poco más.

Resulta que las llaves ( {y }ASCII 123 y 125) y el guión bajo ( _ASCII 95) son muy caros ya que todos los otros caracteres están en el rango de 30-70, por lo que formateé ifla forma en que lo hice, y por qué estoy usando en $AAAAAlugar de la amada de Perl $_.

Lamentablemente, todas las variables con símbolos son de solo lectura, por lo que no puedo aprovechar las combinaciones como $#y $$.

F #, 136718 130303

let(A)=Seq.map;
(stdout.Write(Seq.sum(A(fun(AA)->AA*AA)(A((<||)(-))(((Seq.pairwise(A(int)(stdin.ReadToEnd())))))))))

Donde hay un \ndespués del ;.

POSIX Shell, 172026

{ while IFS= read -N 1 A; do A1=$(printf %d \'"$A");test "$A1" -eq 0 && break;case $A11 in "")A111=0;;*)A111=$((A1-A11));;esac;A11="$A1";A1111=$((A111**2+A1111));done;echo "# POSIX Shell, $A1111";}

lástima que no pueda obtener el mismo resultado que el corrector Pyth (178386) ...

Lua, 171078 117896

Golfizado:

A=string AA=A.sub AAA=io.read()AAAA=#AAA AAA=AAA..AA(AAA,AAAA,AAAA)AAAAA=0 AAAAAA=A.byte for AAAAAAA=1,AAAA do AAAAAAAA=AAAAAA(AA(AAA,AAAAAAA,AAAAAAA))-AAAAAA(AA(AAA,AAAAAAA+1,AAAAAAA+1))AAAAA=AAAAA+AAAAAAAA*AAAAAAAA end print(AAAAA)

Sin golf:

A=string 
AA=A.sub 
AAA=io.read()
AAAA=#AAA 
AAA=AAA..AA(AAA,AAAA,AAAA)
AAAAA=0 
AAAAAA=A.byte 
for AAAAAAA=1,AAAA do 
    AAAAAAAA=AAAAAA(AA(AAA,AAAAAAA,AAAAAAA))-AAAAAA(AA(AAA,AAAAAAA+1,AAAAAAA+1))
    AAAAA=AAAAA+AAAAAAAA*AAAAAAAA 
end 

print(AAAAA)

C ++, 49031

Una macro C ++ que toma una cadena en C y escribe el resultado en la salida estándar

<::>(auto(A))<%long(AAA)=0,AA=A<:0:>;while(*++A)<%AAA+=(*A-AA)*(*A-AA);AA=A<:0:>;%>cout<<"#C++, "<<AAA;%>

Pruébalo en línea!

C ++, 5

    #include <iostream>
    #include <string>
    #include <cmath>
    using namespace std;

    void convertToASCII(string letter)
    {
        int count = 0;
        int ans = 0;
        int *diff = new int[]; //dynamic array

        for(int i=0; i<letter.length(); i++)
        {
            char x = letter[i]; //letter.at(i);

            if(i!=0){
                diff[i-1] = int(x)- int(letter[i-1]);
                count++;
            }
        }

        for(int j=0; j<count; j++){
            ans += pow(diff[j], 2.0);
        }

        cout << "#C++, " << ans << endl;
    }

    int main()
    {
        string plainText;
        cout << "Enter text: ";
        getline(cin, plainText);
        convertToASCII(plainText);
        system ("pause");
        return 0;
    }