Ultimamente, sua empresa contratou um novo grupo de administradores de sistemas extremamente dedicados . Eles acham que apenas observar as telas dos computadores é bastante limitante (quero dizer, a taxa de atualização de 60Hz simplesmente NÃO é suficiente), então conectaram o barramento de dados da CPU a um DAC e o reproduziram em um alto-falante na sala do servidor para que pudessem ouvir. a 20kHz. Um problema: eles são administradores de sistemas, não engenheiros elétricos, e a configuração dos alto-falantes continua quebrando. Eles concluíram que isso é causado por alterações muito abruptas nos valores de bytes no código que os engenheiros de software compilam no mainframe. Os administradores do sistema agora estão organizando uma pequena competição para ver quem pode criar um código que seja o mais gentil para a configuração dos alto-falantes.

Desafio

Sua missão é criar um programa ou função em um idioma de escolha que tenha a menor diferença possível entre bytes consecutivos (consulte a seção Cálculo). Este programa terá a tarefa de calcular sua própria pontuação.

Entrada

Uma sequência ASCII no stdinequivalente mais próximo do seu idioma ou como entrada de função se você estiver criando uma função. Como o seu programa terá que ser usado como entrada para calcular sua pontuação, ele deverá oferecer suporte ao Unicode se ele contiver algum Unicode. Caso contrário, o ASCII é suficiente. A entrada pode ser assumida como sendo pelo menos 2 bytes.

Cálculo

Cada caractere da string será convertido em seu equivalente numérico, usando o padrão ASCII. Em seguida, a diferença entre todos os caracteres será quadrada e depois somada . Por exemplo, a sequência abdreceberá uma pontuação de 1²+2²=5.

Saída

Saída será o título da sua entrada. Isso significa que ele deve ser anexado por uma #ou anexado por uma nova linha e um -(traço). Em seguida, ele deve exibir o nome da sua linguagem de programação, seguida por vírgula, espaço e depois um número inteiro representando o resultado do cálculo. Por exemplo

#C++, 98

seria uma saída válida. A saída deve ser fornecida no stdoutequivalente mais próximo do seu idioma ou como um valor de retorno para sua função.

Pontuação

Sua pontuação será o valor calculado pelo seu programa, com o próprio programa como entrada.

Edit: Deve lidar com novas linhas agora, desculpe-me antes, pessoal

Aqui está um script Pyth para verificar o cálculo da pontuação.

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{}~~~"

O programa acima gera o código-fonte real, com 1.179.112 bytes de comprimento.

Teste

Usando o interpretador Java , o código-fonte pode ser gerado e testado da seguinte forma:

$ 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

Versão alternativa

Ao custo de 36 pontos - para uma pontuação final de 265 -, podemos tornar o código fonte 99,92% mais curto:

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

Você pode experimentar esta versão online no intérprete CJam .

Idéia

Queremos executar o código

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

mantendo a pontuação o mais baixa possível. Para conseguir isso, vamos construir essa sequência de caracteres por caractere (com algumas no-ops antes e depois) e avaliar o resultado.

Felizmente, '(caractere push literal), ((decremento) e )(incremento) são caracteres ASCII consecutivos, portanto, empurrar caracteres arbitrários é relativamente barato.

• Os caracteres ASCII posteriores 'podem ser pressionados como '()…)(, onde o número de )depende do ponto de código.

  Por exemplo, +pode ser pressionado como '())))(. A distância entre 'e (, e (e )é 1. O final se )(cancela; sua única função é pavimentar o caminho para o seguinte '(correspondente ao próximo caractere) com caracteres consecutivos.

  Personagens pressionados dessa maneira aumentarão a pontuação em 4 pontos.

• Os caracteres ASCII anteriores 'podem ser pressionados como ''(…(, onde o número de (depende do ponto de código.

  Por exemplo, #pode ser pressionado como ''((((. A distância entre 'e (é 1.

  Personagens pressionados dessa maneira aumentam a pontuação em 2 pontos.

• ''(…(realmente funciona para todos os caracteres ASCII, já que Character tem 16 bits de largura e envolve. Por exemplo, +pode ser pressionado como '', seguido por 65.532 (s.

  Essa técnica é usada na versão de 1,2 megabyte do código.

• O personagem 'pode ser pressionado como '', deixando a pontuação inalterada.

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: "deve ser evitado):

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

"#Haskell, 71742"

Anexo a sequência vazia ""à sequência de entrada para ajudar o intérprete Haskell a descobrir os tipos. Sem que a inferência de tipo falhe, o código é muito polimórfico. O resto é normal: mapeie cada caractere para ascii, faça uma lista de diferenças de vizinhos, quadrado, soma e nome do idioma.

> <>, 30227

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

Gah, o título dobrou minha pontuação; nas palavras do meu próprio programa, n & oooooo! Levarei algum tempo depois para melhorar isso. Também sei que essa pontuação pode estar baixa, pois não consigo inserir novas linhas no intérprete on-line e não tenho certeza de que haja uma maneira de preencher uma pilha de entrada na oficial.

De maneira alguma completamente otimizado, mas aproveita ao máximo a proximidade relativa (pelo menos em termos de caracteres ASCII) dos comandos em> <>. Como não consegui enviar facilmente a nova linha como entrada, usei o verificador de pontuação Pyth, mas ele corresponde a vários casos de teste aleatórios que usei, por isso deve ficar bem com isso.

Aqui está um com uma pontuação de 30353 (que deve estar correto, pois é uma linha):

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

Java, 66465 65506 62434

Surpreendentemente curto. Aceita uma matriz de caracteres em vez de uma sequência.

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

Eu usei um programa para gerar os melhores nomes de variáveis.

K5, 25478

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

Solução bastante simples. Esta é uma função que recebe sua entrada por meio de uma string.

Windows PowerShell ISE anfitrião, 62,978 63894 67960 77050

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

_{Editar - salvou alguns pontos, livrando-se da $Avariável e, em vez disso, contando ao longo da string e também convertendo algumas palavras-chave em CAPS}

_{Edit2 - salvou mais alguns pontos usando em $($HOST.NAME)vez dePowerShell}

_{Edit3 - economizou mais alguns pontos trocando nomes de variáveis ​​e alterando como a saída é gerada.}

Usa variáveis ​​nomeadas com números, pois elas estão "mais próximas", $portanto nossa penalidade é menor.

É interessante não usar técnicas regulares de golfe. Por exemplo, |%{$é 22534, enquanto |foreach{$é apenas 8718.

Provavelmente, isso está próximo do ideal sem alterar as técnicas.

MATLAB, 19214 39748 39444 38785 37593

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

Obrigado a Luis Mendo por reduzir ainda mais a diferença!

Obrigado ao NumberOne por reduzir a contagem de ruídos alterando o nome da variável de entrada!

Como isso funciona

1. Declara uma função anônima que é armazenada na ansvariável padrão no MATLAB
2. A função recebe uma sequência armazenada A9876543210e imprime a soma das diferenças quadráticas vizinhas da sequência.
3. difflocaliza diferenças vizinhas aos pares em uma matriz e produz uma matriz de length(A9876543210)-1. Ao usar diffem uma matriz de strings, isso é convertido em uma doublematriz em que os códigos ASCII de cada caractere são gerados e as diferenças dos pares consecutivos resultam em outra matriz.
4. Para encontrar a soma das diferenças ao quadrado, basta pegar o produto escalar dessa matriz de diferenças transposto. Fazer diff(A9876543210)'realmente produziu mais barulho do que com A9876543210.'(obrigado Luis Mendo!)
5. O resultado é impresso na tela.

QBasic, 38140

YAY PARA SHOUTY SYNTAX

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

(Testado com QB64 .)

Este é um programa completo que insere a string e gera a resposta. A única limitação aqui é que o programa não pode receber entrada de várias LINE INPUTlinhas ( pode lidar com qualquer coisa, desde que seja uma única linha).

Desofuscada:

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, passar uma sequência de vários caracteres para ASCfornecer o valor ASCII do primeiro caractere. Também convenientemente, variáveis ​​numéricas são inicializadas automaticamente para zero.

Python 2, 91026

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

Define uma função anônima que pega uma string e retorna a pontuação. Experimente online .

A maior parte disso é uma implementação funcional bastante direta: zip Acom A[1:]para obter uma lista de pares de letras e subtrair ords, quadrado e soma com uma expressão geradora.

Observe que as duas variáveis dentro do gerador de expressão são sempre apenas seguido pelos seguintes caracteres: ), ,, e no espaço. Todos os três têm valores ASCII muito baixos, portanto, devemos terminar cada variável com um caractere com o menor valor ASCII possível. O caractere mais baixo que pode terminar uma variável em Python é 0. Além disso, todas as oportunidades que temos para dividir um único salto grande em dois saltos menores diminuirão a pontuação: A0custa 289, mas A90é apenas 145 e A9876543210é insignificante 73.

(Essa abordagem não ajudou a variável lambda A, provavelmente porque é seguida por [uma ocorrência.)

JSFuck, 144420642

Crie a partir de:

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

Cole isto em JSFuck.com caixa de entrada pequeno 's para compilá-lo para JSFuck. O resultado é um script com 112701 caracteres, então não posso colocá-lo aqui. Os dois últimos caracteres deste script são parênteses, coloque a entrada entre eles.

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

O programa leva quase 20 segundos no meu computador para se avaliar.

Explicação

Eu tenho mais tempo para trabalhar nisso, então me sentei e tentei otimizar os nomes das variáveis. Aqui estão os nomes das variáveis ​​que vale a pena usar, em ordem de pontuação.

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

Aqui está o JavaScript que eu traduzi para o JSFuck:

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

Dei uma olhada mais de perto no tradutor do JSFuck.com e descobri como sua função de avaliação funciona. Com a opção "Eval source" marcada, o código se tornará uma função JSFuck de execução automática. Para obter a entrada, no entanto, precisamos acessar argumentos [0] de dentro da função. Isso traz nosso código JS final para ...

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

(Se você está se perguntando por que minha versão anterior teve uma pontuação menor que essa, é porque foi um programa JSFuck que retornou uma string que precisava ser avaliada como JS. É também por isso que não a deixei no post)

CJam, 23663 19389 11547

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

Experimente online

Está começando a parecer que isso pode ser empurrado quase infinitamente, adicionando estrategicamente mais personagens. Mas acho que estou começando a chegar a um ponto de retornos decrescentes aqui, então vou parar por agora. Por exemplo, onde eu tenho ULC;;;, eu poderia usar o alfabeto inteiro para trás, seguido de 26 ;, mas os ganhos ficam cada vez menores.

De longe, a maior diferença que me resta é entre o me o ,na string inicial. Não encontrei nada razoável para me livrar dele. Tenho certeza que existem maneiras. Mas se eu empurrar para o limite, pode começar a parecer a solução de Dennis ...

JAVASCRIPT, 33911

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

Essa é de longe uma das otimizações mais bobas que já fiz em um código de golfe ...

Adereços para Neil para a sugestão "comentar spam" = P

JAVASCRIPT, 31520

Essa solução era significativamente mais ridícula e muito diferente da minha outra, então eu senti que merecia sua própria resposta.

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

São 7306 caracteres, a maioria dos quais é o programa real codificado nessa sequência 0/1 e o restante simplesmente para decodificá-la. Ele funciona obtendo o índice de cada '1' menos o índice do '1' anterior para obter o valor de caractere necessário. Em seguida, avalia a sequência resultante para a função real, que é essencialmente um programa de golfe padrão para resolver o problema (que possui apenas cerca de 105 caracteres).

R, 68911 57183 53816 52224

Pega uma string de STDIN e a converte em um número inteiro via raw. Difere, quadratura e soma o vetor resultante. O resultado é retornado como uma sequência. Obrigado a @nimi pela dica de nome da variável.

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

Mathematica, 33552

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

Esse código é avaliado como uma função sem nome, que calcula o "ruído" de uma sequência de entrada. Ele faz uso do fato de que a representação ASCII de dados binários é essencialmente "silenciosa". Os dados binários que você vê são a sequência

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

que teria sido uma resposta válida por si só, marcando 37848.

Todo o resto

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

apenas decodifica a string binária e a interpreta como código do Mathematica. Observe que o comentário vazio do Mathematica (**)é muito "silencioso" e, na verdade, remove o ruído do "s.

Java8: 117170 100508 99062 98890

Com a ajuda da expressão lambada e a atribuição inline de variável, é possível encurtar um pouco esse 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;}

Na verdade, esse desafio me fez pensar mais profundamente sobre os personagens a serem usados ​​e otimizados do que encontrar a solução mais curta. Vou continuar trabalhando para diminuir o número.

Esta é uma função lambda, Bsendo a sequência que representa a função. Não se esqueça de escapar das aspas ( ") ao passar isso como uma string.

Pyth, 16391

++C38828542027820dsm^-ChdCed2,Vztz

O único truque de observação usado aqui é a codificação de base 256 #Pyth,, que custa muito menos do que a própria string.

++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 isso, precisamos escapar de aspas e caracteres de espaço em branco "escape" (que são significativos em MUMPS!) Da seguinte maneira:

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

Observe que "M" é um nome alternativo para "MUMPS" - há discordância entre os profissionais sobre qual deles está correto. Naturalmente, eu escolhi a opção mais curta aqui.

Ruby, 118402

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

Ele lê um arquivo através da linha de comando, como ruby diff.rb /path/to/file. Há espaço para melhorar, e é nisso que estou trabalhando agora.

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

Vou tentar reduzir isso um pouco mais.

Acontece que os chavetas ( {e }ASCII 123 e 125) e o sublinhado ( _ASCII 95) são muito caros, já que todos os outros caracteres estão na faixa de 30 a 70, e é por isso que formatei ifda maneira que fiz e por que estou usando, em $AAAAAvez da amada de Perl $_.

Infelizmente, todas as variáveis ​​com símbolos são somente leitura, então não posso tirar proveito de combinações como $#e $$.

F #, 136718 130303

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

Onde há um \napós o ;.

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";}

pena que não consigo obter o mesmo resultado que o verificador Pyth (178386) ...

Lua, 171078 117896

Golfe:

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)

Ungolfed:

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

uma macro C ++ que pega uma string c e grava o resultado na saída padrão

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

Experimente online!

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