La tua azienda ha recentemente assunto un nuovo gruppo di amministratori di sistema estremamente dedicati . Pensano che il solo guardare gli schermi dei computer sia piuttosto limitante (voglio dire, la frequenza di aggiornamento a 60Hz non è abbastanza), quindi hanno collegato il bus dati della CPU a un DAC e lo hanno riprodotto su un altoparlante attraverso la stanza del server in modo che possano ascoltare a 20kHz. Un problema: sono amministratori di sistema, non ingegneri elettrici, e la loro configurazione degli altoparlanti continua a rompersi. Hanno pensato che ciò fosse causato da cambiamenti troppo bruschi nei valori di byte nel codice che gli ingegneri del software compilano sul mainframe. Gli amministratori di sistema ospitano ora una piccola competizione per vedere chi può creare il codice più delicato per la configurazione dei loro altoparlanti.

Sfida

La tua missione è quella di creare un programma o una funzione in una lingua di scelta che abbia la minima differenza possibile tra byte consecutivi (vedi la sezione Calcolo). Questo programma avrà il compito di calcolare il proprio punteggio.

Ingresso

Una stringa ASCII su stdino l'equivalente più vicino della tua lingua o come input di funzione se stai creando una funzione. Dal momento che il tuo programma dovrà prendere se stesso come input per calcolare il tuo punteggio, il tuo programma dovrebbe supportare Unicode se contiene Unicode. Altrimenti, ASCII è sufficiente. Si può presumere che l'input sia lungo almeno 2 byte.

Calcolo

Ogni carattere della stringa verrà convertito nel suo equivalente numerico, usando lo standard ASCII. Quindi, la differenza tra tutti i personaggi verrà prima quadrata e quindi sommata . Ad esempio, la stringa abdotterrà un punteggio di 1²+2²=5.

Produzione

L'output sarà il titolo della voce. Ciò significa che dovrebbe essere anteposto da a #o aggiunto da una nuova riga e un -(trattino). Quindi, dovrebbe generare il nome del tuo linguaggio di programmazione, seguito da una virgola, uno spazio e quindi un numero intero che rappresenta il risultato del calcolo. Per esempio

#C++, 98

sarebbe un output valido. L'output deve essere fornito stdouto l'equivalente più vicino alla tua lingua o come valore di ritorno alla tua funzione.

punteggio

Il tuo punteggio sarà il valore calcolato dal tuo programma, con il programma stesso come input.

Modifica: ora dovrebbe gestire le nuove righe, scusatemi prima, gente

Ecco uno script Pyth per verificare il calcolo del punteggio.

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

Il programma precedente genera il codice sorgente effettivo, che è lungo 1.179.112 byte.

analisi

Utilizzando l' interprete Java , il codice sorgente può essere generato e testato in questo modo:

$ 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

Versione alternativa

Al costo di 36 punti - per un punteggio finale di 265 - possiamo ridurre il codice sorgente del 99,92%:

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

Puoi provare questa versione online nell'interprete CJam .

Idea

Vogliamo eseguire il codice

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

mantenendo il punteggio più basso possibile. Per raggiungere questo obiettivo, costruiremo quella stringa carattere per carattere (con qualche no-op prima e dopo) e valuteremo il risultato.

Fortunatamente, '(carattere letterale push), ((decremento) e )(incremento) sono caratteri ASCII consecutivi, quindi spingere caratteri arbitrari è relativamente poco costoso.

• I caratteri ASCII successivi 'possono essere inseriti come '()…)(, dove il numero di )dipende dal punto di codice.

  Ad esempio, +può essere spinto come '())))(. La distanza tra 'e (, e (ed )è 1. I finali si )(annullano a vicenda; la loro unica funzione è di aprire la strada al seguente '(corrispondente al personaggio successivo) con caratteri consecutivi.

  I personaggi spinti in questo modo aumenteranno il punteggio di 4 punti.

• I caratteri ASCII precedenti 'possono essere inseriti come ''(…(, dove il numero di (dipende dal punto di codice.

  Ad esempio, #può essere spinto come ''((((. La distanza tra 'e (è 1.

  I personaggi spinti in questo modo aumenteranno il punteggio di 2 punti.

• ''(…(funziona effettivamente per tutti i caratteri ASCII, poiché Character è largo 16 bit e si avvolge. Ad esempio, +può essere premuto come '', seguito da 65.532 (s.

  Questa tecnica è utilizzata nella versione da 1,2 megabyte del codice.

• Il personaggio 'può essere spinto come '', lasciando il punteggio inalterato.

Codice

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, 152.827 95742 91196 83921 77447 71742

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

Utilizzo (nota: "deve essere evitato):

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

"#Haskell, 71742"

Anticipo la stringa vuota ""alla stringa di input per aiutare l'interprete di Haskell a capire i tipi. Senza di essa l'inferenza di tipo non riesce, il codice è troppo polimorfico. Il resto è come al solito: mappare ogni personaggio su ascii, fare un elenco delle differenze del vicino, quadrare, sommare e anteporre il nome della lingua.

> <>, 30227

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

Gah, il titolo ha raddoppiato il mio punteggio; nelle parole del mio programma, n & oooooo! Ci vorrà un po 'di tempo dopo per renderlo migliore. So anche che questo punteggio potrebbe essere fuori dal momento che non posso davvero inserire nuove righe nell'interprete online e non sono sicuro che ci sia un modo per popolare uno stack di input su quello ufficiale.

Non completamente ottimizzato, ma sfrutta appieno la vicinanza relativa (almeno in termini di caratteri ASCII) dei comandi in> <>. Non ho potuto inviare facilmente la nuova riga come input, quindi ho usato il controllo del punteggio Pyth, ma corrisponde a un sacco di casi di test casuali che ho usato, quindi dovrebbe andare bene al riguardo.

Eccone uno con un punteggio di 30353 (che dovrebbe essere corretto dato che è una riga):

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

Java, 66465 65506 62434

Sorprendentemente breve. Accetta un array di caratteri anziché una stringa.

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

Ho usato un programma per generare i migliori nomi di variabili.

K5, 25478

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

Soluzione abbastanza semplice. Questa è una funzione che accetta il suo input tramite una stringa.

Host ISE di Windows PowerShell, 62978 63894 67960 77050

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

_{Modifica: consente di salvare alcuni punti eliminando la $Avariabile e contando invece all'indietro attraverso la stringa e convertendo alcune parole chiave in MAIUSCOLO}

_{Modifica2 - salvato altri punti usando $($HOST.NAME)invece diPowerShell}

_{Modifica3: ha salvato alcuni altri punti scambiando i nomi delle variabili e modificato la modalità di generazione dell'output.}

Utilizza le variabili denominate con i numeri, in quanto sono "più vicine", $quindi la nostra penalità è inferiore.

È interessante non utilizzare le normali tecniche di golf. Ad esempio, |%{$è 22534, mentre |foreach{$è solo 8718.

Questo è probabilmente vicino all'ottimale senza cambiare tecnica.

MATLAB, 19214 39748 39444 38785 37593

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

Grazie a Luis Mendo per aver ridotto ulteriormente il conteggio delle differenze!

Grazie a NumberOne per ridurre il conteggio del rumore modificando il nome della variabile di input!

Come funziona

1. Dichiara una funzione anonima archiviata nella ansvariabile predefinita in MATLAB
2. La funzione accetta una stringa memorizzata A9876543210e stampa la somma delle differenze quadrate adiacenti della stringa.
3. difftrova le differenze vicine a coppie in un array e produce un array di length(A9876543210)-1. Usando diffun array di stringhe, questo viene castato su un doublearray in cui vengono generati i codici ASCII di ciascun carattere e le differenze delle coppie consecutive si traducono in un altro array.
4. Per trovare la somma delle differenze al quadrato, prendi semplicemente il prodotto punto di questo array di differenze con se stesso trasposto. Fare diff(A9876543210)'effettivamente ha prodotto più rumore rispetto a A9876543210.'(grazie Luis Mendo!)
5. Il risultato viene stampato sullo schermo.

QBasic, 38140

YAY PER LA SINTASSI GRAZIE

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

(Testato con QB64 .)

Questo è un programma completo che inserisce la stringa e genera la risposta. L'unica limitazione qui è che il programma non può accettare input multilinea (LINE INPUT può gestire qualsiasi cosa purché sia ​​una singola riga).

Deobfuscated:

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, passare una stringa di più caratteri per ASCdare il valore ASCII del primo carattere. Inoltre, le variabili numeriche vengono inizializzate automaticamente su zero.

Python 2, 91026

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

Definisce una funzione anonima che accetta una stringa e restituisce il punteggio. Provalo online .

La maggior parte di questa è un'implementazione funzionale piuttosto semplice: comprimere Acon A[1:]per ottenere un elenco di coppie di lettere, quindi sottrarre la loro ords, il quadrato e la somma con un'espressione del generatore.

Osservare che le due variabili all'interno dell'espressione del generatore sono sempre e solo seguite dai seguenti caratteri: ) , ,e lo spazio. Tutti e tre questi hanno valori ASCII molto bassi, quindi è opportuno terminare ogni variabile con un carattere con il valore ASCII più basso possibile. Il carattere più basso che può terminare una variabile in Python è 0. Inoltre, ogni opportunità che abbiamo di dividere un singolo grande salto in due piccoli salti abbasserà il punteggio: A0costa 289, ma A90è solo 145 ed A9876543210è irrisorio 73.

(Questo approccio non ha aiutato la variabile lambda A, probabilmente perché è seguita da [una ricorrenza).

JSFuck, 144420642

Costruiscilo da:

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

Incollalo nella piccola casella di input di JSFuck.com per compilarlo in JSFuck. Il risultato è uno script lungo 112701 caratteri, quindi non posso inserirlo qui. Gli ultimi due caratteri di questo script sono tra parentesi, inserisci l'input tra di loro.

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

Il programma richiede quasi 20 secondi sul mio computer per valutarsi.

Spiegazione

Ho avuto più tempo per lavorare su questo, quindi mi sono seduto e ho cercato di ottimizzare i nomi delle variabili. Ecco i nomi delle variabili che vale la pena usare, in ordine di punteggio.

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

Ecco il JavaScript che ho tradotto in JSFuck:

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

Ho dato un'occhiata più da vicino al traduttore di JSFuck.com e ho scoperto come funziona la sua funzione di valutazione. Con "Eval source" selezionato, il codice diventerà una funzione JSFuck auto-eseguibile. Per ottenere l'input, tuttavia, dobbiamo accedere agli argomenti [0] dall'interno della funzione. Questo porta il nostro codice JS finale 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

(Se ti stai chiedendo perché la mia versione precedente avesse un punteggio inferiore a questo, è perché era un programma JSFuck che ha restituito una stringa che doveva essere valutata come JS. Questo è anche il motivo per cui non l'ho lasciato nel post)

CJam, 23663 19389 11547

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

Provalo online

Sta iniziando a sembrare che questo possa essere spinto quasi all'infinito aggiungendo strategicamente più personaggi. Ma penso che sto iniziando a raggiungere un punto di rendimenti decrescenti qui, quindi mi fermerò per ora. Ad esempio, dove ho ULC;;;, potrei usare l'intero alfabeto al contrario seguito da 26; , ma i guadagni diventano sempre più piccoli.

Di gran lunga il divario più grande che ho lasciato è tra il me il, stringa iniziale. Non ho trovato nulla di ragionevole per liberarmene. Sono sicuro che ci sono modi. Ma se lo spingo al limite, potrebbe iniziare a sembrare la soluzione di Dennis ...

JAVASCRIPT, 33911

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

Questa è di gran lunga una delle ottimizzazioni più stupide che io abbia mai fatto in un golf da codice ...

Propone a Neil per il suggerimento "comment spam" = P

JAVASCRIPT, 31520

Questa soluzione era significativamente più ridicola, molto diversa dalla mia, e quindi mi sentivo meritata la sua risposta.

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

Sono 7306 caratteri, la maggior parte dei quali è il vero programma codificato in quella stringa 0/1, e il resto semplicemente per decodificarlo. Funziona ottenendo l'indice di ogni '1' meno l'indice del precedente '1' per ottenere il valore di carattere necessario. Quindi valuta la stringa risultante nella funzione effettiva, che è essenzialmente un programma di golf standard per risolvere il problema (che è solo circa 105 caratteri).

R, 68911 57183 53816 52224

Prende una stringa da STDIN e la converte in un numero intero tramite raw. Diffonde, quadra e somma il vettore risultante. Il risultato viene restituito come stringa. Grazie a @nimi per la punta del nome della variabile.

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

Mathematica, 33552

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

Questo codice restituisce una funzione senza nome, che calcola il "rumore" di una stringa di input. Si avvale del fatto che la rappresentazione ASCII dei dati binari è essenzialmente "silenziosa". I dati binari che vedi sono la stringa

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

che sarebbe stata una risposta valida da sola, segnando 37848.

Tutto il resto

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

decodifica semplicemente la stringa binaria e la interpreta come codice Mathematica. Nota che il commento vuoto di Mathematica (**)è molto "a basso rumore" e rimuove effettivamente il rumore dalla "s.

Java8: 117170 100508 99062 98890

Con l'aiuto dell'espressione lambada e l'assegnazione in linea della variabile è possibile abbreviare un po 'questo codice.

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

Questa sfida mi ha portato a pensare più a fondo ai personaggi da usare e all'ottimizzazione più che a trovare la soluzione più breve. Continuerò a lavorare per ridurre il numero.

Questa è una funzione lambda, Bessendo la stringa che rappresenta la funzione. Non dimenticare di sfuggire alle virgolette ( ") quando lo passi come una stringa.

Pyth, 16391

++C38828542027820dsm^-ChdCed2,Vztz

L'unico accorgimento usato qui è la codifica base-256 #Pyth,, che costa molto meno della stringa stessa.

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

Per usare questo, dobbiamo sfuggire alle virgolette e "sfuggire" ai caratteri degli spazi bianchi (che sono significativi in ​​MUMPS!) In questo modo:

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

Nota che "M" è un nome alternativo per "MUMPS" - c'è disaccordo tra i professionisti su quale sia corretta. Naturalmente, ho scelto l'opzione più breve qui.

Rubino, 118402

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

Legge in un file tramite riga di comando, ad esempio ruby diff.rb /path/to/file. C'è spazio per migliorare, ed è qualcosa su cui sto lavorando in questo 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

Proverò a ridurlo ancora un po '.

Si scopre che le parentesi graffe ({ e }, ASCII 123 e 125) e il carattere di sottolineatura ( _, ASCII 95) sono molto costosi poiché tutti gli altri caratteri sono compresi nell'intervallo 30-70, motivo per cui ho formattato ifcome ho fatto, e perché sto usando al $AAAAAposto dell'amato Perl $_.

Purtroppo, tutte le variabili con simboli sono di sola lettura, quindi non posso sfruttare combinazioni come $# e $$.

F #, 136718 130303

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

Dove c'è un \ndopo il ;.

Shell POSIX, 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";}

peccato che non riesco a ottenere lo stesso risultato del controllo Pyth (178386) ...

Lua, 171078 117896

golfed:

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

una macro C ++ che accetta una stringa C e scrive il risultato nell'output standard

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

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