โปรแกรมของคุณจะต้องพิมพ์ช่องว่างจำนวนหนึ่งตามด้วยจุดและขึ้นบรรทัดใหม่ จำนวนช่องว่างคือตำแหน่ง x ของจุดที่คุณกำหนดด้วย 0 <x <30

ทุกบรรทัดใหม่คือเทิร์น โปรแกรมของคุณทำงานเป็นเวลา 30 รอบ โปรแกรมของคุณเริ่มต้นด้วยการสุ่มตำแหน่ง x และการหมุนทุกครั้งจะเลื่อนตำแหน่งนี้แบบสุ่มไปทางซ้ายหรือขวา 1 โดยอยู่ในพื้นที่ที่กำหนด ทุกจุดของคุณจะต้องเปลี่ยนตำแหน่งโดย 1

คะแนนของคุณคือจำนวนตัวอักษร คุณจะได้รับ 10 คะแนนโบนัสหากทุกบรรทัดที่พิมพ์ประกอบด้วยอักขระ 30 ตัว (และขึ้นบรรทัดใหม่) คุณจะได้รับ 50 คะแนนโบนัสหากในขณะที่สุ่มโปรแกรมของคุณมีแนวโน้มที่จะอยู่ตรงกลางของพื้นที่ที่กำหนด

แก้ไข: คะแนนโบนัส 50 คะแนนมีจุดประสงค์เพื่อดึงจุดของคุณให้อยู่ตรงกลาง ตัวอย่างเช่นการใช้นี้ถ้าจุดของคุณอยู่ที่ x = 20 และมีโอกาส 66% ที่จะไปทางซ้ายและ 33% เพื่อไปทางขวา สิ่งนี้จะต้องเป็นอิสระจากจุดเริ่มต้นและควรเกิดขึ้นโดยการเปลี่ยนค่าร้อยละของซ้าย / ขวาแบบไดนามิก

ไม่อนุญาตให้อินพุตใด ๆ เอาต์พุตจะต้องอยู่ในคอนโซลการทำงาน!

เพื่อความเข้าใจที่ดีขึ้นต่อไปนี้เป็นตัวอย่างที่อ่านได้ใน java ซึ่งจะให้คะแนน 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 = –21

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

ทดสอบกับ Dyalog ด้วย⎕IO←1และ⎕ML←3มันควรจะพกพาได้

คำอธิบาย

                   ?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

ในทุกขั้นตอนรหัสนี้จะตัดสินใจว่าจะเลื่อนจุดไปทางซ้ายหรือไปทางขวาขึ้นอยู่กับความน่าจะเป็นที่ตัวเลขสุ่มที่เลือกระหว่าง (1.5 2.5 ... 27.5 28.5) นั้นน้อยกว่าตำแหน่งจุดปัจจุบัน

ดังนั้นเมื่อตำแหน่งจุดปัจจุบัน (จำนวนช่องว่างทางซ้าย) เป็น 1 การเพิ่มขึ้นจะเป็น +1 เสมอ (ตัวเลขทั้งหมดเหล่านี้ 1.5 ... 28.5 เป็น> 1) เมื่อเป็น 29 มันจะเป็น -1 เสมอ (ตัวเลขทั้งหมดเหล่านั้น คือ <29); มิฉะนั้นจะถูกเลือกแบบสุ่มระหว่าง +1 ถึง -1 ด้วยความน่าจะเป็นนั่นคือการประมาณเชิงเส้นตรงระหว่างสุดขั้วเหล่านั้น ดังนั้นจุดจึงเคลื่อนที่ตลอดเวลาและมีแนวโน้มที่จะเคลื่อนที่เข้าหาจุดศูนย์กลางมากกว่าทางด้านข้าง หากอยู่ตรงกลางก็มีโอกาส 50% ที่จะย้ายไปด้านใดด้านหนึ่ง

การลด (ขวา - พับ) ของค่าที่ทำซ้ำ{...}/a/bเป็นเพียงกลอุบายที่ฉันทำขึ้นมาเพื่อทำซ้ำฟังก์ชั่นa-1ครั้งเริ่มต้นด้วยมูลค่าbและผลของการวนซ้ำแต่ละครั้งจะเป็น⍵อาร์กิวเมนต์ตัวสะสม ( ) ต่อไป อาร์กิวเมนต์อินพุตที่สองและถัดไป ( ⍺) รวมถึงผลลัพธ์สุดท้ายจะถูกละเว้น ดูเหมือนว่าจะสั้นกว่าการโทรแบบเรียกซ้ำด้วยยาม

ตัวอย่างการวิ่ง

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

Mathematica 138 - 10 - 50 = 78

ฉันไม่ได้โพสต์สิ่งนี้เพราะฉันคิดว่ามันเป็นสนามกอล์ฟที่ดีโดยเฉพาะ แต่ด้วยเหตุผลอื่น มันใช้นิยามกระบวนการมาร์คอฟกับเมทริกซ์การเปลี่ยนแปลงที่ออกแบบมาเพื่อรับลูกบอล "กึ่งกลาง"

การใช้กระบวนการมาร์คอฟใน Mathematica ทำให้เราสามารถคำนวณสถิติที่มีประโยชน์ได้ดังที่คุณจะเห็นด้านล่าง

ก่อนรหัส (ช่องว่างไม่จำเป็น):

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

เอาต์พุตบางส่วน:

เมทริกซ์การเปลี่ยนแปลงที่ฉันใช้คือ:

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

แต่อย่างที่ฉันบอกไปส่วนที่น่าสนใจคือการใช้DiscreteMarkovProcess[]ช่วยให้เราได้ภาพที่ดีว่าเกิดอะไรขึ้น

เรามาดูความน่าจะเป็นของลูกบอลได้15ตลอดเวลาt เริ่มจากสถานะการสุ่ม :

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]

คุณสามารถเห็นความผันผวนระหว่าง 0 และค่าใกล้กับ 0.3 นั่นเป็นเพราะขึ้นอยู่กับสถานะเริ่มต้นที่คุณสามารถเข้าถึง 15 ในขั้นตอนคี่หรือจำนวนคู่ :)

ตอนนี้เราสามารถทำสิ่งเดียวกันได้ แต่บอกให้ Mathematica พิจารณาสถิติที่เริ่มต้นจากสถานะเริ่มต้นทั้งหมดที่เป็นไปได้ ความเป็นไปได้ที่จะเกิดขึ้นใน15ภายหลังtคืออะไร:

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]

คุณจะเห็นว่ามันแกว่งไปมา ... ทำไม คำตอบนั้นง่าย: ในช่วงเวลา[1, 29]นั้นมีคี่มากกว่าเลขคู่ :)

ความผันผวนเกือบจะหายไปถ้าเราถามถึงความน่าจะเป็นของลูกบอลที่14 OR 15:

และคุณสามารถขอขีด จำกัด (ในแง่ของ Cesaro) ของความน่าจะเป็นของรัฐ:

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

โอ้ฉันอาจสมควรได้รับ downvotes บางอย่างสำหรับคำตอบนอกหัวข้อ ตามสบาย.

Bash คะแนน 21 (81 ไบต์ - 50 โบนัส - 10 โบนัส)

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

ในคำตอบนี้จุดคือ "ดึง" กลับไปที่ตรงกลาง สามารถทดสอบได้โดยการเข้ารหัสจุดเริ่มต้นที่ 0 หรือ 30

ทับทิม69 66 64-60 = 4

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

ตัวอย่าง:

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

สมอลล์ทอล์ค, 161 159 145-60 = 85

คอลัมน์ทั้งหมดยาว 30chars (ปฏิบัติการในสตริงที่ไม่แน่นอน b);

โอกาสในการเคลื่อนที่แบบสุ่มจะถูกปรับโดยค่า biasing rnd ด้วย p (rnd (0..29) -p) โดยใช้สัญลักษณ์ (-1/0/1) จากนั้นปรับเป็น (-1 / + 1) ผ่านทาง (-1 | 1) ซึ่งนำมาเป็นเดลต้า move (คำนวณได้อย่างมีประสิทธิภาพ: x ลงชื่อ <= 0 ifTrue: -1 ifFalse: 1) เนื่องจาก ST ใช้การจัดทำดัชนีแบบอิง 1 ฉันต้องปรับการอ้างอิงสตริงทั้งหมดด้วย +1 (โปรดชื่นชมการแฮ็คที่มี -1 | 1 บิต ;-) บิต

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]

ขโมยความคิดจากรุ่น Ruby (thanx & Up @fipgr) ฉันสามารถกำจัดการตรวจสอบขั้นต่ำ / สูงสุด:

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]

ผลลัพธ์: (ฉันเพิ่มหมายเลข col และบาร์แนวตั้งด้วยตนเองหลังจากนั้นโค้ดด้านบนไม่ได้สร้างขึ้นมา)

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

C, 86

สมมติว่าrand()ไม่จำเป็นต้องใช้ฟังก์ชันการเพาะ

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

คำอธิบาย:

ใน C ในหมายความว่าระยะเวลาของการส่งออกจะมีความยาวขั้นต่ำและระยะเวลาขั้นต่ำนี้จะถูกกำหนดโดยข้อโต้แย้งของการเรียกฟังก์ชั่น (ในกรณีนี้ก็คือ. the หมายถึงการโต้แย้งถัดไป ( ) เป็นตัวละคร ( จุด)"%*c"*i+=i==30?-1:i==1||rand()%2?1:-1c46

สำหรับการตรวจสอบขอบเขตฉันขอโทษที่ฉันลืมไป ตอนนี้ฉันได้เพิ่มสิ่งนี้ในคำตอบด้วยค่าใช้จ่าย 15 ตัวอักษร ผู้ประกอบการที่ประกอบไปด้วยทำงานดังต่อไปนี้: boolean_condition?value_if_true:value_if_false. โปรดทราบว่าใน C จริงคือ 1 และเท็จเป็น 0

Java: 204 183 182 176 175 ตัวอักษร - 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);}}

อันดับแรกตำแหน่งจุดต้องเป็น0 < x < 30เช่น [1-29] สิ่งนี้จะสร้างตัวเลขระหว่าง 0 ถึง 28 กระจายอย่างสม่ำเสมอและเพื่อจุดประสงค์ของโปรแกรมนี้ [0-28] มีผลเช่นเดียวกับ [1-29]:

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

ฉันชอบโดยส่วนตัวถ้ามันมักจะกระจายประมาณ 14 แต่คำตอบของฉันจะนานกว่า:

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

ประการที่สองรหัสนี้ทำให้แน่ใจได้ว่ามันมีแนวโน้มที่จะอยู่ตรงกลาง:

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

ความน่าจะเป็นที่จะได้รับ +1 ยิ่งใหญ่ขึ้นเมื่อมีค่าน้อยกว่าiและเรามีสิ่งที่ตรงกันข้ามสำหรับ -1 ถ้าiเป็น 0 ความน่าจะเป็นที่จะได้ +1 เท่ากับ 100% และความน่าจะเป็นที่ได้รับ -1 เท่ากับ 0% หากiเป็น 28 ตรงกันข้ามกับสิ่งนั้นจะเกิดขึ้น

ประการที่สามโดยแทนที่32ตอนท้ายด้วย'_'เพื่อดูผลลัพธ์ที่ง่ายขึ้นเราจะเห็นว่าแต่ละบรรทัดมี 30 ตัวอักษรบวกกับบรรทัดใหม่:

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

ขอบคุณ @VadimR (ตอนนี้ผู้ใช้ 2846289) สำหรับการชี้ให้เห็นความเข้าใจผิดในรุ่นก่อนหน้า

ขอบคุณ @KevinCruijssen สำหรับการกำจัดตัวละคร 6 ตัวแม้จะใช้เวลานานกว่าสองปีครึ่งหลังจากคำตอบนี้ถูกโพสต์ครั้งแรก

Mathematica 157-10-50 = 97

หมายเลขสุ่มตั้งแต่ 1-30 ใช้สำหรับเริ่มต้น หมายเลขคอลัมน์ที่เหลือทั้งหมดจากจุดจะถูกเลือกผ่าน RandomChoice[If[c > 15, {2, 1}, {1, 2}] -> {-1, 1}] + cซึ่งแปลเป็น: "หากหมายเลขคอลัมน์ก่อนหน้ามากกว่า 15 ให้เลือกหนึ่งหมายเลขจากชุด {-1,1} โดยมี -1 ถ่วงน้ำหนัก 2: 1 ด้วยความเคารพ 1; มิฉะนั้นให้พลิกน้ำหนักและเลือกจากชุดเดียวกัน

ReplacePart แทนที่องค์ประกอบในรายการของช่องว่าง 30 ที่สอดคล้องกับคอลัมน์ที่น่าสนใจ

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

สิ่งนี้จะไม่ชนะที่ codegolf แต่ได้ผล (บน windows 7 พร้อมล่ามนี้ซึ่งใช้คำสั่ง "p" ต่างจากหน้า esolang กำหนด)

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<

ชื่อของภาษานี้ไม่สามารถ googled ดังนั้นนี่เป็นบทความ esolangสำหรับคนที่อยากรู้อยากเห็น

PHP, 118 113 112 111 (, -10 คะแนนโบนัส = 101)

(ลองครั้งที่สองโดยมีrand()พฤติกรรมที่คาดเดาได้อย่างน่ากลัวและมีประสิทธิภาพมากกว่าเล็กน้อย)

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";}

ผลลัพธ์ที่เป็นไปได้:

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

PHP, 130 (, -10 คะแนนโบนัส = 120)

(ครั้งแรกลอง)

สิ่งนี้อาจจะยังคงมีประสิทธิภาพมากขึ้น:

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;}

ถ้าฉันแทนที่ช่องว่างด้วยเครื่องหมายขีดล่าง (สำหรับจุดประสงค์ในการแสดงผล) นี่เป็นผลลัพธ์ที่เป็นไปได้:

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

ถ้าฉันแทนที่rand(0,1)ด้วยrand()%2(PHP 5.4, บน Windows XP) ผลการสุ่มจะเปลี่ยนจากคี่เป็นคู่และในทางกลับกันในการทำซ้ำครั้งถัดไปทำให้rand()คาดเดาได้อย่างน่ากังวลในทันที นี้ 'ข้อผิดพลาด' ดูเหมือนจะเป็นหนึ่งที่ได้รับเป็นที่รู้จักกันมาตั้งแต่ปี 2004 ไม่แน่ใจว่าเป็นจุดบกพร่องเดียวกันหรือไม่

ตัวอักษร J 42 - 50 -10 = -18

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

คำอธิบายเริ่มจากด้านขวา (ความรู้เกี่ยวกับรถไฟมีประโยชน์):

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

แนวโน้มศูนย์, -50, ตัวอย่างการรันมากกว่า 1,000 ครั้ง:

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
           *              
           *              
          ***             
          ***             
         ****             
         ****             
         ****             
        ******            
        ******            
        ******            
       *******            
       *******            
       ********           
       ********           
      **********          
    **************        

ตัวอย่างการรันจะให้ผลลัพธ์ 30 ไบต์ทุกบรรทัด

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

Python 2.7: 126 109 -10-50 = 49

กำจัดจุดเริ่มต้นที่กำหนดโค้ดยาก - ตอนนี้เริ่มต้นที่จุดสุ่ม ด้วยเหตุนี้ฉันต้องการ randint ดังนั้นฉันจึงตัดสินใจที่จะใช้แทนการเลือกออฟเซ็ต ใช้เคล็ดลับบูล (-1) ** สำหรับสิ่งนั้น

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)

คำตอบที่ดีบางอย่างที่นี่ ความพยายามครั้งแรกใน Python โดยคำนึงถึงการปรับปรุง ไม่ได้ช่วยโดยการนำเข้า

-10 - ใช่ 30 ตัวอักษร + \ n ในแต่ละบรรทัด

-50 - ยิ่งห่างจากศูนย์กลางมากเท่าไหร่โอกาสที่จะย้ายไปทางอื่นก็จะยิ่งมากขึ้นเท่านั้น (ทำได้โดยการสร้างรายการที่มี + / i ที่แตกต่างกันจำนวนมาก)

ความพยายามก่อนหน้า:

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 ตัวอักษร

นี่เป็นเพียงตัวอย่างของสนามกอล์ฟที่เรียบง่ายตรงไปตรงมาและไม่มีความคิดสร้างสรรค์ที่คุณได้ให้ไว้ในคำถาม

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");}}

รุ่นที่ - (288 ไบต์ - 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.)

ยกเลิกแข็งแรงเล่นกอล์ฟ:

@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.
)

เมื่อต้องการส่งออกช่องว่างแทนขีดล่าง - 372 ไบต์ -

@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.)

กำลังมองหาความช่วยเหลือด้วยตรรกะต่อไปนี้แน่นอนว่านี่ไม่ใช่วิธีที่มีประสิทธิภาพที่สุดในพื้นที่ (! r! จะขยายเป็น 1 หรือ 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

มันลงไปที่: 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 ตัวอักษรไม่มีโบนัส

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

ตัวอย่างการเรียกใช้:

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

Python 2.7 (126 - 10 (ความยาวตัวแก้ไข) - 50 (แนวโน้มศูนย์) = 66)

โปรแกรมต่อไปนี้มีแนวโน้มเป็นศูนย์เหนือกลุ่มตัวอย่างที่มีขนาดใหญ่ขึ้น

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)

การสาธิต

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

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)

แก้ไข:แก้ไขเพื่อรับ 50 คะแนนโบนัสและ 10 คะแนนโบนัส

แก้ไข 2:ยิ่งสั้นลง!

D - 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;}}

ยกเลิกการตีลูก :

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;
    }
}

แก้ไข 1 - ฉันไม่แน่ใจว่ารหัสของฉันมีคุณสมบัติตรงตามโบนัส -50 หรือไม่ iไม่ได้เริ่มตรงกลางเสมอ แต่ในระหว่างการforวนรอบจุดจะไม่เคลื่อนที่มากกว่า 3 ตำแหน่งในทิศทางใดทิศทางหนึ่งดังนั้นเมื่อi ใดที่เริ่มใกล้กลาง

แก้ไข 2 - ตอนนี้โค้ดมีคุณสมบัติสำหรับโบนัส -10 เนื่องจากมันพิมพ์อาร์เรย์จำนวน 29 อักขระตามด้วย LF รวมทั้งหมด 30 ตัวอักษรต่อบรรทัด

PowerShell, 77 - 10 - 50 = 17

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

เอาท์พุต

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

R, 107 ตัวอักษร - 60 คะแนนโบนัส = 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='')}

iคือดัชนีของจุด aคืออาร์เรย์ 30 ช่องว่าง จุดเริ่มต้นคือการสุ่ม (สม่ำเสมอจาก 1 ถึง 29) ในการวนซ้ำแต่ละครั้งเราเพิ่ม -1 หรือ +1 ลงไปiด้วยความน่าจะเป็นแบบถ่วงน้ำหนัก: i-1สำหรับ-1และ29-i สำหรับ+1(ค่าที่ป้อนเป็นความน่าจะเป็นไม่จำเป็นต้องรวมเป็นหนึ่ง) ซึ่งหมายความว่ามันมีแนวโน้มที่จะปรับจุดไปทางกึ่งกลาง 1 หรือสูงกว่า 29 (เนื่องจากความน่าจะเป็นของพวกเขาลดลงเหลือ 0 ทั้งสองกรณี)

ตัวอย่างการรันด้วย_แทนการเว้นวรรคเพื่อความชัดเจน:

> 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;}}}}

เอาท์พุต

spaceแทนที่ด้วย_เพื่อความชัดเจน

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

PHP

ด้วยโบนัสตรงกลาง: 82 - 50 = 32

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

สำหรับเวอร์ชันนี้ (เวอร์ชั่นเก่าด้านล่าง) ให้ลบการตรวจสอบขั้นต่ำ / สูงสุดตามที่ได้รับการจัดการในรหัสกลาง rand(1,28)กลายเป็นสิ่งสำคัญที่นี่เพราะมันอนุญาตให้$i++กดได้สูงสุด 29 (สูงสุดจริง)

แก้ไข: วงเล็บที่ไม่จำเป็นย้ายรหัสการเลื่อน

อัลกอริทึมแบบง่ายสำหรับการจัดกึ่งกลาง: สร้างหมายเลขใหม่ระหว่าง 0 ถึง 29 และเปรียบเทียบกับหมายเลขปัจจุบัน ใช้ประโยชน์จาก "ความน่าจะเป็น" ในการรับตัวเลขทางด้านที่ใหญ่กว่าเพื่อเข้าหาจุดศูนย์กลาง

ผลลัพธ์ที่แท้จริง: (เพิ่มหมายเลขบรรทัดหลังจากนั้น)

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|               .

เก็บถาวร:

$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 ตัวอักษร

$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 ตัวอักษร

JavaScript ES6 125 - 10 (30 บรรทัดอักขระ) - 50 (เลื่อนไปทางกลาง) = 65

ฉันมี Epiphany ขึ้นไปที่ลิฟต์ของฉันดังนั้นฉันต้องลงไปก่อนที่มันจะออกจากความทรงจำของฉัน ...

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))

ตัวแปรการสับเปลี่ยนตำแหน่งเล็ก ๆ น้อย ๆ และความคิดสร้างสรรค์เล็กน้อยสำหรับการคำนวณความน่าจะเป็นกะที่ระบุโดยx/t... (ขอบคุณ Kostronor สำหรับการชี้!) ตอนนี้ฉันได้รับโบนัส -50 สำหรับการเปลี่ยนไปตรงกลางและฉันก็ทำตำแหน่งเริ่มต้นภายใน เต็มรูปแบบของบรรทัดซึ่งอนุญาตให้ฉันโกนสองไบต์!

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

k, 53 - 10 - 50 = -7

โซลูชันที่ 1

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

การใช้

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

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

โซลูชันที่ 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]

สกาลา, 95 - 10 = 85 ไบต์

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

ฉันยังคิดเกี่ยวกับโบนัส 50 ไบต์

คำอธิบาย:

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)}

ความคิดเห็นและคำแนะนำยินดีต้อนรับ

JavaScript

114 ตัวอักษร - 10 (30 ตัวอักษร) - 50 (ดึงจุดไปทางกลาง) = 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('-'))

อย่างไรก็ตามฉันสังเกตเห็นว่าการให้รางวัล 10 ตัวอักษรสำหรับการกรอกข้อมูลบรรทัดถึง 30 ตัวอักษรอาจเป็นเรื่องที่ไม่ดี ดังนั้น:

102 ตัวอักษร - 50 (ดึงจุดไปทางกลาง) = 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('-'))

ความรุ่งโรจน์ถึง @WallyWest สำหรับเงื่อนไขการดึงทิศทางแบบง่ายf()>k/29?1:-1ร่างแรกของฉันใช้สองเงื่อนไขซ้อนกัน

แร็กเก็ต 227 ไบต์ (-10 สำหรับ 30 ตัวอักษร, -50 สำหรับการเปลี่ยนเป็น midline = 167)

ในแต่ละขั้นตอนจุดมีแนวโน้มที่จะเคลื่อนไปสู่เส้นแบ่งมากกว่าสองเท่าจาก:

(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)))

Ungolfed:

(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))))

การทดสอบ:

(println "012345678901234567890123456789")
(f)

เอาท์พุท:

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