Gere um mapa de região selvagem ASCII.

Exemplo de saída:

................^^^^
..................^^
...^^^^........o....
.....^^^^...........
....................
........o....TT.....
..TTTT..............
TTTT.TTTT....~~~~~~.
..TT..........~~~~~~
....................

Anti-exemplo (não faça isso):

....................
...........T........
...^..........oo....
......^.............
....................
..............TT....
T.T.T.T.T........T..
.................T..
T.T.T.T.T..........T
..............TT...T

Regras:

1. Deve ter pelo menos 20 x 10 caracteres
2. Deve ser diferente a cada corrida, ou seja, aleatória
3. Deve conter áreas de forma contínua e variável das árvores 'T', morros '^' e água '~', a maioria das quais deve consistir em mais de 5 células
4. O caractere de chão padrão é '.'
5. Deve conter pelo menos 2 aldeias 'o' que geralmente não estão próximas umas das outras
6. Não deve conter padrões óbvios, como retângulos ou áreas uniformemente espaçadas - "aparência natural" é a chave
7. Você não precisa verificar explicitamente se as regras são seguidas (por exemplo, não há necessidade de lógica anti-retângulo), mas a grande maioria das execuções (por exemplo, 80%) deve produzir resultados conformes
8. Com seu envio, inclua um exemplo de saída

Pontuação:

O vencedor tem a menor pontuação da fórmula: code character count-votes

APL ( 99 76)

F←⍳S←10 20⋄'.T^~^To'[⊃7⌊1++/(⊂7×F∊{?S}¨⍳2),T×{F∊(?S)∘+¨+\{2-?3 3}¨⍳99}¨T←⍳3]

Um pouco mais do que o necessário (para que produza uma melhor saída), mas eu a reduzirei quando a resposta do Golfscript chegar.

A resposta GolfScript foi postada, então aqui está uma resposta mais curta. Pensei em outra maneira (bastante óbvia, em retrospectiva) de reduzi-la para que a saída não seja muito pior que o programa original e seja ainda mais curta que o meu plano de backup original.

(Na versão antiga, eu tinha cinco campos de bits que estava compartilhando, agora tenho três que estou adicionando um ao outro.)

Substituí a saída de exemplo pela saída da nova versão, é claro.

Explicação:

• F←⍳S←10 20: size é 20x10, F é uma matriz em que cada elemento é suas coordenadas
• {F∊(?S)∘+¨+\{2-?3 3}¨⍳99}¨T←⍳5: gere três campos de bits, iniciando em uma coordenada aleatória e executando 99 etapas aleatórias em um campo vizinho e, em seguida, ativando esse bit. 99 parece alto, mas geralmente retrocede, pois é aleatório. Isso faz os mapas para as áreas.
• (⊂7×F∊{?S}¨⍳2): Adicione em duas aldeias.
• ⊃7⌊1++/: soma as áreas, fornecendo uma matriz onde cada número representa um determinado tipo. Limite às 7, porque as aldeias podem aparecer em outra área com números altos.
• '.T^~^To'[... ]: substitua cada número pelo caractere certo. Como existem 3 campos possivelmente sobrepostos, o valor mais alto possível é 6. (3 + 3)

Exemplo de saída:

....TTT.TTT...TTT.^^
...TT....TTT....T..^
....T....TT.......^^
...~..o..T..^^...^^.
...~.........^^^^^^^
...~~~~....^^..^^^..
~..~~~......^.^.^^^^
~~.~~~......^^.^^^..
~.~~~~........o.....
~~~~~~..............

e

.....o........~~..~~
..............~~~~~.
.^T.T..........~~.~.
^T~~TTTTTT.......~~~
~~~~TT.TT.T......~~~
^~^TTT....T.....~~~~
^^^^T.....T...T..~~.
^^^^.......TT.T.....
^^^^.........TT.....
^^^^.........o......

Versão antiga:

F←⍳S←10 20⋄G←{F∊(?S)∘+¨+\{2-?3 3}¨⍳99}¨T←⍳5⋄'.T^~^To'[⊃7⌊1++/(⊂7×F∊{?S}¨⍳2),T×{(⊃⍵⌽G)∧~⊃∨/1↓⍵⌽G}¨T]

JavaScript - 294 290 caracteres

Para encorajar tentativas, eu mesmo fiz uma rachadura. Você pode tentar uma demonstração ao vivo aqui (é necessário abrir o console JS do seu navegador). Testado com Chrome e IE8.

R=function(a){return Math.random()*a|0};t=["~","T"];t.splice(R(3),0,"^");p=["XXX..","XXXX.","XXXXX"];b="....................";for(i=j=0;10>i;++i)j=i%3?j:R(15),s=b.substr(0,i%3?j+R(2):20),s+=p[R(3)].replace(/X/g,t[i/3|0])+b,k=R(19),console.log(s.substr(0,k)+".o"[i%2*R(2)]+s.substr(k,19-k));​

Exemplo de saída:

....................
.......~~~..........
........~~~~~.......
...o................
...............TT.TT
..........o....TTTTT
....................
.....^^^.o..........
.....^^^^^..........
..................o.

Não é o ideal, pois sempre existem apenas três áreas (uma de cada tipo), seu tamanho máximo é de 5x2 células e depois de algumas execuções, você começa a perceber limitações na localização (e nas aldeias). No entanto, cumpre as regras.

GolfScript, 97 caracteres

"T~^o"1/{:z{[20:s.*:<rand{.[s~)1-1s]4rand=+}z"o"=!9**]}3*++}%2/:x;<,{"."x{)3$\?)!!*+}/\;-1=}%s/n*

Exemplo de saídas:

.............~......
...........~.~~.....
........~~~~~~......
........~~~.........
.......~~~..........
.......~............
..^^..............T.
^^^^...........o..T.
...^....TTT...^...T^
^........TT.o.^^^.^^
^.......TT.....^^.T.
........T......^.TT.
................TT..
....................
....~~~.............
....~.~.............
..~o~...............
..~.....TTTT........
.......TT..TT.......
....................

e

.............~......
.............~......
....TTT.....~~TT....
....T.T.....~~TT....
....TT......~~~TT...
.....T.....~~~~T....
.......^^.~~~~......
......^^^..~~.......
......^.^...........
....................
..^^^^..............
..^..^^.............
....^^^^^...........
.......o........TT..
................TT..
....................
......o.............
.............o......
....................
....................

Ruby 1.9 (127 116 112 107)

m=?.*o=W=200
29.times{|i|o+=i%9-i/28>0?[-1,1,20].sample: rand(W);m[o%W]='T~^'[i/9]||?o}
puts m.scan /.{20}/

A saída é um pouco simples, mas acho que atende principalmente às especificações!

Alguns exemplos de saídas:

....................
........TTTTTTT.....
........T^^^........
.........^..........
.........^..........
.........^^^.o......
....................
.....~.o............
...~~~..............
...~~~~~............

Outro:

.....^^.............
......^^............
.......^^...........
...........o........
....................
..............T~~~..
.............TT~~...
.............T.~....
.............T.~....
.o..^^.......TT~....

E de novo:

.....TT.............
..............~.....
..............~.....
..............~~....
..............~~~...
........^^^.........
....o.T...^.........
......TT..^^^.......
..o..TT....^^.......
.....T..............

Devido à maneira como é codificado, quase sempre há uma árvore solitária. Eu gosto de imaginar que é a árvore Deku.

Q ( 116 107 caracteres)

Aqui está um em Q

(-1')20 cut@[199{.[t!`s#'(0 20 20 20;0 0 20 20;0 0 0 20;0 1 2 3)!\:t:"T^~.";(x;rand 30)]}\".";2?200;:;"o"];

Saída de amostra

...........o........
...~~....TTTT..~~o..
......TTTTTTTTT....T
T...................
......^^^........TTT
...~~~~.............
....................
............^^......
..~~~..^^^^^^.......
....~..............T

e

..........^^^..^...o
....................
........^.T.........
.......~~...^.......
....................
....TTTTTTTT....^...
..~.................
.o.....^^^^^.......T
............~~~~~~~~
~~~~~....TTT........

e

....................
...~~~~~~~~~~.....~.
................TT..
....TTTTT..~.TT.TTTT
T................TTT
TTT..........TTTTTTT
TTT....T............
........T.......TToT
TTT..............^^.
...TTT..^.~~~~.o....

Posso ajustar a matriz estocástica para afetar a saída, mas acho que o acima está de acordo com o que você está procurando.

/ edit: saída ajustada

/ edit: reduzido número de caracteres adicionando apenas 2 aldeias

K, 84

f:{,/{x+!y}'[5?200;5?10]};m::200#".";{@[`m;x;:;y]}'[(f`;f`;f`;2?200);"~T^o"];10 20#m

Resultado:

"...................T"
"TTTTT~....TTT...^^^."
"...................^"
"^^..............^^^^"
"^^^..~~~~.......^^o."
".........TTTTT......"
"..~~~~~~........TTTT"
"TTT.~..............."
".........o.....^^^^."
"..........TTTTT....."

e

"...............~~~.."
".......~~~~~......TT"
"TTTT.^^^^^^^^......."
"....TT......~~......"
"..........^........."
"...........oTTT..^^^"
"^^^^^^..........^^^^"
"^^...TTTTTTT........"
"................o.~~"
"~~~.............T..."