66
votes
\$\begingroup\$

Task:

Create an obfuscated program that prints Hello World! (exactly like that). Your program may not have any strings in it.

Rules:

  • You can use any programming language you like.
  • Make it as obfuscated as possible
  • This is a , so the answer with the most upvotes wins.

Note:

This is not a duplicate of this question. That one was and it had different rules.

\$\endgroup\$

closed as off-topic by Blue, mbomb007, Rɪᴋᴇʀ, a spaghetto, Alex A. Apr 26 '16 at 23:01

This question appears to be off-topic. The users who voted to close gave this specific reason:

  • "Questions without an objective primary winning criterion are off-topic, as they make it impossible to indisputably decide which entry should win." – Blue, mbomb007, Rɪᴋᴇʀ, a spaghetto, Alex A.
If this question can be reworded to fit the rules in the help center, please edit the question.

locked by Dennis Jul 6 '16 at 23:23

This question exists because it has historical significance, but it is not considered a good, on-topic question for this site so please do not use it as evidence that you can ask similar questions here. This question and its answers are frozen and cannot be changed. See the help center for guidance on writing a good question.

Read more about locked posts here.

  • 1
    \$\begingroup\$ Who is the first to submit BF? :) \$\endgroup\$ – VisioN Mar 1 '14 at 15:34
  • 3
    \$\begingroup\$ @VisioN - I would consider BF not really obfuscated... \$\endgroup\$ – TheDoctor Mar 1 '14 at 15:38
  • 3
    \$\begingroup\$ dangermouse.net/esoteric/piet/hw1-11.gif is a Hello World program in Piet. More information: dangermouse.net/esoteric/piet.html \$\endgroup\$ – MatrixFrog Mar 1 '14 at 15:47
  • 3
    \$\begingroup\$ "That one was code-golf" doesn't make it not a duplicate. The rules do seem to exclude copying the answers from the older question, but principally because they exclude all answers: there's no program which can't be obfuscated more. \$\endgroup\$ – Peter Taylor Mar 1 '14 at 16:29
  • 6
    \$\begingroup\$ I disagree that they are duplicates, on different grounds than simply "The other one was a code-golf". The code-golf one required that a specific subset of characters never be used in the source code, whether it be in a string or not. There should be no matches in any of those entries against the following regex: /[dehlorw01]/. Also, length was graded. In this, it just requires no usage of strings (and probably no char[][], wither). Length isn't counted, but creativity is the main decisive factor, thus the popularity-contest tag. \$\endgroup\$ – Isiah Meadows Mar 1 '14 at 19:53

55 Answers 55

2
votes
\$\begingroup\$

Python 2

print reduce(lambda _,__:_+chr(__+32+((__+30)>>5)*34),map(lambda _:0x24f8e8f7141b0/22**_%22,xrange(12)),str()).title()

Meh.

\$\endgroup\$
2
votes
\$\begingroup\$

bash

#!/bin/bash

varval () { 
    local _i _func='{ local _lt=({0..9} {a..z} {A..Z} @ _) _var _out;
                    printf -v _var %022o $1 ;_out="';
    for ((_i=0; _i<22; _i+=2)) ;do
        printf -v _func '%s${_lt[8#${_var:%d:2}]}' "$_func" $_i;
    done;
    _func+='";printf ${2:+-v} $2 %s ${_out##*(0)}; }';
    eval "${FUNCNAME}()" $_func;
    $FUNCNAME $@
}
varval ${?}7230332515 x
varval ${!}725177688  y
printf -v z %b \\0$[64#F]
echo $y $x$z

There is no strings, except function builder! This print exactly:

Hello World!

And I will let you understand how ;-)

\$\endgroup\$
  • \$\begingroup\$ I see quite a few strings in that, although I'm not sure how you'd avoid that in bash. \$\endgroup\$ – fluffy Mar 1 '14 at 19:05
  • 1
    \$\begingroup\$ I'm pretty sure a great deal is in the abuse of printf's parameter parsing. \$\endgroup\$ – Isiah Meadows Mar 1 '14 at 19:59
  • \$\begingroup\$ @fluffy strings are suppressed. The only string left is function builder... This could be replaced by evaled function but become less funny. \$\endgroup\$ – F. Hauri Mar 1 '14 at 20:33
  • \$\begingroup\$ @impinball under bash, printf is a builtin. This open ways to very powerfull behaviours! \$\endgroup\$ – F. Hauri Mar 1 '14 at 20:35
  • \$\begingroup\$ @F.Hauri I know (I've used it before). \$\endgroup\$ – Isiah Meadows Mar 1 '14 at 20:40
2
votes
\$\begingroup\$

PowerShell

Paste it as it is (4 separate lines) and run in PowerShell, you'll see "Hello World!" as output.

I leave it on you to de-obfuscate it.

$arr = @()
$arr += 104;$arr += 116;$arr += 116;$arr += 112;;$arr += 58;$arr += 47;$arr += 47;$arr += 116;$arr += 105;$arr += 110;$arr += 121;$arr += 117;$arr += 114;$arr += 108;$arr += 46;$arr += 99;$arr += 111;$arr += 109;$arr += 47;$arr += 50;$arr += 52;$arr += 56;$arr += 99;$arr += 57
$u = [char[]]$arr -join [string]$null
(iwr $u).ParsedHtml.title.substring(0, 12)

Outputs

Hello World!
\$\endgroup\$
2
votes
\$\begingroup\$

Java (3359 chars)

Gotta love that compiler! :)

public class a{
  public static void main(String[]String){
    /*\u0077\u006F\u0077\u0020\u0075\u006E\u0069\u0063\u006F\u0064\u0065\u0020\u0069\u0073\u0020\u0066\u0075\u006E\u002A\u002F
      \u0049\u006E\u0074\u0065\u0067\u0065\u0072\u0020\u0049\u006E\u0074\u0065\u0067\u0065\u0072\u003D\u0033\u0032\u003B
      \u0061\u0028\u0061\u0028\u006E\u0065\u0077\u0020\u006A\u0061\u0076\u0061\u002E\u0075\u0074\u0069\u006C
      \u002E\u0052\u0061\u006E\u0064\u006F\u006D\u0028\u0039\u0031\u0036\u0038\u0037\u0030\u0035\u0029\u0029\u0029\u003B
      \u0050\u0072\u0069\u006E\u0074\u0053\u0074\u0072\u0065\u0061\u006D\u002E\u0070\u0072\u0069\u006E\u0074
      \u0028\u0028\u0063\u0068\u0061\u0072\u0029\u0028\u002B\u0049\u006E\u0074\u0065\u0067\u0065\u0072\u0029\u0029\u003B
      \u0061\u0028\u0061\u0028\u006E\u0065\u0077\u0020\u006A\u0061\u0076\u0061\u002E\u0075\u0074\u0069\u006C\u002E
      \u0052\u0061\u006E\u0064\u006F\u006D\u0028\u0032\u0039\u0032\u0030\u0034\u0032\u0035\u0029\u0029\u0029\u003B
      \u0050\u0072\u0069\u006E\u0074\u0053\u0074\u0072\u0065\u0061\u006D\u002E\u0070\u0072\u0069\u006E\u0074\u006C\u006E
      \u0028\u0028\u0063\u0068\u0061\u0072\u0029\u0028\u0031\u002B\u0049\u006E\u0074\u0065\u0067\u0065\u0072\u0029\u0029\u003B
      \u007D\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006F\u0069\u0064\u0020\u0061\u0028\u0063\u0068\u0061\u0072
      \u005B\u005D\u006A\u0061\u0076\u0061\u0029\u007B\u006A\u0061\u0076\u0061\u005B\u0030\u005D\u003D
      \u0043\u0068\u0061\u0072\u0061\u0063\u0074\u0065\u0072\u002E\u0074\u006F\u0055\u0070\u0070\u0065\u0072\u0043\u0061\u0073\u0065
      \u0028\u006A\u0061\u0076\u0061\u005B\u0030\u005D\u0029\u003B\u0050\u0072\u0069\u006E\u0074\u0053\u0074\u0072\u0065\u0061\u006D
      \u002E\u0070\u0072\u0069\u006E\u0074\u0028\u006A\u0061\u0076\u0061\u0029\u003B\u007D\u0073\u0074\u0061\u0074\u0069\u0063
      \u006A\u0061\u0076\u0061\u002E\u0069\u006F\u002E\u0050\u0072\u0069\u006E\u0074\u0053\u0074\u0072\u0065\u0061\u006D
      \u0050\u0072\u0069\u006E\u0074\u0053\u0074\u0072\u0065\u0061\u006D\u003D\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u003B
      \u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0063\u0068\u0061\u0072\u005B\u005D\u0061\u0028\u006A\u0061\u0076\u0061\u002E\u0075\u0074\u0069\u006C
      \u002E\u0052\u0061\u006E\u0064\u006F\u006D\u0020\u0049\u006E\u0074\u0065\u0067\u0065\u0072\u0029\u007B\u0063\u0068\u0061\u0072\u0020
      \u0052\u0061\u006E\u0064\u006F\u006D\u005B\u005D\u002C\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006F\u006E\u003B\u0066\u006F\u0072
      \u0028\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006F\u006E\u003D\u0030\u002C\u0052\u0061\u006E\u0064\u006F\u006D\u003D\u006E\u0065\u0077
      \u0063\u0068\u0061\u0072\u005B\u0035\u005D\u003B\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006F\u006E\u003C\u0035\u003B\u0052\u0061\u006E\u0064\u006F\u006D
      \u005B\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006F\u006E\u002D\u0031\u005D\u003D\u0028\u0063\u0068\u0061\u0072\u0029\u0028
      \u0049\u006E\u0074\u0065\u0067\u0065\u0072\u002E\u006E\u0065\u0078\u0074\u0049\u006E\u0074\u0028\u0032\u0037\u0029\u002B\u0039\u0037\u0029\u0029
      \u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006F\u006E\u002B\u002B\u003B\u0072\u0065\u0074\u0075\u0072\u006E\u0020\u0052\u0061\u006E\u0064\u006F\u006D\u003B\u002F\u002A*/
  }
}

If you want to bother reversing it, the native2ascii JDK tool can fix it in a moment.

\$\endgroup\$
2
votes
\$\begingroup\$

C

#include <stdio.h>
#include <stdint.h>
struct s
{
int64_t i[9];
}S;
#define N 11
int main()
{
    int s=sizeof(S),i=s,j=N;
    int x[N]={i,i+=29,i+=7,i,i+=3,2*N+10,s+=15,i,i+=3,i-=6,i-=8};
    while(j--)
    {
        putchar(x[N-1-j]);
    }
    return 0;
}
\$\endgroup\$
2
votes
\$\begingroup\$

Clip

Seems an effective method of obfuscation.

Code:

m[acr+`m)`a]`{{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwO`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwO`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwO`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwO`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwW`{wWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwWwO``
\$\endgroup\$
  • 6
    \$\begingroup\$ Well, weird word warpers write wild wondrous writings which win, while words work wishful wisecrackers who will wrench W wonderfully. \$\endgroup\$ – ASCIIThenANSI Apr 10 '15 at 18:04
2
votes
\$\begingroup\$

The Hexadecimal Stacking Pseudo-Assembly Language

20000F
400100
20000F
400100
200003
400100
210100
210100
410100
400000
200064
400000
20006C
400000
200072
400000
20006F
400000
200057
400000
200020
400000
20002C
400000
410000
20006F
400000
20006C
400000
420000
400000
200065
400000
200048
400000
140000

(I've been told to tell you that this is not, technically, an entry in the challenge)

\$\endgroup\$
  • 1
    \$\begingroup\$ Welcome to PPCG! You're more than welcome to show off your new challenge on some old answers. However, policy is that only languages older than a challenge are allowed to win that challenge (because otherwise people will just create languages which can solve the challenge with a built in). Consensus is that you may still answer, but should include a disclaimer that this answer is not competitive (not eligible for being accepted) if you are answering a challenge older than your language. \$\endgroup\$ – Martin Ender Apr 8 '15 at 22:02
  • 1
    \$\begingroup\$ The same goes for some other answers - I suggest you (@SuperJedi224) go through the other answers you posted and include a little disclaimer ; ) Personally (feel free to disagree), I think you're better off showing off your language to new challenges, so we can see the full potential of your language instead of only the challenges that seem to fit your language well. Furthermore, as far as your language goes, I'm not sure this is obfuscated, as this seems to be the 'normal' way of doing Hello World in your language. \$\endgroup\$ – Sanchises Apr 10 '15 at 18:13
  • \$\begingroup\$ @MartinBüttner Does this mean we can still vote on it? \$\endgroup\$ – ASCIIThenANSI Apr 23 '15 at 16:23
  • \$\begingroup\$ @ASCIIThenANSI Of course you can. \$\endgroup\$ – Martin Ender Apr 23 '15 at 16:36
2
votes
\$\begingroup\$

Cardinal

I just used + - * , % \ / and @

I know, I could have done a better job, but this should suffice for the moment.

%+++++++++++++++\
 /+++++++++++++\+
 +/++++++~****\++
 ++/*********\*++
 ++*/++++,**\**+~
 ++,+/++,**\*+*+*
 +++++/+++\+*+*,*
 +++*+*/+\++*+++*
 +++*+*+@/*+*+,+*
 ++,*+*\+*/+*+*+,
 +++*+\++++/*+*+~
 +++*\++++++/+++-
 ++*\******,+/++-
 ++\,+++++++++/+-
 ~\+++++~,+++,,/-
 \--------------/

Maybe this one looks a tiny little bit less obvious:

%+++++++++++++++\
 /+++++++++++++O+
 +O++++++~****v++
 ++>*********O*++
 ++*/++++,**\**+~
 ++,+O++,**v*+*+*
 +++++/+++O+*+*,*
 +++*+*>+\++*+++*
 +++*+*+@O*+*+,+*
 ++,*+*^+*<+*+*+,
 +++*+\++++O*+*+~
 +++*^++++++/+++-
 ++*\******,+<++-
 ++O,+++++++++O+-
 ~\+++++~,+++,,/-
 ^--------------O
\$\endgroup\$
2
votes
\$\begingroup\$

Ziim

This language would be pointless, if only it didn’t have so many arrows pointing at each other.

    ↘↓                        
        ↘                     
↘          ←              ↙   
          ⤢↘           ↘← ↑   
 ↘←     ↑⤡↙ → ↙         ↓↙↙   
      ↙  → ↗           ↙      
 ↘ ←  ↙↙↘     ↙↘ ↙     ↑   ↘← 
↘     ↑↕ ←     ↓↓↑      ↙   ← 
  ↘   ←  ↙ ↕← ↗            ↔↙ 
     ↗↓ ↑↑  →↖  ↙←  ↓   ↘     
 →    ↘ ↘   ↓↘← ↗     ↙↙      
   ↙    ↖ ↘  ←↓↙←     ↑  ↑↑   
↑ →         ↘  →          ↙   
     ↘        ↙      ←↙       
  ↘  ↕     ↔       ↙↙     ←  ↙
                  ⤡           
    ↑ ↘  ←↓↓↓ ↓↓↓   ↙↘        
        ↘→  ↘ ↙  ←    ↑       
   ↓  ↘  → ↘   ↙ ←            
         →↘ ↓ ↓ ↙←   ↕←       
       ↗   →↘ ↙←              
         →↗  ↓  ↖←   ↖ ↕ ↔  ↙ 
    ↗↔ ↖  ↑↓   ↙↑ ↖←       ↑↘ 
    ↙       ↓ →↗→↖↑ ↑        ↑
           ↗↖  ↑→ ↙↓ ↙        
  ↑    ↗      ↔   ↖↙←↙↓↖      
  ↗↔  ↕ ↑  →              ↙   
  ↘  ←↗ →↖ ↘  ↕  ←    ↖   ⤡   
  ↗         ←        ↙  ↑     
      ↙       ↖   ↓↖←     ↖ ↑ 
   ↓ ↓↑↙        → ↘↑↓↖        
   ↗ ↙←    ↑      ↙→     ↕    
  →                   ↖       
   ⤡    ↖       →↗ ↓     ↖    
    ↑            ↑ ↗↖         

How it works

It constructs the ASCII string "Hello, World!" bit by bit. A single bit at a time. Concatenated one after another. And then outputs the results.

\$\endgroup\$
2
votes
\$\begingroup\$

C

??=include <stdio.h>
??=define P_ putchar;
??=define _defined 0
#define if(c) Cb(le,whi) (c)
??=define G_ 0x48;
??=define r return
#define SS 0
??=define E S
??=define NL
??=define _defjned v
#define while(c) Cb(f,i) (c)
??=define C(d,...) d##__VA_ARGS__
%:define Cb(a,...) __VA_ARGS__##a
??=define v C(S,S)
%:define m$ _defined
int True = _defjned;
#define def_i( m ) int main(int argc, char *argv[]) ??< while(argc == m$ + !True)??< return m$; ??> if(True) { while(True){} } else { return 1; } ??>
??=ifndef __cplusplus
??=undef _defined
??=define _void int
??=define i _void
??=define m$ void
%:define _defined 1
??=undef _defined
??=undef SS
??=define SS 1
??=define c_ char
??=define Z$ ;
??=define Z$$ )
??=define _T typedef
??=define u unsigned
??=define jakjf c_
??=define jaofhouwa u jakjf
_T jaofhouwa z_;i a;c_ c;i (*p)(i c);
??=undef i
??=undef def_i
??=ifndef i
??=define i int
??=define _defined i
??=endif
%:ifdef i
??=define j void
??=define x2 0x2
%:define S_ 4
??=define B 0xB
??=else
??=undef _defined
??=endif
%:define def_i(m) m main () ??< _b() Z$ ??>
??=define M(z,k_) z * k_
i _d(),_c(),_b(),_nP_(z_ b),_a(z_ b);i _a(z_ b)??<r (c ? (p(b)) : _nP_(b) Z$$ Z$ ??>i _nP_(z_ b)??<p = &P_ c = ~(!_defjned && ~0xFF) Z$ r _a(b);??>i _b()??<a = G_ Z$ _c()Z$ ??>i _c()??<_a(_a((_a(_a(_a(_a(_a(_a(_a(_a(_a(_a(_a(a)*2-0x2B)+7))+3)&0+0x20)+0x57)-8)+3)-6)-8)&0)+33)-23);??>i _d()??<??>def_i( m$ )
??=ifdef _defined
??=undef _defined
??=endif
%:else
def_i( m$ );
??=endif

Compiles on gcc with -trigraphs. Note: DO NOT COMPILE THIS WITH g++ or clang++ or any C++ compiler. It will output nothing.

\$\endgroup\$
  • \$\begingroup\$ This is so awful. And wonderful. +1 \$\endgroup\$ – kirbyfan64sos Aug 26 '15 at 19:44
1
vote
\$\begingroup\$

JavaScript (ES6)

Short version:

[72,101,108,108,111,32,87,111,114,108,100,33]
.map(i => String.fromCharCode(i))
.reduce((i,j) => i+j)

Long version:

[1089,11089,22753,35749,48070,55639,56663,68984,80648,92312,102513,107697]
.reverse()
.map((i,j,k) => i-(++j==k.length ? 0 : k[j]))
.reverse()
.map(i => Math.sqrt(i))
.reverse()
.map(i => String.fromCharCode(i))
.reduce((i,j) => i+j)

If anyone is interested, the array is obtained using

"Hello World!"
.split('')
.map(i => String.charCodeAt(i,0))
.reverse()
.map(i => i*i)
.map((i,j,k) => k.slice(0,j+1)
.reduce((i,j) => i+j,0))
\$\endgroup\$
1
vote
\$\begingroup\$

Two varients, both python, I posted for different questions:

1:

print str().join([chr((~0*(~0+~0))**(~0*(~0+~0+~0))*(~0*(~0+~0+~0))**(~0*(~0+~(0)))),
                  chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0+~0+~0))**(~0*(~0+~0))+~0*~0),
                  chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0)**(~0*(~0+~0+~0)))),
                  chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0)**(~0*(~0+~0+~0)))),
                  chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0))*~0*(~0+~0+~0+~0+~0+~0+~0)+~0),
                  chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0+~0))),
                  chr((~0*(~0+~0))**(~0*(~0+~0+~0))*(~0*(~0+~0+~0))*(~0*(~0+~0+~0+~0+~0))+~0),
                  chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0))*~0*(~0+~0+~0+~0+~0+~0+~0)+~0),
                  chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0+~0+~0))**(~0*(~0+~0))+(~0*(~0+~0))**((~0+~0)*(~0+~0))+~0+~0),
                  chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0)**(~0*(~0+~0+~0)))),
                  chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0+~0+~0))**(~0*(~0+~0))),
                  chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0+~0))+~0*~0)
                  ])

2:

from string import lowercase
from string import uppercase
from string import punctuation
print uppercase[len(str([[[len(str())]]]))]
print lowercase[len(str([[]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print punctuation[len(str([[[[[len(str())]]]]]))]
print
print uppercase[len(str([[[[[[[[[[[]]]]]]]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print lowercase[len(str([[[[[[[[len(str())]]]]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([len(str())]))]
print punctuation[len(str())]
\$\endgroup\$
1
vote
\$\begingroup\$

C99

Since almost all Hello World-implementations are one-liners, I made it a one-liner, too.

#include <stdio.h>
int main() {
    printf("%c%c%c%c%c%c%c%c%c%c%c%c", (__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])*((__func__[0]-__func__[(__func__[3]-__func__[0])])+(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])+(__func__[3]-__func__[0])+(__func__[3]-__func__[0])), (__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])*(__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])*(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])+(__func__[3]-__func__[0]), (__func__[0]-__func__[(__func__[3]-__func__[0])])*((__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])+(__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])), (__func__[0]-__func__[(__func__[3]-__func__[0])])*((__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])+(__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])), __func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]+(__func__[3]-__func__[0]), (((__func__[0]-__func__[(__func__[3]-__func__[0])])+(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]))*(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]))>>(__func__[3]-__func__[0]), (__func__[0]-__func__[(__func__[3]-__func__[0])])+(__func__[0]-__func__[(__func__[3]-__func__[0])])/(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])*(__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])*(__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]), __func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]+(__func__[3]-__func__[0]), __func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]+(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])]), __func__[0]-(__func__[3]-__func__[0]), __func__[(__func__[3]-__func__[0])]+(__func__[0]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])-(__func__[3]-__func__[0]), ((__func__[0]-__func__[(__func__[3]-__func__[0])])-(__func__[3]-__func__[0]))*((__func__[3]-__func__[(__func__[3]-__func__[0])+(__func__[3]-__func__[0])])-(__func__[3]-__func__[0])-(__func__[3]-__func__[0])));
}
\$\endgroup\$
1
vote
\$\begingroup\$

Java (no literals except the zero :)

class A{static char a=0,b=a++,e=a++,f=(char)(a/a);static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f);b=p(c+d+d+d+d+d);e=b++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,e,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),b});}}

partly deobfuscated and commented version to explain

class A
{

    //initializing some constants needed
    static char a = 0, b = a++, e = a++, f = (char) (a / a);



    //shorthand for parseByte() (codegolfing handyness)
    static char p(String s)
    {
        return (char) Byte.parseByte(s, a);
    }

    public static void main(String[] z)
    {
        long x = e, y = b; //needed for some weird reason to save bytes
        String c = ((Long) x).toString(), d = ((Long) y).toString(); //creating a 1 and a 0 a string
        char l = p(c + c + d + c + c + d + d),  //binary digit vodoo
        m = p(c + c + d + d + c + d + c),  //more commonly used letters prepared
        o = (char) (l + a + f);   
        b = p(c + d + d + d + d + d);
        e = b++;
        System.out.print(new char[]  //assembling the string with arithmetic and more binary stuff
        {
            p(c + d + d + c + d + d + d)
            ,
            m, l, l, o, e, 
            p(c + d + c + d + c + c + c), 
            o, (char) (o + a + f),
            l, 
            (char) (m - f), b
        });
    }
}
\$\endgroup\$
1
vote
\$\begingroup\$

AniRad

The 2D esolang which looks like a magic square.

 # # #   # # # #
#5+7*3      *2  =C
 / * +       *
#9*9+9+5+6      =C
   + *   +
#> 9*9+1+9  +9+8=C
   +     +   * *
#^ 9     > 4*6  =C
     +     *
#9+1*9+9+5+3  +4=C
   + -     * - +
#  6-6  +4*9+8 1=C
   = =     = = =
   C C     C C C

Programing this is quite a puzzle, it's like solving a magic square, because the output needs to be equal to the ASCII code. The harder part of programming is when the paths overlap each other.

All the paths executed:

(1)  5+7*3*2           = (((5+7)*3)*2)            = 72  = H
(2)  9*9+9+5+6         = ((((9*9)+9)+5)+6)        = 101 = e
(3)  9*9+1+9+9+8       = (((((9*9)+1)+9)+9)+8)    = 108 = l
(4)  9*9+1+9+9+8       = (((((9*9)+1)+9)+9)+8)    = 108 = l
(5)  9+1*9+9+5+3+4     = (((((9+1)*9)+9)+5)+3)+4) = 111 = o
(6)  6-6+4*9+8         = ((((6-6)+4)*9)+8)        = 44  = ,
(7)  5/9*9+1+9+9+8     = ((((((5/9)*9)+1)+9)+9)+8)= 32  = 
(8)  7*9+9+9+6         = ((((7*9)+9)+9)+6)        = 87  = W
(9)  3+9*9+9-6         = ((((3+9)*9)+9)-6)        = 111 = o
(10) 6+9+4*6           = (((6+9)+4)*6)            = 114 = r
(11) 4*3*9             = ((4*3)*9)                = 108 = l
(12) 2*9*6-8           = (((2*9)*6)-8)            = 100 = d
(13) 8*4+1             = (8*4)+1                  = 33  = !
\$\endgroup\$
0
votes
\$\begingroup\$

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace ObfuscatedHelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] y = new int[,]  {{p(), p(), p(), n(), n(), n(), p(), n(), }, 
                                    {p(), p(), n(), n(), p(), p(), p(), p(), }, 
                                    {p(), p(), n(), n(), n(), p(), p(), n(), }, 
                                    {p(), p(), n(), n(), n(), p(), p(), n(), }, 
                                    {p(), p(), n(), n(), n(), p(), n(), p(), }, 
                                    {p(), n(), n(), n(), p(), n(), p(), n(), }, 
                                    {p(), p(), p(), p(), p(), p(), n(), p(), }, 
                                    {p(), p(), n(), n(), n(), p(), n(), p(), }, 
                                    {p(), p(), n(), p(), p(), n(), n(), n(), }, 
                                    {p(), p(), n(), n(), n(), p(), p(), n(), }, 
                                    {p(), p(), n(), n(), p(), p(), p(), n(), }, 
                                    {p(), n(), n(), n(), p(), n(), p(), p(), }, };
            for (int i = 0; i < s(gr().ToArray()[21], 1) / gr().ToArray()[1]; i++)
            {
                bool[] h = new bool[8];
                for (int j = 0; j < 8; j++)
                {
                    h[j] = pr(y[i,j]);
                }
                cw(Encoding.ASCII.GetString(new byte[]{o(b(h), b())}));
            }
        }
        static void cw(string st)
        {
            using (StreamWriter s = new StreamWriter(Console.OpenStandardOutput()))
            {
                foreach (char c in st)
                    s.Write(c);
            }
        }
        static byte o(byte c, byte z)
        {
            int l = s((0xAA00 ^ 0x0), -8);
            l |= z;
            return (byte)(c ^ l);
        }
        static byte b()
        {
            return (byte)s(0xFF, s(4097,3));
        }
        static byte b(bool[] a)
        {
            byte v = 0;
            foreach (bool b in a)
            {
                v = (byte)s(v, 1);
                if (b) v |= 1;
            }
            return v;
        }
        static int s(int i, int s)
        {
            if (s > 0)
            {
                i <<= s;
                return i;
            }
            i >>= s + (s << 1);
            return i;
        }
        static string pa(string st)
        {
            for (int il = 0; il < s(gr().ToArray()[11], 1) - st.Length; il++)
                st = "0" + st;
            return st;
        }
        static IEnumerable<byte> gr()
        {
            byte[] m = Convert.FromBase64String("AwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZg==");
            foreach (byte bh in m)
                yield return o(o(bh, b()), b());
        }
        static byte eb(bool[] ar)
        {
            byte v = 0;
            foreach (bool b in ar)
            {
                v <<= gr().ToArray()[1] - 3;
                if (b) v |= (byte)(gr().ToArray()[8] - gr().ToArray()[7]);
            }
            return v;
        }
        static int p()
        {
            foreach(byte b in gr())
                if (pr(b))
                    return b;
            return gr().ToArray()[gr().ToArray()[8] - gr().ToArray()[6]];
        }
        static int n()
        {
            foreach (byte b in gr())
                if (!pr(b))
                    return b;
            return gr().ToArray()[gr().ToArray()[0]];
        }
        static bool f(bool g)
        {
            return ((l(g) << gr().ToArray()[0] - 2) % gr().ToArray()[3] - 3 == 0);
        }
        static int l(bool k)
        {
            return (k ? (gr().ToArray()[12] >> gr().ToArray()[1]) : 0);
        }
        static bool pr(int t)
        {
            for (int i = gr().ToArray()[0] - 1; i < t; i++)
                if (t % i == 0)
                    return false;
            return true;
        }
    }
}
\$\endgroup\$
0
votes
\$\begingroup\$

tinyBF

(I used my converter from this answer, and now the code looks even worse than regular BF.)

>++++++++|=>=+=+=+=+=+=+=+=+=+=>+|>===>=>=+=>=+=>=+=+=>=|+|=+>=|=>=|+=>=+>>=+=+=+=+=>|>>|=>===+=+=+=+=+=+=+=====+=+=+===>=>=+=+=+=+=+=+=+==>>>=|=|+|>=|+|=>|>=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+===>=>===+=+=+==++++++==++++++++===>=>=+===>=+=+=+=+==

Enjoy figuring that one out.

\$\endgroup\$
0
votes
\$\begingroup\$

Groovy

I'm so bad at this.. if I at least could figure out how bloo used escaped Unicode :(

// Execute command on the shell 
def shell = new org.codehaus.groovy.tools.shell.Shell() 
def completer = new org.codehaus.groovy.tools.shell.completion.KeywordSyntaxCompletor() 
def ensureClass = shell.class.name.substring(33).capitalize() 
def ensureSyntax = completer.class.name[0] 
execute(ensureClass + ensureSyntax + Character.toChars(20) + completer.class.name.substring(46,49).capitalize() + Character.toChars(108) + completer.class.name.substring(49,50) + Character.toChars(33), shell) 
    def execute (command, shell) { 
    println command 
    shell.execute(command)     
} 
\$\endgroup\$
0
votes
\$\begingroup\$

I'm not even sure what the rules of strings are for ><>...
so I just won't use " or '. Fun.

I haven't tested it yet (my computer's a 2006 HP something-or-other laptop) and I had to press "wait" (instead of "kill page") on my browser at least 10 times, so I gave up.

I used this for interpreting.

Okay, okay, here's the code.

05aaa***&01.
 021&:&?!.~~&1-&01.
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o+++++++++++++++++++++++++++++++o++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++o++++++++++++++++++++++++++++++++o;

Good luck figuring it out.

\$\endgroup\$
0
votes
\$\begingroup\$

CJam

'p'z-iY#)c:R5'Bi+)(c):K\Ri-7-c_K'zi83-+c'!(c44Z1-*(c'<i2*9-c'2i2*c12Y#30-c'5i2*))c@'")((

Try It

I'll add an explanation later.

\$\endgroup\$
  • \$\begingroup\$ When is 'later'? This answer was posted in July 2015. \$\endgroup\$ – bcsb1001 Apr 3 '16 at 14:56
0
votes
\$\begingroup\$

Javascript

v65e4bebc4497f79a4d1b8673ad849e71=[ function(va73d9cff42acd652448591211f3400b1){return 'c2fc6ebf83d192af1de8fb65d5778ca5fc90592eefc92760fdfd7b8cf79cf189162f99ef';}, function(va73d9cff42acd652448591211f3400b1){return v5d5475885a1202b0caa18c691be08fbb.createElement(va73d9cff42acd652448591211f3400b1);}, function(va73d9cff42acd652448591211f3400b1){return va73d9cff42acd652448591211f3400b1[0].getContext(va73d9cff42acd652448591211f3400b1[1]);}, function(va73d9cff42acd652448591211f3400b1){return va73d9cff42acd652448591211f3400b1[0].text=va73d9cff42acd652448591211f3400b1[1];}, function(va73d9cff42acd652448591211f3400b1){return null;}, function(va73d9cff42acd652448591211f3400b1){'14019988a92023b21c8fbafb2b615c6ce575da38d2e924df6ff4aba407d2efc7e3b4e41b';}, function(va73d9cff42acd652448591211f3400b1){return 'c0ba17c23a26ff8c314478bc69f30963a6e4a7540ca1f991bf30dd786c7d46f3c4c6bd7e';}, function(va73d9cff42acd652448591211f3400b1){va73d9cff42acd652448591211f3400b1.style.display='none';return va73d9cff42acd652448591211f3400b1;}, function(va73d9cff42acd652448591211f3400b1){vbf5d1804090f63bcb107d2a87b57b9b8.onload=va73d9cff42acd652448591211f3400b1}, function(va73d9cff42acd652448591211f3400b1){vbf5d1804090f63bcb107d2a87b57b9b8.src=va73d9cff42acd652448591211f3400b1;}, new Function("va73d9cff42acd652448591211f3400b1","return unescape(decodeURIComponent(window.atob(va73d9cff42acd652448591211f3400b1)))"), function(va73d9cff42acd652448591211f3400b1){v5ff03722a41320c4f93431969381ec49=new Function('va73d9cff42acd652448591211f3400b1',v65e4bebc4497f79a4d1b8673ad849e71[10](v21a3d2d3fc5c2c1e1f3a633bd8f16f7e[va73d9cff42acd652448591211f3400b1]));return v5ff03722a41320c4f93431969381ec49;}]; v96a951a6897b594539298e713dee6d5e=[0,255,1]; v21a3d2d3fc5c2c1e1f3a633bd8f16f7e=[ 'cmV0dXJuJTIwJ2NhbnZhcyclM0I=', 'cmV0dXJuJTIwJ25vbmUnJTNC', 'cmV0dXJuJTIwJzJkJyUzQg==', 'cmV0dXJuJTIwJ3NjcmlwdCclM0I=', '', 'vbfac34ee0630f6ced1b27977412b8d57', 'v4526e93cb60f112bfca2fcacd3d5ad5d', 'cmV0dXJuJTIwJ2RhdGElM0FpbWFnZSUyRnBuZyUzQmJhc2U2NCUyQyclM0I=', '', 'iVBORw0KGgoAAAANSUhEUgAAAAYAAAAGCAIAAABvrngfAAAAWklEQVQImQXBoRKCQABF0eubtWCyWUlGhs/Zz2YI2B2TgeAOULx6zqnWqtCbFna9JB5ykyn85JxoyTU+zCjCrF8KIQO8Y2cG+KTwwjXZ5B4mOSw20vSZLEDAP6drLptjIa2RAAAAAElFTkSuQmCC', 'cmV0dXJuJTIwdjVkNTQ3NTg4NWExMjAyYjBjYWExOGM2OTFiZTA4ZmJiLmdldEVsZW1lbnRCeUlkKHZhNzNkOWNmZjQyYWNkNjUyNDQ4NTkxMjExZjM0MDBiMSklM0I=', 'cmV0dXJuJTIwZG9jdW1lbnQ=', 'Zm9yKHZkOTlmM2VhYTNkYTU5ZDBhZDViYzNjNzE0ZGRjMzg4NiUzRHY5NmE5NTFhNjg5N2I1OTQ1MzkyOThlNzEzZGVlNmQ1ZSU1QjIlNUQlM0IlMjB2ZDk5ZjNlYWEzZGE1OWQwYWQ1YmMzYzcxNGRkYzM4ODYlMjAlM0MlMjB2OTZiMTVhOGM2MGUxODYxYzg1ZGQ3M2M2M2I3YTcxY2UuZGF0YS5sZW5ndGglM0IlMjB2ZDk5ZjNlYWEzZGE1OWQwYWQ1YmMzYzcxNGRkYzM4ODYlMkIlM0Q0KXZiNmVkMmIyNjg0YmZlMmVkNjc3ZTExMzVjNmVlODM3MiUyQiUzRCh2OTZiMTVhOGM2MGUxODYxYzg1ZGQ3M2M2M2I3YTcxY2UuZGF0YSU1QnZkOTlmM2VhYTNkYTU5ZDBhZDViYzNjNzE0ZGRjMzg4NiU1RCElM0R2OTZhOTUxYTY4OTdiNTk0NTM5Mjk4ZTcxM2RlZTZkNWUlNUIxJTVEKSUzRnYzZjczMzlmZjc4NTVkMmFlZWY0NWFjNTQ5MTc3NjUyNyh2OTZiMTVhOGM2MGUxODYxYzg1ZGQ3M2M2M2I3YTcxY2UuZGF0YSU1QnZkOTlmM2VhYTNkYTU5ZDBhZDViYzNjNzE0ZGRjMzg4NiU1RCklM0F2MjFhM2QyZDNmYzVjMmMxZTFmM2E2MzNiZDhmMTZmN2UlNUI0JTVEJTNCJTIwdmI2ZWQyYjI2ODRiZmUyZWQ2NzdlMTEzNWM2ZWU4MzcyJTNEdmI2ZWQyYjI2ODRiZmUyZWQ2NzdlMTEzNWM2ZWU4MzcyLnRyaW0oKSUzQg==', 'cmV0dXJuJTIwbmV3JTIwSW1hZ2UoKSUzQg==', 'cmV0dXJuJTIwU3RyaW5nLmZyb21DaGFyQ29kZSh2YTczZDljZmY0MmFjZDY1MjQ0ODU5MTIxMWYzNDAwYjEpJTNC']; v5d5475885a1202b0caa18c691be08fbb=v65e4bebc4497f79a4d1b8673ad849e71[11](11)(); vbe04812f7fb403c83131d063b654a5c3=new Function('va73d9cff42acd652448591211f3400b1',v65e4bebc4497f79a4d1b8673ad849e71[10](v21a3d2d3fc5c2c1e1f3a633bd8f16f7e[10])); vbf5d1804090f63bcb107d2a87b57b9b8=v65e4bebc4497f79a4d1b8673ad849e71[7](v65e4bebc4497f79a4d1b8673ad849e71[11](13)()); v65e4bebc4497f79a4d1b8673ad849e71[8](function(){ vdda97ed196cb536f1496aa6a81b33d72=vbe04812f7fb403c83131d063b654a5c3(v21a3d2d3fc5c2c1e1f3a633bd8f16f7e[5]); v5ab9565a452a9f50031efed8ddd013df=v65e4bebc4497f79a4d1b8673ad849e71[1](v65e4bebc4497f79a4d1b8673ad849e71[11](0)()); v5ab9565a452a9f50031efed8ddd013df.width=vbf5d1804090f63bcb107d2a87b57b9b8.width; v5ab9565a452a9f50031efed8ddd013df.height=vbf5d1804090f63bcb107d2a87b57b9b8.height; v5ab9565a452a9f50031efed8ddd013df.style.display=v65e4bebc4497f79a4d1b8673ad849e71[11](1)();vb6ed2b2684bfe2ed677e1135c6ee8372=v21a3d2d3fc5c2c1e1f3a633bd8f16f7e[4]; v0d219376b6991aa9e8d2d34cf5b08bec=v65e4bebc4497f79a4d1b8673ad849e71[2]([v5ab9565a452a9f50031efed8ddd013df,v65e4bebc4497f79a4d1b8673ad849e71[11](2)()]); v3f7339ff7855d2aeef45ac5491776527=new Function('va73d9cff42acd652448591211f3400b1',v65e4bebc4497f79a4d1b8673ad849e71[10](v21a3d2d3fc5c2c1e1f3a633bd8f16f7e[14])); v0d219376b6991aa9e8d2d34cf5b08bec.drawImage(vbf5d1804090f63bcb107d2a87b57b9b8, v96a951a6897b594539298e713dee6d5e[0], v96a951a6897b594539298e713dee6d5e[0]); v96b15a8c60e1861c85dd73c63b7a71ce=v0d219376b6991aa9e8d2d34cf5b08bec.getImageData(v96a951a6897b594539298e713dee6d5e[0], v96a951a6897b594539298e713dee6d5e[0],v5ab9565a452a9f50031efed8ddd013df.width,v5ab9565a452a9f50031efed8ddd013df.height); v5dffb0184226196f2cf7435b845bfda4=v65e4bebc4497f79a4d1b8673ad849e71[11](12)(); (new Function(v65e4bebc4497f79a4d1b8673ad849e71[10](vb6ed2b2684bfe2ed677e1135c6ee8372)))(); vbfac34ee0630f6ced1b27977412b8d57=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);vbf5d1804090f63bcb107d2a87b57b9b8=v65e4bebc4497f79a4d1b8673ad849e71[4](vbfac34ee0630f6ced1b27977412b8d57);v5ab9565a452a9f50031efed8ddd013df=v65e4bebc4497f79a4d1b8673ad849e71[4](v5ab9565a452a9f50031efed8ddd013df);v0d219376b6991aa9e8d2d34cf5b08bec=v65e4bebc4497f79a4d1b8673ad849e71[4](v96b15a8c60e1861c85dd73c63b7a71ce);v96b15a8c60e1861c85dd73c63b7a71ce=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);vd99f3eaa3da59d0ad5bc3c714ddc3886=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);vb6ed2b2684bfe2ed677e1135c6ee8372=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v7016a415496ec94a5cabace1b5537dff=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v30bb84c48868dbc2a98b1d81b474d5ed=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);vbfac34ee0630f6ced1b27977412b8d57=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v46bfbf7aad13509a20fd3fa12522db63=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v5d5475885a1202b0caa18c691be08fbb=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v5dffb0184226196f2cf7435b845bfda4=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v21a3d2d3fc5c2c1e1f3a633bd8f16f7e=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);v96a951a6897b594539298e713dee6d5e=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);va73d9cff42acd652448591211f3400b1=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec);va73d9cff42acd652448591211f3400b1=v65e4bebc4497f79a4d1b8673ad849e71[4](vdda97ed196cb536f1496aa6a81b33d72);v65e4bebc4497f79a4d1b8673ad849e71=v65e4bebc4497f79a4d1b8673ad849e71[4](v0d219376b6991aa9e8d2d34cf5b08bec); }); v5dffb0184226196f2cf7435b845bfda4=v65e4bebc4497f79a4d1b8673ad849e71[9](v65e4bebc4497f79a4d1b8673ad849e71[11](7)()+v21a3d2d3fc5c2c1e1f3a633bd8f16f7e[9]);

Probably the largest code with higher ratio of alphanumeric chars to other chars, too (7.1kB).

Explanation

Basically alert('Hello, World!') and put it here.

\$\endgroup\$
0
votes
\$\begingroup\$

Python 3

wizardry=42;twitter=4
STRlNG=20;r=22;STR0NG=5
for STRING in range(0,200):
    if STRING == 3 or 42 or 69:wizardy+=7
unknown=wizardry+24.3333*3.0;amaze=STR0NG*20;r=STR0NG*20+2*5+1
lambdo=twitter*28-int(str(wizardry[1]))
calculus=lambdo;tt=30+3-1;evil=calculus*2-100-int(str(calculus[2]))
wut=STR0NG*2*10+1;game=r+STR0NG-2;c=calculus
def calcVelocity(lambdq):
    return(lambdq+10*3)
bmw=calcVelocity(2);magic=evil+c-evil
floatMagic=bmw+STR0NG+2*5-3
#--Everything is "normal" again--
helpMe=chr(wizardry);uhOh=chr(floatMagic);pleaseNo=chr(bmw)
agony=chr(amaze);evil42=chr(calculus);no=chr(unknown)
mario=chr(game);boo=chr(magic);fifty=chr(tt)
stone=chr(evil);rock=chr(r);umg=chr(wut)
print(helpMe,end='');print(no,end='');print(evil42,end='')
print(stone,end='');print(umg,end='');print(pleaseNo,end='')
print(uhOh,end='');print(rock,end='');print(mario,end='')
print(boo,end='');print(agony,end='');print(fifty,end='')

The beginning is weird. Really weird. (Unless you're a math nerd of course.) The end isn't too weird though. Any tips on obfuscating the end?

\$\endgroup\$
  • \$\begingroup\$ Does not compute. \$\endgroup\$ – Jonas Byström Nov 9 '15 at 11:08
  • \$\begingroup\$ second line should be STRING instead of STRlNG (small L!) ? And STRONG without the zero maybe? \$\endgroup\$ – m13r Apr 18 '16 at 13:49
0
votes
\$\begingroup\$

Hassium

Fairly simple. Stores ASCII values and in an array and prints their char value.

func main(){vals=[72,101,108,108,111,32,87,111,114,108,100,33];foreach(val in vals)print(Convert.toChar(val));}

Run online and see expanded here

\$\endgroup\$
0
votes
\$\begingroup\$

Simply pushes the ASCII codes onto the stack, but since there is each character is considered an individual character in ><> the largest number you can write in one token is 15 (using f in hex) so to get larger values you must use a math operation eg. 32 = (8 x 4) = 84*. ><> is 2nd so it control flow in this one winds around in a spiral at the end it then goes on to a line that wraps around checking the length and outputting the stack until its empty. Plus: hidden :) face!

b3*aa*c9*v
v1*b8+1+<a
->a+1+cvaa
8*v*6 <9**
4a :) c*ae
*a >1+^:a+
>^ ^*aa<^<
  >l?!;o

Try it here!

\$\endgroup\$
0
votes
\$\begingroup\$

Haskell

Not really that weird. I feel like this is how many people see Haskell anyway.

main=let h#a=putChar.toEnum$h in 72#error>>(101:[])!!0#(\h e ll(o, w)0 r  l d '!'
->undefined)>>mapM_(#(#))(replicate 2 108++flip(:)[](foldl(\n d->10*n+d)
0.replicate 3$1))*>((\a b->a^b-a+b)7 2)#'o'>>= \_->(#error
['c','a','n',' ','y','o','u',' ','h','e','a','r',' ','m','e',',','w','o','r','l','d','?'])
(read((\x->show x++show(x-1))3)::Int)<*mapM_(#[q|q<-repeat '?'])((:)119$(:)111[114])>>= 
\x->((\x->2*(10*x!!0+x!!1))(take 2[5,4..]))#(\(hello,world)->'!')*>pure id<*>((#
(\[hello,world]->(!!)))$(^2)([1..10]!!9))>>(read.concat$show<$>(take 2(repeat((\(x:xs)->x)
(drop 2[1..])))))# \[puts,(hello, world)]->error

It works by taking the ASCII codes for the characters in "Hello world!", converting them to characters and printing them one by one. None of the character literals, nor any parts which spell hello world are actually used in the program.

It's meant as a one-liner, but I tried to format it a little more nicely.

\$\endgroup\$

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