Einführung:

Ich denke, jeder weiß, was eine Lava-Lampe ist, aber für den Fall, dass dies nicht der Fall ist:

^(Bildquelle)

Im Grunde handelt es sich um Glasröhren, die Wachs in einer durchscheinenden Flüssigkeit enthalten. Der untere Teil erwärmt sich beim Einschalten der Lampe, wodurch sich die Dichte ändert und das Wachs nach oben schwimmt. Wenn es abkühlt, fällt es wieder ab und verursacht den oben gezeigten Effekt.

Normalerweise dauert es etwa 45 bis 60 Minuten, bis der Lampensockel eine Temperatur erreicht hat, die ausreicht, um das feste Wachs in flüssiges Wachs umzuwandeln (wenn sich die Lampe in einem Raum mit Raumtemperatur befindet).

Weitere Informationen finden Sie auf Wikipedia, das auch als Quelle für einen Teil des obigen Textes dient.

Herausforderung:

Bei einer positiven Ganzzahl, die nangibt, wie viele Minuten seit dem Einschalten der Lava-Lampe vergangen sind, wird ein zufälliger Status der Lava-Lampe basierend auf Ganzzahlen auf fünf Ebenen ausgegeben.

Für diese Herausforderung sagen wir, dass die Lava-Lampe insgesamt 1000 Einheiten Wachs enthält, und wir haben fünf Ebenen, in denen das Wachs sein kann.

1) Wenn nder Wert unter 45 liegt, heizt die Lava-Lampe immer noch auf, sodass der Ausgang vier leere Zeilen mit 1000unten aufweist:

1000

2) Befindet nsich [45, 60)die Lava-Lampe im Bereich, hat sich die Temperatur so weit erhöht, dass sich das Wachs bewegen kann, aber noch nicht sehr hoch. Das Wachs kann bis einschließlich zur dritten Stufe reichen.
3) Wenn nist 60oder höher ist , kann das Wachs bei einem der fünf Stufen sein.

Wenn Sie also eine positive Ganzzahl nals Eingabe angeben , geben Sie einen zufälligen Zustand unter Berücksichtigung der drei oben genannten Regeln aus.

Hier sind einige Beispielausgaben:

Mögliche Ausgänge für jeden n, der ist >= 45:

523
106
371

913

87

Mögliche Ausgänge für jeden n, der ist >= 60:

73
113
312
5
497

284
55
637

24

Konstante Ausgabe dafür nist <= 44(und mögliche Ausgabe für jede n):

1000

Herausforderungsregeln:

• Es kann leere Zeilen geben, auch wenn die darüber liegende Ebene nicht leer ist.
• Nur 0ist in keiner Zeile erlaubt. Sollte stattdessen leer sein.
• Die Ausgabe ist etwas flexibel. Sie können eine Liste / ein Array von Zeichenfolgen / Objekten anstelle des oben beschriebenen Ergebnisses mit Zeilenumbruch ausgeben. Der Grund, warum ich Strings / Objekte sage, liegt in der obigen Regel. Eine leere Zeile sollte sein "", null, []usw., kann aber nicht sein 0oder eine negative ganze Zahl ist (noch kann es sein false) (Ie ["", "", 913, "", 87]für n >= 45). Sie können auch die Ausgabe umkehren (dh 1000\n\n\n\nanstelle von \n\n\n\n1000oder [87, null, 913, null, null]anstelle von [null, null, 913, null, 87]).
• Die Zahlen sollten alle ganze Zahlen sein. Es kann sich um Dezimalstellen mit einem 0Dezimalwert handeln, aber keine der Zahlen sollte Dezimalstellen haben, und die Ganzzahlen sollten immer exakt summieren 1000.
• Alle möglichen zufälligen Ausgaben, die auf basieren, nsollten eine Wahrscheinlichkeit ungleich Null haben.
• Eine abschließende neue Zeile (also sechs Ausgabezeilen) ist zulässig.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

MathGolf , 21 20 Bytes

5º*♪{k[K∞╟(]m<Σ∞wΦ}σ

Probieren Sie es online!

Dies ist meine erste Antwort in meiner neuen Sprache. Ich habe meine Lösung auf der 05AB1E-Lösung von Emigna aufgebaut, aber einige nette Funktionen von MathGolf verwendet, um sie ein bisschen kürzer zu machen.

Erläuterung

5º*                   push 5, [0], multiply (yielding [0,0,0,0,0]
   ♪                  push 1000
    {                 start block
     k                push input as integer
      K∞              push 22 and double it, yielding 44
        ╟(            push 60 and decrease, yielding 59
          α           wrap last two elements in array, yielding [44,59]
           m<         map is less than, giving [0,0], [1,0] or [1,1]
             Σ        sum array, giving 0, 1 or 2
              ∞       double, giving 0, 2 or 4
               w      push random integer in range
                Φ     increase array element
                 }    execute for loop (loops 1000 times)
                  σ   convert to string and remove leading zeroes (implicit map)

Python 2 , 117 113 108 107 106 105 Bytes

from random import*
def f(n):a=['']*5;exec"i=randint(0,(n>44)+(n>59)<<1);a[i]=(a[i]or 0)+1;"*1000;print a

Probieren Sie es online!

Gibt eine umgekehrte Liste zurück (unten zuerst)

Version inspiriert von der Stackoverflow- Antwort in den Kommentaren (Edgecases sind wahrscheinlicher):

Python 2 , 129 Bytes

from random import*
def f(n):a=sorted([1000]*5+sample(range(1001)*5,(n>44)+(n>59)<<1));print[y-x or''for x,y in zip([0]+a,a)[:5]]

Probieren Sie es online!

JavaScript (ES6), 78 Byte

Gibt ein umgekehrtes Array zurück, in dem leere Ebenen mit einem Leerzeichen gefüllt sind.

t=>(a=[...'     '],g=k=>k?g(k-1,a[Math.random()*(t>59?5:t<45||3)|0]++):a)(1e3)

Probieren Sie es online!

Kommentiert

t => (                      // t = input
  a = [...'     '],         // a[] = output array, initially filled with 5 spaces
  g = k =>                  // g = recursive function taking an iteration counter k
    k ?                     //   if k is not equal to zero:
      g(                    //     do a recursive call:
        k - 1,              //       decrement k
        a[                  //       update a[]:
          Math.random() * ( //         pick a random slot:
            t > 59 ? 5 :    //           among all 5 slots if t > 59
            t < 45          //           force the 1st slot if t < 45
            || 3            //           among the 3 first slots otherwise
          ) | 0             //         round the above result to an integer
        ]++                 //       increment the wax amount on this slot
      )                     //     end of recursive call
    :                       //   else:
      a                     //     stop recursion and return a[]
)(1e3)                      // initial call to g() with k = 1000

R , 85 84 Bytes

function(n)write(ifelse(t<-table(cut(runif(1e3,2*(n<60)+3*(n<45),5),0:5)),t,""),1,1)

-1 Byte dank @Giuseppe

Probieren Sie es online!

Erklärung (ungolfed):

function(n){
      # Generate 1000 random uniform numbers in [5,5] (if n<45),
      # in [2,5] (if 45<=n<60) and in [0,5] (if n>=60).
    x = runif(1e3,2*(n<60)+3*(n<45),5) 
      # Code each by the number of the interval it falls in (0,1],(1,2]...(4,5]
    cx = cut(x,0:5)
      # Tabulate the intervals. Because cut() returns a factor,
      # zero counts are included 
    t = table(cx)
      # Vector-wise replace zero elements with "" and cat out, 1 per line.
    t1 = ifelse(t,t,"")
    write(t1,1,1)
}

C (gcc) , 131 , 116 , 90 , 89 , 87 Bytes

L(l,a,v,A){for(A=5,v=1e3;A--;v-=a)printf("%d\n"+!a*2,a=l>59|A<3&l>44?rand()%-~v:!A*v);}

Probieren Sie es online!

Update : Ein Fehler im Original wurde behoben. In der Hilfefunktion zusammengeführt, um zusätzliche 15 Byte zu reduzieren.

Update 2 : -25 Bytes dank ErikF.

Update 3 : -1 Byte dank ceilingcat.

Degolf

L(l,a,v,A){
    for(A=5,v=1e3;A--;v-=a)
        printf("%d\n"+!a*2, // No clue how this works anymore, but it'll advance the pointer 
                            // to the string constant when a number shouldn't be printed.
        a=l>59|A<3&l>44?rand()%-~v // Random integer to print in [0, v]
        :!A*v); // If bottom layer, return remaining volume
}

05AB1E , 27 26 25 Bytes

Ein Byte dank Adnan gespeichert .
Dank Kevin Cruijssen wurde ein weiteres Byte gespeichert .

5Å0₄FD„,;ÇI‹O·ÝΩ©è>®ǝ]ε0Û

Probieren Sie es online!

Erläuterung

5Å0                         # initialize with a list of 5 zeroes
   ₄F                       # 1000 times do:
     D                      # duplicate the list
      „,;ÇI‹                # check if the input is larger than 44 and/or 59
            O·              # sum and double, yielding (0,2 or 4)
             ÝΩ             # pick a random number between and 0 and the number above
               ©è           # get the count in that level
                 >          # increment it
                  ®ǝ        # insert it at the same position
                     ]      # end loop
                      ε0Û   # remove leading zeroes on each level

JavaScript (Node.js) , 87-86 Byte

f=(n,w=1e3,s=5,r=n<45|n<60&s<4|s<2?w:Math.random()*w|0)=>s?`${r||""}
`+f(n,w-r,s-1):""

Probieren Sie es online!

Die 83-Byte-Lösung ( (n/15-2|0)*s<4) wird zuerst reserviert, da ich nach größeren suchen muss n.

UPDATE: Ja, (n/15-2|0)*s<4nicht , weil für eine größere Arbeit , nweil ngroß genug , um die Summe macht 1000 zu erreichen scheitern.

PHP, 92 Bytes

$i=5;for($n=1e3;$i--;$n-=$x)echo($x=rand($i?0:$n,$i<($argn<60?$argn<45?:3:5)?$n:0))?:"","
";

Laufen Sie als Pipe mit -Roder probieren Sie es online aus .

Sauber , 215 Bytes

import StdEnv,Math.Random,Text
? ::!Int->Int
?_=code{ccall time "I:I"
}
$n#l=take(max(2*min(n/15-2)2)0+1)(genRandReal(?0))
#l=map toInt[1E3*e/sum l\\e<-l]
|sum l==1000=map(\v|v>0=v<+"\n"="\n")(l++repeat 0)%(0,4)= $n

Probieren Sie es online!

So hat mich endlich einen kürzeren Weg zu einem zufälligen Samen als Import gefunden System._Unsafe, System.Timeund mit toInt(accUnsafe time)...
Einbetten einen Anrufs zu C, ohne auf den Weltstaat Typen normalerweise verwendet , um sicherzustellen , die Auswertung - Und Junge ist es wirklich im Geist des codegolf Reihenfolge solcher Dinge.

Java (JDK 10) , 121 117 113 111 Bytes

m->{for(int w=1000,j,i=5;i-->0;w-=j=i>0?j*=Math.random():w,System.out.println(j<1?"":j))j=m>59|m>44&i<3?w+1:0;}

Probieren Sie es online!

Es ist voreingenommen, mehr Wachs in die Nähe der Oberseite zu bringen, aber theoretisch kann jede rechtliche Anordnung von Wachs auftreten.

edit: 4 Bytes wurden von @KevinCruijssen gespeichert

In lesbarem Java:

(int minutes /* golfed variable m */) -> {
  int waxRemaining = 1000; // golfed variable w

  // golfed version goes from index 4 to 0 in a bit of a roundabout way
  // starting at 5 but decrementing right away
  for (int level = 4 /* golfed variable i */; level <= 0; level--) {
    // golfed variable j
    // the golfed version initializes this to (waxRemaining + 1)
    // in order to juice out some extra bytes during the Math.random() call
    int waxAtLevel = 0;

    // the golfed version does all of these ifs as ternary operations
    // and avoids using 2-character operators wherever possible
    // so e.g. "a == 0" becomes "a<1" and "a && b" becomes "a&b"
    // since here we are certain things can't be negative,
    // and took a good look at the Java operator precedence cheat-sheet
    // to make sure "&" and "|" would work properly to give a truthy value
    if (level == 0) {
      // if we are at the bottom level, just put the rest of the wax there
      waxAtLevel = waxRemaining;
    } else if (minutes >= 60 || (minutes >= 45 && level < 3)) {
      // otherwise if we are at a legal level put a random portion of the remaining wax there
      // note: the random portion can be between 0 and waxRemaining inclusive
      waxAtLevel = (int) (Math.random() * (waxRemaining + 1));
    }

    if (waxAtLevel > 0) {
      // only print the amount of way at this level if its greater than 0
      System.out.print(waxAtLevel);
    }
    System.out.println();

    waxRemaining -= waxAtLevel;
  }
}

Powershell , 188 162 Bytes

param($m);$t=0;$a=,0*5;$s=if($m-lt45){4}elseif($m-lt60){2}else{0};$s..4|%{$t+=$a[$_]=if($_-eq4){1e3-$t}elseif($t-ne1e3){Random(1000-$t)}}$a|%{if($_){$_}else{''}}

Probieren Sie es online!

-2 Bytes von @Kevin Cruijssen
-4 Bytes durch Entfernen des optionalen Getverbs
-20 Bytes durch Verkürzen der Schleife und Entfernen von Leerzeichen

Pascal (FPC) , 192 - 190 Byte

var n,a:word;z:array[0..4]of word;begin read(n);if n>44then a:=a+3;if n>59then a:=a+2;Randomize;for n:=0to 999do inc(z[random(a)]);for n:=0to 4do if z[n]>0then writeln(z[n])else writeln end.

Probieren Sie es online!

Unter Verwendung der Methode der Verpackung in Behälter von TFeld . Gibt die unterste Zeile zuerst mit einer nachgestellten Zeile aus.

Es scheint, dass FPC keine Probleme damit hat random(0), also habe ich dort einige ungewöhnliche Ergänzungen.

var n,i,a,r:int32;begin read(n);if n>44then a:=a-2;if n>59then a:=a-2;r:=1000;Randomize;for i:=-3to-0do begin if i>a then begin n:=random(r+1);if n>0then write(n);r:=r-n;end;writeln;end;if r>0then write(r)end.

Probieren Sie es online!

Kohle , 37 Bytes

Ｆ²Ｆ²⊞υ∧‹³⁺ι÷Ｉθ¹⁵‽⊕⁻φΣ∨υω⊞υ⁻φΣυＥυ⎇ιＩιω

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆ²Ｆ²

Schleife zweimal zweimal. Alternativ könnte ich Integer den Schleifenindex durch 2 für die gleiche Byteanzahl geteilt haben.

‹³⁺ι÷Ｉθ¹⁵

Wenn der äußere Index plus ein Fünfzehntel der Temperatur größer als drei ist ...

⊞υ∧...‽⊕⁻φΣ∨υω

... dann schieben Sie eine zufällige ganze Zahl bis einschließlich 1000 - die bisherige Summe. Leider kann Charcoal die Summe einer leeren Liste nicht berechnen, sodass ich stattdessen die leere Zeichenfolge ersetzen muss.

⊞υ⁻φΣυ

Schieben Sie den Restbetrag in die Liste.

Ｅυ⎇ιＩιω

Konvertieren Sie die Liste in eine Zeichenfolge, verwenden Sie jedoch die leere Zeichenfolge anstelle von Null.

Gelee , 28 Bytes

>“,;‘SḤ‘µȷŻṗS⁼¥ƇȷX;0ẋ5¤ḣ5Yḟ0

Ein vollständiges Programm druckt das Ergebnis aus (auf den Kopf gestellt, wie erlaubt).

7ȷ$n>59$$10^{15}$

Wie?

>“,;‘SḤ‘µȷŻṗS⁼¥ƇȷX;0ẋ5¤ḣ5Yḟ0 - Main Link: integer, n
 “,;‘                        - list of code-page indices = [44,59]
>                            - greater than? (vectorises)
     S                       - sum (i.e. 0, 1 or 2)
      Ḥ                      - double (i.e 0, 2 or 4)
       ‘                     - increment (i.e. 1, 3 or 5)
        µ                    - start a new monadic link, call that x (i.e. f(x))
         ȷ                   - literal 1000
          Ż                  - zero-range = [0,1,2,...,1000]
           ṗ                 - Cartesian power (all tuples of length x using those numbers)
               Ƈ             - filter keep if:
              ¥              -   last two links as a dyad:
            S                -     sum
             ⁼  ȷ            -     equals 1000? (i.e. only valid tuples)
                 X           - random choice (get one of these tuples)
                      ¤      - nilad followed by link(s) as a nilad:
                   0         -   zero
                    ẋ5       -   repeat five times = [0,0,0,0,0]
                  ;          - concatenate     (e.g. [354,388,258,0,0,0,0,0])
                       ḣ5    - head to index 5 (e.g. [354,388,258,0,0])
                         Y   - join with newlines
                          ḟ0 - filter out zeros
                             - implicit print

Zweig , 126 Bytes

Das war eine wirklich lustige Herausforderung!

Dieser Code erstellt ein Makro, das importiert werden muss.

{%macro a(s,z=1000)%}{%for _ in 4..1%}{%set t=s>59or(s>44and _<3)?random(z):''%}{%set z=z-t%}{{t}}
{%endfor%}{{z}}{%endmacro%}

So importieren Sie es:

{%- import 'macro.twig' as a -%}
{{- a.a(50) -}}

Dies sollte den Trick machen.

Sie können es unter https://twigfiddle.com/t4dfgy ausprobieren.
Hinweis : Da die Seite Leerzeichen entfernt, musste ich -am Ende der Zeile ein einfügen, um zu beweisen, dass sie die richtige Anzahl von Zeilen ausgibt.

Bei einer regulären Installation würden Sie nur die Zeilenumbrüche ohne Probleme sehen.

Perl 6 , 62 Bytes

{($!=1e3)||@,|((+$!-($!-=$!.rand+|0)||@)xx($_/15+|0)*2-4)[^4]}

Probieren Sie es online!

Ein anonymer Codeblock, der eine Zeichenfolge verwendet und eine Liste mit ganzen Zahlen zurückgibt, wobei anstelle von s Nileine leere Liste ( []) verwendet wird 0.

Erläuterung:

{($!=1e3)||@,|((+$!-($!-=$!.rand+|0)||@)xx($_/15+|0)*2-4)[^4]}
{                                                            }  # Anonymous code block
 ($!=1e3)  # Initialise $! to 1000
                +$!-($!-=$!.rand+|0)     # Pick a random value from 0 to $!
                                    ||@  # Or an empty array if it is zero
            ,  (                       )xx  # Repeat this
                                          ($_/15+|0)*2-4  # The given value mapped to 0,2,4
             |(                                         )[^4] # Get the first four values
 ($!    )||@  # Where the first value is the leftover number in $! or an empty array

PHP ,113 108 99 97 93 Bytes

<?php $i=$argv[1];while($a++<1e3){${r.rand(1,$i<60?$i<45?:3:5)}++;}echo"$r5
$r4
$r3
$r2
$r1";

Probieren Sie es online!

-11 Bytes dank @titus
-9 Bytes, weil alles ein String ist

J , ^{56 55 54 48 43} 40 Bytes

5{.1e3(2<@-/\[,0,~[:\:~?@$~)2*1#.>&44 59

Probieren Sie es online!

-3 Bytes dank FrownyFrog

Ein weiteres Konzept schöne Methode , die etwas länger ist , aber garantiert vollkommen gleichmäßige Verteilung über alle Möglichkeiten, je das Verfahren hier :

J , 53 Bytes

5$!.a:[:<@(+/);._1 0:,(1e3#1)({~#?#)@,0$~2*1#.>&44 59

Probieren Sie es online!

PowerShell , 115 105 98 Byte

^{-17 bytes dank mazzy}

$a=,0*5
45,60-ge"$args"|%{$i+=2}
$i..4|%{$t+=$a[$_]=random(1001-$t)}
$a[4]+=1e3-$t
$a|%{"$_"*!!$_}

Probieren Sie es online!

Ein Golf von Edwins reizender Antwort . Wenn du das magst, stimme ihm zu.

Ruby , 62-55 Bytes

->n{w=1000;[4,4,3,3].map{|r|r*15>n||w-=q=rand(w);q}<<w}

Probieren Sie es online!

Tests sind auf 0-99 Grad begrenzt, da Lavalampen bei höheren Temperaturen gefährlich sein können: