Genere un mapa de desierto ASCII.

Salida de ejemplo:

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

Anti-ejemplo (no hagas esto):

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

Reglas:

1. Debe tener al menos 20x10 caracteres de tamaño
2. Debe ser diferente en cada ejecución, es decir, aleatorio
3. Debe contener áreas de forma continua y variada de árboles 'T', colinas '^' y agua '~', la mayoría de las cuales deben consistir en más de 5 celdas
4. El carácter predeterminado de tierra es '.'
5. Debe contener al menos 2 pueblos 'o' que generalmente no están uno al lado del otro
6. No debe contener patrones obvios, como rectángulos o áreas espaciadas uniformemente: la clave es el "aspecto natural"
7. No es necesario que compruebe explícitamente que se siguen las reglas (p. Ej., No es necesaria una lógica anti-rectángulo), pero la gran mayoría de las ejecuciones (digamos, 80%) deben producir resultados conformes.
8. Con su envío, incluya un ejemplo de salida

Puntuación:

El ganador tiene el puntaje más bajo de la 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]

Un poco más de lo necesario (para que produzca mejor) pero lo acortaré cuando llegue la respuesta de Golfscript.

La respuesta de GolfScript fue publicada, así que aquí hay una más corta. Pensé en otra forma (bastante obvia, en retrospectiva) de acortarlo para que el resultado no sea mucho peor que el programa original, e incluso sea más corto que mi plan de copia de seguridad original.

(En la versión anterior, tenía cinco campos de bits que estaba trabajando juntos, ahora tengo tres que estoy agregando entre sí).

He reemplazado la salida de ejemplo con la salida de la nueva versión, por supuesto.

Explicación:

• F←⍳S←10 20: el tamaño es 20x10, F es una matriz donde cada elemento son sus coordenadas
• {F∊(?S)∘+¨+\{2-?3 3}¨⍳99}¨T←⍳5: genera 3 campos de bits, comenzando en una coordenada aleatoria, y dando 99 pasos aleatorios a un campo vecino y luego activando ese bit. 99 parece alto pero a menudo retrocede, ya que es aleatorio. Esto hace los mapas para las áreas.
• (⊂7×F∊{?S}¨⍳2): Añadir en dos pueblos.
• ⊃7⌊1++/: suma las áreas, dando una matriz donde cada número representa un tipo determinado. Límite a las 7, porque las aldeas podrían aparecer en otra área dando números altos.
• '.T^~^To'[... ]: reemplaza cada número con el carácter correcto. Hay 3 campos posiblemente superpuestos, por lo que el valor más alto posible es 6. (3 + 3)

Salida de ejemplo:

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

y

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

Versión antigua:

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 alentar los intentos, me di cuenta de esto yo mismo. Puede probar una demostración en vivo aquí (debe abrir la consola JS de su navegador). Probado con 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));​

Salida de ejemplo:

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

No es ideal, ya que siempre hay solo tres áreas (una de cada tipo), su tamaño máximo es de 5x2 celdas y después de algunas ejecuciones, comienzas a notar limitaciones en su ubicación (y en las de las aldeas). Sin embargo, cumple con las reglas.

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*

Salidas de ejemplo:

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

y

.............~......
.............~......
....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}/

El resultado es un poco simple, pero creo que cumple con las especificaciones.

Algunas salidas de ejemplo:

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

Otro:

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

Y otra vez:

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

Debido a la forma en que está codificado, casi siempre hay un árbol solitario. Me gusta imaginar que es el árbol Deku.

Q ( 116 107 char)

Aquí hay uno en 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"];

Salida de muestra

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

y

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

y

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

Puedo ajustar la matriz estocástica para afectar la salida, pero creo que lo anterior se ajusta a lo que estás buscando.

/ edit: salida modificada

/ edit: recuento reducido de carbonos al agregar solo 2 pueblos

K, 84

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

Salida:

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

y

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