Votre entreprise a récemment embauché un nouveau groupe d' administrateurs système extrêmement dévoués . Ils estiment que le simple fait de regarder des écrans d’ordinateur est très limitatif (je veux dire, une fréquence de rafraîchissement de 60Hz n’est PAS suffisant), ils ont donc connecté le bus de données de la CPU à un DAC et le reproduire sur un haut-parleur via la salle des serveurs afin de leur permettre de mieux entendre. à 20kHz. Un problème: ce sont des administrateurs système, pas des ingénieurs électriciens, et la configuration de leurs haut-parleurs ne cesse de se dégrader. Ils ont supposé que cela était dû à des modifications trop brutales des valeurs d'octet dans le code que les ingénieurs logiciels compilent sur le grand système. Les administrateurs système organisent maintenant un petit concours pour voir qui peut créer un code le plus doux possible pour la configuration de leurs haut-parleurs.

Défi

Votre mission est de créer un programme ou une fonction dans la langue de votre choix en laissant le moins de différences possible entre octets consécutifs (voir la section Calcul). Ce programme aura pour tâche de calculer son propre score.

Contribution

Une chaîne ASCII sur stdinou l'équivalent le plus proche de votre langue ou une entrée de fonction si vous créez une fonction. Étant donné que votre programme devra se prendre lui-même en tant qu'entrée pour calculer votre score, votre programme devrait prendre en charge Unicode s'il contient un caractère Unicode. Sinon, ASCII est suffisant. On peut supposer que la longueur d’entrée est d’au moins 2 octets.

Calcul

Chaque caractère de la chaîne sera converti en son équivalent numérique, en utilisant le standard ASCII. Ensuite, la différence entre tous les personnages sera d'abord mise au carré , puis additionnée . Par exemple, la chaîne abdobtiendra un score de 1²+2²=5.

Sortie

La sortie sera le titre de votre entrée. Cela signifie qu’il devrait être précédé d’un #ou ajouté par un retour à la ligne et d’un -(tiret). Ensuite, le nom de votre langage de programmation devrait être indiqué, suivi d'une virgule, d'un espace, puis d'un entier représentant le résultat du calcul. Par exemple

#C++, 98

serait sortie valide. La sortie doit être indiquée sur stdoutou dans votre équivalent linguistique le plus proche, ou comme valeur de retour pour votre fonction.

Notation

Votre score sera la valeur calculée par votre programme, avec le programme lui-même en entrée.

Edit: Devrait gérer les nouvelles lignes maintenant, désolé pour avant, les gens

Voici un script Pyth pour vérifier le calcul de la partition.

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

Le programme ci-dessus génère le code source réel, long de 1 179 112 octets.

Essai

À l'aide de l' interpréteur Java , le code source peut être généré et testé comme suit:

$ 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

Version alternative

Au prix de 36 points - pour un score final de 265 - nous pouvons raccourcir le code source de 99,92%:

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

Vous pouvez essayer cette version en ligne dans l' interpréteur CJam .

Idée

Nous voulons exécuter le code

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

garder le score aussi bas que possible. Pour ce faire, nous allons construire cette chaîne caractère par caractère (avec quelques no-ops avant et après) et évaluer le résultat.

Heureusement, '(littéral), ((décrémentation) et )(incrémentation) sont des caractères ASCII consécutifs. Il est donc relativement peu coûteux d’envoyer des caractères arbitraires.

• Les caractères ASCII suivants 'peuvent être insérés après '()…)(, le nombre de )dépend du point de code.

  Par exemple, +peut être poussé comme '())))(. La distance entre 'et (, et (et )est égale à 1. La fin )(s’annule; leur seule fonction est d’ouvrir la voie aux' (correspondant au caractère suivant) avec des caractères consécutifs.

  Les personnages poussés de cette manière augmenteront le score de 4 points.

• Les caractères ASCII précédents 'peuvent être poussés comme ''(…(, le nombre de (dépend du point de code.

  Par exemple, #peut être poussé comme ''((((. La distance entre 'et (est 1.

  Les personnages poussés de cette manière augmenteront le score de 2 points.

• ''(…(fonctionne réellement pour tous les caractères ASCII, puisque caractère est large de 16 bits et enroule autour. Par exemple, +peut être poussé comme '', suivi de 65 532 (s.

  Cette technique est utilisée dans la version de 1,2 Mo du code.

• Le personnage 'peut être poussé comme '', laissant le score inchangé.

Code

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`(""++)

Usage (note: "doit être échappé):

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

"#Haskell, 71742"

Je préfixe la chaîne vide ""à la chaîne d'entrée pour aider l'interpréteur Haskell à déterminer les types. Sans cela, l'inférence de type échoue, le code est trop polymorphe. Le reste fonctionne comme d’habitude: mappez chaque caractère en ascii, dressez une liste des différences entre voisins, ainsi que les noms de carré, somme et préfixe.

> <>, 30227

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

Gah, le titre a doublé mon score; dans les mots de mon propre programme, n & oooooo! Je prendrai du temps plus tard pour améliorer la situation. Je sais aussi que ce score est peut-être faux, car je ne sais pas vraiment entrer de nouvelles lignes sur l'interprète en ligne et je ne suis pas sûr qu'il existe un moyen de renseigner une pile d'entrées sur celle officielle.

Bien que non totalement optimisé, il tire pleinement parti de la proximité relative (au moins en termes de caractères ASCII) des commandes dans> <>. Je ne pouvais pas envoyer facilement la nouvelle ligne en entrée. J'ai donc utilisé l'outil de vérification du score Pyth, mais il correspond à un grand nombre de tests aléatoires que j'ai utilisés, donc tout devrait bien se passer.

En voici un avec un score de 30353 (ce qui devrait être correct puisqu'il ne s'agit que d'une ligne):

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

Java, 66465 65506 62434

Étonnamment court. Accepte un tableau de caractères au lieu d'une chaîne.

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

J'ai utilisé un programme pour générer les meilleurs noms de variables.

K5, 25478

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

Solution assez simple. C'est une fonction qui prend son entrée via une chaîne.

Hôte ISE Windows PowerShell, 62978 63894 67960 77050

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

_{Éditer - économise des points en éliminant la $Avariable et en comptant à rebours dans la chaîne, ainsi qu'en convertissant certains mots clés en CAPS}

_{Edit2 - a enregistré quelques points supplémentaires en utilisant $($HOST.NAME) au lieu dePowerShell}

_{Edit3 - a enregistré quelques points supplémentaires en échangeant les noms de variables et en modifiant la façon dont la sortie est générée.}

Utilise des variables nommées avec des nombres, car elles sont "plus proches" de $ notre pénalité.

Il est intéressant de ne pas utiliser les techniques de golf habituelles. Par exemple,|%{$ est 22534, alors que |foreach{$n’est que 8718.

Ceci est probablement proche de l'optimum sans changer de technique.

MATLAB, 19214 39748 39444 38785 37593

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

Merci à Luis Mendo pour avoir réduit davantage la différence!

Merci à NumberOne d’avoir réduit le nombre de bruit en modifiant le nom de la variable en entrée!

Comment ça marche

1. Déclare une fonction anonyme qui est stockée dans la ansvariable par défaut dans MATLAB
2. La fonction prend une chaîne stockée dans A9876543210et affiche la somme des différences carrées voisines de la chaîne.
3. difftrouve des différences voisines par paires dans un tableau et produit un tableau de length(A9876543210)-1. En utilisant diffun tableau de chaînes, cela devient castdouble tableau dans lequel les codes ASCII de chaque caractère sont générés et les différences des paires consécutives résultent en un autre tableau.
4. Pour trouver la somme des différences au carré, il suffit de prendre le produit scalaire de ce tableau de différences avec lui-même transposé. Faire diff(A9876543210)'réellement produit plus de bruit qu'avec A9876543210.'(merci Luis Mendo!)
5. Le résultat est imprimé à l'écran.

QBasic, 38140

YAY POUR 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

(Testé avec QB64 .)

C'est un programme complet qui entre la chaîne et sort la réponse. La seule limitation ici est que le programme ne peut pas prendre une entrée multiligne ( LINE INPUTpeut gérer n'importe quoi tant que c'est une seule ligne).

Désobfusqué:

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

De manière pratique, le passage d'une chaîne de plusieurs caractères à ASCdonne la valeur ASCII du premier caractère. De plus, les variables numériques sont automatiquement initialisées à zéro.

Python 2, 91026

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

Définit une fonction anonyme qui prend une chaîne et renvoie le score. Essayez-le en ligne .

La plupart de ceci est une implémentation fonctionnelle assez simple: zip Aavec A[1:]pour obtenir une liste de paires de lettres, puis soustrayez leursord s, leur carré et leur somme avec une expression génératrice.

Observez que les deux variables dans l'expression du générateur ne sont jamais suivies par les caractères suivants: ), ,, et dans l' espace. Ces trois valeurs ont des valeurs ASCII très basses, il est donc important de terminer chaque variable par un caractère de valeur ASCII aussi basse que possible. Le caractère le plus bas pouvant terminer une variable en Python est 0. De plus, chaque occasion que nous avons de scinder un grand saut en deux petits sauts fera baisser le score: A0289, mais A90seulement 145 et A987654321073!

(Cette approche n'a pas aidé la variable lambda A, probablement parce qu'elle est suivie d' [une occurrence.)

JSFuck, 144420642

Construisez-le à 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

Coller dans JSFuck.com petite boîte d'entrée de compiler à JSFuck. Le résultat est un script long de 112701 caractères, je ne peux donc pas le mettre ici. Les deux derniers caractères de ce script sont des parenthèses, insérez l’entrée entre eux.

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

Il faut presque 20 secondes au programme sur mon ordinateur pour s’évaluer.

Explication

J'ai plus de temps pour travailler dessus, alors je me suis assis et j'ai essayé d'optimiser les noms de variables. Voici les noms de variables qui valent la peine d’être utilisés, dans l’ordre de leur score.

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

Voici le code JavaScript que j'ai traduit en JSFuck:

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

J'ai examiné de plus près le traducteur de JSFuck.com et compris comment fonctionne sa fonction d'évaluation. Si "Source Eval" est coché, le code deviendra une fonction JSFuck à exécution automatique. Cependant, pour obtenir les entrées, nous devons accéder aux arguments [0] depuis la fonction. Cela porte notre code JS final à ...

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 vous vous demandez pourquoi ma version précédente avait un score inférieur à celui-ci, c'est parce que c'était un programme JSFuck qui renvoyait une chaîne qui devait être évaluée en tant que JS. C'est aussi pourquoi je ne l'ai pas laissé dans le post)

CJam, 23663 19389 11547

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

Essayez-le en ligne

On commence à penser que cela peut être poussé presque sans fin en ajoutant stratégiquement plus de personnages. Mais je pense que je commence à atteindre un point de rendements décroissants ici, alors je vais arrêter pour le moment. Par exemple, où j'aiULC;;; , je pourrais utiliser tout l’alphabet à l'envers suivi de 26; , mais les gains deviennent de plus en plus petits.

De loin, le plus grand écart qui me reste est entre le met le ,dans la chaîne initiale. Je n'ai rien trouvé de raisonnable pour m'en débarrasser. Je suis sûr qu'il y a des moyens. Mais si je le pousse à l'extrême, cela pourrait ressembler à la solution de Dennis ...

JAVASCRIPT, 33911

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

C'est de loin l'une des optimisations les plus stupides que j'ai jamais faites dans un code de golf ...

Accessoires de Neil pour la suggestion "commentaire spam" = P

JAVASCRIPT, 31520

Cette solution était nettement plus ridicule et très différente de la précédente, et j’ai estimé qu’elle méritait sa propre réponse.

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

Il s’agit de 7306 caractères, dont la plupart sont le programme réel codé dans cette chaîne 0/1, le reste servant simplement à le décoder. Cela fonctionne en obtenant l'index de chaque '1' moins l'indice du précédent '1' pour obtenir la valeur de caractère nécessaire. Il évalue ensuite la chaîne résultante dans la fonction réelle, qui est essentiellement un programme de golf standard permettant de résoudre le problème (qui ne compte que 105 caractères environ).

R, 68911 57183 53816 52224

Prend une chaîne de STDIN et la convertit en un entier via raw. Diffs, carrés et résume le vecteur résultant. Le résultat est renvoyé sous forme de chaîne. Merci à @nimi pour le nom de variable tip.

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

Mathematica, 33552

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

Ce code est évalué à une fonction non nommée, qui calcule le "bruit" d'une chaîne d'entrée. Il tire parti du fait que la représentation ASCII des données binaires est essentiellement "sans bruit". Les données binaires que vous voyez sont la chaîne

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

ce qui aurait été une réponse valable en elle-même, marquant 37848.

Tout le reste

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

décode simplement la chaîne binaire et l’interprète en tant que code Mathematica. Notez que le commentaire vide de Mathematica (**)est très "peu bruyant" et supprime réellement le bruit du "s.

Java8: 117170 100508 99062 98890

Avec l'aide de l'expression lambada et l'affectation en ligne d'une variable, vous pouvez raccourcir un peu ce code.

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, 129 300 128 400 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;}

Ce défi m'a en fait amené à approfondir la réflexion sur l'utilisation et l'optimisation des personnages plutôt que sur la recherche de la solution la plus courte. Je vais continuer à travailler pour réduire le nombre.

C'est une fonction lambda, Bla chaîne représentant la fonction. N'oubliez pas d'échapper à la citation ( ") lorsque vous transmettez ceci sous forme de chaîne.

Pyth, 16391

++C38828542027820dsm^-ChdCed2,Vztz

Le seul truc à noter utilisé ici est le codage en base 256 #Pyth,, qui coûte beaucoup moins cher que la chaîne elle-même.

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

Pour utiliser cela, nous devons échapper les guillemets et "échapper" les caractères d'espaces (qui sont significatifs dans MUMPS!) Comme ceci:

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

Notez que "M" est un nom alternatif pour "MUMPS" - il existe un désaccord parmi les praticiens à propos de celui qui est correct. Naturellement, j'ai choisi l'option plus courte ici.

Ruby, 118402

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

Il lit dans un fichier via la ligne de commande, telle que ruby diff.rb /path/to/file. Il y a place à l'amélioration, et c'est un sujet sur lequel je travaille actuellement.

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

Je vais essayer de réduire cela un peu plus.

Il s'avère que les accolades ( {et les }ASCII 123 et 125) et le trait de soulignement ( _, ASCII 95) sont très coûteux, car tous les autres caractères se situent autour de 30 à 70, c'est pourquoi j'ai formaté ifla manière que j'ai faite, et pourquoi j'utilise$AAAAA plutôt que le bien-aimé de Perl $_.

Malheureusement, toutes les variables contenant des symboles sont en lecture seule. Je ne peux donc pas tirer parti des combinaisons telles que $#et $$.

F #, 136718 130303

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

Où il y a un \naprès le ;.

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

dommage que je ne puisse pas obtenir le même résultat que le vérificateur Pyth (178386) ...

Lua, 171078 117896

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)

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

une macro C ++ qui prend une chaîne de caractères et écrit le résultat dans la sortie standard

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

Essayez-le en ligne!

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