127
\$\begingroup\$

Create the shortest possible obfuscated program that displays the text "Hello World".

In order to be considered an obfuscated program, it must meet at least two of the following requirements:

  • Does not contain the characters: h, l, w and d in any case
  • Does not contain the characters: e, o, r, 0, and 1 in any case
  • Does not contain the characters: 2 or 7

Input:
none

Output:
Hello World

Leaderboard

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 307; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

\$\endgroup\$
  • 7
    \$\begingroup\$ I guess import in python is not permitted. \$\endgroup\$ – Alexandru Feb 1 '11 at 0:07
  • 26
    \$\begingroup\$ Does these rules apply to language keywords as well? \$\endgroup\$ – hallvabo Feb 1 '11 at 13:04
  • 8
    \$\begingroup\$ are those case insensitive restrictions? \$\endgroup\$ – oenone Aug 4 '11 at 14:22
  • 20
    \$\begingroup\$ Could someone explain why 2 and 7 are not allowed? I'm just curious as I don't see why those were chosen in particular. \$\endgroup\$ – Thomas Eding Aug 5 '11 at 23:01
  • 4
    \$\begingroup\$ @trinithis, and others, ASCII character 72 is "H" which is why I chose those two \$\endgroup\$ – Kevin Brown Sep 18 '11 at 23:18

129 Answers 129

1
\$\begingroup\$

05AB1E, 5 bytes (non-competing)

Breaks none of the rules, code:

”Ÿ™‚ï

Uses CP-1252 encoding. Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ This is invalid. The expected output isn't Hello Dc. You must use ”Ÿ™‚ï instead. \$\endgroup\$ – Erik the Outgolfer Apr 26 '17 at 16:44
  • \$\begingroup\$ @EriktheOutgolfer Thanks, I have corrected it. \$\endgroup\$ – Adnan Apr 26 '17 at 16:55
1
\$\begingroup\$

Brainf*** (106 characters)

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! \$\endgroup\$ – FlipTack Nov 11 '17 at 19:53
  • 1
    \$\begingroup\$ BTW, there's an open-ended +500 bounty for anyone beating the current Brainfuck "Hello, World!" record (78 bytes -- with a comma and an exclamation point). \$\endgroup\$ – Arnauld Nov 11 '17 at 20:01
1
\$\begingroup\$

Data URI 28 bytes

data:;base64,SGVsbG8gV29ybGQK

Copy and paste into the browser url bar

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Befunge-93, 24 bytes

9"mu{x`)xuunQ">9#,-#$:_@

Try it online!

Violates no rules. Simply pushes the text shifted by 9 and subtracts 9 from each character before printing.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Japt, 9 bytes

`HÁM WŽld

Try it online!

The built-in shoco compressor just did the perfect job to remove eor.

Alternatively, slightly less obvious:

16 bytes

"Ifmmp!Xpsme"c_É

Try it online!

c maps over the charcodes, and is a decrement function. É is a shorthand for -1.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

PI based program: 168 char

#!/bin/bash  

pi=$(bc -l <<<'scale=4000;4*a(1)')
pi=${pi//[$'\n\\']}
for v in aF Fb e3d F78 67a 172 496 12A 867 52D E3d 667 eAc;do
    printf -vv %b \\${pi:16#$v:3}
    o+=$v
done
echo $o  

Do render:

Hello, World!

Nota: in order to prevent long time compute, you could use pre-computed 4k pi value:

#!/bin/bash  

pi=$(gunzip < <(base64 -d <<-eof
H4sIAHM1DVwCAyXXB3IDMQwDwB9lJFH1/x/L4pxJcWwVEgRAXv312dcbe9W677wadecee1bdGuetNu6d/Z2+X71XZ/W27mjvzDenjdXO7Xu2Pe4e7b7nz20171g1R++n7fPu6PO2u1evcW3Ze5723DR3e2vlxFH92LLebLePO2+3d+b62ds4rVu+nNfWWm/bOMab9635qtXt
eUukXWBr7/WqLMk5/hVL1bn73Op7jdOH09rrMx9ZLQlxCHn3NtessbOlV73a7YzdxrS4j1NnzHVPE3/b1ddy4Zl+LYD4lvl4Y01nn74KiO70xmsOat2Jbfm2Y7QpSnfIbu63+lOF3qExs+hIuPY6663Xnz1vdNH1k0zF59UrUPR+ndZO4KjzBKAsa59a/V7bh4Dv60Mh7bwl
hieX8W4Jzc+YKgeCWarTxOPjueutMaZ0wXS8q4BfZF6fIwXRnH72EMPZbgll4NDzB5yzpc6ttbWV8sB57Fq7XbtFdTpiHH/v20GqtovOPTiyMaK9JmBplKC8pcLrLkvaaucllR1M/dSaqaSEex+SEqkTLzIqfleVd7sU3zkzlzb4iEz9XCWG931dRX3nNv+G2u/ICUlTCiW+
KwoI0ecS0H4NiNQxAAQyhA3P7molR6VREJTorcu+OtLVhc/FfH8LKN7oot4BMFh1MNv8Prm8hsNnLScKQ/wrqip0KQD45NPfC3Q9QF61SCnG2BcnpQiOYaHXKo13KrU/kC4CkNpALcEB9S4nW3sjlo2tIcgHrsQAb624vKC6IJ5bgYnMqFoh1XxwPEmv5nmdHigCDVwx6QSh
G2bDjygcj90ojNk3ukGs1V7QONKtMzchw09lbWuzCR3X+j5K9fx3o5qJGgIXL70u25pU5TMDOWlMN8Uekm+4CH/aYFTgheDHBFhl+bQpFZ1xrajxzgh1//QhXALB9+sk8s4Vflu79ttxBJ4V31kxJjoME8SnAiW9g4MENLkSMtET+3gS4iVz7Pdj8UlZZ9wz7vBqAke1UNmC
mfI4HdugBkFeCF1mOoMay5QWHC17OVFYQUygsoSsfaDADo6Hoo+8iDfYtMGYQhcnPCy5MYYZbLjvFsuLoWgIITnXhFyPtBVKlQ5EeKyvz1PQPO4vLtTbUTr4Yg/hJUFbViBicukhzo9fWaiCffnf4THambPd8eIA8XlSUfXDjjpDLGyiljFDoSEcEEgY1QiErCE2BodkK6HP
SOj7qgKR0ZRT2weDIvsP5a1Lc+M6/GKd3Fkf+cFgUQ97lWSRXhpHpUs1mxsxuR8w8V7hjfAypjO/nuVkYa1UWb4MXqESWcTJwCvlmx+oxPXixTocNjLvmMWOIaI1O2a9ALxBHJnSCtwWBEgvjVRz3lyJNaZPOeOmvBHKy2r8Y68i3YG0ghd240+MRrMNkUd6g3VY6TYnRBl+
KdfBKD7siqZUqiCgGGALCkJHbBjMpftlKtDXZ7E1zJEUd6FiFDwyl5I+zBly9Yodzs9lb5wVjxAbD7lT6HPSWjQROSUYgfsharJlLdiq4O+7WGlsd2l8++Qt1bnex3M2NdNTJaPoN40O3lIGbmxLtVSPVg02gS6v4Ro94Bggo4W+4s2M2WvUZoEsRywoiHdovHK+5lkZc4aW
MgLsxwEM9yEWpPyhXogJRIjv87OlGytO+/dedMgD9443or0D1o6JMYb1cSoTwcm0AmD2wq8pYmf2KIxAR0ZxdrzruMUMlO0adkubogPTm9grA4+sCrLCVYmUf8U/YzSZAMiF3dwMMz4+X3vmahm9brill+OFlq+WIypeAY07ODxdNGMTgrzYr0owkUtxmUTCJCggKhPKeMCN
eZ1oif1kfDEskV3sfU55rGyOR35jjvqwgIoIrO/fBNGJKiOLXNHBCUyG6WG1gI8+b1h0wVHYdFj6ML+aL1xnODmZn/QiDNj842NmVKQ5fJI2IfEv23tImLaLDS2DUoxm6VS4lzHVmKMP7Qwvnzt/HbjHWU+0sdLsYwZqluY+M3F9cvpUfz+3/OaQlzpk3OP3TnNleoVV71cp
fshDWIZMscOYF0q1tPWMSXGaYKMz3kyJwTsilF2l576Yu0IZG06mmCQuRNQ9FV+XFtdMf4drPHt87WenzUHmxIStpqKVmfUTuVlC/TN5I2DFmdG4pSjkZZC/GSCD066MVWny8YqAvtSfxiULQDNCPFLjVMuXjqgfZDCksMwstkBH6wG0y42x4eLIQ0eLhkEkv0BCuBGs1L+R
/2WEJ04KSlfOvJpHDLmqv3jjvRmi0F7JmE7G7BHiqb4QEcN93+zx9Lmv0b1vsM5sA7QoZGVICYJiTPB5tmD9TcYY44YMRQw7mutxYmUBAZtOLyHNyk1EofXm0QrtRKjZ5GGrUhz5Vp5A8irLfi1gwQlvvhkko9L6HiG8DS91x/zcxjk3fG+US5d8Vw/AdvXM6FYBO/aRGe5+
T4Ei3d+DhQk4pXzxBhsDfh5cTnqJBwMx4z9HjINDlUWG0XlaA4NGlJGbt8bt9C8dMsNDnhnT3wHJ/b8y4ldF2xk6MqiifM9zjgZhNmSMysfHm1KM9IawV4HjTNS8EtuIpMwoxh4RS14GYb80I3nROorUvmc/g3L44YQgt/NU6bsZk+Sq7rF6HVzkvKUyprOHPBPdzI4QN9R8
/gQdxZLdztSrPdf35JFHUg4Crbyl4QkDpnnMQAvMy0xpYZ4T8vgAkDyW7ozmOXdkkFPKnWP+AVkFcIuiDwAA
eof
))
for v in af fB e3D F78 67a 172 496 12A 867 {52,E3}d 667 EaC;do
    printf -vv %b \\${pi:16#$v:3}
    o+=$v
done 
echo $o

Will render (same, but quicker):

Hello, World!
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Z80Golf, 21 bytes

Contains unprintable bytes, so here's xxd (breaks rule 1):

00000000: 0063 6b71 6e56 1f6e 6b6b 6447 2e0b 7e3c  .ckqnV.nkkdG..~<
00000010: ff2d 20fa 76                             .- .v

Try it online!

    nop
    ld h, e ; 'Hello World' backwards if you add 1 to each byte
    ld l, e ; execution falls through
    ld (hl), c
    ld l, (hl)
    ld d, (hl)
    rra
    ld l, (hl)
    ld l, e
    ld l, e
    ld h, h
    ld b, a
    ld l, loop - 3
loop:
    ld a, (hl)
    inc a
    rst $38
    dec l
    jr nz, loop
    halt
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

DOS .com executable: 31 bytes

BE 13 01 AC B4 02 34 FF 88 C2 75 03 80 C4 4A CD
21 EB F0 B7 9A 93 93 90 DF A8 90 8D 93 9B FF

Stores the string byte-inverted, outputs using DOS syscalls. Contains none of the banned characters.

source:

.code16
.org 0x100
start:
 movw $str, %si
l:
 lodsb
 mov $0x02, %ah
 xor $0xff, %al
 mov %al, %dl
 jnz 1f
 add $0x4a, %ah
1: int $0x21
 jmp l
str:
.ascii "\xb7\x9a\x93\x93\x90\xdf\xa8\x90\x8d\x93\x9b\xff"
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Runic Enchantments, 39 bytes

\>`''`
\+kw+kwb8qn;' 83*´34 f-;@

Try it online!

As seen in Notepad++ to better distinguish the non-printing bytes:

Notepad++ view

Violates only rule 1. I had fun computing the first line (a sequence of raw byte values). Alternatively I could have violated rule 2, but I felt that doing so was less obfuscated. There's four different methods used in the 39 byte solution for generating integer values, making it hard to figure out what's going on (compared to just some mathematical operators in the 17 byte solution).

39 byte solution must occupy two lines.

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

Gol><>, 21 bytes

"mu{x`)xuunQ"T:Z;9-ot

This is a program that JoKing made, golfing the heck out of it.

Try it online!

Old version, 37 bytes

"Fcjjm"b3+s"Umpjb"c&rT&M:&33-)QPPot|;

This is a really simple, not very creative way of doing this, all it does is just encode everything 2 below their actual ascii encoding, the hardest part is not using 'l', which in gol><> is the length of the stack!

Try it online!

| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

naz, 80 bytes

9a8m1o9a9a8a3a1o6a1a1o1o3a1o0m9a4m8a1o9s3s1o3m9s1o9a9a6a1o3a1o6s1o8s1o0m4a8m1a1o

Breaks rule 2 only.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Assembly: 117 source chars, 29 byte .com file

Assemble using A86.

mov si,273
mov ah,2
mov dl,133
lodsb
add dl,al
int 21h
lodsb
add dl,al
jne 266
ret
sbb ax,7
add si,[bx+di+6199]
add di,dx
clc
pushf
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I don't have A86. nasm assembles it, but in 31 bytes, and it crashes DOSBox when run. \$\endgroup\$ – J B Feb 9 '11 at 19:50
  • 1
    \$\begingroup\$ @J B: There's a link to A86 in the post. \$\endgroup\$ – Skizz Feb 10 '11 at 9:13
  • 2
    \$\begingroup\$ This contains the characters 1 and 2 and therefore violates the rules. Maybe you didn’t mean “assembly” but rather machine code and you only posted the assembly representation of it? You need to say this. Otherwise I can just post some C code and say that the entry is the compiled binary... \$\endgroup\$ – Timwi Mar 8 '11 at 20:33
  • 1
    \$\begingroup\$ @timwi: it contains 'h', 'd', 'l', '7', 'e' and 'o' as well. But then you'd be hard pressed to write any assembler code that didn't have those characters. Even the machine codes would have 0,1,2 or 7 somewhere. \$\endgroup\$ – Skizz Mar 8 '11 at 21:49
  • \$\begingroup\$ I guess that means your entry violates the rules. Sorry. \$\endgroup\$ – Timwi Apr 4 '11 at 10:50
0
\$\begingroup\$

dc 48

8 9*P101P108P108P111P4 8*P81 6+P111P114P108P100P

One way how to execute:

dc<<<"8 9*P101P108P108P111P4 8*P81 6+P111P114P108P100P"

The solution conforms to the first and the third rule.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

C code:

#include
main(){int x=0,y[14],*z=&y;*(z++)=0x48;*(z++)=y[x++]+0x1D;*(z++)=y[x++]+0x07;*(z++)=y[x++]+0x00;*(z++)=y[x++]+0x03;*(z++)=y[x++]-0x43;*(z++)=y[x++]-0x0C;*(z++)=y[x++]+0x57;*(z++)=y[x++]-0x08;*(z++)=y[x++]+0x03;*(z++)=y[x++]-0x06;*(z++)=y[x++]-0x08;*(z++)=y[x++]-0x43;*(z++)=y[x]-0x21;x=*(--z);while(y[x]!=NULL)putchar(y[x++]);}

Output :

Hello, world!
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Ruby (42 chars, rules I & III)

puts"\x48e\x6c\x6co #{'V'.succ}or\x6c\x64"
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Python: 66 characters

op=""
for i in "Tqxx{,c{~xp":
    op=op+chr(ord(i)-(4*3))
print op
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$
void main(){
int a[100]={4,1,8,8,11,-68,19,11,14,8,0,0,0};
for(;a[13]<a[4];a[13]++)
{
    printf("%c",100+a[a[13]]);
}

}

Funny,isn't it?

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

XeTeX

Compile with xetex, output is in generated PDF. Of course, this still breaks some of the rules (still uses forbidden digits) and could be obfuscated and compacted a lot more, but I am tired and have to go to bed. Well, maybe you like it anyway :-)

\let~\def
\toksdef\|0
\let\ea\expandafter
~\>{\uppercase{\|\ea{\the\|.}}} 
~\.{\uccode`.\numexpr32+}
~\u#1{\|{}\ea\v\number`#1 \^^J{\iffalse}..\fi\relax}
~\v1#1#2#3#4{\.#1#2\>\.#3#4\>\ea\v\number`}
\u{㛵䔌䘣䘾䔄}\the\|
\bye
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Brainfuck, 94 Characters

++++++++[>++++[>++>+++>+++>+++>+<<<<<-]>+>+>+>-[<]<-]
>>.>---.>++++..+++.>>.<-.<.+++.------.<-.

Obvious, being BF it breaks none of the rules.

If I lowercase the output it's only 86, but I don't think that's allowed.

>+>++>++>+++[>[->+++<<+++>]<<]
>--.---.>>+++..+++.>-.<++++++++.--------.+++.------.<<-.

The first one is a balanced nested loop generator, the second is a slipping (or sliding) loop generator

NB: The newlines in the code are for this message, they should be removed for running or counting.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

PHP

This is a very cheap trick (30 bytes):

<?=cONSTAnTINO_^'+*"?;a9;;"+'

Not much to see here.

Rules broken: none (the O.P. said o, not O)


Going really cheap on this one (25 bytes):

Create a file called cONSTAnTINO_ and run:

<?=__FILE__^'+*"?;a9;;"+'

There's nothing saying about file names being forbidden.


But if we want to go REALLY dirty, just do (10 bytes):

<?=__DIR__

And run a file from a directory called Hello World.


Enough of being cheap!

Here is another attempt (97 bytes):

<?foreach([144,405,650,867,1114,389,1224,1783,2060,2169,2210]as$k=>$v)echo chr($v/(($k+1*2)+$k));

Yeah, pretty huge, right?

Sadly, it breaks 2 rules.

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ You were successful in breaking the second restriction in your first one because the OP mentioned "in any case" (but it's only one restriction, so it's fine). But your second and third ones use a standard (forbidden) loophole and break restrictions 1 and 2. \$\endgroup\$ – Kevin Brown Jul 6 '15 at 1:19
  • \$\begingroup\$ @KevinBrown Those aren't serious answers. The purpose of those is to show how much I can cut If I go really cheap (a.k.a.: cheat). \$\endgroup\$ – Ismael Miguel Jul 6 '15 at 1:28
0
\$\begingroup\$

Cardinal, 73 71 68 chars

>----~n*,n*,n*,,n*,n*v
- xx  Nj kr rx  u  &],
\-%xx,*u,*u,*u,*u ,*u<

My previous, less obfuscated version (73 chars) for better understanding:

>--- ~n*,n*,n*,,n*,n*,n*,n*,n*,n*,n*,
\---%xN  k  r   u  &  ]  u  x  r  j

Start at %, first move to the left, decrement the active value by 3 (---). () reflects the IP upwards, (>) changes the direction to the right. Then decrement by 3 more (---), swap active and inactive value (~). Then read in the char below (n), store it as active value, add the inactive value to it (*) and output the result (,)... rinse and repeat.

‘n’ places the active value of the ip above the arc of the character n, u puts it below the arc of the character u, then picks up the value of the character above (u) or below (n) the “open” side of the letter and stores the value as new active value. The corresponding instructions in horizontal direction are ‘(’ and ‘)’.

Cardinal is an esolang invented in 2010 http://esolangs.org/wiki/Cardinal

The original interpreter has some bugs, but this example works without problems. I recompiled the source to get rid of the worst bugs so far, in case someone is interested.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Ruby, 66

puts ""<<(61+11)<<101<<108<<108<<111<<' '<<(31+56)<<111<<114<<108<<100

It breaks rule 2

Ruby, 43

Also based upon @Nemo157 answer:

puts "Gdkkn~Vnqkc".split("").map(&:succ)*''

It breaks rule 1

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

CBM BASIC v2.0 (66 characters)

I think Mark's answer, while very clever, verges on cheating as it exploits the lack of lowercase letters in the machine's default non-ASCII character set. Here's a somewhat longer program that doesn't rely on the PETSCII quirk. It breaks only Rule 2.

3a=44-33:a$="emspX!pmmfI
4?cH(aS(mI(a$,a,a/a))-a/a);:a=a-a/a:ifagO4
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Swift 2.0, 243 bytes

Works for Swift 2.0 on Xcode 7 and above.

var s = " ".join(["Gdkkn", "Vnqkc"].map({
    var usv = String.UnicodeScalarView()
    for a in $0.unicodeScalars.map({ 
        UnicodeScalar(($0.value + 4 - 3)) }) { usv.append(a) }
    return String(usv)
}));

print(s, appendNewline: false)
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG, this challenge type is called code-golf, and for that we include the length of our program in bytes/characters in the title. Also, as a side challenge, you should try and get your program as short as possible by removing unnecessary whitespace, newlines etc. \$\endgroup\$ – Beta Decay Jul 6 '15 at 13:13
0
\$\begingroup\$

C#, 143 bytes

First i put in an array the decimal values for each letter in text

Hello World.

Then in each world i call (char)decimalValue

Example

(char)111

returns o in C#.

namespace N{class P{static void Main(){int[] i={13*8,69,36*3,36*3,111,119,111,114,19*4,68};foreach(int v in i)System.Console.Write((char)v);}}}
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ You should say a little something about how this works in your answer. \$\endgroup\$ – Justin Feb 20 '14 at 19:55
  • \$\begingroup\$ Breaks the rules. Have a look at TimWi's solution. That's how it's done. \$\endgroup\$ – RobIII Feb 21 '14 at 1:15
0
\$\begingroup\$

Detour, 18 bytes

`<u
@'Ifmmp!Xpsme'

Basically the same as @gnibbler's answer, only breaks rule 2.

Try it online!

The 19-byte version breaks none of the rules:

Detour, 19 bytes

`<<u
@'Jgnnq"Yqtnf'

Try it online!

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

JavaScript, 77 70 69 characters

This satisfies conditions number 2 and 3.

"H"+([]+![])[4]+"ll"+([]+{})[+!![]]+" W"+([]+{})[+!![]]+([]+!![])[+!![]]+"ld"

a=!![];b=([]+{});c=b[+a];"H"+([]+![])[4]+"ll"+c+" W"+c+([]+a)[+a]+"ld"

a=!![];b=([]+{});c=b[+a];`H${([]+![])[4]}ll${c} W${c}${([]+a)[+a]}ld`

Please help me shorten this up.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Molecule, 7 chars (18 bytes)

"ৣ҆͢๡Ԫł"C

Molecule uses Chocolate Compressor to compress strings.
So I just decompress it.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Vim, 31 keystrokes

ia<C-v><C-v>92<esc>22<C-a>SU<C-o>@"yyb Jb<C-v>x65yq<esc>g?g

This was really fun! I'll write an explanation a little bit later.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

tcl, 104

\u6cmap x {G d k k n \U1F V n q k c} {scan $x %c n;incr n;puts -n\u6Fn\u65w\u6cin\u65 [f\U6Frmat %c $n]}

Almost meets 3 requirements. Unfortunately I am not successful when I try to use directly the char by key pressing Alt+Num 31, representable as:

Dec U-Hex  Oct
\31 \U1F   \037

which happens to have forbidden chars in all number bases!

Available to run on: http://rextester.com/live/GQBHU26987

| improve this answer | |
\$\endgroup\$

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