Your company lately hired a new bunch of extremely dedicated sysadmins. They feel that just watching computer screens is quite limiting (I mean, 60Hz refresh rate is just NOT enough), so they hooked up the CPU data bus to an DAC and play that on a speaker through the server room so that they can hear up to 20kHz. One problem: they're sysadmins, not electrical engineers, and their speaker setup keeps breaking. They figured that this is caused by too abrupt changes in byte values in the code that the software engineers compile on the mainframe. The sysadmins are now hosting a little competition to see who can make code that is the most gentle to their speaker setup.


Your mission is to create a program or function in a language of choice that has as little difference as possible between consecutive bytes (see the Calculation section). This program will have the task of calculating its own score.


An ASCII string on stdin or your language's closest equivalent, or as a function input if you're creating a function. Since your program will have to take itself as input to calculate your score, your program should support Unicode if it contains any Unicode. Otherwise, ASCII is sufficient. Input can be assumed to be at least 2 bytes long.


Each character of the string will be converted to it's numerical equivalent, using the ASCII standard. Then, the difference between all characters will first be squared and then summed. For example, the string abd will get a score of 1²+2²=5.


Output will be the title to your entry. This means that it should be prepended by a # or appended by a newline and a - (dash). Then, it should output the name of your programming language, followed by a comma, a space and then an integer representing the result of the calculation. For example

#C++, 98

would be valid output. Output should be given on stdout or your language closest equivalent, or as a return value to your function.


Your score will be the calculated value by your program, with the program itself as input.

Edit: Should handle newlines now, sorry for before, folks

Here is a Pyth script to verify the score calculation.

  • 1
    \$\begingroup\$ Will the program have to interpret anything other than its own code? And just to clarify, two consecutive equal characters are a value of 0? \$\endgroup\$
    – Daniel M.
    Commented Sep 29, 2015 at 19:01
  • 10
    \$\begingroup\$ uh. \$\endgroup\$
    – bopjesvla
    Commented Sep 29, 2015 at 19:08
  • 1
    \$\begingroup\$ @bopjesvla Fine. Arbitrary strings, but you may assume them to be able to fit in the universe. Or on your computer, for that matter. \$\endgroup\$
    – Sanchises
    Commented Sep 29, 2015 at 19:14
  • 11
    \$\begingroup\$ First person to create a valid answer in Unary wins! \$\endgroup\$ Commented Sep 29, 2015 at 19:24
  • 3
    \$\begingroup\$ Too late now, but one option to prevent Unary-style answers would have been to define the difference between equal characters as 1. Also would have made the logic slightly more interesting. \$\endgroup\$ Commented Sep 29, 2015 at 23:46

26 Answers 26


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

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

The above program generates the actual source code, which is 1,179,112 bytes long.


Using the Java interpreter, the source code can be generated and tested like this:

$ 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

Alternate version

At the cost of 36 points – for a final score of 265 – we can make the source code 99.92% shorter:


You can try this version online in the CJam interpreter.


We want to execute the code

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

keeping the score as low as possible. To achieve this, we're going to build that string character by character (with a few no-ops before and after) and evaluate the result.

Fortunately, ' (push character literal), ( (decrement) and ) (increment) are consecutive ASCII characters, so pushing arbitrary characters is relatively inexpensive.

  • ASCII characters after ' can be pushed as '()…)(, where the number of ) depends on the code point.

    For example, + can be pushed as '())))(. The distance between ' and (, and ( and ) is 1. The trailing )( cancel each other; their only function is to pave the way for the following ' (corresponding to the next character) with consecutive characters.

    Characters pushed in this fashion will raise the score by 4 points.

  • ASCII characters before ' can be pushed as ''(…(, where the number of ( depends on the code point.

    For example, # can be pushed as ''((((. The distance between ' and ( is 1.

    Characters pushed in this fashion will raise the score by 2 points.

  • ''(…( actually works for all ASCII characters, since Character is 16 bits wide and wraps around. For example, + can be pushed as '', followed by 65,532 (s.

    This technique is used in the 1.2 megabyte version of the code.

  • The character ' can be pushed as '', leaving the score unaffected.


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# 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.
  • 7
    \$\begingroup\$ ........... wat \$\endgroup\$
    – DLosc
    Commented Sep 30, 2015 at 2:36
  • \$\begingroup\$ It almost looks like this language was built for this exact challenge. Nice! \$\endgroup\$
    – Domino
    Commented Sep 30, 2015 at 4:10
  • 3
    \$\begingroup\$ Damn. I thought I finally made a challenge that would put CJam at a disadvantage since it's often a mix of 'early' symbols and 'late' letters. But nooooo, you show up and ruin it again... Cheers! \$\endgroup\$
    – Sanchises
    Commented Sep 30, 2015 at 6:54

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: " has to be escaped):

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

"#Haskell, 71742"

I prepend the empty string "" to the input string to help the Haskell interpreter figuring out the types. Without it type inference fails, the code is too polymorphic. The rest is business as usual: map each character to ascii, make a list of neighbor differences, square, sum and prepend language name.


><>, 30227

'#><>, '<;n&oooooo

Gah, the title doubled my score; in the words of my own program, n&oooooo! I'll take some time later to make this better. I also know that this score may be off since I can't really enter newlines on the online interpreter and I'm not sure there's a way to populate an input stack on the official one.

By no means completely optimized, but takes full some advantage of the relative proximity (at least in terms of ASCII characters) of the commands in ><>. I couldn't easily submit the newline as input, so I used the Pyth score checker, but it matches for a bunch of random test cases I used so it should be fine with regards to that.

Here's one with a score of 30353 (which ought to be correct since it's one line):

0&l1=66+*77++0.$:@-:*&+&10.' ,><>#'oooooo&n;
  • \$\begingroup\$ Nice, a competitive entry in ><>! \$\endgroup\$
    – Sanchises
    Commented Sep 30, 2015 at 7:02

Java, 66465 65506 62434

Surprisingly short. Accepts a char array instead of a string.

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

I used a program to generate the best variable names.

  • \$\begingroup\$ How would you use this in a program? (I'm not entirely familiar with java 8 features yet) \$\endgroup\$ Commented Oct 10, 2015 at 15:38
  • \$\begingroup\$ @aditsu ideone.com/0yy6id \$\endgroup\$ Commented Oct 11, 2015 at 6:14
  • \$\begingroup\$ Oh, so you have to define a target functional interface for it... not exactly a first-class object. \$\endgroup\$ Commented Oct 11, 2015 at 8:45
  • \$\begingroup\$ @aditsu You could also use Function<char[],String> if you wanted. \$\endgroup\$ Commented Oct 11, 2015 at 14:24
  • \$\begingroup\$ Oh I see… ((Function<char[],String>) ABCD->{…}).apply(…), thanks. These lambdas seem to be quite incomplete without the type context. \$\endgroup\$ Commented Oct 11, 2015 at 14:53

K5, 25478

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

Pretty simple solution. This is a function that takes its input via a string.

  • 1
    \$\begingroup\$ @TimmyD Fixed!! \$\endgroup\$ Commented Sep 29, 2015 at 21:00

Windows PowerShell ISE Host, 62978 63894 67960 77050

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

Edit -- saved some points by getting rid of the $A variable and instead counting backwards through the string, and also by converting some keywords to CAPS

Edit2 -- saved some more points by using $($HOST.NAME) instead of PowerShell

Edit3 -- saved some more points by swapping variable names and changed how the output is generated.

Uses variables named with numbers, as they're "closer" to $ so our penalty is less.

It's interesting to not use regular golfing techniques. For example, |%{$ is 22534, while |foreach{$ is only 8718.

This is probably close to optimal without changing techniques.

  • 1
    \$\begingroup\$ This was exactly what I was hoping for. Cheers! \$\endgroup\$
    – Sanchises
    Commented Sep 29, 2015 at 20:47

MATLAB, 19214 39748 39444 38785 37593

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

Thanks to Luis Mendo for reducing the difference count further!

Thanks to NumberOne for reducing the noise count by changing the input variable name!

How this works

  1. Declares an anonymous function that is stored in the default ans variable in MATLAB
  2. The function takes in a string stored in A9876543210 and prints out the sum of squared neighbouring differences of the string.
  3. diff finds pairwise neighbouring differences in an array and produces an array of length(A9876543210)-1. By using diff on a string array, this gets cast to a double array where the ASCII codes of each character are generated and the differences of the consecutive pairs results in another array.
  4. To find the sum of squared differences, you simply take the dot product of this difference array with itself transposed. Doing diff(A9876543210)' actually produced more noise than with A9876543210.' (thanks Luis Mendo!)
  5. The result is printed to the screen.
  • \$\begingroup\$ It's usual in PPCG to allow unnamed functions. So you can remove A= \$\endgroup\$
    – Luis Mendo
    Commented Sep 29, 2015 at 20:56
  • \$\begingroup\$ Also, norm(diff(B))^2 is shorter \$\endgroup\$
    – Luis Mendo
    Commented Sep 29, 2015 at 20:58
  • \$\begingroup\$ @LuisMendo - Tried that. It prints out scientific notation and doesn't respect the %d. \$\endgroup\$
    – rayryeng
    Commented Sep 29, 2015 at 20:58
  • \$\begingroup\$ Why do you use B as a variable name? A=@(A)... is valid MATLAB, since A is scoped. \$\endgroup\$
    – Sanchises
    Commented Sep 29, 2015 at 21:04
  • 3
    \$\begingroup\$ A -> A9876543210 \$\endgroup\$ Commented Sep 30, 2015 at 12:39

QBasic, 38140


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

(Tested with QB64.)

This is a full program that inputs the string and outputs the answer. The only limitation here is that the program can't take multiline input (LINE INPUT can handle anything as long as it's a single line).


WHILE i<LEN(line$)
PRINT "#QBasic,"; score

Conveniently, passing a multi-character string to ASC gives the ASCII value of the first character. Also conveniently, numeric variables are auto-initialized to zero.

  • \$\begingroup\$ I've never coded in QBasic before, so forgive me if I'm wrong, but would it be possible to replace the variables with uppercase letters to save some extra points? \$\endgroup\$ Commented Oct 1, 2015 at 11:49
  • \$\begingroup\$ @DLosc Ah, OK. I was reading the deobfuscated version as the actual program. :| \$\endgroup\$ Commented Oct 1, 2015 at 19:44

Python 2, 91026

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

Defines an anonymous function that takes a string and returns the score. Try it online.

Most of this is a pretty straightforward functional implementation: zip A with A[1:] to get a list of letter pairs, then subtract their ords, square, and sum with a generator expression.

Observe that the two variables inside the generator expression are only ever followed by the following characters: ), ,, and space. All three of these have very low ASCII values, so it behooves us to end each variable with as low-ASCII-valued a character as possible. The lowest character that can end a variable in Python is 0. Furthermore, every opportunity we have to split a single large jump into two smaller jumps will lower the score: A0 costs 289, but A90 is only 145 and A9876543210 is a paltry 73.

(This approach didn't help the lambda variable A, probably because it's followed by [ in one occurrence.)


JSFuck, 144420642

Build it from:

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

Paste this into JSFuck.com's small input box to compile it to JSFuck. The result is a 112701 characters long script, so I can't put it here. The last two characters of this script are parentheses, put the input between them.


It takes the program almost 20 seconds on my computer to evaluate itself.


I got more time to work on this, so I sat down and tried to optimize the variable names. Here are the variable names worth using, in order of their 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

Here is the JavaScript I've translated to JSFuck:

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

I gave a closer look at JSFuck.com's translator and figured out how its evaluation function works. With "Eval source" checked, the code will become a self-executing JSFuck function. To get the input, however, we need to access arguments[0] from within the function. This brings our final JS code to...

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

(If you're wondering why my previous version had a lower score than this, it's because it was a JSFuck program that returned a string that needed to be evaluated as JS. This is also why I didn't leave it in the post)

  • \$\begingroup\$ Your abs is unnecessary. I guess that might just make the difference... :) \$\endgroup\$
    – Sanchises
    Commented Sep 29, 2015 at 21:25
  • 6
    \$\begingroup\$ I found the score confusing. You should remove the spaces. Especially since the output of your program should be JSFuck, 102280181. \$\endgroup\$
    – mbomb007
    Commented Sep 29, 2015 at 21:26
  • \$\begingroup\$ @sanchises indeed, I had actually forgotten to put the square two at first, which is why there was a Math.abs. Will fix. \$\endgroup\$
    – Domino
    Commented Sep 30, 2015 at 2:00
  • \$\begingroup\$ @mbomb007 Oh, ok then, will fix too. \$\endgroup\$
    – Domino
    Commented Sep 30, 2015 at 2:00

CJam, 23663 19389 11547

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

Try it online

It's starting to feel like this can be pushed almost endlessly by strategically adding more characters. But I think that I'm starting to reach a point of diminishing returns here, so I'll stop for now. For example, where I have ULC;;;, I could use the whole alphabet backwards followed by 26 ;, but the gains get smaller and smaller.

By far the biggest gap I have left is between the m and the , in the initial string. I haven't found anything reasonable to get rid of it. I'm sure there are ways. But if I push it to the limit, it might start looking like Dennis' solution...



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

This is by far one of the silliest optimizations I have ever done in a code golf...

Props to Neil for the "comment spam" suggestion =P

  • \$\begingroup\$ I think you can save 5180 simply by inserting /**/ in appropriate places. \$\endgroup\$
    – Neil
    Commented Sep 30, 2015 at 8:54


This solution was significantly more ridiculous very different from my other one, and so I felt it deserved it's own answer.


That's 7306 characters, most of which is the actual program encoded into that 0/1 string, and the rest simply to decode it. It works by getting the index of each '1' minus the index of the previous '1' to get the necessary character value. It then eval's the resulting string into the actual function, which is essentially a standard-golf program to solve the problem (which is only about 105 characters itself).


R, 68911 57183 53816 52224

Takes a string from STDIN and converts it to an integer via raw. Diffs, squares and sums the resulting vector. The result is returned as a string. Thanks to @nimi for the variable name tip.

  • \$\begingroup\$ @nimi Thanks for that, was 2 stuck it trying to keep it short :) \$\endgroup\$
    – MickyT
    Commented Sep 29, 2015 at 21:32

Mathematica, 33552


This code evaluates to an unnamed function, which calculates the "noise" of an input string. It makes use of the fact that the ASCII representation of binary data is essentially "noiseless". The binary data you see is the string

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

which would have been a valid answer on its own, scoring 37848.

Everything else


just decodes the binary string and interprets it as Mathematica code. Note that Mathematica's empty comment (**) is very "low-noise" and actually removes noise from the "s.


Java8 : 117170 100508 99062 98890

With the help of lambada expression and inline assignment of variable can shorten this code a bit.

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;}
  • \$\begingroup\$ A -> A9876543210; B -> $0123456; C -> A; D -> AA; E -> $0123456789 \$\endgroup\$ Commented Sep 30, 2015 at 12:59

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

This challenge actually got me thinking deeper about characters to use and optimization more so than finding the shortest solution. I'll keep working to bring the number down.

This is a lambda function, with B being the string representing the function. Don't forget to escape the quotes (") when passing this as a string.


Pyth, 16391


The only trick of note used here is base-256 encoding #Pyth,, which costs far less than the string itself.

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

To use this, we have to escape quotes and "escape" whitespace characters (which are significant in MUMPS!) like so:

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

Note that "M" is an alternative name for "MUMPS" - there is disagreement among practitioners about which one is correct. Naturally, I have chosen the shorter option here.

  • \$\begingroup\$ Shouldn't you initialise AAAA? \$\endgroup\$
    – SSH
    Commented Oct 1, 2015 at 5:47
  • \$\begingroup\$ Also because of lack of operator priorities, you can just S AAA=$A($E(A,AA-1))-$A($E(A,AA))**2+AAA -- should give a lower score... \$\endgroup\$
    – SSH
    Commented Oct 1, 2015 at 5:53
  • \$\begingroup\$ @SSH I'm assuming a clean symbol table before calling the function (so I don't have to NEW stuff). So when I start doing arithmetic on AAAA (now AAA9876543210), it gets coerced to 0 (maybe that's just a Caché implementation detail? I don't have a GT.M install to test against). Good call on the operator priorities thing; I always find it difficult to think in terms of purely left-to-right operations. (I also forgot that M has an exponentiation operator - it's not something that comes up often when you're writing CRUD applications.) \$\endgroup\$
    – senshin
    Commented Oct 1, 2015 at 16:03
  • \$\begingroup\$ Nice! Also, because of left-to-right execution, you don't need brackets before **2 \$\endgroup\$
    – SSH
    Commented Oct 2, 2015 at 0:22
  • \$\begingroup\$ @SSH Thanks, dunno how those got in there. The version I actually measured doesn't have it, so the score is still the same. \$\endgroup\$
    – senshin
    Commented Oct 2, 2015 at 0:24

Ruby, 118402

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

It reads in a file through command line, such as ruby diff.rb /path/to/file. There's room to improve, and that's something I'm working on right now.


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

I'll try to cut this down some more.

It turns out that curly braces ({ and }, ASCII 123 and 125) and the underscore (_, ASCII 95) are very expensive since all the other characters are around the range 30-70, which is why I formatted the if the way I did, and why I'm using $AAAAA instead of Perl's beloved $_.

Sadly, all the variables with symbols in them are read-only, so I can't take advantage of combinations like $# and $$.


F#, 136718 130303


Where there is a \n after the ;.


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

too bad I can't get the same result as the Pyth checker (178386)...

  • \$\begingroup\$ 1. "Shell" is not a programming language. This looks like Bash. 2. You can simply read from STDIN. No need to read the source code itself. \$\endgroup\$
    – Dennis
    Commented Sep 30, 2015 at 3:06
  • \$\begingroup\$ @Dennis Thanks, edited... Although I can't get the same result, maybe there's a bug still (at least once I got the same result but not in the "compressed" version)... \$\endgroup\$ Commented Sep 30, 2015 at 3:19

Lua, 171078 117896




for AAAAAAA=1,AAAA do 


C++, 49031

a C++ macro that takes a c-string and writes the result to the standard output

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

Try it online!


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.