Tạo một bản đồ hoang dã ASCII.

Ví dụ đầu ra:

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

Chống ví dụ (không làm điều này):

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

Quy tắc:

1. Phải có kích thước tối thiểu 20x10 ký tự
2. Phải khác nhau mỗi lần chạy, tức là ngẫu nhiên
3. Phải chứa các khu vực hình dạng liên tục và khác nhau của cây 'T', đồi '^' và nước '~', hầu hết trong số đó phải bao gồm hơn 5 ô
4. Mặc định, ký tự mặt đất là '.'
5. Phải chứa ít nhất 2 làng 'o' thường không nằm cạnh nhau
6. Không được chứa các mẫu rõ ràng, chẳng hạn như hình chữ nhật hoặc các vùng cách đều nhau - "giao diện tự nhiên" là chìa khóa
7. Bạn không cần kiểm tra rõ ràng rằng các quy tắc được tuân theo (ví dụ: không cần logic chống hình chữ nhật), nhưng phần lớn các lần chạy (giả sử, 80%) phải tạo ra kết quả phù hợp
8. Với trình của bạn, bao gồm một đầu ra ví dụ

Ghi điểm:

Người chiến thắng có điểm thấp nhất từ ​​công thức: 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]

Một chút lâu hơn nó cần (để nó cho đầu ra tốt hơn) nhưng tôi sẽ rút ngắn nó khi câu trả lời Golfscript xuất hiện.

Câu trả lời GolfScript đã được đăng nên đây là câu trả lời ngắn hơn. Tôi đã nghĩ đến một cách khác (khá rõ ràng, trong nhận thức muộn) để rút ngắn nó để đầu ra không tệ hơn nhiều so với chương trình ban đầu, và nó thậm chí còn ngắn hơn kế hoạch dự phòng ban đầu của tôi.

(Trong phiên bản cũ, tôi có năm bitfield mà tôi đã xor-ing với nhau, bây giờ tôi có ba cái mà tôi đang thêm vào nhau.)

Tôi đã thay thế đầu ra ví dụ bằng đầu ra của phiên bản mới, tất nhiên.

Giải trình:

• F←⍳S←10 20: kích thước là 20x10, F là ma trận trong đó mỗi phần tử là tọa độ của nó
• {F∊(?S)∘+¨+\{2-?3 3}¨⍳99}¨T←⍳5: tạo 3 bitfield, bằng cách bắt đầu tại tọa độ ngẫu nhiên và thực hiện 99 bước ngẫu nhiên sang trường lân cận và sau đó đặt bit đó vào. 99 có vẻ cao nhưng nó thường quay lại vì nó là ngẫu nhiên. Điều này làm cho các bản đồ cho các khu vực.
• (⊂7×F∊{?S}¨⍳2): Thêm vào hai làng.
• ⊃7⌊1++/: tổng hợp các khu vực, đưa ra một ma trận trong đó mỗi số đại diện cho một loại nhất định. Giới hạn ở mức 7, vì các ngôi làng có thể xuất hiện ở một khu vực khác với số lượng cao.
• '.T^~^To'[... ]: thay thế mỗi số bằng ký tự đúng. Có 3 trường có thể chồng lấp nên giá trị cao nhất có thể là 6. (3 + 3)

Ví dụ đầu ra:

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

và

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

Phiên bản cũ:

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 ký tự

Để khuyến khích những nỗ lực, tôi đã tự mình bẻ khóa. Bạn có thể thử bản demo trực tiếp tại đây (bạn cần mở bảng điều khiển JS của trình duyệt). Đã thử nghiệm với Chrome và 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));​

Ví dụ đầu ra:

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

Điều đó không lý tưởng, vì luôn chỉ có ba khu vực (một trong mỗi loại), kích thước tối đa của chúng là 5x2 ô và sau một vài lần chạy, bạn bắt đầu nhận thấy những hạn chế trong vị trí (và làng) của chúng. Tuy nhiên, nó đáp ứng các quy tắc.

GolfScript, 97 ký tự

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

Kết quả ví dụ:

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

và

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

Đầu ra hơi đơn giản, nhưng tôi nghĩ rằng nó chủ yếu đáp ứng thông số kỹ thuật!

Một số ví dụ đầu ra:

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

Khác:

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

Và một lần nữa:

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

Do cách mã hóa, hầu như luôn có một cây đơn độc. Tôi thích tưởng tượng đó là cây Deku.

Q ( 116 107 char)

Đây là một trong 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"];

Sản lượng mẫu

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

và

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

và

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

Tôi có thể điều chỉnh ma trận ngẫu nhiên để ảnh hưởng đến đầu ra nhưng tôi nghĩ ở trên phù hợp với những gì bạn đang tìm kiếm.

/ chỉnh sửa: đầu ra được điều chỉnh

/ chỉnh sửa: giảm số lượng char bằng cách chỉ thêm 2 làng

K, 84

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

Đầu ra:

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

và

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