Twój program musi wydrukować pewną liczbę spacji, a następnie kropkę i nowy wiersz. Liczba spacji to pozycja x kropki zdefiniowana za pomocą 0 <x <30

Każda nowa linia to kolej. Twój program działa przez 30 tur. Twój program zaczyna się od losowej pozycji x i każda kolejka losowo przesuwa tę pozycję o 1 w lewo lub w prawo, pozostając w obrębie określonego obszaru. Za każdym razem twoja kropka musi zmieniać swoją pozycję o 1.

Twój wynik to liczba znaków. Otrzymasz 10 punktów bonusowych, jeśli każda drukowana linia składa się dokładnie z 30 znaków (i nowej linii). Dostajesz 50 punktów bonusowych, jeśli, choć losowo, twój program ma tendencję do pozostawania na środku określonego obszaru.

Edycja: 50 punktów bonusowych ma na celu przyciągnięcie twojej kropki do środka. Na przykład dotyczy to, jeśli twoja kropka wynosi x = 20 i ma szansę 66% na pójście w lewo i 33% na pójście w prawo. Musi to być niezależne od punktu początkowego i powinno się to odbywać jedynie poprzez dynamiczną zmianę wartości procentowej lewej / prawej.

Żadne dane wejściowe nie są dozwolone, dane wyjściowe muszą znajdować się na konsoli wykonawczej!

Dla lepszego zrozumienia, oto czytelny przykład w Javie, który dałby wynik 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

Testowane na Dyalog z ⎕IO←1 a ⎕ML←3, ale powinien być dość przenośne.

Wyjaśnienie

                   ?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

Na każdym etapie kod ten decyduje, czy przesunąć kropkę w lewo czy w prawo, w zależności od prawdopodobieństwa, że ​​liczba losowa wybrana spośród (1,5 2,5 ... 27,5 28,5) jest mniejsza niż bieżąca pozycja kropki.

Dlatego gdy bieżąca pozycja kropki (liczba spacji po lewej) wynosi 1, przyrost wynosi zawsze +1 (wszystkie te liczby 1,5 ... 28,5 są> 1), a gdy 29 to zawsze -1 (wszystkie te liczby są <29); w przeciwnym razie jest wybierany losowo między +1 a -1, z prawdopodobieństwem, które jest interpolacją liniową między tymi skrajnościami. Tak więc kropka zawsze się porusza i zawsze bardziej prawdopodobne jest przesuwanie się w kierunku środka niż w bok. Jeśli jest dokładnie pośrodku, ma 50% szans na przejście w dowolną stronę.

Zmniejszenie (prawy krotnie) powielonej wartości {...}/a/bto tylko sztuczka, którą wymyśliłem, aby powtórzyć a-1czasy funkcji , zaczynając od wartości bi mając wynik każdej iteracji jako ⍵argument accumulator ( ) do następnego. Drugi i następny argument wejściowy ( ⍺) oraz wynik końcowy są ignorowane. Okazuje się, że jest znacznie krótszy niż zwykłe rekurencyjne połączenie ze strażą.

Przykładowy przebieg

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

Mathematica 138-10-50 = 78

Nie publikuję tego, ponieważ uważam, że jest szczególnie dobrze golfowany, ale z innych powodów. Wykorzystuje definicję procesu Markowa z macierzą przejścia zaprojektowaną w celu „wyśrodkowania” piłki.

Zastosowanie procesu Markowa w Mathematica pozwala nam obliczyć przydatne statystyki , jak zobaczycie poniżej.

Najpierw kod (spacje nie są potrzebne):

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

Niektóre wyjścia:

Użyłem macierzy przejścia:

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

Ale, jak powiedziałem, interesującą częścią jest to, że użycie DiscreteMarkovProcess[]pozwala nam zrobić dobre zdjęcie tego, co się dzieje.

Zobaczmy prawdopodobieństwo, że piłka będzie 15w dowolnym momencie, t zaczynając od określonego losowego stanu :

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]

Widać, że waha się między 0 a wartością bliską 0,3, to znaczy, że w zależności od stanu początkowego można osiągnąć 15 na nieparzystej lub parzystej liczbie kroków :)

Teraz możemy zrobić to samo, ale powiedzieć Mathematice, aby rozważyła statystykę, zaczynając od wszystkich możliwych stanów początkowych. Jakie jest prawdopodobieństwo bycia 15po pewnym czasie 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]

Widać, że również oscyluje ... dlaczego? Odpowiedź jest prosta: w przedziale [1, 29]jest więcej liczb nieparzystych niż parzystych :)

Oscylacja prawie zniknęła, jeśli poprosimy o prawdopodobieństwo, że piłka znajdzie się w 14 OR 15:

Możesz też poprosić o limit (w sensie Cesaro) prawdopodobieństwa stanu:

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

No cóż, być może zasługuję na trochę pochlebnych odpowiedzi na taką nie-tematyczną odpowiedź. Nie krępuj się.

Bash, wynik 21 (81 bajtów - 50 premii - 10 premii)

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

W tej odpowiedzi kropka jest „ciągnięta” z powrotem na środek. Można to sprawdzić, wpisując punkt początkowy na 0 lub 30.

Rubin 69 66 64-60 = 4

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

Próba:

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

Smalltalk, 161 159 145-60 = 85

wszystkie kolumny mają długość 30 znaków (operują ciągiem zmiennym b);

losowa szansa na ruch jest korygowana poprzez odchylenie wartości rnd za pomocą p (rnd (0..29) -p), przyjmując znak (-1/0/1), a następnie dostosowując do (-1 / + 1) za pomocą (-1 | 1), który jest traktowany jako delta ruchu (efektywnie oblicza: znak x <= 0 ifTrue: -1 ifFalse: 1). Ponieważ ST używa indeksowania opartego na 1, muszę skorygować wszystkie referencje ciągów o +1 (plz doceniam bicie -1 | 1-bitowy 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]

kradnąc pomysł z wersji Ruby (thanx & Up @fipgr), mogę pozbyć się kontroli min / max:

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]

dane wyjściowe: (później ręcznie dodałem liczby kolumn i pionowe słupki; powyższy kod ich nie generuje)

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

C 86

Zakładając, że uruchomienie rand()funkcji nie jest wymagane.

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

Wyjaśnienie:

W C, "%*c"o *oznacza, że długość wyjściowy będzie miał minimalną długość, a to minimalna długość jest określana przez parametr wywołania funkcji (w tym przypadku, jest to i+=i==30?-1:i==1||rand()%2?1:-1. Te cśrodki następnego argument ( 46) to znak ( kropka).

Jeśli chodzi o kontrolę granic, przepraszam, że o tym zapomniałem. Dodałem to do odpowiedzi, kosztem 15 znaków. Operator trójargumentowy działa w następujący sposób: boolean_condition?value_if_true:value_if_false. Zauważ, że w C prawda ma wartość 1, a fałsz wynosi 0.

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

Po pierwsze, pozycja kropki musi być 0 < x < 30, tj. [1-29]. Generuje to liczbę od 0 do 28 równomiernie rozmieszczoną, a dla celów tego programu [0-28] ma taki sam efekt jak [1-29]:

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

Ja osobiście wolałbym, aby był normalnie rozpowszechniany około 14, ale moja odpowiedź byłaby dłuższa:

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

Po drugie, ten kod zapewnia, że ​​zwykle znajduje się na środku:

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

Prawdopodobieństwo uzyskania +1 jest większe, ponieważ mniejsza jest wartość i, i mamy odwrotność dla -1. Jeśli iwynosi 0, prawdopodobieństwo uzyskania +1 wynosi 100%, a prawdopodobieństwo uzyskania -1 wynosi 0%. Jeśli iwynosi 28, to stanie się odwrotnie.

Po trzecie, zamieniając 32na końcu na, '_'aby łatwiej zobaczyć wynik, widzimy, że każda linia ma 30 znaków plus nowy wiersz:

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

Podziękowania dla @VadimR (obecnie użytkownik 2846289) za wskazanie nieporozumienia w poprzedniej wersji.

Dzięki @KevinCruijssen za golenie 6 znaków, nawet po ponad dwóch i pół roku od opublikowania tej odpowiedzi.

Mathematica 157-10-50 = 97

Do uruchomienia używana jest liczba losowa od 1 do 30. Wszystkie pozostałe numery kolumn z kropki są wybierane za pomocą RandomChoice[If[c > 15, {2, 1}, {1, 2}] -> {-1, 1}] + c, co przekłada się na: „Jeśli poprzedni numer kolumny był większy niż 15, wybierz jedną liczbę z zestawu {-1,1}, z -1 ważoną 2: 1 w odniesieniu do 1; w przeciwnym razie odwróć obciążniki i wybierz z tego samego zestawu.

ReplacePart zastępuje element na liście 30 pustych miejsc, które odpowiadają zainteresowanej kolumnie.

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

W codegolf nie wygra, ale działa. (W systemie Windows 7 z systemie tym tłumaczem , który implementuje instrukcję „p” inaczej niż strona esolang ją definiuje)

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<

Nazwy tego języka nie można wyszukiwać w Google, więc oto ciekawy artykuł w esolang .

PHP, 118 113 112 111 (, -10 punktów bonusowych = 101)

(druga próba, z okropnie przewidywalnym rand()zachowaniem i nieco większą wydajnością)

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

Możliwy wynik:

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

PHP, 130 (, -10 punktów bonusowych = 120)

(pierwsza próba)

Prawdopodobnie mogłoby to być znacznie bardziej wydajne:

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

Jeśli zastąpię spację znakiem podkreślenia (do celów wyświetlania), jest to możliwy wynik:

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

Co dziwne, jeśli mogę wymienić rand(0,1)z rand()%2(PHP 5.4 w systemie Windows XP), losowy wynik zawsze przełącza się z dziwne, nawet, i odwrotnie, na każdej kolejnej iteracji, dzięki czemu rand()niepokojąco przewidywalne, w tym sensie, wszystko nagle. Ten „błąd” wydaje się być znany od 2004 roku . Nie do końca wiadomo, czy to dokładnie ten sam „błąd”.

J 42 znaki - 50-10 = -18

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

Wyjaśnienie, zaczynając od prawej ( przydaje się trochę wiedzy o pociągach ):

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

Tendencja środkowa, -50, przykład ponad 1000 przebiegów:

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

Przykładowy przebieg, wyświetlający dokładnie 30 bajtów w każdym wierszu

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

Python 2.7: 126 109-10-50 = 49

Pozbyłem się zakodowanego punktu początkowego - teraz zaczyna się w losowym punkcie. Z tego powodu potrzebowałem randinta, więc zdecydowałem się użyć tego zamiast wyboru dla offsetu. Zastosował do tego sztuczkę bool (-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)

Kilka świetnych odpowiedzi tutaj. Pierwsza próba w Pythonie, myślenie o ulepszeniach. Nie pomaga konieczność importu.

-10 - tak 30 znaków + \ n w każdej linii

-50 - im dalej od centrum, tym bardziej prawdopodobne jest przesunięcie w drugą stronę (dokonane przez zbudowanie listy z inną liczbą przesunięć + / i)

Poprzednia próba:

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 znaków

To tylko prosty, prosty, bezpośredni i mało kreatywny golf z przykładu, który podałeś w pytaniu.

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

Partia - (288 bajtów - 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.)

Bez golfa:

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

Aby wyprowadzać spacje zamiast znaków podkreślenia - 372 bajtów -

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

Szukając pomocy z następującą logiką, z pewnością nie jest to metoda zajmująca najwięcej miejsca (! R! Rozwinie się do 1 lub 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

Gra w golfa do: 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 znaki, bez bonusów

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

Przykładowy przebieg:

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

Python 2.7 (126-10 (stała długość) - 50 (Tendencja środkowa) = 66)

Poniższy program ma tendencję centralną w stosunku do większej próby

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)

Próbny

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

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)

EDYCJA: Naprawiono premię 50 punktów i premię 10 punktów.

EDYCJA 2: Jeszcze krótsza!

D - 167, 162, 144 (154–10)

Gra w golfa :

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

Bez golfa :

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

EDYCJA 1 - Nie jestem pewien, czy mój kod kwalifikuje się do premii -50, czy nie. inie zawsze zaczynają się w środku, ale podczas forpętli, kropka przesuwa nigdy więcej niż 3 miejsc jak obu kierunkach, więc kiedy i ma rozpocząć pobliżu środka, cała sprawa ma tendencję do pozostawania tam również.

EDYCJA 2 - Kod kwalifikuje się teraz do premii -10, ponieważ drukuje tablicę 29 znaków, a następnie LF, w sumie dokładnie 30 znaków w wierszu.

PowerShell, 77–10–50 = 17

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

Wynik

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

R, 107 znaków - bonus 60 punktów = 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='')}

ijest indeksem kropki. ato tablica 30 spacji. Punkt początkowy jest losowy (jednolicie od 1 do 29). Przy każdej iteracji losowo dodajemy -1 lub +1 do iważonych prawdopodobieństw: i-1dla -1i29-i for +1(wartości podawane jako prawdopodobieństwa nie muszą sumować się do jednego), co oznacza, że ​​dąży on do zorientowania kropki w kierunku środka, jednocześnie zapobiegając jej od dołu 1 lub powyżej 29 (ponieważ ich prawdopodobieństwo spada do 0 w obu przypadkach).

Przykład uruchomienia z _zamiast spacji dla czytelności:

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

Wynik

spacezastąpione przez _dla czytelności.

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

PHP

Z premią za centrowanie: 82-50 = 32

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

W przypadku tej wersji (starsze wersje poniżej) usunięto sprawdzanie wartości min./maks., Jak to opisano w kodzie centrującym. rand(1,28)staje się tutaj ważne, ponieważ pozwala na $i++przesuwanie się do 29 (rzeczywista maksymalna).

edycja: niepotrzebny nawias, przeniesiony kod zmiany

Prosty algorytm centrowania: generuje nową liczbę od 0 do 29 i porównuje ją z bieżącą. Wykorzystuje „prawdopodobieństwo” uzyskania liczby po większej stronie, aby zbliżyć się do środka.

Rzeczywisty wynik: (później dodano numerację linii)

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

Zarchiwizowane:

$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 znaków

$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 znaków

JavaScript ES6 125-10 (30 linii znaków) - 50 (przesuwa się w kierunku środka) = 65

Miałem objawienie, gdy jechałem windą do mojego oddziału, więc musiałem to znieść, zanim opuściło moją pamięć ...

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

Trochę zmienne tasowanie pozycji i trochę kreatywności do obliczania prawdopodobieństwa przesunięcia wskazywanego przez x/t ... (Dzięki Kostronor za wskazanie tego!) Teraz zyskuję premię -50 za przesunięcie na środek, a także osiągnąłem pozycję początkową w pełny zakres linii, co pozwoliło mi ogolić dwa bajty!

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

k, 53–10–50 = -7

Rozwiązanie 1

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

Stosowanie

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

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

Rozwiązanie 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 bajtów

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

Nadal myślę o premii 50 bajtów.

Wyjaśnienie:

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

Komentarze i porady są mile widziane.

JavaScript

114 znaków - 10 (30 linii znaków) - 50 (pociągnij kropkę w kierunku środka) = 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('-'))

Zauważyłem jednak, że nagroda za 10 znaków za wypełnienie linii do 30 znaków może być złym interesem; więc:

102 znaki - 50 (pociągnij kropkę w kierunku środka) = 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('-'))

Uznanie dla @WallyWest za uproszczony warunkowy kierunek ściągania f()>k/29?1:-1, mój pierwszy szkic użył dwóch zagnieżdżonych warunków.

Rakieta 227 bajtów (-10 dla 30 znaków, -50 dla przejścia do linii środkowej = 167)

Na każdym kroku kropka dwa razy częściej przesuwa się w kierunku linii środkowej, niż od niej:

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

Nie golfowany:

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

Testowanie:

(println "012345678901234567890123456789")
(f)

Wynik:

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