text:
Draw the shadows of buildings
Input:
1
      X
      X
      X
      X      XX    XXXXXX     X X X
      X      XX    XXXXXX     X X X
XXX   X      XX    XXXXXX     X X X
XXX   X      XX    XXXXXX     X X X

Output:
      X.
      X..
      X...
      X....  XX.   XXXXXX.    X.X.X.
      X..... XX..  XXXXXX..   X.X.X..
XXX.  X......XX... XXXXXX...  X.X.X...
XXX.. X......XX....XXXXXX.... X.X.X....

Input:
2
         XX
         XX
         XX
         XX
         XX
     XX  XX
     XX  XX
     XX  XX
     XX  XX

Output:
        .XX
       ..XX
      ...XX
     ....XX
    .....XX
   ..XX..XX
  ...XX..XX
 ....XX..XX
.....XX..XX

Specification:

You must take as input

A flag signifying whether the light is coming from the top left or top right. This can be 1 or 2, -1 or 1, 0 or 65536, or whatever is convenient for you, as long as both flags are integers.
Rows composed of either X or , all of the same length in characters (i.e. padded with )

All Xs will either be on the last row or have an X under them (meaning no floating buildings)

You must output the rows (buildings) with shadows added. This is done with the following procedure:

If the light is coming from the top left, draw a right triangle of .s with the same height and width as the height of the building, starting from one space past its right edge and going rightwards.
Otherwise, if it's from the top right, do the same thing but start from one space past its left edge and pointing left.
Remember, do not alter Xs by changing them to .s; leave them as they are.
There will always be "room" for your shadows, i.e. if there's a 3-space tall building at the end there will be at least 3 spaces of padding after it.

This is code-golf, so the shortest code in bytes will win!

Can I use {} and {-1*} as  flag values?

@Jan Yes, yes you can. You could even use potato and while(1){}. As quoted in the question, "whatever is convenient."

:( I was going to solve this in (.NET-flavoured) regex, but I think I found a bug in Regex.Replace which I can't work around... do I have two problems now?

@Doorknob Someone is going to abuse this rule to just have their entire code in the input.

@Doorknob Now that would open a huge loophole. You can put almost the entire code into the first line and the program would mainly consist of an eval.

@Synthetica That is one of the "standard loopholes."

@Howard (see above comment)

GolfScript, 67 characters
n%(~:S\zip\%.0=\{.' '3$);+{{\(@[\].~<=}%+}:M~'X'/'.'*@@M}%S%zip\;n*

1/-1 for shadows going right/left. Run the example online:
      X.
      X..
      X...
      X....  XX.   XXXXXX.    X.X.X.
      X..... XX..  XXXXXX..   X.X.X..
XXX.  X......XX... XXXXXX...  X.X.X...
XXX.. X......XX....XXXXXX.... X.X.X....

Perl - 85
BEGIN{$d=-<>}$d?s/X /X./g:s/ X/.X/g;s/ /substr($p,$+[0]+$d,1)eq'.'?'.':$&/ge;$p=$_;

EDIT: I totally forgot about the -p flag this needs to be run with. Added 2 to char count.
The flag specified at the first line is 0 for shadows going left and 2 for shadows going right.

Python 3 - 233
Well, that turned out longer than expected...
1 for shadows going right, -1 for shadows going left.
d,x=int(input()),[1]
while x[-1]:x+=[input()]
x,o,l,h=list(zip(*x[1:-1]))[::d],[],0,len(x)-1
for i in x:o+=[''.join(i[:len(i)-l])+''.join(i[len(i)-l:]).replace(' ','.')];l=max(l-1,i.count('X'))
for i in zip(*o[::d]):print(''.join(i))

EDIT: Didn't see the either side padding in the rules. Ehehe. ^^'

JavaScript - 14
eval(prompt())

The flag on the first line  is for(p='';l=prompt();)console.log(p=l.replace(/ /g,function(a,b){return p[b+1]=='.'||p[b]=='.'||l[b+1]=='X'?'.':a})); for shadows facing the left or for(p='';l=prompt();)console.log(p=l.replace(/ /g,function(a,b){return p[b-1]=='.'||p[b]=='.'||l[b-1]=='X'?'.':a})); for shadows to the right.
This might abuse the "whatever is convenient for you" rule for the flag :P

Edit: without abuse (127):
c=prompt();for(p='';l=prompt();)console.log(p=l.replace(/ /g,function(a,b){return p[b+c]=='.'||p[b]=='.'||l[b+c]=='X'?'.':a}));

The flag for this is 1 or -1

Fine, I fixed the rules. :-P

Aaww, that's no fun :-(   This does make "both flags are integers" conflict with your comment "You could even use potato...", unless potato is an integer. :-P

c=+prompt() or else b+c will concatenate as a string.

Optimized a few things and got this down to 119: for(c=p=+(P=prompt)(d='.');l=P();)console.log(p=l.replace(/ /g,function(a,b){return p[b]==d|p[b+=c]==d|l[b]=='X'?d:a})) (demo)

Save another byte on converting c to a number by subtracting instead. b-c or b-=c in my code above. (demo)

Python 2.7 - 229
p,s,M,J,L=input(),__import__('sys').stdin.readlines(),map,''.join,len
n,s,r,f=L(s),M(str.strip,M(J,zip(*s[::-1]))),0,[]
for l in s[::p]:f,r=f+[(l+'.'*(r-L(l))+' '*n)[:n]],max(r-1,L(l))
print'\n'.join(M(J,zip(*f[::p])[::-1]))

Ungolfed Version
def shadow(st, pos):
    _len = len(st)
    st = map(str.strip, map(''.join,zip(*st[::-1])))
    prev = 0
    res = []
    for line in st[::[1,-1][pos-1]]:
        res +=[(line+'.'*(prev-len(line)) + ' '*_len)[:_len]]
        prev = max(prev - 1, len(line))
    return '\n'.join(map(''.join,zip(*res[::[1,-1][pos-1]])[::-1]))


text:
Where will the ball land?
Given a string where the first line contains spaces and one period (., the "ball"), followed by lines containing spaces, forward slashes (/), and backslashes (\), determine what column the ball will land in after falling from its starting position. Each / moves it to the left by 1 column and each \ moves it to the right by 1 column.
Sample input
    .
  /   \  \
    /   /
 \   \/  \
   \   /\
    \ /\  \
     \    /

Sample output
The ball starts in column 5, hits the / on line 3, then the three \'s on lines 5 through 7 for a final position of:
7

Note that columns are 1-indexed, mostly for consistency with text editor conventions.
Edge cases
If the ball hits a / in the first column, it's eternally stuck in the nonexistent column 0. Your program should handle this correctly by printing 0.
If the ball hits either side of a \/ pattern, the result is undefined. Your program is permitted to terminate with no output, loop infinitely, or print an error message (my solution prints -1), but it must not print anything that can be perceived to be valid output.
If the ball hits the left slash in a \\ pattern, it should end up directly beneath the right slash, not to the right of it. The solution I originally envisioned was prone to getting this wrong, so don't go down that path!
There may or may not be spaces after the . or the last / or \ on each line. Your program should not rely on such padding being available. On a similar note, there may or may not be any lines following the first line.
You may assume that the first line will have zero or more spaces and exactly one .. Subsequent lines, if any, will have zero or more spaces and zero or more slashes.
Implementation details
Your program may read from a file (specified as a command-line argument) or read from standard input, at your convenience.
Your program must output a single number to standard output. (Yes, a trailing newline is fine. Yes, the number may have more than one digit.)
Test cases

Input:
.

Output:
1

Note that the input here is exactly one byte. This is the smallest case you should be able to handle.

Input:
 .
 \
  \
   \
    \

Output:
 6

Note that there are no spaces after these slashes.

Input:
  .
  /
 /\\  /  \
//\ \/// //
\\/ \/\ /\/

Output:
0

Input:
  .
/ / /
 \\\
  /\\
 /   \

Output:
1

Input:
   .

 \
       /
/

      \

Output:
4

Input:
 .
 \

\/\/\/

Output:
(anything but a nonnegative number)

Closing remarks
This question is similar to Simulate a (gravity-based) billiard-ball-type computer, but significantly simpler, so hopefully it will gain more interest.
I have a 169-character solution in Python. I'm sure the talented golfers here can tear that record to pieces, though. :^)
This is code-golf, so the shortest answer in characters will be accepted at the end of the month!

It's also very similar to A Mere Bagatelle with a slightly different import format and only one throw. You can borrow and modify my test scripts if you want.

Well, shoot, the title of that question wasn't suspicious enough for me to check it. Sorry about that.

It's okay, that question was two and a half years ago.

I suggest that in the last example, the output should be "The ball is stuck".

Does it count as the end of the month yet >.<

Indeed it does.

Python, 143B
import sys
for l in sys.stdin:
 a=l.find('.')
 if a>-1:F=a
 elif F>-1:
    if'\\/'in l[F-1:F+2]:z
    F+={'\\':1,'/':-1}.get((l+' '*F)[F],0)
print F+1

Using the space/tab indentation trick. I haven't done anything particularly clever here. F is the current index, l is the current line; z is undefined so it throws an exception, which is definitely not a positive integer, handling the \/ situation.

05AB1E, 37 bytes
¶¡ð«ć'.ksvU…/ \yXD>‚èJD„\/Qiõqëнk<X+]>

Input as a multi-line string. Outputs \/ if the ball is stuck.
Try it online or verify all test cases.
Explanation:
¶¡                       # Split the (implicit) input-string on newlines
                         # (work-around instead of `|`, because it will stop at empty lines)
  ð«                     # Add a trailing space to each line (work-around because indexing
                         # -1 in 05AB1E will wrap around to the other side)
    ć                    # Extract head; pop and push the remainder-lines and first line
                         # separated to the stack
     '.k                '# Get the 0-based index of "." in this first line
s                        # Swap to get the remainder-list of lines
v                        # Loop over each line `y`:
 U                       #  Pop and store the top value (the index) in variable `X`
       X                 #  Push the current index `X`
        D>               #  Duplicate it, and increase the copy by 1
          ‚              #  Pair to [X, X+1]
      y    è             #  Index both of those into the current line `y`
            JD           #  Join the two characters together, and duplicate it
              „\/Qi      #  If it's equal to "\/":
                   q     #   Stop the program
                         #   (after which the string is output implicitly as result)
                  ë      #  Else:
                   н     #   Only leave the first character (at index `X`)
  …/ \              k    #   Get its 0-based index in string "/ \"
                     <   #   Decrease it by 1
                      X+ #   And add it to `X`
]                        # After the loop:
 >                       # Increase the top of the stack (`X`) by 1
                         # (after which it's output implicitly as result)

CJam, 61 bytes
qN/('.#)\_:,0+:e>f{' e]" /"f#0\+}{1$1$=\@2$-_@=@[\]$[W1]#/z}/

If the rule regarding \/ is lifted (and we are not required to handle it), this can be shortened to 41 bytes:
qN/('.#)\_:,:e>f{' e]" /"f#0\+0+}{1$=-}/

Java 11, 213 208 190 175 162 160 bytes
s->{int r=s.indexOf('.'),c;for(var x:s.split("\n"))if((c=(x+=" ".repeat(r+2)).charAt(r))!=46&&(r+=c<33?0:c<48?-1:x.charAt(r+1)==47?r/0:1)<0)return 0;return++r;}

Throws a division by zero error when we are stuck inside a \/.
-5 bytes thanks to @EdgyNerd
-17 bytes thanks to @ceilingcat
Try it online.
Explanation:
s->{                             // Method with String parameter and integer return-type
  int r=s.indexOf('.'),          //  Get the index of the dot on the first line
      c;                         //  Temp integer
  for(var x:s.split("\n"))       //  Split the input by newlines, and loop over the lines:
    if((c=(x+=" ".repeat(r+2))   //   Append trailing spaces to the line if necessary
          .charAt(r))            //   Get the character at the current index of this line
       !=46                      //   If this is NOT the first line (the char isn't a dot):
       &&(r+=c<33?               //    If the current char is a space:
              0                  //     Index `r` remains the same
             :c<48?              //    Else-if it's a '/':
              -1                 //     Index `r` is decreased by 1
             :x.charAt(r+1)==47? //    Else-if we're stuck in a `\/`:
              r/0                //     Divide by 0 to exit with an error
             :                   //    Else (it's a '\'):
              1)                 //     Index `r` is increased by 1
         <0)                     //    If `r` is now -1:
      return 0;                  //     Return 0
  return++r;}                    //  After the loop: return the index `r` + 1

I don't know Java at all, but wouldn't causing an error be shorter than returning -1?

@EdgyNerd Thanks, that indeed saves 5 bytes. :)

@ceilingcat Thanks. And been able to save a few more bytes by getting rid of the brackets by putting everything inside the ifs.

Python 3, 124 bytes
import sys
for l in sys.stdin:i=('.'in l)*l.find('.')or(i<0)*i-2*('\\/'in l[i-1:i+2])or' \\'.find((l+i*' ')[i])+i
print(i+1)

Try it online!
Also works in Python 2.
Explanation
for l in sys.stdin:i=          # Change value i for each line in the input
('.'in l)*l.find('.')          # Set i to (0-indexed) dot position if present
or(i<0)*i                      # Keep i fixed if it is below zero
-2*('\\/'in l[i-1:i+2])        # Set i to -2 if \/ trap is encountered
or' \\'.find((l+i*' ')[i])+i   # Else: move position based on character
print(i+1)                     # Print final 1-indexed position

J, 95 bytes
[:>[:(<"1@|.@}.([:(1&{+_*0>[:*/2-/\])(]+{~ ::])^:(<3))&.>/@,2<@i.~{.)[:(0,'/ \'<:@i.]);._1 LF,]

Try it online!
Returns infinity _ when the ball gets stuck.  Lost many bytes handling that special case.  Otherwise it's more or less a simple reduction of the rows.  Could surely be golfed further.

JavaScript (Node.js), 123 bytes
x=>(g=(i,c)=>y[j++][i]==c?g:y[j]+1?(k=y[j][i])=='/'?g(i-1,'\\'):k=='\\'?g(i+1,'/'):g(i,g):i)(x.indexOf`.`,j=0,y=x.split`
`)

Try it online!
0-index, output g if stucked

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Convert image pixels to quadruples
Example given an image which width and height is a power of two .
First step : Divide each image into Cartesian coordinate quadrants

 _____ _____
|     |     |
|  2  |  1  |
|_____|_____|
|     |     |
|  4  |  3  |
|_____|_____|

Second step :  Divide each quadrant to another four quadrants and add new quadrant id after the old one , like this :

 _____ _____ _____ _____
|     |     |     |     |
|  22 |  21 |  12 |  11 |
|_____|_____|_____|_____|
|     |     |     |     |
|  23 |  24 |  13 |  14 |
|_____|_____|_____|_____|
|     |     |     |     |
|  32 |  31 |  42 |  41 |
|_____|_____|_____|_____|
|     |     |     |     |
|  33 |  34 |  43 |  44 |
|_____|_____|_____|_____|

And so on...

 _____ _____ _____ _____ _____ _____ _____ _____
|     |     |     |     |     |     |     |     |
| 222 | 221 | 212 | 211 | 122 | 121 | 112 | 111 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 223 | 224 | 213 | 214 | 123 | 124 | 113 | 114 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 232 | 231 | 242 | 241 | 132 | 131 | 142 | 141 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 233 | 234 | 243 | 244 | 133 | 134 | 143 | 144 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 322 | 321 | 312 | 311 | 422 | 421 | 412 | 411 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 323 | 324 | 313 | 314 | 423 | 424 | 413 | 414 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 332 | 331 | 342 | 341 | 432 | 431 | 442 | 441 |
|_____|_____|_____|_____|_____|_____|_____|_____|
|     |     |     |     |     |     |     |     |
| 333 | 334 | 343 | 344 | 433 | 434 | 443 | 444 |
|_____|_____|_____|_____|_____|_____|_____|_____|

Until number of quadrants is equal to the number of pixels
Should return a 2d array of quadruple coordinates .
Inspired from : https://i.stack.imgur.com/Ib88h.jpg

So what is the input and output?

Did you mean "power of two" height and width instead of "even" ?

Suggestion for input: the side length of the image, in pixels.

What do you mean by "given an image"? Are we given the filename of the image? Or is the binary data of the image piped to the stdin of our program? What is the format of this image (e.g. jpg, png, gif)? If we are to "return a 2d array", does this mean we only have to write a function, not a complete program? P.S. it's "divide", not "devide".

I don't see the problem you guys have. If input and output aren't clearly specified, you're free to choose what's convenient. The problem itself is clearly specified in my opinion.

Well i don't think that file format is important , it could also be a Canvas with imageData .. you choose the problem still there .

Mathematica, 95 86 bytes
Since the method of input has not been specified, I'm simply expecting the resolution to be saved as an integer in the variable n
r={{""}};Do[r=ArrayFlatten[r/.q_String:>{{q<>"2",q<>"1"},{q<>"3",q<>"4"}}],{Log2@n}];r

With indentation:
r = {{""}};
Do[
  r = ArrayFlatten[
    r /. q_String :> {{q <> "2", q <> "1"}, {q <> "3", q <> "4"}}
  ],
  {Log2@n}
];
r

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
The Easter Egg Hunt on the Hill
Easter Egg Hunt
Bot find egg before bunny find egg. Bot happy.
Overview
This is a king-of-the-hill challenge in honor of Easter and the Easter egg hunting tradition!
Your bot has a vision of two spaces in every direction, including diagonals, creating a 5x5 square around you that you can see. It is looking for eggs, and whoever finds the most eggs wins!
The Board
The board will consist of os, which are Easter eggs, #s, which are walls, *s, which are other players, and s, which are empty spaces.

It will be a square with edge length (number of entries) * 3.
It will be surrounded by walls.
Inside of the walls will be an assortment of randomly placed, straight line walls of #, which will have a random length between 2 and 10 inclusive. There will be (number of entries) * 3 of them.
The eggs will then be placed randomly. There will be (number of entries) * 4 of them, and they will only be generated on blank () squares.
There must be at least 7 entires for the board generating process to work properly.

Here is a JSFiddle that will generate a random board for you to test with. Here's an example, with (number of entries) = 7:
#####################
#        o         ##
#    #    o        ##
#    #o    ######  ##
######     #       ##
## o #     #       ##
##  o#   #o#    o o##
##   #o  # # o  #   #
##   # o # #    #   #
##  ##   # #  o #   #
##  #    #  o   # # #
##  # o  #   ## # # #
##  #           # # #
# o #          ## # #
# o oo         ##o  #
#o  ####### oo ##   #
#        #      #   #
#   o o o#          #
#   o ####   o     o#
#                   #
#####################

After the board is generated, each player is placed on a random  square (empty space).
Input
You will take six lines of input. The first five lines are your field of vision (spaces out of bounds of the board will be represented by X, and the middle space will always be *, you), and the sixth line will be empty (at first).
Output
You will output three lines. First, the direction that you want to move in:
1  2  3
8 YOU 4
7  6  5

(9 is a no-op if you don't want to move), second, one of Attack, Counter, or Nothing (this will be explained in depth soon), and the thrid line will be any string of length up to 1024. This will be your bot's memory. You may use it for whatever you would like, or you may leave it blank. This memory will then be the sixth line of input to your program on the next run.
All further lines of output are ignored, and if there is only one line, the second is assumed to be blank.
Moving
The following process is used to determine where you moved:

If, when you move, you end up in an empty space (), your player is placed into that space.
If you end up in a wall (#), your move is ignored and you lose your turn.
If you end up in an egg (o) or on a player (*), this information is stored and will be used after everybody has moved.

After everybody has moved, ambiguities are resolved.
If there are two players that have landed on the same space, a fight occurs! This is where the A/C/N comes in to play. Attack beats Nothing (normal attack), Nothing beats Counter (you can't counter nothing), and Counter beats Attack (counterattack). The player who wins this fight stays on their square, and the player who loses goes back to the original square that they started on. In the event of a tie, both players go back to where they were.
If a losing or tied player goes back to where they were and there is another player there, there is no fight and the other player will also revert to its original space. If this space has another player, that player goes back, and this continues until all players are in different spaces.
If there are three or more players on one space, they all revert back to their original positions.
If any player is still standing on an egg...

If the player chose A, the egg is destroyed.
If the player chose C, nothing happens and the player reverts to its original space.
If the player chose N, the player picks up the egg! The player's score is incremented by one and the egg is removed.

Languages
You may use any language that is freely available on Windows, OSX, and Linux, to ensure fairness among each contestant. If the code is not freely runnable but can be compiled or packaged into a format that is, please include this format in your answer as well. Ideally, if you can compile your code into a more common language (i.e. CoffeeScript -> JavaScript), please do so.
Scoring
Your score will be the average number of eggs you collect out of ten runs. A run ends when all eggs are collected or when (number of entries * 25) turns have passed. I will manually make sure that it is possible to reach all eggs for each map (by continually generating maps until all eggs are reachable).
Scoreboard
A scoreboard will be added when all of the following conditions are met:

At least seven valid entries with a positive or zero score (not downvoted) have been submitted
At least 48 hours has passed since the creation of this challenge (UTC 14:23)

The rules will not change during this pre-contest period, except to add clarification where a rule was unclear. Once the scoreboard is put up, the testing program will also be posted here so that you can test your entries. The testing code for this is still work-in-progress, but it's playable and it works. Here's the GitHub repo.

Can we get the testing program before 7 entries are posted? I like to test before posting, even if it's against "dumb" test-bots. It seems this gives a significant advantage to not posting until several others have.

Regarding players going back. So I could potentially be unlucky and win against an opponent but he steps back into another player and starts a cascade that loop around back to the site of our fight, such that the player who started there sends me back a step as well? (if that's not clear, I'll post a github gist with an example)

@m.buettner Ok fixed that (sorry I'm in a hurry right now, will clarify more later)

Oh and we can see through walls?

A sample control program would be very useful here.

@Geobits Alright, I'll upload my testing program in a sec. There's still a few bugs that need to be ironed out, but it works. (That's why I didn't post it immediately in the first place.)

@m.buettner Yes, that could happen, but the board scales according to how many players there are so it's unlikely.

@m.buettner The "walls" are more like... unpassable obstacles, shall we say. ;) I'll add a cap on the amount of moves per game, but I still think this generation method produces better obstacles for this kind of game.

@m.buettner Yeah, that discarding method sounds better. Thanks for all the help you're putting in to this ;) I would assume that at least one bot would have the ability to scan the whole map, but a move cap would be good anyway in case of an infinite loop or it just taking way too long.

Why not just wrap the map in two layers of walls (#)? It seems simpler to me.

Will I be informed if I am pushed back (whether or not I win)? Also, what will I get for the tile that I'm on? Will I see a space, a *, or what?

@Quincunx in the current implementation your own position is a space.

What is the procedure in determining the order of which bot fights which bot in the event where more than one bots go to the same space? And what happen when bot reverts back to its own space after doing C on an egg?

How can I use the testing code to test a bot? I don't know ruby and am new here :)

@starbeamrainbowlabs at the end of the tester.rb there's a string with loads of ruby dumbbot.rb lines. Add the command for your own bot to that string (and remove some of the dumb bots if you wish). Then do either ruby tester.rb < map.txt on Unix or cat map.txt | ruby tester.rb on Windows.

@m.buettner Thanks! That worked, lthough I had to change chat map.txt | ruby tester.rb to type map.txt | ruby tester.rb in order to pass the map to tester.rb.

I like the memory line idea

@Einacio I was just about to post that, I think more KotH challenges should use that. However, due to the variable size of the problem (i.e. the map) a fixed size of memory could really be a problem. I'm still not sure if I like that or not (although I suppose it was a conscious decision). This allows me to build a bot that memorises the entire map (or what it has seen of it so far), but might break if there  are suddenly more then, say 15 submissions, a fix for which would make the bot considerably more difficult.

After doing a few tests on a new bot I have to agree with @Quincunx that some feedback about the result of a fight would be very useful. Otherwise keeping track of where you are will require some quite elaborate pattern matching (and won't even be possible if you're in a region like the bottom left of the example map where there are no walls at all).

Also are you aware of the implication of your rules: if a player (A) chooses 9, he can never be meaningfully attacked. If another player (B) steps onto that players square and wins, A will be moved back to its original square (which is the same). But now there is a clash because both A and B are there, so B has to go back to his own square. So the result is independent of the actual fight, B always moves back to the initial square and A always stays put. That would allow me to write a both that could help another submission by blocking of a path for everyone else.

Yet another thing: if two walls touch on a corner can I move through them diagonally? i.e. if there is a wall in direction 2 and 4 can I move to 3?

Okay I just answered the question myself be looking at the test script. Such a move is indeed possible. Is that intentional or a bug?

Unfortunately, it doesn't currently look like we're going to get far beyond 7 entries (so this question probably doesn't really matter), but what's your rationale behind increasing the map size with the square of the submissions but the number of walls only linearly (and their size not at all). If you generate maps for like 20 participants, they look really sparse.

I'm also not sure I'm happy with the "If there are three or more players on one space, they all revert back to their original positions." rule (which you did add after the challenge started). If two other bots are in deadlock over an egg that makes it impossible for any other bot to break up that deadlock. Basically the three (or more) positions of the egg and the two (or more) players around the egg are completely inaccessible for the rest of the round.

Cart'o'Gophers
Here is another submission - and this one is actually meant to be competitive. Again, it's in Ruby. So run it with ruby cartogophers.rb. This took a lot longer than expected...
require 'zlib'
require 'base64'

def encode map, coords
    zipped = Zlib::Deflate.deflate map.join
    encoded = Base64.encode64(zipped).gsub("\n",'')
    "#{coords[:x]}|#{coords[:y]}|#{map.length}|#{encoded}"
end

def decode memory
    memory =~ /^(\d+)[|](\d+)[|](\d+)[|](.*)$/
    coords = {x: $1.to_i, y: $2.to_i}
    n_rows = $3.to_i
    encoded = $4
    decoded = Base64.decode64 encoded
    unzipped = Zlib::Inflate.inflate decoded
    n_cols = unzipped.length / n_rows;
    return unzipped.scan(/.{#{n_cols}}/), coords
end

def update map, fov, coords
    if coords[:x] < 2
        map.map! { |row| '?' << row }
        coords[:x] += 1
    elsif coords[:x] >= map[0].length - 2
        map.map! { |row| row << '?' }
    end

    if coords[:y] < 2
        map.unshift '?' * map[0].length
        coords[:y] += 1
    elsif coords[:y] >= map.length - 2
        map.push '?' * map[0].length
    end

    fov.each_index do |i|
        map[coords[:y]-2+i][coords[:x]-2, 5] = fov[i]
    end

    return map, coords
end

def clean_up map
    map.each do |row|
        row.gsub!('*', ' ')
    end
end

DIRECTIONS = [
    [],
    [-1,-1],
    [ 0,-1],
    [ 1,-1],
    [ 1, 0],
    [ 1, 1],
    [ 0, 1],
    [-1, 1],
    [-1, 0],
    [ 0, 0]
]

def move_to dir, coords
    {
        x: coords[:x] + DIRECTIONS[dir][0],
        y: coords[:y] + DIRECTIONS[dir][1]
    }
end

def get map, coords
    if coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        return '?'
    end
    map[coords[:y]][coords[:x]]
end

def set map, coords, value
    unless coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        map[coords[:y]][coords[:x]] = value
    end
    map[coords[:y]][coords[:x]]
end

def scan_surroundings map, coords
    not_checked = [coords]
    checked = []
    cost = { coords => 0 }
    direction = { coords => 9 }
    edges = {}

    while not_checked.length > 0
        current = not_checked.pop

        checked.push current
        (-1..1).each do |i|
            (-1..1).each do |j|
                c = { x: current[:x]+i, y: current[:y]+j }
                unless not_checked.include?(c) || checked.include?(c)
                    if get(map, c) == '#'
                        checked.push c
                    elsif get(map, c) == '?'
                        checked.push c
                        edges[current] = { cost: cost[current], move: direction[current] }
                    else
                        not_checked.unshift c

                        cost[c] = cost[current] + 1
                        if direction[current] == 9 # assign initial direction
                            direction[c] = DIRECTIONS.find_index([i,j])
                        else
                            direction[c] = direction[current]
                        end

                        if get(map, c) == 'o'
                            return direction[c], if cost[c] == 1 then 'N' else 'A' end
                        end

                        edges[c] = { cost: cost[c], move: direction[c] } if c[:x] == 0 || c[:x] == map[0].length - 1 ||
                                                                            c[:y] == 0 || c[:y] == map.length - 1
                    end
                end
            end
        end
    end

    # If no egg has been found return the move to the closest edge
    nearest_edge = edges.keys.sort_by { |c| edges[c][:cost] }.first
    if edges.length > 0
        return edges[nearest_edge][:move], 'A'
    else
        # The entire map has been scanned and no more eggs are left.
        # Wait for the game to end.
        return 9, 'N'
    end
end

input = $<.read.split "\n"
fov = input[0..4]
memory = input[5]

if memory
    map, coords = decode memory
    map, coords = update(map, fov, coords)
else
    map = fov
    coords = {x: 2, y: 2}
end
clean_up map

move, attack = scan_surroundings(map, coords)

memory = encode map, move_to(move, coords)

puts "#{move}
#{attack}
#{memory}"

This bot remembers what it has seen before and tries to construct a larger map at each turn. It then uses a breadth-first search for the nearest egg and heads that way. If there is no egg that can be reached on the current map, the bot heads for the nearest open edge of its map (so as to expand the map quickly in a direction it can still move).
This bot has no concept of other bots yet and no fighting strategy either. Since I haven't found a reliable way to determine if my move has been successful, this can cause some problems. I simply always assume that the move has been successful - so if it wasn't new patches will be loaded into the map in the wrong places, which may or may not be harmful to pathfinding.
The bot uses the memory to store the map and its new position on the map (assuming the move will be successful). The map is stored without line breaks, zipped and base64 encoded (along with the number of rows of the map, so that the line breaks can be reinserted). This compression brings the size down to about a third of the uncompressed map, so having a shade over 1000 bytes, I could store a map of about 3000 cells, which roughly corresponds to fully exploring a map with 18 bots. As long as there are nowhere near that many submissions, I don't think I can be bothered to figure out a fix for that case.
After a few test runs against 5 dumbbots and 1 naivebot (my other submission), it either performed really badly (like 1 or 2 eggs) or outperformed the others by a considerable margin (7 to 9 eggs). I may think about a better fighting strategy and how I can determine if I actually moved or not. Both might be able to improve the score somewhat.
Oh and if you're wondering about the name of the bot, you should read The Order of The Stick (last panel on this comic).
EDIT: There were a few bugs with detecting the edges of the discovered map. Now that I've fixed them this bot always gets scores of about 20 against 5 dumbbots and 1 naivebot. That's more like it! If you add $stderr.puts map to my bot now, you can really see how he systematically uncovers the map and collects all eggs in the meantime. I've also decided to choose A instead of N whenever not stepping onto an egg, to reduce the probability of moving back to the bot's original cell (which partly screws up the map).
(It doesn't perform quite as well against 6 naivebots, especially since it's very possible to end up in a "deadlock" with another bot when they both repeatedly want to grab an egg and choose N. I need to think about that...)

Java Bunny
This bunny hasn't finished growing up yet (I still plan to make changes), but it's a starting point for right now.  He looks for the closest egg and goes towards it.  There isn't wall detection or out-of-bounds detection (yet).  He'll go to pick up the egg he lands on, but otherwise he'll try to push he way around and attack anything else.  If there are no nearby eggs, he'll start following the nearest bunny.  They might know something that he doesn't.  Otherwise, he'll just pick a random direction to walk.  And he's pretty forgetful (no use of the memory variable).
Plans moving forward:

Make decisions based on walls/out-of-bounds
Pick paths with a purpose, rather than randomly
Use the memory to determine the direction I was going before

Update 1
My bunny will follow other bunnies if he doesn't see an egg.  Also refactored the "find nearest egg" code into it's own method.
import java.util.*;

public class EasterEggHunt {

    // board chars
    public static final char EGG = 'o';
    public static final char WALL = '#';
    public static final char BUNNY = '*';
    public static final char SPACE = ' ';
    public static final char OUT_OF_BOUNDS = 'X';

    // player moves
    public static final char ATTACK = 'A';
    public static final char COUNTER = 'C';
    public static final char NOTHING = 'N';

    // directions
    public static final int UPPER_LEFT = 1;
    public static final int UP = 2;
    public static final int UPPER_RIGHT = 3;
    public static final int RIGHT = 4;
    public static final int LOWER_RIGHT = 5;
    public static final int DOWN = 6;
    public static final int LOWER_LEFT = 7;
    public static final int LEFT = 8;
    public static final int STAY = 9;

    // the size of the immediate area
    // (I'll be at the center)
    public static final int VISION_RANGE = 5;

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        char[][] immediateArea = new char[VISION_RANGE][VISION_RANGE];

        for (int i = 0; i < VISION_RANGE; ++i) {
            String line = input.nextLine();
            for (int j = 0; j < VISION_RANGE; ++j) {
                immediateArea[i][j] = line.charAt(j);
            }
        }

        String memory = input.nextLine();

        int moveDirection = decideMoveDirection(immediateArea, memory);
        System.out.println(moveDirection);

        char action = decideAction(immediateArea, memory, moveDirection);
        System.out.println(action);

        // change the memory?
        System.out.println(memory);

    }

    private static int decideMoveDirection(char[][] immediateArea, String memory) {

        // if there's a nearby egg, go towards it
        int direction = nearestBoardObject(immediateArea, EGG);

        // if we didn't find an egg, look for a bunny
        // (maybe he knows where to find eggs)
        if (direction == STAY)
            direction = nearestBoardObject(immediateArea, BUNNY);

        // otherwise, pick a random direction and go
        // we want to also have the chance to stop and catch our breath
        if (direction == STAY)
            direction = new Random().nextInt(STAY + 1);

        return direction;
    }

    private static int nearestBoardObject(char[][] immediateArea, char boardObject) {

        // start at the center and go outward (pick a closer target over a farther one)
        int spacesAway = 1;
        int meX = immediateArea.length / 2;
        int meY = immediateArea[meX].length / 2;

        while (spacesAway <= immediateArea.length / 2) {

            // I like to look right, and go clockwise
            if (immediateArea[meX][meY + spacesAway] == boardObject)
                return RIGHT;
            if (immediateArea[meX + spacesAway][meY + spacesAway] == boardObject)
                return LOWER_RIGHT;
            if (immediateArea[meX + spacesAway][meY] == boardObject)
                return DOWN;
            if (immediateArea[meX + spacesAway][meY - spacesAway] == boardObject)
                return LOWER_LEFT;
            if (immediateArea[meX][meY - spacesAway] == boardObject)
                return LEFT;
            if (immediateArea[meX - spacesAway][meY - spacesAway] == boardObject)
                return UPPER_LEFT;
            if (immediateArea[meX - spacesAway][meY] == boardObject)
                return UP;
            if (immediateArea[meX - spacesAway][meY + spacesAway] == boardObject)
                return UPPER_RIGHT;

            ++spacesAway;
        }

        // if the target object isn't in the immediate area, stay put
        return STAY;

    }

    private static char decideAction(char[][] immediateArea, String memory, int moveDirection) {

        char destinationObject = getDestinationObject(immediateArea, moveDirection);

        switch (destinationObject) {

            case EGG:
                // don't break the egg
                return NOTHING;
            default:
                // get really aggressive on everything else
                // other players, walls, doesn't matter
                return ATTACK;

        }

    }

    private static char getDestinationObject(char[][] immediateArea, int moveDirection) {

        // start at my spot (middle of the board) and figure out which direction I'm going
        int targetX = immediateArea.length / 2;
        int targetY = immediateArea[targetX].length / 2;

        switch (moveDirection) {

            case RIGHT:
                ++targetY;
                break;
            case LOWER_RIGHT:
                ++targetX;
                ++targetY;
                break;
            case DOWN:
                ++targetX;
                break;
            case LOWER_LEFT:
                ++targetX;
                --targetY;
                break;
            case LEFT:
                --targetY;
                break;
            case UPPER_LEFT:
                --targetX;
                --targetY;
                break;
            case UP:
                --targetX;
                break;
            case UPPER_RIGHT:
                --targetX;
                ++targetY;
                break;
            // otherwise we aren't moving

        }

        return immediateArea[targetX][targetY];

    }

}

I also learned that Java enums are pretty much full on classes, and I like .NET enums a lot better.

NaiveBot (in Ruby)
Here is a very simplistic bot to get the egg rolling (we want to hit those 7 submissions quick, right?). My Ruby isn't very idiomatic so this code may make proper rubyists cringe in pain. Read at your own risk.
input = $<.read
$data = input.split("\n")

def is_egg x, y
    $data[y+2][x+2] == 'o'
end

def is_wall x, y
    $data[y+2][x+2] == '#'
end

def is_empty x, y
    $data[y+2][x+2] == ' '
end

def is_player x, y
    $data[y+2][x+2] == '*'
end

if (is_egg(-2,-2) || is_egg(-2,-1) || is_egg(-1,-2)) && !is_wall(-1,-1) || is_egg(-1,-1)
    dir = 1
elsif is_egg(0,-2) && !is_wall(0,-1) || is_egg(0,-1)
    dir = 2
elsif (is_egg(2,-2) || is_egg(2,-1) || is_egg(1,-2)) && !is_wall(1,-1) || is_egg(1,-1)
    dir = 3
elsif is_egg(2,0) && !is_wall(1,0) || is_egg(1,0)
    dir = 4
elsif (is_egg(2,2) || is_egg(2,1) || is_egg(1,2)) && !is_wall(1,1) || is_egg(1,1)
    dir = 5
elsif is_egg(0,2) && !is_wall(0,1) || is_egg(0,1)
    dir = 6
elsif (is_egg(-2,2) || is_egg(-2,1) || is_egg(-1,2)) && !is_wall(-1,1) || is_egg(-1,1)
    dir = 7
elsif is_egg(-2,0) && !is_wall(-1,0) || is_egg(-1,0)
    dir = 8
else
    dir = rand(8) + 1
end

attack = 'N'
puts "#{dir}
#{attack}
"

Run with ruby naivebot.rb.
I'm simply hardcoding a few cases, where an egg is visible and not obstructed by a wall. It doesn't even go for the closest egg, but picks the first move that makes sense. If no such egg is found, the bot makes a random move. It disregards all other players and never attacks or counters.

WallFolower
(deliberate pun) in Python 3:
import sys
import random

#functions I will use
dist       = lambda p1,p2: max(abs(p2[1] - p1[1]), abs(p2[0] - p1[0]))
distTo     = lambda p    : dist((2,2), p)
cmp        = lambda x,y  : (x > y) - (x < y)
sgn        = lambda x    : (-1,0,1)[(x>0)+(x>=0)]
move       = lambda p    : (sgn(p[0] - 2), sgn(p[1] - 2))
unmove     = lambda p    : (p[0] * 2 + 2, p[1] * 2 + 2)
outputmove = lambda p    : (1,2,3,8,9,4,7,6,5)[(sgn(p[0] - 2) + 1) + 3*(sgn(p[1]-2) + 1)]
def noeggfinish(move):
    print(outputmove(unmove(move)))
    print('ACN'[random.randint(0, 2)])
    print("1"+move)
    sys.exit(0)

#beginning of main body
view    = [list(l) for l in map(input, ('',)*5)] #5 line input, all at once.
memory  = input() #currently used only as last direction moved in a tuple
eggs    = []
enemies = []
for y in range(5):
    for x in range(5):
        if   view[y][x] == 'o': eggs    += [(x,y)]
        elif view[y][x] == '*': enemies += [(x,y)]

eggs.sort(key = lambda p:distTo(p)) #sort by how close to me they are.

tiedeggs = []
end = 0
for egg in eggs[:]:
    if end:break
    for enemy in enemies:
        exec({
            -1: 'eggs.remove(egg)',
             0: 'tiedeggs += egg',
             1: 'end=1'
        }[cmp(dist(enemy, egg), distTo(egg))])
        if end:break
if eggs:
    print(outputmove(eggs[0]))
    print('N')              #no attack here
    print("0"+move(eggs[0]))
    sys.exit(0)
elif tiedeggs:
    print(outputmove(tiedeggs[0]))
    print('N')              #no attack here
    print("0"+move(tiedeggs[0]))
    sys.exit(0)
#now there are no eggs worth going for
#do a LH wall follow

lastmove = eval(memory[1:]) #used to resolve ambiguity
if lastmove[0] and lastmove[1]:
    lastmove[random.randint(0,1)] = 0 #disregard diagonal moves
if eval(memory[0]):
    exec("check=view[%n][%n]"%{(0,-1):(0,0),(1,0):(4,0),(0,1):(4,4),(-1,0):(0,4)}[lastmove])
    if check == '#':
        noeggfinish(lastmove)
    else:pass
#currently unimplemented
#move randomly
noeggfinish(tuple([(x,y) for x in [-1,0,1] for y in [-1,0,1] if (x,y) != (0,0)))

Moves to an egg if there is an egg in sight, but only if it is closer to that egg than another robot. If there is a tie in distance, it goes for it anyways. Otherwise, does a LH wall follow (not currently well implemented).
Still needs work on the wall follow, but I'll post this here anyways.

When I run your bot with the tester.py, I get this error in the console: http://pastebin.com/cT5xGdSW

Same here. Could you look into that? I'd like to test my new bot against this.

@m.buettner What happens if you change sys.exit(0) to exit(0)? Also, I do need to work on this (right now, it assumes itself is a  ), but I don't really have the time. When I do have time, I'll come and fix this.

@Quincunx unfortunately, that didn't change anything.


text:
Program that permutes itself to encode a string (quine-variant)
Write a program that prints the following 80-character line:

This program from codegolf.stackexchange.com permutes itself to encode a string.

then accepts one line of input, then prints its source code with its code points possibly reordered (none added and none deleted). When that code is executed, the same has to happen, except the printed line would be the most recent line of input.
The Perl-style regex ^[A-Za-z0-9. ]{80}$ will match any line of input. You cannot make any additional assumption.
A submission's score is the number of code points in its source code less 94. Lower is better.
The code must not do anything that would be unacceptable in a quine (e.g. file reading). In particular, any submission with a negative score must be cheating somehow, as 93! is less than 6480.
Added 2014-04-21: Your program's entire source code must be well-formed in the character encoding under which you count code points. For example, you cannot use 80 consecutive bytes in the UTF-8 trailing byte range (80..BF) and count each as a single U+FFFD REPLACEMENT CHARACTER (or worse, as not a code point at all).
Additionally, if the encoding allows multiple ways to encode a code point (e.g. SCSU), your program, as well as all programs it directly or indirectly generates, must only use one of them (or at least all must be treated equivalently throughout the code).

After rereading your question, I'm not sure if my answer does exactly what you had in mind. Is piping the new string to the program OK or does it have to launch an interactive prompt?

@Dennis: That's not why your answer is not acceptable. Rather, it reads the input before printing "This program from [...]".

That's what I meant, I just did't express it well. The GolfScript interpreter reads everything that is piped to it before started to execute the script. The only way to avoid this is to launch a prompt, which makes piping impossible.

Hi, I'm trying this in JavaScript. It seems impossible to make a quine without reading the text between the
GolfScript, 231 162 131
'1àâ4ÿaVo5GùpZBtiXOürsóNîMmWåKHc09JdñúêyzíECäYïhDU ãáIFõ6é8òRìjTv23ønuðLwxfSkôbëAelqý.çèPQ
öûg7'{0@.$[{}/]:&\{@2$,*2$2$?+@@^}/{;65base}:b~{&=}%''+puts'"#{`head -1`}"'~{&?}%)b[94,{)1$1$%@@/}/;]-1%&\[{1$=.@^}/]"'".@+\+\'.~'}.~

How it works
We start by choosing 94 different characters that will get permuted to encode a string. Any 94 characters would work, but we choose the following for golfing purposes:
\n .0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
àáâãäåçèéêëìíîïðñòóôõöøùúûüýÿ

Let's call the array of these characters “&”.
The line of input will always contain 81 characters (including the LF). All of those characters are present in the first 65 characters of “&”. This is the sole reason for choosing characters in the upper 128 bytes.
We replace each character of the string by its index in “&”, so LF becomes 0, space becomes 1, etc.
We consider the 81 obtained numbers the digits of a single base 65 number. Let's call this number “N”.
Now, we enumerate all possible permutations of “&” and retrieve the permutation corresponding to the number from above. This is achieved in the following manner:

Set c = 1 and A = [].
Prepend N % c to A.
Set N = N / c and c = c + 1.
If c < 95, go back to 2.
Set i = 0 and s = "".
Retrieve the charcter &[A[i]], append it to “s” and remove it from “&”.
Set i = i + 1.
If i < 94 go back to 6.

Suppose we have code blocks “E” and “D” that encode and decode a string as explained above.
Now, we need a wrapper for those code blocks that complies with the requirements of the question:
'encoded string'{\.$[{}/]:&; D puts '"#{`head -1`}"'~ E "'".@+\+\'.~'}.~

This does the following:

{…}.~ defines a block, duplicates it and executes the second copy. The first copy will remain on the stack.
\.$ swaps the encoded string with the block and creates a copy of the encoded string, with sorted characters.
[{}/]:&; converts the string from above into an array, saves it in “&” and discards it.
D puts decodes the encoded string and prints the result.
'"#{`head -1`}"'~ reads one line of input by executing head -1 in the shell.
E "'".@+\+ encodes the string and prepends and appends a single quote.
\'.~' swaps the encoded string and the block and appends the string '.~'.
After the block has been executed, GolfScript prints the contents of the stack (encoded string, block, '.~') and exits.

“E” can be defined as follows:
{&?}%        # Replace each character by its index in “&”.
);           # Remove the last integer from the array, since it corresponds to the LF.
65base       # Convert the array to an integer “N” by considering it a base 65 number.
[            #
  94,        # For each integer “c” in 0 … 93:
  {          #
    )        # Increment “c”.
    1$1$%    # Push “N % c”.
    @@/      # Rotate “N % c” below “N” and “c” and divide the first by the latter.
  }/;        # Discard “N”.
]            # Collect the results of “N % c” in an array “A”.
-1%          # Reverse “A”.
&\           # Push “&” and swap it with “A”.
[            #
  {          # For each “j” in “A”:
    1$=.[]+  # Push “&[j] [&[j]]”.
    @^       # Rotate “&” on top of “[&[j]]” and take their symmetric difference.
  }/         #
]            # Collect the charcters into an array.

“D” can be defined as follows:
0&           # Push 0 (initial value of the accumulator “A”) and “&”.
@            # Rotate the encoded string on top of “&”.
{            # For each character “c” of the encoded string:
    @2$,*    # Rotate “A” on top of the stack and multiply it by the length of “&”.
    2$2$?+   # Get the index of “c” in “&” and add it to “A”.
    @@^      # Rotate “A” below “&” and “c” and take their symmetric difference.
}/;          # Discard “&”.
65base       # Convert “A” into the array of its digits in base 65.
{&=}%        # Replace each digit by the corresponding character in “&”.
''+          # Convert the resulting array into a string.

Final golfing:

Replace \.$[{}/]:&;0&@ with 0@.$[{}/]:&\ to save two characters.
Define the function {;65base}:b to save one character.
Remove all whitespace except the trailing LF and the LF in the string.

Example
$ # Create GolfScript file using base64 to avoid encoding issues.
$ base64 > permute.gs -d <<< JzHg4jT/YVZvNUf5cFpCdGlYT/xyc/NO7k1tV+VLSGMwOUpk8frqeXrtRUPkWe9oRFUg4+FJRvU26TjyUuxqVHYyM/hudfBMd3hmU2v0YutBZWxx/S7n6FBRCvb7ZzcnezBALiRbe30vXTomXHtAMiQsKjIkMiQ/K0BAXn0vezs2NWJhc2V9OmJ+eyY9fSUnJytwdXRzJyIje2BoZWFkIC0xYH0iJ357Jj99JSliWzk0LHspMSQxJCVAQC99LztdLTElJlxbezEkPS5AXn0vXSInIi5AK1wrXCcufid9Ln4K
$
$ # Set locale to en_US (or any other where one character is one byte).
$ LANG=en_US
$
$ # Go back and forth between two different strings.
$ # Second and sixth line are user input, not output from the script.
$
$ golfscript permute.gs | tee >(tail -n+2 > tmp.gs) && golfscript tmp.gs && rm tmp.gs
This program from codegolf.stackexchange.com permutes itself to encode a string.
Permuting source code code points to encode a string is a certain quine variant.
'18äJoS3sgV9qdçëxm0ÿKMNe5íPî.Htn2ciâIuøbRZéð4AwB7áìUüöôWõèûfñåLàóDrhQlO6
pTaýzòkùYCyFêïãG júEvX'{0@.$[{}/]:&\{@2$,*2$2$?+@@^}/{;65base}:b~{&=}%''+puts'"#{`head -1`}"'~{&?}%)b[94,{)1$1$%@@/}/;]-1%&\[{1$=.@^}/]"'".@+\+\'.~'}.~
Permuting source code code points to encode a string is a certain quine variant.
This program from codegolf.stackexchange.com permutes itself to encode a string.
'1àâ4ÿaVo5GùpZBtiXOürsóNîMmWåKHc09JdñúêyzíECäYïhDU ãáIFõ6é8òRìjTv23ønuðLwxfSkôbëAelqý.çèPQ
öûg7'{0@.$[{}/]:&\{@2$,*2$2$?+@@^}/{;65base}:b~{&=}%''+puts'"#{`head -1`}"'~{&?}%)b[94,{)1$1$%@@/}/;]-1%&\[{1$=.@^}/]"'".@+\+\'.~'}.~
$
$ # Sort all characters from the original source code and hash them.
$ fold -1 permute.gs | sort | md5sum
b5d978c81df5354fcda8662cf89a9784  -
$
$ # Sort all characters from the second output (modified source code) and hash them.
$ golfscript permute.gs | tail -n+2 | fold -1 | sort | md5sum
Permuting source code code points to encode a string is a certain quine variant.
b5d978c81df5354fcda8662cf89a9784  -
$
$ # The hashes match, so the characters of the modified source code are a permutation
$ # of the character of the original one.

224 minus 94 is 130.

Could you elaborate?

Perl, 1428 1099
This has 1193 ASCII characters (including 960 permuted binary digits).
1193 - 94 = 1099
$s='010011100001100010101100111111101001101011101000100000101011011010100110111111011111101011101000100110111111011100101000011101011110100000101000100101011111111110101100101101011010011100100100011110110001011100100001011010100111100000011110111110011100101000100110111111101001011110101011100110101110101101011110101100111111100010101101101100011110100101011111111111101101101000111111011110100111011100101000011101011110111111011010111111101100101101101011100010100111100000111110';$_=q{$i=join'',A..Z,a..z,0..9,'. ';print map({substr$i,oct'0b'.$_,1}$s=~/.{6}/g),$/;chop($s=<>);$s=join'',map{sprintf"%06b",index$i,$_}$s=~/./g;$t=join'',map{$_ x(480-(()=$s=~/$_/g))}0,1;print"\$s='$s';\$_=q{$_};eval#$t"};eval#000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

My first design
Before I took a suggestion from Dennis to switch to binary, my program permuted octal digits.
My first design encodes each string in 160 octal digits, with 2 digits per character. This encoding has 1008=64 different characters. The octal system has 8 different digits. The program must have 160 copies of each digit, so it permutes 8×160=1280 digits.
I keep 160 digits in $s and the other 1120 digits in $t. I start with a program that is not a quine, but only prints the assignments to $s and $t for the next run. This is it:
$s = '2341425477515350405332467737535046773450353640504537765455323444366134413247403676345046775136534656553654774255543645377755507736473450353677327754555342474076';
$t = '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777';

# $i = character map of 64 characters, such that:
#  substr($i, $_, 1) is the character at index $_
#  index($i, $_) is the index of character $_
$i = join '', 'A'..'Z', 'a'..'z', '0'..'9', '. ';

# Decode $s from octal, print.
#  1. ($s =~ /../g) splits $s into a list of pairs of octal digits.
#  2. map() takes each $_ from this list.
#  3. oct() converts $_ from an octal string to a number.
#  4. substr() on $i converts number to character.
#  5. print() outputs the characters from map() and a final "\n".
print map({ substr $i, oct, 1 } $s =~ /../g), "\n";

# Read new $s, encode to octal.
#  1. ($s = <>) reads a line.
#  2. chop($s) removes the last character of $s, the "\n".
#  3. ($s =~ /./g) splits $s into characters.
#  4. map() encodes each character $_ as a pair of octal digits.
#  5. join() concatenates the pairs from map().
chop($s = <>);
$s = join '', map { sprintf "%02o", index $i, $_ } $s =~ /./g;

# Make new $t.
#  1. map() takes each $_ from 0 to 7.
#  2. $_ x (160 - (() = $s =~ /$_/g)) makes a string where $_ repeats
#     160 times, minus the number of times that $_ appears in $s.
#  3. join() concatentates the strings from map().
$t = join '', map { $_ x (160 - (() = $s =~ /$_/g)) } 0..7;

# Print the new assignments for $s and $t.  This is not yet a quine,
# because it does not print the rest of the program.
print "\$s = '$s';\n\$t = '$t';\n";

(() = $s =~ /$_/g)) is an assignment to an empty list of variables. I take this trick from the context tutorial at PerlMonks. It forces list context on the match operator =~. In scalar context, the match would be true or false, and I would need a loop like $i++ while ($s =~ /$_/g) to count the matches. In list context, $s =~ /$_/g is a list of matches. I put this list in the scalar context of a subtraction, so Perl counts the list elements.
To make a quine, I take the form $_=q{print"\$_=q{$_};eval"};eval from the Perl quines at Rosetta Code. This one assigns a string q{...} to $_ and then calls eval, so I can have my code in a string and also run it. My program becomes a quine when I wrap my third to last lines in $_=q{ and };eval, and change my last print to print "\$s = '$s';\n\$t = '$t';\n\$_=q{$_};eval".
Finally, I golf my program by changing the first assignment to $t to a comment, and by removing extra characters.
This has 1522 ASCII characters (including 1280 permuted octal digits).
1522 - 94 = 1428
$s='2341425477515350405332467737535046773450353640504537765455323444366134413247403676345046775136534656553654774255543645377755507736473450353677327754555342474076';#0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
$_=q{$i=join'','A'..'Z','a'..'z','0'..'9','. ';print map({substr$i,oct,1}$s=~/../g),"\n";chop($s=<>);$s=join'',map{sprintf"%02o",index$i,$_}$s=~/./g;$t=join'',map{$_ x(160-(()=$s=~/$_/g))}0..7;print"\$s='$s';#$t\n\$_=q{$_};eval"};eval

The switch to binary
In the comments, Dennis noticed that 960 permuted binary digits would be fewer than 1280 octal digits. So I graphed the number of permuted digits for each base from 2 to 16.
Maxima 5.29.1 http://maxima.sourceforge.net
using Lisp ECL 13.5.1
...
(%i36) n : floor(x);
(%o36)                             floor(x)
...
(%i41) plot2d(n * ceiling(log(64) / log(n)) * 80, [x, 2, 16],
              [xlabel, "base"], [ylabel, "number of permuted digits"]);
(%o41)

Though base 8 is a local minimum, bases 2 and 3 and 4 tie for best base, at 960 permuted digits. For code golf, base 2 is best because Perl has conversions for base 2.
Replacing 1280 octal digits with 960 binary digits saves 320 characters.
Switching code from octal to binary costs 8 characters:

Change oct to oct'0b'.$_ costs 7.
Change /../g to /.{6}/g costs 2.
Change "%02o" to "%06b"` costs 0.
Change 160 to 480 costs 0.
Change 0..7 to 0,1 saves 1.

I learned some Perl golf tips. They save 14 characters:

Change 'A'..'Z','a'..'z','0'..'9' to A..Z,a..z,0..9, using barewords and bare numbers, saves 12 characters.
Change "\n" to $/ saves 2 characters.

I save 3 characters by moving the #$t comment to the end of the file. This removes the newline that ends the comment, and a literal \n in the quine.
These changes save a total of 329 characters, and reduce my score from 1428 to 1099.

Using binary instead of octal digits would require "only" 960 permutable characters.

@Dennis Thanks for the tip! I made the switch to binary (saving 312 characters). While here, I golfed away 17 more characters.


text:
Print "Hello World" in Ascii Art ... without its characters
Your mission is to write a program that prints "Hello World!". Simple?
The text must be human readable and should not be "|-| € |_ |_ 0  // 0 |? |_ |)  \./" or something like that.
The program should not contain:

Newline character
Any characters in the string "Hello World!" including whitespace (whitespace outside strings is allowed)
Graphics (it must be run on text console (or master boot record in text mode)
Number constants that represent chars (Ascii-values, Hex chars)
Any simple tricks that create above numbers (ex. 36*2 or 176/2-1 (72, ASCII code of "H") )
Non-ASCII chars
Web request
User input
Over 1000 chars
Random numbers

It can contain:

Ascii-art
system calls that do not return letters (a-z and A-Z)
h, e, l, o, w, r, d and ! chars outside strings or equal datatypes

It is possible and allowed to change line by going over line max width (program must detect that itself). Linux command
stty size

may help.
Fewer chars are better.
Basically, write 'Hello World' in Ascii Art.

"Less chars is better" -> should this be tagged code-golf? And restricted-source?

Edit1: over 1000 chars and random numbers forbidden, because cat /v/uand*m and other like this

Mathematica
n is an integer (in base 10).
IntegerDigits[n, 2] is a list of digits {0,1} that, when concatenated, represent n in base 2.
a=ArrayReshape[ IntegerDigits[n, 2], {19, 130}] is the same digit list rearranged as a grid of 0's and 1's with the dimensions {19, 130}.
a/. {1 -> Style["b", 0], 0 -> Style["*", 16]} replaces each 1 with "b" of font size 0 (hence it is invisible) and replaces each 0 with "*" of font size 16.
Grid[%, Spacings-> 0] tightly displays the array, with replacements. (% stands for the line of code just preceding.)
n = 35001712241657190367892609813472861877431771881809334927846103886350214620897333001318391750688831360911930936377842577561578307677143958805011717980866099960819297494949545473701708671861367649525697579614849813048033148938384921009819295565066663593631828895192249784580492554132824237605034894192899878952441264004931502456152233835512128208573340080592412541607535529943162874085478980356198477815840725568296012406592398594861031009108478191718964371749381682556005188569781665817649936105396104242935885784130227679335972626450197115544027612921177483696531170727698036575934297259107966503600164537149096917592511980213534973597038276657982204662616524347887277731541480128061438343931154467720012975561086600146498015257664764847849471;
Grid[ArrayReshape[ IntegerDigits[n, 2], {19, 130}] /. {1 -> " ", 0 -> Style["*", 16]},
   Spacings -> 0]

Is the " " legal? Wondering because of "...including whitespace..." in the character restrictions.

Just to be safe, I replaced spaces with the letter b of font size 0.

This contains an h, an e, an l, ...

@Doorknob I've found a way to eliminate the h and the l, but no solution yet for the e.

It still contains an l and a d as well.

J - 59 or 84 char
Two versions, depending on how you define 'human-readable'. Any modifications to the resulting ASCII art would ultimately be based on this kind of compression scheme.
,.'#'#~"0#:86235578437 123845917517 91625269844 92707043917
,._45#&'#'"0\#:36761300340830444705259651524275206394141032533795647996053048645081x

The first version works by taking its list of numbers, expanding them into bitvectors (#:), using those to select (#~) how many '#' to take for each point ("0) in the matrix, and then running the result (a 2D matrix of strings of length at most 1) into a matrix of characters (,.).
The second does the same thing, except it's shorter—by one character, mind you!—to pack all of its bitvectors into a single extended precision number, which you then take 45 bit cuts (_45(blah)\) of.
Here's what they look like:
screenshot of jconsole running code http://i.snag.gy/XzYYa.jpg

Bash + tr, 82 79 bytes
a=({q..s});a=${a[@]};s=${a:1:1};t${a:2:1} "[$s-~]" "[u-~][$s-v]"<<<Tqxx{,c{~xp-

Output:
$ a=({q..s});a=${a[@]};s=${a:1:1};t${a:2:1} "[$s-~]" "[u-~][$s-v]"<<<Tqxx{,c{~xp-
Hello World!
$

Java generating the Strings only from a 0 as integer; 391 chars
class A{static int a=0,b=a++,e=a++,f=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),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

in that code the only literal variable is an Integer 0, the rest is made via Wizardry and other math tricks