Hasilkan peta hutan belantara ASCII.

Contoh output:

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

Anti-contoh (jangan lakukan ini):

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

Aturan:

1. Harus berukuran setidaknya 20x10 karakter
2. Harus berbeda setiap kali dijalankan, yaitu acak
3. Harus mengandung bidang bentuk 'T', bukit '^' dan air 'pohon yang kontinu dan bervariasi, yang sebagian besar terdiri dari lebih dari 5 sel.
4. Default, karakter dasar adalah '.'
5. Harus mengandung setidaknya 2 desa 'o' yang biasanya tidak bersebelahan
6. Harus tidak mengandung pola yang jelas, seperti persegi panjang atau area yang berjarak sama - "tampilan alami" adalah kuncinya
7. Anda tidak perlu memeriksa secara eksplisit bahwa aturan diikuti (mis. Tidak perlu logika anti-persegi panjang), tetapi sebagian besar proses (misalnya, 80%) harus menghasilkan hasil yang sesuai
8. Dengan kiriman Anda, sertakan contoh output

Mencetak:

Pemenang memiliki skor terendah dari rumus: 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]

Sedikit lebih lama dari yang seharusnya (sehingga memberikan hasil yang lebih baik) tetapi saya akan mempersingkat ketika jawaban Golfscript masuk

Jawaban GolfScript telah diposting jadi inilah yang lebih pendek. Saya memikirkan cara lain (agak jelas, di belakang) untuk mempersingkat sehingga output tidak jauh lebih buruk daripada program asli, dan bahkan lebih pendek dari rencana cadangan asli saya.

(Dalam versi yang lama, saya memiliki lima bitfield yang saya xor satu sama lain, sekarang saya memiliki tiga bit yang saya tambahkan satu sama lain.)

Saya telah mengganti contoh output dengan output dari versi baru, tentu saja.

Penjelasan:

• F←⍳S←10 20: ukuran adalah 20x10, F adalah matriks di mana setiap elemen adalah koordinatnya
• {F∊(?S)∘+¨+\{2-?3 3}¨⍳99}¨T←⍳5: menghasilkan 3 bitfield, dengan mulai dari koordinat acak, dan mengambil 99 langkah acak ke bidang tetangga dan kemudian menyetel bit itu. 99 terlihat tinggi tetapi sering kali backtracks karena acak. Ini membuat peta untuk area.
• (⊂7×F∊{?S}¨⍳2): Tambahkan dua desa.
• ⊃7⌊1++/: jumlah area, memberikan matriks di mana setiap angka mewakili tipe tertentu. Tutupi angka 7, karena desa-desa mungkin muncul di daerah lain dengan angka tinggi.
• '.T^~^To'[... ]: ganti setiap nomor dengan karakter yang tepat. Ada 3 bidang yang mungkin tumpang tindih sehingga nilai tertinggi yang mungkin adalah 6. (3 + 3)

Contoh output:

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

dan

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

Versi lama:

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 karakter

Untuk mendorong upaya, saya mengambil celah sendiri. Anda dapat mencoba demo langsung di sini (Anda perlu membuka konsol JS browser Anda). Diuji dengan Chrome dan 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));​

Contoh output:

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

Ini tidak ideal, karena selalu ada hanya tiga area (satu dari setiap jenis), ukuran maksimumnya adalah 5x2 sel dan setelah beberapa kali berjalan, Anda mulai melihat keterbatasan dalam penempatan (dan desa) mereka. Namun, itu memenuhi aturan.

GolfScript, 97 karakter

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

Output contoh:

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

dan

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

Outputnya agak polos, tapi saya pikir sebagian besar memenuhi spesifikasi!

Beberapa contoh keluaran:

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

Lain:

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

Dan lagi:

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

Karena cara kode itu, hampir selalu ada pohon tunggal. Saya suka membayangkan itu pohon Deku.

Q ( 116 107 char)

Ini satu di 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"];

Output sampel

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

dan

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

dan

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

Saya dapat men-tweak matriks stokastik untuk mempengaruhi output tapi saya pikir di atas sesuai dengan apa yang Anda cari.

/ edit: output tweak

/ edit: pengurangan jumlah char dengan hanya menambahkan 2 desa

K, 84

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

Keluaran:

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

dan

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