Ihr Programm muss eine Reihe von Leerzeichen, gefolgt von einem Punkt und einer neuen Zeile, ausgeben. Die Anzahl der Leerzeichen ist die x-Position Ihres Punktes, definiert mit 0 <x <30

Jede neue Linie ist eine Wende. Ihr Programm läuft 30 Runden. Ihr Programm beginnt mit einer zufälligen x-Position und verschiebt diese Position bei jeder Umdrehung zufällig um 1 nach links oder rechts, während Sie innerhalb des definierten Bereichs bleiben. Bei jeder Runde muss Ihr Punkt seine Position um 1 ändern.

Ihre Punktzahl ist die Anzahl der Zeichen. Sie erhalten 10 Bonuspunkte, wenn jede gedruckte Zeile aus genau 30 Zeichen (und einer neuen Zeile) besteht. Sie erhalten 50 Bonuspunkte, wenn Ihr Programm zufällig dazu neigt, in der Mitte des definierten Bereichs zu bleiben.

Bearbeiten: Die 50 Bonuspunkte sollen Ihren Punkt in die Mitte ziehen. Dies gilt zum Beispiel, wenn Ihr Punkt bei x = 20 liegt und eine Chance von 66% hat, nach links und 33% nach rechts zu gehen. Dies muss vom Startpunkt unabhängig sein und sollte nur durch dynamisches Ändern des Prozentwerts von links / rechts geschehen.

Keine Eingabe jeglicher Art erlaubt, die Ausgabe muss auf der ausführenden Konsole erfolgen!

Zum besseren Verständnis ist hier ein lesbares Beispiel in Java, das eine Punktzahl von 723 ergeben würde:

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

Getestet mit ⎕IO←1und auf Dyalog ⎕ML←3sollte es aber durchaus tragbar sein.

Erläuterung

                   ?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

Bei jedem Schritt entscheidet dieser Code, ob der Punkt nach links oder rechts verschoben wird, abhängig von der Wahrscheinlichkeit, dass eine unter (1,5 2,5 ... 27,5 28,5) ausgewählte Zufallszahl kleiner als die aktuelle Punktposition ist.

Wenn die aktuelle Punktposition (Anzahl der Leerzeichen links) 1 ist, ist das Inkrement immer +1 (alle diese Zahlen 1,5 ... 28,5 sind> 1), wenn es 29 ist, ist es immer -1 (alle diese Zahlen) sind <29); Andernfalls wird es zufällig zwischen +1 und -1 ausgewählt, mit einer Wahrscheinlichkeit, dass es sich um eine lineare Interpolation zwischen diesen Extremen handelt. Der Punkt bewegt sich also immer und mit größerer Wahrscheinlichkeit zur Mitte als zu den Seiten. Wenn es genau in der Mitte ist, hat es eine 50% ige Chance, sich zu beiden Seiten zu bewegen.

Die Verkleinerung (nach rechts) eines replizierten Werts {...}/a/bist nur ein Trick, den ich mir ausgedacht habe, um die a-1Zeiten einer Funktion zu wiederholen , wobei ich mit dem Wert beginne bund das Ergebnis jeder Iteration ⍵zum nächsten Argument akkumuliere ( ). Das zweite und nächste Eingabeargument ( ⍺) sowie das Endergebnis werden ignoriert. Es stellt sich heraus, dass es viel kürzer ist als ein regulärer rekursiver Aufruf mit Wache.

Beispiellauf

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

Mathematica 138-10-50 = 78

Ich poste dies nicht, weil ich denke, dass es besonders gut ist, aber aus anderen Gründen. Es verwendet eine Markov-Prozessdefinition mit einer Übergangsmatrix, mit der der Ball "zentriert" wird.

Die Verwendung eines Markov-Prozesses in Mathematica ermöglicht es uns, einige nützliche Statistiken zu berechnen , wie Sie weiter unten sehen werden.

Zuerst den Code (Leerzeichen werden nicht benötigt):

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

Einige Ausgaben:

Die von mir verwendete Übergangsmatrix ist:

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

Aber wie gesagt, der interessante Teil ist, DiscreteMarkovProcess[]dass wir mit Hilfe von ein gutes Bild von dem bekommen, was passiert.

Sehen wir uns die Wahrscheinlichkeit an, dass der Ball 15zu einem beliebigen Zeitpunkt t von einem bestimmten zufälligen Zustand ausgeht :

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]

Sie können sehen, dass es zwischen 0 und einem Wert in der Nähe von 0,3 schwankt. Das liegt daran, dass Sie je nach Ausgangszustand nur bei einer ungeraden oder geraden Anzahl von Schritten 15 erreichen können :)

Jetzt können wir dasselbe tun, aber Mathematica anweisen, die Statistik ausgehend von allen möglichen Anfangszuständen zu betrachten. Wie groß ist die Wahrscheinlichkeit, 15nach einer bestimmten Zeit wieder zu sein 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]

Sie können sehen, dass es auch schwingt ... warum? Die Antwort ist einfach: Im Intervall [1, 29]gibt es mehr ungerade als gerade Zahlen :)

Die Schwingung ist fast verschwunden, wenn wir nach der Wahrscheinlichkeit fragen, dass der Ball auf 14 OR 15:

Und Sie könnten auch nach der Grenze (im Sinne von Cesaro) der staatlichen Wahrscheinlichkeiten fragen:

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

Oh, na ja, vielleicht verdiene ich ein paar Ablehnungen für eine solche nicht themenbezogene Antwort. Fühlen Sie sich frei.

Bash, 21 Punkte (81 Bytes - 50 Bonus - 10 Bonus)

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

Bei dieser Antwort wird der Punkt in die Mitte "zurückgezogen". Dies kann getestet werden, indem der Startpunkt bei 0 oder 30 fest codiert wird.

Ruby 69 66 64-60 = 4

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

Stichprobe:

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

Smalltalk, 161 159 145-60 = 85

Alle Spalten sind 30 Zeichen lang (arbeiten in der veränderlichen Zeichenfolge b).

Die zufällige Bewegungschance wird angepasst, indem der rnd-Wert mit p (rnd (0..29) -p) vorgespannt wird, das Vorzeichen (-1/0/1) genommen und dann mit (-1 |) auf (-1 / + 1) angepasst wird 1), der als Verschiebungsdelta verwendet wird (berechnet effektiv: x Vorzeichen <= 0 ifTrue: -1 ifFalse: 1). Da ST 1-basierte Indizierung verwendet, muss ich alle String-Refs um +1 anpassen (bitte schätzen Sie den -1 | 1-Bit-Fiddling-Hack ;-)).

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]

Wenn ich eine Idee aus der Ruby-Version (thanx & Up @fipgr) klaue, kann ich den Min / Max-Check loswerden:

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]

Ausgabe: (Ich habe die Spaltennummern und vertikalen Balken danach manuell hinzugefügt; der obige Code generiert sie nicht)

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

C 86

Vorausgesetzt, dass das Seeding der rand()Funktion nicht erforderlich ist.

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

Erläuterung:

In C, in "%*c"den *Mitteln , dass die Länge des Ausgangs eine minimale Länge hat, und diese minimale Länge wird durch das Argument der Funktion Aufrufs (in diesem Fall bestimmt wird , ist es i+=i==30?-1:i==1||rand()%2?1:-1. Die cMittel das nächste Argument ( 46) ist ein Zeichen ( der Punkt).

Was die Grenzkontrolle angeht, ich entschuldige mich, dass ich das vergessen habe. Ich habe dies nun zu der Antwort hinzugefügt, zum Preis von 15 Zeichen. Der ternäre Operator funktioniert wie folgt: boolean_condition?value_if_true:value_if_false. Beachten Sie, dass in C wahr 1 und falsch 0 ist.

Java: 204 183 182 176 175 Zeichen - 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);}}

Erstens muss die 0 < x < 30Punktposition [1-29] sein. Dies erzeugt eine gleichmäßig verteilte Zahl zwischen 0 und 28 und für die Zwecke dieses Programms hat [0-28] den gleichen Effekt wie [1-29]:

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

Ich persönlich bevorzuge es, wenn es normalerweise um 14 verteilt wäre, aber meine Antwort wäre länger:

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

Zweitens stellt dieser Code sicher, dass er tendenziell in der Mitte liegt:

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

Die Wahrscheinlichkeit, +1 zu bekommen, ist größer als der Wert von i, und wir haben das Gegenteil für -1. Wenn i0 ist, ist die Wahrscheinlichkeit, +1 zu bekommen, 100% und die Wahrscheinlichkeit, -1 zu bekommen, ist 0%. Wenn i28 ist, wird das Gegenteil passieren.

Drittens sehen wir, wenn wir das 32am Ende durch ersetzen '_', um die Ausgabe zu vereinfachen, dass jede Zeile 30 Zeichen plus eine neue Zeile enthält:

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

Vielen Dank an @VadimR (jetzt user2846289) für den Hinweis auf ein Missverständnis in einer früheren Version.

Vielen Dank an @KevinCruijssen für das Aussparen von 6 Zeichen, auch nach mehr als zweieinhalb Jahren, nachdem diese Antwort ursprünglich veröffentlicht wurde.

Mathematica 157-10-50 = 97

Zum Starten wird eine Zufallszahl von 1 bis 30 verwendet. Alle verbleibenden Spaltennummern aus dem Punkt werden über ausgewählt. Dies RandomChoice[If[c > 15, {2, 1}, {1, 2}] -> {-1, 1}] + cbedeutet: "Wenn die vorherige Spaltennummer größer als 15 war, wählen Sie eine Zahl aus der Menge {-1,1} mit -1, gewichtet mit 2: 1 in Bezug auf 1; andernfalls drehen Sie die Gewichte um und wählen Sie aus demselben Satz.

ReplacePart Ersetzt das Element in einer Liste mit 30 Leerzeichen, die der gewünschten Spalte entsprechen.

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

Das wird beim Codegolf nicht gewinnen, aber es funktioniert. (Unter Windows 7 mit diesem Interpreter , der die "p" -Anweisung anders implementiert als die esolang-Seite definiert)

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<

Der Name dieser Sprache kann nicht gegoogelt werden. Hier ist der Esolang-Artikel für Neugierige.

PHP, 118 113 112 111 (, -10 Bonuspunkte = 101)

(Zweiter Versuch, mit schrecklich vorhersehbarem rand()Verhalten und etwas mehr Effizienz)

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

Mögliches Ergebnis:

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

PHP, 130 (, -10 Bonuspunkte = 120)

(erster Versuch)

Dies könnte wahrscheinlich noch viel effizienter sein:

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

Wenn ich das Leerzeichen durch einen Unterstrich ersetze (für Anzeigezwecke), ist dies ein mögliches Ergebnis:

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

Merkwürdigerweise wechselt das zufällige Ergebnis beim Ersetzen rand(0,1)durch rand()%2(PHP 5.4 unter Windows XP) bei jeder nächsten Iteration von ungerade zu gerade und umgekehrt, was rand()in diesem Sinne auf einmal beunruhigend vorhersehbar macht . Dieser 'Bug' scheint seit 2004 bekannt zu sein . Ich bin mir nicht ganz sicher, ob es genau derselbe "Bug" ist.

J 42 Zeichen - 50 -10 = -18

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

Erklärung, von rechts beginnend (einige Kenntnisse über Züge sind nützlich):

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

Mittentendenz, -50, Beispiel über 1000 Läufe:

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

Beispiellauf, Ausgabe von genau 30 Bytes pro Zeile

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

Python 2.7: 126 109 -10-50 = 49

Den hartcodierten Startpunkt losgeworden - beginnt jetzt an einem zufälligen Punkt. Aus diesem Grund brauchte ich randint und entschied mich, dies anstelle der Auswahl für den Offset zu verwenden. Benutzte dafür den (-1) ** Bool-Trick.

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)

Einige gute Antworten hier. Erster Versuch in Python, über Verbesserungen nachzudenken. Nicht durch die Notwendigkeit eines Imports geholfen.

-10 - ja 30 Zeichen + \ n in jeder Zeile

-50 - je weiter vom Zentrum entfernt, desto wahrscheinlicher ist eine Bewegung in die andere Richtung (durch Erstellen einer Liste mit einer anderen Anzahl von +/- Offsets).

Vorheriger Versuch:

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 Zeichen

Dies ist nur ein schlichtes, einfaches, direktes und unkreatives Golfspiel des Beispiels, das Sie in der Frage angegeben haben.

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

Stapel - (288 Bytes - 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.)

Nicht golfen:

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

Leerzeichen anstelle von Unterstrichen ausgeben - 372 Bytes -

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

Wenn Sie Hilfe bei der folgenden Logik suchen, ist dies sicherlich nicht die platzsparendste Methode (! R! Wird auf 1 oder 2 erweitert).

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

Es golfen bis zu: 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 Zeichen, keine Boni

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

Beispiellauf:

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

Python 2.7 (126 - 10 (feste Länge) - 50 (Mitteltendenz) = 66)

Das folgende Programm hat eine mittlere Tendenz gegenüber einer größeren Stichprobe

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)

Demo

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

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)

BEARBEITEN: Fix für 50-Punkte-Bonus und 10-Punkte-Bonus.

EDIT 2: Noch kürzer!

D - 167, 162144 (154-10)

Golf gespielt :

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

Nicht golfen :

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

BEARBEITEN 1 - Ich bin nicht ganz sicher, ob sich mein Code für den -50 Bonus qualifiziert oder nicht. iBeginnt nicht immer in der Mitte, aber während der forSchleife bewegt sich der Punkt nie mehr als 3 Stellen in beide Richtungen. Wenn i also in der Mitte begonnen wird, bleibt das Ganze ebenfalls dort.

BEARBEITEN 2 - Code ist jetzt für den Bonus -10 qualifiziert, da ein Array von 29 Zeichen gefolgt von LF ausgegeben wird, was genau 30 Zeichen pro Zeile ergibt.

PowerShell, 77 - 10 - 50 = 17

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

Ausgabe

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

R, 107 Zeichen - 60 Bonuspunkte = 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='')}

iist der Index des Punktes. aist die Anordnung von 30 Räumen. Der Startpunkt ist zufällig (gleichmäßig von 1 bis 29). Bei jeder Iteration addieren wir zufällig -1 oder +1 zu imit gewichteten Wahrscheinlichkeiten: i-1for -1und 29-i for +1(Werte, die als Wahrscheinlichkeiten eingegeben werden, müssen nicht zu eins summiert werden), was bedeutet, dass der Punkt tendenziell zur Mitte hin ausgerichtet wird, ohne dass er von unten kommt 1 oder höher 29 (da ihre Wahrscheinlichkeit in beiden Fällen auf 0 fällt).

Beispiellauf mit _statt Leerzeichen zur besseren Lesbarkeit:

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

Ausgabe

spacemit Fassung _für die Lesbarkeit.

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

PHP

Mit dem Zentrierbonus: 82 - 50 = 32

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

Entfernen Sie für diese Version (ältere Versionen unten) die Min / Max-Prüfung, die im Zentrierungscode berücksichtigt wird. rand(1,28)wird hier wichtig, da es dem erlaubt $i++, sich auf 29 zu schieben (aktuelles Maximum).

Bearbeiten: unnötige Klammern, verschobener Umschaltcode

Einfacher Algorithmus zum Zentrieren: Erzeugt eine neue Zahl zwischen 0 und 29 und vergleicht sie mit der aktuellen. Nutzt die "Wahrscheinlichkeit", dass eine Zahl auf der größeren Seite zur Mitte hin gezogen wird.

Tatsächliches Ergebnis: (Zeilennummerierung nachträglich hinzugefügt)

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

Archiviert:

$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 Zeichen

$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 Zeichen

JavaScript ES6 125 - 10 (30 Zeichenzeilen) - 50 (Verschiebung in Richtung Mitte) = 65

Ich hatte eine Erleuchtung, die den Aufzug zu meiner Einheit hinaufging, also musste ich sie runterholen, bevor sie mein Gedächtnis verließ ...

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

Ein wenig variables Positionsmischen und ein wenig Kreativität bei der Berechnung der Verschiebungswahrscheinlichkeit von x/t... (Vielen Dank, Kostronor, für den Hinweis!) Ich erhalte jetzt den Bonus von -50 für die Verschiebung in die Mitte und habe auch die Startposition innerhalb von erreicht voller Bereich der Linie, die mir erlaubte, zwei Bytes zu rasieren!

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

k, 53-10-50 = -7

Lösung 1

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

Verwendung

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

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

Lösung 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 Bytes

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

Ich denke immer noch über den 50-Byte-Bonus nach.

Erläuterung:

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

Kommentare und Ratschläge sind willkommen.

JavaScript

114 Zeichen - 10 (30 Zeichen) - 50 (Punkt in die Mitte ziehen) = 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('-'))

Mir ist jedoch aufgefallen, dass eine Belohnung von 10 Zeichen für das Ausfüllen der Zeilen auf 30 Zeichen ein schlechter Deal sein kann. so:

102 Zeichen - 50 (Punkt zur Mitte ziehen) = 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('-'))

Ein großes Lob an @WallyWest für die vereinfachte Zugrichtungsbedingung f()>k/29?1:-1, mein erster Entwurf verwendete zwei verschachtelte Bedingungen.

Racket 227 Bytes (-10 für 30 Zeichen, -50 für Verschiebung zur Mittellinie = 167)

Bei jedem Schritt bewegt sich der Punkt mit doppelter Wahrscheinlichkeit zur Mittellinie als von dieser weg:

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

Testen:

(println "012345678901234567890123456789")
(f)

Ausgabe:

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