on the Dyalog APL terminal

abcde fghij

outputs

VALUE ERROR

BF

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

It just outputs a set of laughing smileys:

:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D:D

Size of code and its output are both 80.

Python, 0 (kind of cheating)

Here's a totally valid Python program:

And here's the output of that program, of same shape:

:)

Python

Smallest thing I could think of.

print 'a'*5+' '+'a'*16

Output

aaaaa aaaaaaaaaaaaaaaa

That space in the middle is part of a string so it doesn't count.

Quines

Any quine (a program producing a copy of its own source code) would do the trick. There are thousand examples on the internet written in many different languages. For example:

Perl, 34 Author: V Vinay

$_=q(print"\$_=q($_);eval;");eval;

Python, 33 Author: Frank Stajano

l='l=%s;print l%%`l`';print l%`l`

Java, 252 Bertram Felgenhauer

class S{public static void main(String[]a){String s="class S{public static void main(String[]a){String s=;char c=34;System.out.println(s.substring(0,52)+c+s+c+s.substring(52));}}";char c=34;System.out.println(s.substring(0,52)+c+s+c+s.substring(52));}}

Tcl, 34 Author: Joe Miller

join {{} \{ \}} {join {{} \{ \}} }

or if you are picky

5 ⍴ 1 + 1

outputs

2 2 2 2 2

Perl

Any program which reads it's own source file will do (technically, it's not considered to be a quine). Here's a simple Perl script (my lack of inspiration restricted me from giving to the code a shape more complex than a diamond/rhombus)!

         use
      warnings;
   use strict;open
(my $IN,'<',$0)or die
   "PCG FTW";print
     <$IN>;close
         $IN

Which will print:

         use
      warnings;
   use strict;open
(my $IN,'<',$0)or die
   "PCG FTW";print
     <$IN>;close
         $IN

HQ9+

 +++    +++
 +++    +++

     ++
++   +Q   ++
++        ++
 ++      ++
  +++  +++
    ++++

Or, something like this:

                  ___                       __   _____ 
  ____  ____   __| _/____      ____   ____ |  |_/ ____\
_/ ___\/  _ \ / __ |/ __ \    / ___\ /  _ \|  |\   __\ 
\  \__(  <_> ) /_/ \  ___/   / /_/  >  <_> )  |_|  |   
 \___  >____/\____ |\___  >  \___  / \____/|____/__|   
     \/           \/    \/  /_____/                  Q  

Credits to this site ;)

Basically, anything will work, as long as it has exactly:

• 0 Hs
• 0 9s
• 1 Q

Or, some minimalist solutions:

• 1 char

  Q
  

• 0 chars

Python

Generic solution. Just save the file as 'source.py' and execute.

import random

def main():
    f = open('source.py')
    s = ''
    d = {' ':1,
     '\t':2,
     '\n' :3}
    rstring = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`1234567890-=~!@#$%^&*()_+,./<>?;:[]{}|'
    for line in f:
        for char in line:
            if char in d:
                s += char
            else:
                s += random.choice(rstring)
    print s

main()

May be simplest solution for Python

print'*'*11

and for Py3K

print('*'*13)

and another generic solution for Py3K

import random, sys

def main():
    f = open(__file__).read()
    d = ' \t\n'
    r = ''.join(chr(c) for c in range(33, 127))
    sys.stdout.write(''.join(c if c in d else random.choice(r) for c in f))

if __name__ == '__main__':
    main()

Perl 44 chars

open O,"<$0";while(<O>){y|!-~|P-~!-O|;print}

In action:

echo $'#!/usr/bin/perl\nopen O,"<$0";while(<O>){y|!-~|P-~!-O|;print}' >/tmp/autohide.pl
chmod  +x /tmp/autohide.pl 
/tmp/autohide.pl 
RP^FDC^3:?^A6C=
@A6? ~[QkS_QjH9:=6Wk~mXLJMP\OM!\OP\~MjAC:?EN

reverse:

/tmp/autohide.pl | perl -pe 'y|!-~|P-~!-O|'
#!/usr/bin/perl
open O,"<$0";while(<O>){y|!-~|P-~!-O|;print}

Rot47 vs Rot13:

To correspond to behaviour of Rot13, but from ! to ~, there is 94 chars. I wrote rot47:

#!/usr/bin/perl -s
$                 s
?           $     O
=          *      STDIN
:                   open
$                   O
,                "<"
.                  $
0           ;while
(       <$O>
)      {#
y|!-~|P-~!-O|
;    print   }

(I've tried to draw beavis, but this is not very well!)

Store them, for sample in autohide.pl:

chmod  +x autohide.pl 

with executable rights,

./autohide.pl
RP^FDC^3:?^A6C= \D
S                 D
n           S     ~
l          Y      $%sx}
i                   @A6?
S                   ~
[                QkQ
]                  S
_           jH9:=6
W       kS~m
X      LR
JMP\OM!\OP\~M
j    AC:?E   N

Than, there is no reverse operation, it's only repeat same translation.

When run with -s parameter, this use STDIN instead of himself code, so running ./autohide.pl -s <autohide.pl do same as if run without argument:

./autohide.pl -s <autohide.pl | ./autohide.pl -s
#!/usr/bin/perl -s
$                 s
?           $     O
=          *      STDIN
:                   open
$                   O
,                "<"
.                  $
0           ;while
(       <$O>
)      {#
y|!-~|P-~!-O|
;    print   }

Bash 9 8 chars (Thanks @FireFly)

rot13<$0

This match requirement:

• output same amount of character in the same shape as the code
• rot13

Practical

echo  >autorot13.sh 'rot13 <$0' 
chmod  +x autorot13.sh 
./autorot13.sh 
ebg13<$0