Introduzione:

Penso che tutti sappiano cos'è una Lava Lamp, ma nel caso in cui non lo facciano:

^{(Fonte immagine)}

Sono fondamentalmente tubi di vetro che contengono cera in un liquido traslucido. La parte inferiore viene riscaldata quando la lampada viene accesa, causando un cambiamento di densità e quindi la cera galleggia verso l'alto. Quando si raffredda, cade di nuovo, causando l'effetto che vediamo sopra.

Di solito sono necessari circa 45-60 minuti affinché la base della lampada si alzi a una temperatura sufficientemente elevata da cambiare la cera solida in cera liquida (se la lampada si trova in un'area a temperatura ambiente).

Maggiori informazioni su Wikipedia, che è anche usato come fonte per alcuni dei testi sopra.

Sfida:

Dato un numero intero positivo che nindica la quantità di minuti trascorsi da quando abbiamo acceso la lampada lava, emette uno stato casuale della lampada lava basato su numeri interi su cinque livelli.

Per questa sfida diremo che la lampada lava contiene 1000 unità di cera in totale e abbiamo cinque livelli in cui la cera può trovarsi.

1) Se nè inferiore a 45, la lampada lava si sta ancora riscaldando, quindi l'uscita sarà di quattro righe vuote con 1000in basso:

1000

2) Se si ntrova nel raggio d'azione, [45, 60)la lampada lava ha aumentato la temperatura abbastanza da consentire alla cera di muoversi, ma non è ancora molto alta. La cera può arrivare fino al terzo livello incluso.
3) Se nè 60o superiore, la cera può trovarsi in uno dei cinque livelli.

Quindi, dato il numero intero positivo ncome input, genereremo uno stato casuale tenendo presenti le tre regole sopra.

Ecco alcuni esempi di output:

Possibili uscite per qualsiasi ncosa sia >= 45:

523
106
371

913

87

Possibili uscite per qualsiasi ncosa sia >= 60:

73
113
312
5
497

284
55
637

24

L'output costante nè <= 44(e l'output possibile per qualsiasi n):

1000

Regole della sfida:

• Possono esserci linee vuote, anche se il livello sopra non è vuoto.
• Semplicemente 0non è permesso su nessuna linea. Dovrebbe essere vuoto invece.
• L'output è alquanto flessibile. È consentito produrre un elenco / array di stringhe / oggetti anziché un risultato delimitato da nuova riga come sopra. Il motivo per cui dico stringhe / oggetti è dovuto alla regola sopra. Una riga vuota deve essere "", null, [], ecc, ma non può essere 0o un intero negativo (né può essere false) (Ie ["", "", 913, "", 87]per n >= 45). È anche possibile invertire l'output (vale a dire 1000\n\n\n\nanziché \n\n\n\n1000o [87, null, 913, null, null]invece di [null, null, 913, null, 87]).
• I numeri dovrebbero essere tutti numeri interi. I decimali possono essere 0come valore decimale, ma nessuno dei numeri deve avere cifre decimali e gli interi devono sempre essere sommati esattamente 1000.
• Tutte le possibili uscite casuali basate su ndovrebbero avere una probabilità diversa da zero di verificarsi.
• È consentita una nuova riga finale (quindi ci sono sei righe di output).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

MathGolf , 21 20 byte

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

Provalo online!

Questa è la mia prima risposta nella mia nuova lingua. Ho basato la mia soluzione sulla soluzione 05AB1E di Emigna, ma ho usato alcune funzioni pulite di MathGolf per renderla un po 'più breve.

Spiegazione

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 107 105 105 byte

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

Provalo online!

Restituisce un elenco invertito (prima in basso)

Versione ispirata alla risposta stackoverflow nei commenti (le edgecase sono più probabili):

Python 2 , 129 byte

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

Provalo online!

JavaScript (ES6), 78 byte

Restituisce un array invertito in cui i livelli vuoti sono riempiti con uno spazio.

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

Provalo online!

Commentate

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 byte

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

-1 byte grazie a @Giuseppe

Provalo online!

Spiegazione (non golfizzato):

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 byte

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

Provalo online!

Aggiornamento : corretto un bug nell'originale. Fuso nella funzione di aiuto, riducendo altri 15 byte.

Aggiornamento 2 : -25 byte grazie a ErikF.

Aggiornamento 3 : -1 byte grazie a 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 byte

Salvato un byte grazie ad Adnan . Ho
salvato un altro byte grazie a Kevin Cruijssen .

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

Provalo online!

Spiegazione

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

Provalo online!

La soluzione a 83 byte ( (n/15-2|0)*s<4) è riservata per prima perché devo verificarne la dimensione n.

AGGIORNAMENTO: Sì, (n/15-2|0)*s<4non ha funzionato perché più grande nperché nabbastanza grande fa sì che la somma non riesca a raggiungere 1000.

PHP, 92 byte

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

Esegui come pipe -Ro provalo online .

Pulito , 215 byte

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

Provalo online!

Così ho finalmente trovato un modo più breve per ottenere un seme casuale di importazione System._Unsafe, System.Timee l'utilizzo di toInt(accUnsafe time)...
E il ragazzo è veramente nello spirito di codegolf - incorporare una chiamata a C, ignorando il tipo di stato mondiale normalmente utilizzato per garantire la valutazione ordine di tali cose.

Java (JDK 10) , 121 117 113 111 byte

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

Provalo online!

È tendente a mettere più cera vicino alla cima, ma è teoricamente possibile che appaia qualsiasi accordo legale di cera.

modifica: 4 byte sono stati salvati da @KevinCruijssen

In Java leggibile dall'uomo:

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

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{''}}

Provalo online!

-2 byte di @Kevin Cruijssen
-4 byte rimuovendo Get-verb opzionale
-20 byte accorciando il ciclo e rimuovendo gli spazi

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.

Provalo online!

Utilizzo del metodo di imballaggio in cassonetti di TFeld . Stampa prima la riga inferiore con una nuova riga finale.

Sembra che FPC non abbia problemi con random(0), quindi ho qualche aggiunta insolita lì.

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.

Provalo online!

Carbone , 37 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆ²Ｆ²

Ripeti due volte, due volte. In alternativa, avrei potuto dividere l'intero indice del ciclo per 2 per lo stesso numero di byte.

‹³⁺ι÷Ｉθ¹⁵

Se l'indice esterno più un quindicesimo della temperatura è maggiore di tre ...

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

... quindi invia un numero intero casuale fino a 1000 inclusi, la somma finora. Sfortunatamente il carbone non può calcolare la somma di un elenco vuoto, quindi devo sostituire la stringa vuota.

⊞υ⁻φΣυ

Spingere la quantità rimanente nell'elenco.

Ｅυ⎇ιＩιω

Converti l'elenco in stringa, ma utilizza la stringa vuota anziché zero.

Gelatina , 28 byte

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

Un programma completo che stampa il risultato (sottosopra, come è stato permesso).

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

Come?

>“,;‘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

Ramoscello , 126 byte

Questa è stata una sfida davvero divertente!

Questo codice crea una macro che deve essere importata.

{%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%}

Per importarlo, basta fare questo:

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

Questo dovrebbe fare il trucco.

Puoi provarlo su https://twigfiddle.com/t4dfgy
Avviso : a causa della pagina che rimuove gli spazi bianchi, sono stato costretto ad aggiungere un- alla fine della riga, per dimostrare che sta producendo il numero corretto di righe.

Su una normale installazione, vedresti le nuove righe senza problemi.

Perl 6 , 62 byte

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

Provalo online!

Un blocco di codice anonimo che accetta una stringa e restituisce un elenco di numeri interi, con Nilo un elenco vuoto ( []) al posto di 0s.

Spiegazione:

{($!=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 byte

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

Provalo online!

-11 byte grazie a @titus
-9 byte perché tutto è una stringa

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

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

Provalo online!

-3 byte grazie a FrownyFrog

Un altro metodo concettualmente piacevole che è un po 'più lungo ma garantisce una distribuzione perfettamente uniforme su tutte le possibilità, secondo il metodo qui :

J , 53 byte

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

Provalo online!

PowerShell , 115 105 98 byte

^{-17 byte grazie a mazzy}

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

Provalo online!

Un golf della bella risposta di Edwin . Se ti piace, votalo.

Rubino , 62 55 byte

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

Provalo online!

I test sono limitati a 0-99 gradi, perché le lampade di lava potrebbero essere pericolose a temperature più elevate: