Chương trình của bạn phải in ra một số khoảng trắng, theo sau là dấu chấm và dòng mới. Số lượng khoảng trắng là vị trí x của dấu chấm của bạn được xác định bằng 0 <x <30

Mỗi dòng mới là một lượt. Chương trình của bạn chạy trong 30 lượt. Chương trình của bạn bắt đầu với một vị trí x ngẫu nhiên và mỗi lượt chuyển vị trí này ngẫu nhiên 1 sang trái hoặc phải, trong khi vẫn ở trong khu vực được xác định. Mỗi lượt của bạn phải thay đổi vị trí của nó bằng 1.

Điểm của bạn là số lượng nhân vật. Bạn nhận được 10 điểm thưởng, nếu mỗi dòng in bao gồm chính xác 30 ký tự (và dòng mới). Bạn nhận được 50 điểm thưởng, nếu, trong khi ngẫu nhiên, chương trình của bạn có xu hướng ở giữa khu vực được xác định.

Chỉnh sửa: 50 điểm thưởng được dự định để kéo dấu chấm của bạn vào giữa. Ví dụ: điều này áp dụng nếu dấu chấm của bạn ở x = 20 và có cơ hội 66% ở bên trái và 33% ở bên phải. Điều này phải độc lập với điểm bắt đầu và chỉ nên xảy ra bằng cách thay đổi giá trị phần trăm của trái / phải một cách linh hoạt.

Không có đầu vào của bất kỳ loại nào được cho phép, đầu ra phải nằm trên bàn điều khiển thực thi!

Để hiểu rõ hơn, đây là một ví dụ dễ đọc trong java, nó sẽ cho bạn điểm 723:

public class DotJumper{
    public static void main(String[] args){
        int i = (int)(Math.random()*30);
        int max = 29;
        int step = 1;
        int count = 30;
        while(count>0){
            if(i<=1){
                i+=step;
            }else if(i>=max){
                i-=step;
            }else{
                if(Math.random() > 0.5){
                    i+=step;
                }else{
                    i-=step;
                }
            }
            print(i);
            count--;
        }
    }
    public static void print(int i){
        while(i>0){
            System.out.print(' ');
            i--;
        }
        System.out.println('.');
    }
}

APL, 39 - 10 - 50 = nhận21

0/{⎕←30↑'.',⍨⍵↑''⋄⍵+¯1*⍵>.5+?28}/31/?29

Đã thử nghiệm trên Dyalog với ⎕IO←1và ⎕ML←3nó phải khá di động.

Giải trình

                   ?29  take a random natural from 1 to 29
                31/     repeat it 31 times
              }/        reduce (right-fold) the list using the given function:
          ⍵↑''          . make a string of ⍵ (the function argument) spaces
     '.',⍨              . append a dot to its right
⎕←30↑                   . right-pad it with spaces up to length 30 and output
                ◇       . then
             ?28        . take a random natural from 1 to 28
          .5+           . add 0.5, giving a number ∊ (1.5 2.5 ... 27.5 28.5)
        ⍵>              . check whether the result is <⍵ (see explanation below)
     ¯1*                . raise -1 to the boolean result (0 1 become resp. 1 -1)
   ⍵+                   . add it to ⍵ and return it as the new accumulator value
0/{                     finally ignore the numeric result of the reduction

Ở mỗi bước, mã này quyết định di chuyển dấu chấm sang trái hay sang phải tùy thuộc vào xác suất một số ngẫu nhiên được chọn trong số (1.5 2.5 ... 27.5 28.5) nhỏ hơn vị trí chấm hiện tại.

Do đó, khi vị trí chấm hiện tại (số khoảng trắng ở bên trái) là 1, số gia luôn luôn là +1 (tất cả các số đó 1,5 ... 28,5 là> 1), khi đó là 29 luôn là -1 (tất cả các số đó là <29); mặt khác, nó được chọn ngẫu nhiên giữa +1 và -1, với xác suất đó là phép nội suy tuyến tính giữa các cực trị đó. Vì vậy, dấu chấm luôn luôn chuyển động và luôn có khả năng di chuyển về phía trung tâm hơn là về phía hai bên. Nếu nó chính xác ở giữa, nó có 50% cơ hội để di chuyển sang hai bên.

Việc giảm (gấp đúng) của một giá trị {...}/a/bđược sao chép chỉ là một mẹo tôi đã nghĩ ra để lặp lại một a-1lần hàm , bắt đầu bằng giá trị bvà có kết quả của mỗi lần lặp là ⍵đối số tích lũy ( ) cho lần tiếp theo. Các đối số đầu vào thứ hai và tiếp theo ( ⍺) cũng như kết quả cuối cùng bị bỏ qua. Nó hóa ra là ngắn hơn so với một cuộc gọi đệ quy thông thường với người bảo vệ.

Chạy ví dụ

0/{⎕←30↑'.',⍨⍵↑''⋄⍵+¯1*⍵>.5+?28}/31/?29
                   .          
                    .         
                   .          
                  .           
                 .            
                .             
               .              
                .             
               .              
                .             
               .              
              .               
             .                
              .               
             .                
              .               
               .              
              .               
               .              
                .             
                 .            
                  .           
                 .            
                  .           
                 .            
                  .           
                 .            
                .             
               .              
                .             

Toán học 138 - 10 - 50 = 78

Tôi không đăng bài này vì tôi nghĩ nó đặc biệt tốt, nhưng vì những lý do khác. Nó sử dụng định nghĩa Quy trình Markov với ma trận chuyển tiếp được thiết kế để lấy bóng "tập trung".

Việc sử dụng quy trình Markov trong Mathematica cho phép chúng tôi tính toán một số thống kê hữu ích , như bạn sẽ thấy bên dưới.

Đầu tiên mã (không cần khoảng trắng):

r = Range@28/28;
s = DiagonalMatrix;
ListPlot[RandomFunction[DiscreteMarkovProcess[RandomInteger@#, r~ s ~ -1 + s[29/28- r, 1]], 
                                              #], PlotRange -> #] &@{1, 29}

Một số kết quả đầu ra:

Ma trận chuyển tiếp tôi đã sử dụng là:

MatrixPlot[s[r, -1] + s[29/28 - r, 1]]

Nhưng như tôi đã nói, phần thú vị là việc sử dụng DiscreteMarkovProcess[]cho phép chúng ta có được một bức tranh tốt về những gì đang xảy ra.

Chúng ta hãy xem xác suất bóng xuất hiện 15bất cứ lúc nào t bắt đầu từ một trạng thái ngẫu nhiên cụ thể :

d = DiscreteMarkovProcess[RandomInteger@29, s[r, -1] + s[29/28 - r, 1]];
k[t_] := Probability[x[t] == 15, x \[Distributed] d]
ListLinePlot[Table[k[t], {t, 0, 50}], PlotRange -> All]

Bạn có thể thấy nó dao động trong khoảng từ 0 đến một giá trị gần 0,3, đó là bởi vì tùy thuộc vào trạng thái bắt đầu, bạn chỉ có thể đạt 15 trên một số bước lẻ hoặc chẵn :)

Bây giờ chúng ta có thể làm điều tương tự, nhưng nói với Mathematica xem xét thống kê bắt đầu từ tất cả các trạng thái ban đầu có thể. Xác suất xuất hiện 15sau một thời gian là tbao nhiêu?

d = DiscreteMarkovProcess[Array[1 &, 29]/29, s[r, -1] + s[29/28 - r, 1]];
k[t_] := Probability[x[t] == 15, x \[Distributed] d]
ListLinePlot[Table[k[t], {t, 0, 100}], PlotRange -> All]

Bạn có thể thấy nó cũng dao động ... tại sao? Câu trả lời rất đơn giản: trong khoảng [1, 29]có nhiều số lẻ hơn số chẵn :)

Dao động gần như biến mất nếu chúng ta yêu cầu xác suất bóng ở 14 OR 15:

Và bạn cũng có thể yêu cầu giới hạn (theo nghĩa Cesaro) về xác suất trạng thái:

ListLinePlot@First@MarkovProcessProperties[d, "LimitTransitionMatrix"]

Oh, tốt, có lẽ tôi xứng đáng với một số downvote cho một câu trả lời ngoài chủ đề như vậy. Đừng ngại.

Bash, điểm 21 (81 byte - 50 tiền thưởng - 10 tiền thưởng)

o=$[RANDOM%28];for i in {D..a};{ printf " %$[o+=1-2*(RANDOM%29<o)]s.%$[28-o]s
";}

Trong câu trả lời này, dấu chấm được "kéo" trở lại giữa. Điều này có thể được kiểm tra bằng cách mã hóa điểm bắt đầu từ 0 hoặc 30.

Ruby 69 66 64-60 = 4

i=rand(30);30.times{a=' '*30;a[i]=?.;puts a;i+=rand>i/29.0?1:-1}

Mẫu vật:

            .             
           .              
            .             
           .              
          .               
           .              
            .             
             .            
              .           
             .            
              .           
               .          
              .           
               .          
              .           
             .            
            .             
             .            
              .           
             .            
              .           
             .            
            .             
             .            
            .             
             .            
            .             
           .              
          .               
           .              

Smalltalk, 161 159 145-60 = 85

tất cả các cột dài 30 ký tự (hoạt động trong chuỗi b có thể thay đổi);

cơ hội di chuyển ngẫu nhiên được điều chỉnh bằng giá trị rnd thiên vị với p (rnd (0,29) -p), lấy dấu (-1/0/1) và sau đó điều chỉnh thành (-1 / + 1) thông qua (-1 | 1), được coi là di chuyển delta (tính toán hiệu quả: x dấu <= 0 ifTrue: -1 ifFalse: 1). Vì ST sử dụng lập chỉ mục dựa trên 1, tôi phải điều chỉnh tất cả các tham chiếu chuỗi bằng +1 (xin vui lòng đánh giá cao bản hack fiddling -1 | 1 bit ;-)).

p:=((r:=Random)next*29)rounded.(b:=String new:30)at:p+1put:$..0to:29do:[:i|b at:p+1put:$ .p:=(p+(((r next*29)-p)sign-1|1))min:29max:0.b at:p+1put:$..b printCR]

đánh cắp một ý tưởng từ phiên bản Ruby (thanx & Up @fipgr), tôi có thể thoát khỏi kiểm tra tối thiểu / tối đa:

p:=((r:=Random)next*29)rounded.(b:=String new:30)at:p+1put:$..1to:30 do:[:i|b at:p+1put:$ .p:=p+((r next-(p/29))sign-1|1).b at:p+1put:$.;printCR]

đầu ra: (Tôi đã thêm thủ công các số col và các thanh dọc sau đó; mã ở trên không tạo ra chúng)

 012345678901234567890123456789
|                     .        |
|                    .         |
|                   .          |
|                  .           |
|                 .            |
|                  .           |
|                 .            |
|                  .           |
|                 .            |
|                .             |
|                 .            |
|                .             |
|               .              |
|                .             |
|                 .            |
|                  .           |
|                 .            |
|                  .           |
|                 .            |
|                  .           |
|                 .            |
|                .             |
|               .              |
|                .             |
|               .              |
|                .             |
|               .              |
|              .               |
|               .              |
|              .               |
 012345678901234567890123456789

C, 86

Giả sử rằng gieo hạt rand()chức năng là không cần thiết.

k=30;main(i){i=rand()%k;while(k--){printf("%*c\n",i+=i==30?-1:i==1||rand()%2?1:-1,46);}}

Giải trình:

Trong C, trong "%*c"các *phương tiện mà chiều dài của đầu ra sẽ có độ dài tối thiểu, và thời gian tối thiểu này được xác định bởi đối số của cuộc gọi chức năng (trong trường hợp này, nó là i+=i==30?-1:i==1||rand()%2?1:-1. Các cphương tiện tham số tiếp theo ( 46) là một nhân vật ( dấu chấm).

Đối với việc kiểm tra ranh giới, tôi xin lỗi rằng tôi đã quên điều đó. Bây giờ tôi đã thêm điều này vào câu trả lời, với chi phí là 15 ký tự. Toán tử ternary hoạt động như sau : boolean_condition?value_if_true:value_if_false. Lưu ý rằng trong C true là 1 và false là 0.

Java: 204 183 182 176 175 ký tự - 10 - 50 = 115

class K{public static void main(String[]y){int k,j=0,i=(int)(29*Math.random());for(;j++<30;i+=Math.random()*28<i?-1:1)for(k=0;k<31;k++)System.out.print(k>29?10:k==i?'.':32);}}

Đầu tiên, vị trí dấu chấm phải là 0 < x < 30, tức là [1-29]. Điều này tạo ra một số từ 0 đến 28 được phân phối đồng đều và cho các mục đích của chương trình này [0-28] có tác dụng tương tự như [1-29]:

i=(int)(29*Math.random());

Cá nhân tôi thích nếu nó được phân phối bình thường vào khoảng 14, nhưng câu trả lời của tôi sẽ dài hơn:

i=0;for(;j<29;j++)i+=(int)(2*Math.random());

Thứ hai, mã này đảm bảo rằng nó có xu hướng ở giữa:

i+=Math.random()*28<i?-1:1

Xác suất để có được +1 là lớn hơn nhỏ hơn là giá trị của ivà chúng ta ngược lại với -1. Nếu ilà 0, xác suất lấy +1 là 100% và xác suất lấy -1 là 0%. Nếu ilà 28, điều ngược lại sẽ xảy ra.

Thứ ba, bằng cách thay thế 32ở cuối bằng cách '_'xem đầu ra dễ dàng hơn, chúng ta thấy rằng mỗi dòng có 30 ký tự cộng với một dòng mới:

__________.___________________
_________.____________________
________._____________________
_________.____________________
__________.___________________
___________.__________________
__________.___________________
_________.____________________
________._____________________
_________.____________________
________._____________________
_________.____________________
__________.___________________
_________.____________________
__________.___________________
___________.__________________
__________.___________________
_________.____________________
__________.___________________
___________.__________________
____________._________________
_____________.________________
____________._________________
_____________.________________
______________._______________
_____________.________________
______________._______________
_______________.______________
______________._______________
_____________.________________

Cảm ơn @VadimR (bây giờ, user2846289) đã chỉ ra một sự hiểu lầm trong phiên bản trước.

Cảm ơn @KevinCruijssen đã loại bỏ 6 ký tự, thậm chí sau hơn hai năm rưỡi sau khi câu trả lời này ban đầu được đăng.

Toán học 157-10-50 = 97

Một số ngẫu nhiên từ 1-30 được sử dụng để bắt đầu. Tất cả các số cột còn lại từ dấu chấm được chọn thông qua RandomChoice[If[c > 15, {2, 1}, {1, 2}] -> {-1, 1}] + c, nghĩa là: "Nếu số cột trước lớn hơn 15, hãy chọn một số từ tập {-1,1}, với -1 có trọng số 2: 1 1, nếu không, lật các trọng số và chọn từ cùng một bộ.

ReplacePart thay thế phần tử trong danh sách 30 khoảng trắng tương ứng với cột quan tâm.

f@c_ := Switch[d = RandomChoice[If[c > 15, {2, 1}, {1, 2}] -> {-1, 1}] + c, 1, 2, 30, 29, d, d]
Row@ReplacePart[Array["_" &, 29], # -> "."] & /@ NestList[f, RandomInteger@29+1, 30] // TableForm

> <>, 358 - 10 = 348

Điều này sẽ không giành chiến thắng tại codegolf, nhưng nó hoạt động. (Trên windows 7 với trình thông dịch này , thực hiện lệnh "p" khác với trang esolang định nghĩa nó)

1v        >a"                              "v
v<      0<} vooooooooooooooooooooooooooooooo<
&  _>   v : >$" "@p1+:2f*(?v;
  |x1>  v^}!               <
  |xx2> v p
  |xxx3>v  
  |xxxx4v $
>!|xxx< v }
  |xxxx6v }
  |xxx7>v @
  |xx8> v :
  |x9v  < @>  5)?v$:67*)?vv
   _>>&?v!@^     >$:b(?v v
  v }"."< :        v+ 1<  <
  >a+b+00}^0}}${"."< <- 1<

Tên của ngôn ngữ này không thể được googled, vì vậy đây là bài viết esolang của nó cho tò mò.

PHP, 118 113 112 111 (, -10 điểm thưởng = 101)

(lần thử thứ hai, với rand()hành vi có thể dự đoán khủng khiếp và hiệu quả hơn một chút)

for($n=30,$i=rand(1,29),$t=$s=pack("A$n",'');$n--;$i+=$i<2|rand()%2&$i<28?1:-1,$t=$s){$t[$i-1]='.';echo"$t\n";}

Kết quả có thể:

______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________
______._______________________
_____.________________________

PHP, 130 (, -10 điểm thưởng = 120)

(lần thử đầu tiên)

Điều này có thể vẫn còn hiệu quả hơn nhiều:

for($n=30,$i=rand(1,29),$t=$s=str_repeat(' ',$n)."\n";$n--;$i=$i<2?2:($i>28?28:(rand(0,1)?$i+1:$i-1)),$t=$s){$t[$i-1]='.';echo$t;}

Nếu tôi thay thế khoảng trắng bằng dấu gạch dưới (cho mục đích hiển thị), đây là kết quả có thể xảy ra:

________._____________________
_______.______________________
______._______________________
_______.______________________
________._____________________
_______.______________________
______._______________________
_______.______________________
______._______________________
_______.______________________
________._____________________
_______.______________________
________._____________________
_________.____________________
__________.___________________
___________.__________________
__________.___________________
___________.__________________
__________.___________________
_________.____________________
________._____________________
_________.____________________
________._____________________
_______.______________________
______._______________________
_____.________________________
____._________________________
_____.________________________
____._________________________
___.__________________________

Thật kỳ lạ, nếu tôi thay thế rand(0,1)bằng rand()%2(PHP 5.4, trên Windows XP), kết quả ngẫu nhiên luôn chuyển từ lẻ sang chẵn và ngược lại, trên mỗi lần lặp lại tiếp theo, làm cho mọi thứ trở nên rand()đáng lo ngại, theo nghĩa đó, thật bất ngờ. "Lỗi" này dường như là một lỗi đã được biết đến từ năm 2004 . Không hoàn toàn chắc chắn liệu nó có chính xác cùng một 'lỗi' hay không.

J 42 ký tự - 50 -10 = -18

'_.'{~(|.~((I.%<:@#)*@-?@0:))^:(<@#)1=?~30

Giải thích, bắt đầu từ bên phải (một số kiến ​​thức về xe lửa có ích):

init=: 0=?~30          NB. where is the 0 in the random permutation of [0,29]
rep =: ^:(<@#)         NB. repeat as many times as the array is long, showing each step

rnd =: ?@0:            NB. discards input, generates a random number between 0 and 1

signdiff =: *@-        NB. sign of the difference (because this works nicely with
                       NB. the shift later on).

left_prob =: (I.%<:@#) NB. probability of shifting left. The position of the one (I.) divided by the length -1.

shift =: |.~           NB. x shift y , shifts x by y positions to the left.

output =: {&'_.'       NB. for selecting the dots and bars.

NB. Piecing things together:
output (shift (left_prob signdiff rnd))rep init

Xu hướng trung tâm, -50, ví dụ trên 1000 lượt chạy:

NB. Amounts of ones in each column (sum)
   ]a=:+/ (|.~((I.%<:@#)*@-?@0:))^:(<1000)0=?30
0 0 0 0 0 0 2 6 10 12 25 60 95 121 145 161 148 99 49 27 19 13 6 1 1 0 0 0 0 0
   +/a NB. check the number of ones in total
1000
   |. |:(<.a%10) #"0 1] '*' NB. plot of those values
           *              
           *              
          ***             
          ***             
         ****             
         ****             
         ****             
        ******            
        ******            
        ******            
       *******            
       *******            
       ********           
       ********           
      **********          
    **************        

Ví dụ chạy, xuất chính xác 30 byte mỗi dòng

_______________.______________
________________._____________
_______________.______________
________________._____________
_______________.______________
________________._____________
_______________.______________
________________._____________
_______________.______________
________________._____________
_______________.______________
______________._______________
_______________.______________
________________._____________
_________________.____________
________________._____________
_______________.______________
______________._______________
_____________.________________
____________._________________
___________.__________________
__________.___________________
___________.__________________
__________.___________________
___________.__________________
__________.___________________
___________.__________________
____________._________________
_____________.________________
______________._______________

Con trăn 2.7: 126 109 -10-50 = 49

Đã thoát khỏi điểm bắt đầu được mã hóa cứng - bây giờ bắt đầu tại điểm ngẫu nhiên. Vì điều này, tôi cần randint, vì vậy tôi quyết định sử dụng nó thay vì lựa chọn cho phần bù. Đã sử dụng thủ thuật bool (-1) ** cho việc đó.

from random import randint as r;p=r(0,29)
for i in range(30):
 print' '*p+'.'+' '*(29-p);p+=(-1)**(r(0,29)<p)

Một số câu trả lời tuyệt vời ở đây. Nỗ lực đầu tiên trong Python, suy nghĩ về các cải tiến. Không được giúp đỡ bởi nhu cầu nhập khẩu.

-10 - có 30 ký tự + \ n trên mỗi dòng

-50 - càng xa trung tâm, càng có nhiều khả năng di chuyển theo cách khác (hoàn thành bằng cách xây dựng một danh sách với số lần bù + / i khác nhau)

Lần thử trước:

from random import choice;p,l=15,[]
for i in range(30):
 q=29-p;l+=[' '*p+'.'+' '*q];p+=choice([1]*q+[-1]*p)
print'\n'.join(l)

Java - 198 183 ký tự

Đây chỉ là một môn đánh gôn đơn giản, đơn giản, trực tiếp và không sáng tạo về ví dụ mà bạn đã đưa ra trong câu hỏi.

class A{public static void main(String[]y){int c,j,i=(int)(Math.random()*30);for(c=30;c>0;c--)for(j=i+=i<2?1:i>28?-1:Math.random()>0.5?1:-1;j>=0;j--)System.out.print(j>0?" ":".\n");}}

Mẻ - (288 byte - 10) 278

@echo off&setlocal enabledelayedexpansion&set/ap=%random%*30/32768+1&for /l %%b in (1,1,30)do (set/ar=!random!%%2&if !r!==1 (if !p! GTR 1 (set/ap-=1)else set/ap+=1)else if !p! LSS 30 (set/ap+=1)else set/ap-=1
for /l %%c in (1,1,30)do if %%c==!p! (set/p"=."<nul)else set/p"=_"<nul
echo.)

Chưa chơi gôn:

@echo off
setlocal enabledelayedexpansion
set /a p=%random%*30/32768+1
for /l %%b in (1,1,30) do (
    set /a r=!random!%%2
    if !r!==1 (
        if !p! GTR 1 (set /a p-=1) else set /a p+=1
    ) else if !p! LSS 30 (set /a p+=1) else set /a p-=1
    for /l %%c in (1,1,30) do if %%c==!p! (set /p "=."<nul) else set /p "=_"<nul
    echo.
)

Để đầu ra không gian thay vì dấu gạch dưới - 372 Byte -

@echo off&setlocal enabledelayedexpansion&for /f %%A in ('"prompt $H &echo on&for %%B in (1)do rem"')do set B=%%A
set/ap=%random%*30/32768+1&for /l %%b in (1,1,30)do (set/ar=!random!*2/32768+1&if !r!==1 (if !p! GTR 1 (set/ap-=1)else set/ap+=1)else if !p! LSS 30 (set/ap+=1)else set/ap-=1
for /l %%c in (1,1,30)do if %%c==!p! (set/p"=."<nul)else set/p"=.%B% "<nul
echo.)

Tìm kiếm một số trợ giúp với logic sau, chắc chắn đây không phải là phương pháp hiệu quả nhất về không gian (! R! Sẽ mở rộng thành 1 hoặc 2) -

if !r!==1 (
    if !p! GTR 1 (set /a p-=1) else set /a p+=1
) else if !p! LSS 30 (set /a p+=1) else set /a p-=1

Nó đánh gôn xuống: if !r!==1 (if !p! GTR 1 (set/ap-=1)else set/ap+=1)else if !r! LSS 30 (set/ap+=1)else set/ap-=1

J, 42 ký tự, không có tiền thưởng

' .'{~(i.30)=/~29<.0>.+/\(-0&=)?(,2#~<:)30

Chạy ví dụ:

          ' .'{~(i.30)=/~29<.0>.+/\(-0&=)?(,2#~<:)30
                       .
                      .
                     .
                      .
                     .
                      .
                     .
                      .
                       .
                      .
                     .
                    .
                     .
                    .
                     .
                    .
                     .
                      .
                       .
                        .
                       .
                        .
                       .
                      .
                     .
                      .
                       .
                      .
                     .
                    .

Python 2.7 (126 - 10 (độ dài sửa) - 50 (Xu hướng trung tâm) = 66)

Chương trình sau đây có xu hướng trung tâm so với mẫu lớn hơn

s=id(9)%30
for e in ([[0,2][s>15]]*abs(s-15)+map(lambda e:ord(e)%2*2,os.urandom(30)))[:30]:
    s+=1-e;print" "*s+"."+" "*(28-s)

Bản giới thiệu

         .           
        .            
       .             
      .              
     .               
      .              
       .             
        .            
         .           
          .          
           .         
          .          
           .         
          .          
         .           
        .            
       .             
        .            
       .             
      .              
     .               
      .              
       .             
      .              
     .               
    .                
   .                 
    .                
   .                 
    .              

Javascript 125 73 72 60 (120 - 50 - 10)

i=0;r=Math.random;s=r()*30|0;do{a=Array(30);a[s=s>28?28:s?r()<s/30?s-1:s+1:1]='.';console.log(a.join(' '))}while(++i<30)

EDIT: Sửa lỗi cho 50 điểm thưởng và 10 điểm thưởng.

EDIT 2: Thậm chí ngắn hơn!

Đ - 167, 162, 144 (154 - 10)

Golfed :

import std.stdio,std.random;void main(){int i=uniform(1,30),j,k;for(;k<30;++k){char[30]c;c[i]='.';c.writeln;j=uniform(0,2);i+=i==29?-1:i==0?1:j==1?1:-1;}}

Chưa chơi gôn :

import std.stdio, std.random;

void main()
{
    int i = uniform( 1, 30 ), j, k;

    for(; k < 30; ++k )
    {
        char[30] c;
        c[i] = '.';
        c.writeln;
        j = uniform( 0, 2 );
        i += i == 29 ? -1 : i == 0 ? 1 : j == 1 ? 1 : -1;
    }
}

EDIT 1 - Tôi không chắc chắn liệu mã của tôi có đủ điều kiện nhận phần thưởng -50 hay không. ikhông phải lúc nào bắt đầu ở giữa, nhưng trong forvòng lặp, các chấm không bao giờ di chuyển hơn như 3 địa điểm hai hướng, vì vậy khi i nào bắt đầu gần giữa, toàn bộ điều có xu hướng ở lại đó là tốt.

EDIT 2 - Mã hiện đủ điều kiện nhận phần thưởng -10, vì nó in ra một mảng gồm 29 ký tự, theo sau là LF với tổng số chính xác là 30 ký tự trên mỗi dòng.

PowerShell, 77 - 10 - 50 = 17

$x=random 30
1..30|%{$x+=random(@(-1)*$x+@(1)*(29-$x))
'_'*$x+'.'+'_'*(29-$x)}

Đầu ra

_.____________________________
__.___________________________
___.__________________________
____._________________________
___.__________________________
____._________________________
_____.________________________
______._______________________
_______.______________________
______._______________________
_____.________________________
______._______________________
_______.______________________
________._____________________
_________.____________________
__________.___________________
___________.__________________
__________.___________________
___________.__________________
____________._________________
___________.__________________
__________.___________________
_________.____________________
__________.___________________
_________.____________________
________._____________________
_________.____________________
________._____________________
_________.____________________
__________.___________________

R, 107 ký tự - Phần thưởng 60 điểm = 47

s=sample;i=s(29,1);for(j in 1:30){a=rep(' ',30);i=i+s(c(-1,1),1,p=c(i-1,29-i));a[i]='.';cat(a,'\n',sep='')}

ilà chỉ số của dấu chấm. alà mảng 30 khoảng trắng. Điểm bắt đầu là ngẫu nhiên (thống nhất từ ​​1 đến 29). Ở mỗi lần lặp, chúng tôi thêm ngẫu nhiên -1 hoặc +1 vào ivới xác suất có trọng số: i-1for -1và 29-i for +1(giá trị được cung cấp dưới dạng xác suất không cần phải tổng hợp thành một), có nghĩa là nó có xu hướng hướng dấu chấm về phía trung tâm trong khi ngăn nó từ bên dưới 1 hoặc trên 29 (vì xác suất của họ giảm xuống 0 trong cả hai trường hợp).

Ví dụ chạy với _thay vì khoảng trắng cho mức độ dễ đọc:

> s=sample;i=s(1:30,1);for(j in 1:30){a=rep('_',30);i=i+s(c(-1,1),1,p=c(i-1,29-i));a[i]='.';cat(a,'\n',sep='')}
_______________________.______
______________________._______
_____________________.________
______________________._______
_____________________.________
______________________._______
_____________________.________
______________________._______
_____________________.________
____________________._________
_____________________.________
______________________._______
_____________________.________
______________________._______
_____________________.________
____________________._________
___________________.__________
____________________._________
___________________.__________
__________________.___________
_________________.____________
________________._____________
_______________.______________
______________._______________
_______________.______________
________________._____________
_________________.____________
________________._____________
_______________.______________
______________._______________

C # 184 - 10 - 50 = 123

using System;namespace d{class P{static void Main(){var r=new Random();int p=r.Next(30);for(int i=0;i<30;i++){Console.WriteLine(".".PadLeft(p+1).PadRight(29));p+=r.Next(30)<p?-1:1;}}}}

Đầu ra

spacethay thế _cho mức độ dễ đọc.

____________.________________
___________._________________
__________.__________________
___________._________________
____________.________________
_____________._______________
______________.______________
_____________._______________
______________.______________
_______________._____________
______________.______________
_______________._____________
______________.______________
_______________._____________
______________.______________
_____________._______________
____________.________________
___________._________________
____________.________________
_____________._______________
______________.______________
_____________._______________
____________.________________
___________._________________
____________.________________
___________._________________
____________.________________
___________._________________
__________.__________________
___________._________________

PHP

Với phần thưởng định tâm: 82 - 50 = 32

$i=rand(0,29);for($c=0;$c++<30;rand(0,28)<$i?$i--:$i++)echo pack("A$i",'').".\n";

Đối với phiên bản này (các phiên bản cũ bên dưới), đã xóa kiểm tra tối thiểu / tối đa như được quan tâm trong mã định tâm. rand(1,28)trở nên quan trọng ở đây vì nó cho phép $i++tự đẩy mình lên tới 29 (tối đa thực tế).

chỉnh sửa: dấu ngoặc đơn không cần thiết, di chuyển mã dịch chuyển

Thuật toán đơn giản để định tâm: tạo một số mới trong khoảng từ 0 đến 29 và so sánh nó với số hiện tại. Tận dụng "xác suất" để có được một số ở phía lớn hơn để vẽ về phía trung tâm.

Kết quả thực tế: (đánh số dòng được thêm vào sau đó)

01|        .
02|       .
03|        .
04|         .
05|          .
06|           .
07|            .
08|           .
09|            .
10|             .
11|              .
12|             .
13|            .
14|             .
15|            .
16|             .
17|            .
18|             .
19|              .
20|               .
21|              .
22|             .
23|              .
24|               .
25|                .
26|               .
27|                .
28|                 .
29|                .
30|               .

Lưu trữ:

$i=rand(0,29);for($c=0;$c++<30;){($i<1?$j=1:($i>28?$j=28:$j=rand(0,29)));($j<$i?$i--:$i++);echo pack("A$i",'').".\n";} 119 ký tự

$i=rand(0,29);for($c=0;$c++<30;){($i<1?$i++:($i>28?$i--:(rand(0,29)<$i?$i--:$i++)));echo pack("A$i",'').".\n";} 112 ký tự

JavaScript ES6 125 - 10 (30 dòng ký tự) - 50 (dịch chuyển về giữa) = 65

Tôi đã có một epiphany đi lên thang máy đến đơn vị của mình, vì vậy tôi phải hạ nó xuống trước khi nó rời khỏi ký ức của tôi ...

z=(j=Array(t=29).join`_`)+"."+j;x=(r=Math.random)()*t;for(i=30;i--;)console.log(z.substr(x=(x+=r()<x/t?-1:1)>t?t:x<0?0:x,30))

Một chút thay đổi vị trí xáo trộn và một chút sáng tạo để tính xác suất dịch chuyển được chỉ định bởi x/t... (Cảm ơn Kostronor đã chỉ ra điều đó!) Bây giờ tôi đã nhận được phần thưởng -50 cho việc chuyển sang giữa và tôi cũng đã tạo được vị trí bắt đầu trong phạm vi đầy đủ của dòng, cho phép tôi cạo hai byte!

....5....0....5....0....5....0 <-- Ruler
_.____________________________
__.___________________________
___.__________________________
__.___________________________
___.__________________________
__.___________________________
_.____________________________
__.___________________________
___.__________________________
__.___________________________
___.__________________________
____._________________________
_____.________________________
______._______________________
_______.______________________
________._____________________
_______.______________________
______._______________________
_______.______________________
________._____________________
_______.______________________
________._____________________
_________.____________________
__________.___________________
_________.____________________
__________.___________________
___________.__________________
____________._________________
_____________.________________
______________._______________

k, 53 - 10 - 50 = -7

Giải pháp 1

{{a:30#" ";a[x]:".";a}'{x+$[*x<1?!30;1;-1]}\[x;*1?x]}

Sử dụng

{{a:30#" ";a[x]:".";a}'{x+$[*x<1?!30;1;-1]}\[x;*1?x]}30

"      .                       "
"       .                      "
"      .                       "
"       .                      "
"      .                       "
"       .                      "
"        .                     "
"         .                    "
"        .                     "
"         .                    "
"        .                     "
"         .                    "
"          .                   "
"           .                  "
"            .                 "
"             .                "
"              .               "
"               .              "
"              .               "
"             .                "
"            .                 "
"           .                  "
"          .                   "
"         .                    "
"        .                     "
"       .                      "
"        .                     "
"         .                    "
"          .                   "
"         .                    "
"          .                   "

Giải pháp 2

{r::x;{a:r#" ";a[x]:".";a}'{a:r#0b;a[x?r]:1b;x+$[a@*1?r;-1;1]}\[x;*1?x]}[30]

Scala, 95 - 10 = 85 byte

def r=math.random
Seq.iterate(r*30,30){n=>println(("#"*30)updated(n.toInt,'.'))
(r*2-1+n)round}

Tôi vẫn đang suy nghĩ về phần thưởng 50 byte.

Giải trình:

def r=math.random //define a shortcut for math.random, which returns a number 0 <= n < 1
Seq.iterate(      //build a sequence,
  r*30,             //starting with a random number bewteen 0 and 29
  30                //and containing 30 elements.
){n=>             //Calculate each element by applying this function to the previous element
  println(        //print...
    (" "*30)             //30 spaces
    updated(n.toInt,'.') //with the n-th char replaced with a dot
  )               //and a newline.
                  //The next element is
  (r*2-1+n)       //an random number between -1 and 1 plus n
  round           //rounded to the nearest integer.
}

Javascript, 125 (135 - 10)

q=Math.random,p=~~(q()*31)+1;for(i=0;i++<30;){s='',d=j=1;for(;j++<31;)s+=j==p?'.':" ";p+=q()<.5?1:-1;p-=p>28?2:p<2?-2:0;console.log(s)}

Bình luận và lời khuyên được chào đón.

JavaScript

114 ký tự - 10 (30 dòng char) - 50 (kéo chấm về giữa) = 54

for(f=Math.random,a=[],i=30,j=k=f()*i|0;i--;a[j]='.',a[j+=29-k]='\n',j+=k+=f()>k/29?1:-1);console.log(a.join('-'))

Tuy nhiên, tôi nhận thấy rằng phần thưởng 10 ký tự cho việc điền vào các dòng đến 30 ký tự có thể là một thỏa thuận xấu; vì thế:

102 ký tự - 50 (kéo chấm về giữa) = 52

for(f=Math.random,a=[],i=30,j=k=f()*i|0;i;i--,a[j]='.\n',j+=k+=f()>k/29?1:-1);console.log(a.join('-'))

Kudos gửi @WallyWest cho điều kiện hướng kéo đơn giản hóa f()>k/29?1:-1, dự thảo đầu tiên của tôi sử dụng hai điều kiện lồng nhau.

Vợt 227 byte (-10 cho 30 ký tự, -50 cho chuyển sang đường giữa = 167)

Ở mỗi bước, dấu chấm có khả năng di chuyển về đường giữa nhiều hơn gấp đôi so với cách xa:

(let lp((r(random 1 31))(c 0)(g(λ(n)(make-string n #\space))))(set! r
(cond[(< r 1)1][(> r 30)30][else r]))(printf"~a~a~a~n"(g r)"*"(g(- 29 r)))
(when(< c 30)(lp(+ r(first(shuffle(if(> r 15)'(-1 -1 1)'(1 1 -1)))))(add1 c)g)))

Ung dung:

(define (f)
    (let loop ((r (random 1 31))
               (c 0)
               (g (λ (n) (make-string n #\space))))
      (set! r (cond
                [(< r 1) 1]
                [(> r 30) 30]
                [else r] ))
      (printf "~a~a~a~n" (g r) "*" (g (- 29 r)))
      (when (< c 30)
        (loop (+ r
                 (first
                  (shuffle
                   (if (> r 15)
                       '(-1 -1 1)
                       '(1 1 -1)))))
              (add1 c)
              g))))

Kiểm tra:

(println "012345678901234567890123456789")
(f)

Đầu ra:

"012345678901234567890123456789"
                       *       
                      *        
                       *       
                        *      
                         *     
                        *      
                       *       
                      *        
                     *         
                      *        
                     *         
                    *          
                     *         
                      *        
                     *         
                    *          
                   *           
                  *            
                 *             
                *              
               *               
                *              
                 *             
                *              
                 *             
                *              
                 *             
                *              
                 *             
                *              
               *