Tembel bir fizikçi çift yarık deneyi yapmakla görevlidir. Ancak, tembeldirler ve tüm ekipmanı kendileri kurmaktan rahatsız olmazlar ve bu nedenle etkileri simüle ederler. Programlayamazlar, bu yüzden yardıma ihtiyaç duyacaklar. Tembel oldukları için programınız mümkün olduğunca kısa olmalıdır.

Garip bir pozitif tamsayı n( n >= 1ve n % 2 == 1) verildiğinde simülasyonu gerçekleştirin.

Nasıl çalışır

Boş bir tuvalle başlayacaksınız ve her çerçeve tek bir ışık parçacığı yarıklardan geçecek ve tuval üzerine inecek. Parçacık bir maksimuma inecektir:

n = 1:

+-----+
|     |
| 1/2 |
|     |
+-----+

n = 3:

+-----+ +-----+ +-----+
|     | |     | |     |
| 1/4 | | 1/2 | | 1/4 |
|     | |     | |     |
+-----+ +-----+ +-----+

n = 5:

+-----+ +-----+ +-----+ +-----+ +-----+
|     | |     | |     | |     | |     |
| 1/8 | | 1/4 | | 1/2 | | 1/4 | | 1/8 |
|     | |     | |     | |     | |     |
+-----+ +-----+ +-----+ +-----+ +-----+

vb.

Örneğin n=5orta kutuyu işaretliyoruz, içine% 50 düşme şansı var. Çerçevenin sonuna düşerse, sonraki ikisine geçmezseniz, bunlara% 25 düşme şansı vardır. Çerçevenin sonuna düşerse, sonraki ikisine geçmezseniz, bunlarda% 12.5'lik bir düşüş şansı vardır. Düşmezse önemli değil, hala çerçevenin sonu.

Şansın nasıl hesaplanacağı konusunda bazı karışıklıklar olmuştur, bunların çoğu, onları 1'e kadar olması gereken olasılıklar olarak düşünmesinden kaynaklanmaktadır. Bu fikri zihninizden çıkarın ve sizin için biraz temizlemelidir.

• En fazla bir parçacık kare başına delik açacaktır, yani bir parçacık o kareye hiç inmeyebilir.
• Bir parçacık yazdırılabilir herhangi bir karakterle temsil edilebilir.
• Parçacık, rastgele bir şansla kutunun herhangi bir yerine inecektir.
• Kutuların genişliği 2n-1tuvalin boyutu olmalıdır . Bu yüzden tuvalin genişliğinin th n=5olması gerekir 1/9.
• Kutuların yüksekliği tuvalin yüksekliği olmalıdır.
• Parçacık kutuların dışına hiç inmemelidir.
• Bir parçacık zaten seçilmiş olan bir noktaya düştüyse, oraya tekrar inebilir.
• Yukarıdaki ascii kutuları netlik içindir, çizilmemelidir.
• Makul olduğu sürece kendi tuval boyutunuzu seçebilirsiniz. Örneğin, yalnızca birkaç piksel yüksekliğinde olmamalıdır. Ayrıca üzerindeki tüm kutuları sığdırmalıdır.
• Kodunuz çerçeveler arasında uyuyorsa, bunu bayt sayınıza eklemenize gerek yoktur.

Her maxima, bir minima arasında boşluklar olmalıdır. Bu bir kutu ile aynı genişlikte olmalıdır, ancak hiçbir parçacık oraya inmeyecektir. Aşağıdaki şemaya bakın:

+---+---+---+---+---+
|   |   |   |   |   |
|max|min|max|min|max|
|   |   |   |   |   |
+---+---+---+---+---+

Program manuel olarak durdurulana kadar çalıştırılmalıdır.

kurallar

• Bir sahte rasgele sayı üreteci (pRNG) iyidir.
• Standart boşluklar yasaktır.
• Giriş herhangi bir makul formatta alınabilir.
• STDOUT'a çıktı almalısınız.
• Bu kod golf bu yüzden en kısa cevap kazanır.

Misal

Aşağıdaki GIF için örnek bir çalışmadır n = 5. Sadece hızlı bir şekilde çaldı, bu yüzden şans biraz hafif olabilir.

Python 2, 207200 bayt

Bu deliliğe bir yöntem var, söz veriyorum. OP'de yorumladığım olasılık yorumunu izler.

Düzenleme: Bazı akıllı tembel değerlendirme ile -7 bayt (ve bazı işaretleri kaldırarak)

import time  # not counted for byte total
import random as R,curses as C
r=R.randint
c=C.initscr()
h,w=c.getmaxyx()
n=input()
w/=2*n-1
while 1:
 all(r(0,1)or c.addch(r(0,h-1),(i*(2-4*r(0,1))+n)*w-r(1,w),42)for i in range(n/2+1))
 c.refresh()
 time.sleep(0.1)  # not counted for byte total

BASH, 396-11 = 385 bayt

E='echo -en';$E "\e[2J\e[99A";while :;do sleep 0.01;for i in `seq $((($1+1)/2)) -1 1`;do p=$(((($1+1)/2 - $i)));[ $p -lt 0 ]&&p=$((-$p));p=$((2**(p+1)));if [ $RANDOM -lt $((32768/$p)) ];then [ $(($RANDOM%2)) -eq 1 ]&&i=$((($1+1)-i));sector=$(((i*2-1)-1));C=`tput cols`;R=`tput lines`;SS=$((C/($1*2-1)));SX=$((SS*sector));X=$((SX+(RANDOM%SS)));Y=$((RANDOM%R));$E "\e[$Y;${X}H*";break;fi;done;done

Ne yazık ki, imleci hareket ettiren sonsuz döngü ve ANSI kaçış dizileri nedeniyle TryItOnline'da bunu gösteremiyorum, ancak yine de terminalinize kopyalayıp yapıştırabilirsiniz!

Sonlandırılmamış sürüm:

E='echo -en'
$E "\e[2J\e[99A"

while :
do
    sleep 0.01
    for i in `seq $((($1+1)/2)) -1 1`
    do
        p=$(((($1+1)/2 - $i)))
        [ $p -lt 0 ] && p=$((-$p));
        p=$((2**(p+1)))
        if [ $RANDOM -lt $((32768/$p)) ]
        then
            [ $(($RANDOM%2)) -eq 1 ] && i=$((($1+1)-i));
            sector=$(((i*2-1)-1))
            C=`tput cols`
            R=`tput lines`
            SS=$((C/($1*2-1)))
            SX=$((SS*sector))
            X=$((SX+(RANDOM%SS)))
            Y=$((RANDOM%R))
            $E "\e[$Y;${X}H*"
            break
        fi
    done
done

Mathematica, 231 bayt

(R=RandomInteger;p=20(#+1)+10;s=Array[0&,{20,6p-3}];i=(#+1)/2;Monitor[While[1<2,y=RandomChoice[Join[q=Riffle[Array[2^#&,i,0],Table[0,i-1]],Reverse@Most@q]->Array[Range[4#+1]&,i,0][[i]]];s[[R@19+1,10y-R@9]]=1;s],Grid[s//. 0->" "]])&

giriş

[5]

çıktı

C # (.NET 4.5), 319254 bayt

TheLethalCoder sayesinde 65 bayt tasarruf edildi!

namespace System{using static Console;n=>{for(var r=new Random();;)for(int w=WindowWidth/(2*n-1),i=(n-1)/2,c=0,m=2,l;i>-1;i--,c+=2)if((l=r.Next(0,(m*=2+1)*2))<2){SetCursorPosition((i+(l<1?c:0))*2*w+r.Next(0,w),r.Next(0,WindowHeight));Write('*');break;}}}

Vay be, bu çok işti, ama bir şekilde işe yarıyor.

Bu Consoleözel işlevler ve İplik uyku kullandığından , ne yazık ki TIO üzerinde çalışmaz.

Clojure + Quil, 394 bayt

(use '[quil.core])(defn -main[n](let[w 999 h 100 c(/ w(-(* n 2)1))s(range 0 w c)a(vec(take-nth 2 s))v(fn[x](<(rand)x))q(fn[a b](+ a(rand-int(- b a))))g(for[i(range(int(/ n 2))-1 -1)][i(- n 1 i)])z(for[[j i](map vector(range 1(inc(count g)))g)][(/ 1(Math/pow 2 j))i])](defsketch m :size[w h]:draw #(loop[[[p i]& r]z](when p(if(v p)(let[o(a(rand-nth i))](point(q o(+ o c))(q 0 h)))(recur r)))))))

Kesinlikle kazanmadım, ama bu iyi bir beyin antrenmanıydı! Bunu yapmak için aşırı dolambaçlı bir yol seçmiş olabilirim, ama işe yarıyor! Temel olarak, nasıl çalışır:

1. Her sütunun x-değerleri, esas alınarak hesaplanır n. Ardından, noktaları içerecek olan "aktif sütunlar" filtrelenir. Sütunlar daha sonra seçilecekleri olasılıklarla sıkıştırılır.

2. Animasyon başlar ve her kareye bir döngü girilir. Ortadan başlayarak, her sütun çifti denenir. Bir çift sütun seçildiğinde, çiftten bir sütun rastgele seçilir.

3. Seçilen sütun içinde rastgele bir konumda bir nokta çizilir, iç döngü çıkar ve yeni bir çerçeve başlar.

Temel olarak Clojure için bir İşlem sarmalayıcısı olan Quil grafik kütüphanesini kullanır.

Golf kodunun GIF'te gösterilenle aynı animasyonu üretmediğini unutmayın. Golf kodunda arka plan gri, pencere ve noktalar daha küçüktür. Aynı etkiye sahip, o kadar da güzel değil.

Ayrıntılı bir açıklama için ungolfed koduna bakın:

(ns bits.golf.interference.interference
  (:require [quil.core :as q]))

; Canvas size
(def width 1800)
(def height 800)

(defn -main [n]
  (let [col-width (/ width (- (* n 2) 1))
        ; The left-most x of each column
        col-starts (range 0 width col-width)

        ; The columns that need to be drawn. Need "vec" so I can index it later.
        active-cols (vec (take-nth 2 col-starts))

        ; Function taking a decimal percentage, and returning whether or not it's satisfied.
        ; (chance? 0.5) would be used to simulate a coin toss.
        chance? (fn [perc] (< (rand) perc))

        ; Function that returns a random int between a and b
        r-int (fn [a b] (+ a (rand-int (- b a))))

        ; Generates index pairs for each complimentary column.
        indices (for [i (range (int (/ n 2)) -1 -1)]
                  [i (- n 1 i)])

        ; Zips each index pair from above with the chance that it will be" chosen"
        zipped-perc (for [[j i] (map vector (range 1 (inc (count indices))) indices)]
                      [(/ 1 (Math/pow 2 j)) i])]

    ; Animation boilerplate
    (q/defsketch Interference
      :size [width height]
      :draw
      ; The animation loop. It contains a loop over each complimentary column. It tries each column pair starting
      ;  from the middle, and works outward. Once it picks a pair of columns, it randomly chooses one of them.
      #(loop [[[p i] & r] zipped-perc]
         (when p
           ; Pick this column?
           (if (chance? p)
             ; Pick one of the column pairs
             (let [col (active-cols (rand-nth i))]
               ; Set the coloring and dot size
               (q/fill 0 0 0)
               (q/stroke-weight 5)
               ; And finally draw the dot
               (q/point (r-int col (+ col col-width))
                        (r-int 0 height)))

             ; If the column wasn't chosen, loop again to try the next one
             (recur r)))))))

C #, 238 bayt

namespace System{using static Console;n=>{for(var r=new Random();;)for(int i=0,p=1,w=WindowWidth/(2*n-1),x;i<n+1;i+=2)if(r.Next(p*=2)<1){SetCursorPosition(r.Next(x=(n-1+(r.Next(2)<1?i:-i))*w,x+w),r.Next(WindowHeight));Write("*");break;}}}

Çevrimiçi deneyin! (Çalışmayacak ama biliyorsun).

Tam / Biçimlendirilmiş sürüm:

namespace System
{
    using static Console;

    class P
    {
        static void Main()
        {
            Action<int> f = n =>
            {
                for (var r = new Random(); ;)
                {
                    for (int i = 0, p = 1, w = WindowWidth / (2 * n - 1), x; i < n + 1; i += 2)
                        if (r.Next(p *= 2) < 1)
                        {
                            SetCursorPosition(r.Next(x = (n - 1 + (r.Next(2) < 1 ? i : -i)) * w, x + w), r.Next(WindowHeight));
                            Write("*");
                            break;
                        }

                    Threading.Thread.Sleep(25);
                }
            };

            f(5);
        }
    }
}