Introducción:

Creo que todos saben lo que es una lámpara de lava, pero en caso de que no:

^{(Fuente de imagen)}

Básicamente son tubos de vidrio que contienen cera en un líquido translúcido. La parte inferior se calienta cuando se enciende la lámpara, lo que provoca un cambio de densidad y, por lo tanto, la cera flota hacia la parte superior. Cuando se enfría, vuelve a caer, causando el efecto que vemos arriba.

Por lo general, la base de la lámpara tarda entre 45 y 60 minutos en alcanzar una temperatura lo suficientemente alta como para cambiar la cera sólida a cera líquida (si la lámpara se encuentra en un área a temperatura ambiente).

Más información en Wikipedia, que también se utiliza como fuente de algunos de los textos anteriores.

Desafío:

Dado un número entero positivo que nindica la cantidad de minutos que han pasado desde que encendimos la lámpara de lava, genera un estado aleatorio de la lámpara de lava basado en enteros en cinco niveles.

Para este desafío, diremos que la lámpara de lava contiene 1000 unidades de cera en total, y tenemos cinco niveles donde puede estar la cera.

1) Si nestá por debajo de 45, la lámpara de lava todavía se está calentando, por lo que la salida será de cuatro líneas vacías con 1000en la parte inferior:

1000

2) Si nestá dentro del rango, [45, 60)la lámpara de lava ha aumentado su temperatura lo suficiente como para que la cera se mueva, pero aún no muy alta. La cera puede alcanzar hasta el tercer nivel inclusive.
3) Si nes 60o mayor, la cera puede estar en cualquiera de los cinco niveles.

Entonces, dado el entero positivo ncomo entrada, generaremos un estado aleatorio con las tres reglas anteriores en mente.

Aquí hay algunos ejemplos de resultados:

Posibles salidas para cualquiera nque sea >= 45:

523
106
371

913

87

Posibles salidas para cualquiera nque sea >= 60:

73
113
312
5
497

284
55
637

24

Salida constante para neso es <= 44(y salida posible para cualquiera n)

1000

Reglas de desafío:

• Puede haber líneas vacías, aunque el nivel superior no esté vacío.
• Simplemente 0no está permitido en ninguna línea. Debería estar vacío en su lugar.
• La salida es algo flexible. Se le permite generar una lista / matriz de cadenas / objetos en lugar de un resultado delimitado por una nueva línea como se indicó anteriormente. La razón por la que digo cadenas / objetos se debe a la regla anterior. Una línea de vacío debe ser "", null, [], etc., pero no puede ser 0o un entero negativo (ni puede ser false) (es decir ["", "", 913, "", 87]para n >= 45). También puede invertir la salida (es decir, en 1000\n\n\n\nlugar de \n\n\n\n1000o en [87, null, 913, null, null]lugar de [null, null, 913, null, 87]).
• Los números deben ser todos enteros. Pueden ser decimales con un 0valor decimal, pero ninguno de los números debe tener dígitos decimales, y los enteros siempre deben sumar exactamente 1000.
• Todas las salidas aleatorias posibles basadas en ndeberían tener una probabilidad distinta de cero de ocurrir.
• Se permite una nueva línea final (por lo que hay seis líneas de salida).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, se recomienda agregar una explicación para su respuesta.

MathGolf , 21 20 bytes

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

Pruébalo en línea!

Esta es mi primera respuesta en mi nuevo idioma. Basé mi solución en la solución 05AB1E de Emigna, pero usé algunas características interesantes de MathGolf para hacerlo un poco más corto.

Explicación

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

Pruébalo en línea!

Devuelve una lista invertida (primero en la parte inferior)

Versión inspirada en la respuesta de stackoverflow en los comentarios (es más probable que las mayúsculas y minúsculas):

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

Pruébalo en línea!

JavaScript (ES6), 78 bytes

Devuelve una matriz invertida donde los niveles vacíos se llenan con un espacio.

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

Pruébalo en línea!

Comentado

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 gracias a @Giuseppe

Pruébalo en línea!

Explicación (sin golf):

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

Pruébalo en línea!

Actualización : se corrigió un error en el original. Fusionada en la función auxiliar, reduciendo 15 bytes adicionales.

Actualización 2 : -25 bytes gracias a ErikF.

Actualización 3 : -1 byte gracias 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 bytes

Salvó un byte gracias a Adnan .
Salvó otro byte gracias a Kevin Cruijssen .

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

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

La solución de 83 bytes ( (n/15-2|0)*s<4) se reserva primero porque necesito verificar si es más grande n.

ACTUALIZACIÓN: Sí, (n/15-2|0)*s<4no funcionó porque para más grande nporque lo nsuficientemente grande hace que la suma no llegue a 1000.

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))?:"","
";

Ejecutar como tubería -Ro probarlo en línea .

Limpio , 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

Pruébalo en línea!

Así que finalmente encontré una forma más corta de obtener una semilla aleatoria que la importación System._Unsafe, System.Timey usando toInt(accUnsafe time)...
Y vaya, realmente está en el espíritu de codegolf: incrustar una llamada a C, ignorando el tipo de estado mundial normalmente utilizado para garantizar la evaluación orden de tales cosas.

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

Pruébalo en línea!

Está sesgado a poner más cera cerca de la parte superior, pero es teóricamente posible que aparezca cualquier disposición legal de cera.

editar: 4 bytes fueron guardados por @KevinCruijssen

En Java legible para humanos:

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

Pruébalo en línea!

-2 bytes por @Kevin Cruijssen
-4 bytes eliminando Get-verb opcional
-20 bytes acortando el bucle y eliminando espacios

Pascal (FPC) , 192 190 bytes

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.

Pruébalo en línea!

Usando el método de empaque en contenedores por TFeld . Imprime la fila inferior primero con una nueva línea final.

Parece que FPC no tiene problemas random(0), por lo que tengo algunas adiciones inusuales allí.

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.

Pruébalo en línea!

Carbón , 37 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆ²Ｆ²

Bucle dos veces, dos veces. Alternativamente, podría tener un número entero dividido el índice de bucle por 2 para el mismo recuento de bytes.

‹³⁺ι÷Ｉθ¹⁵

Si el índice externo más una decimoquinta parte de la temperatura es mayor que tres ...

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

... luego empuje un entero aleatorio hasta 1000 inclusive, la suma hasta ahora. Lamentablemente, el carbón no puede calcular la suma de una lista vacía, por lo que tengo que sustituir la cadena vacía.

⊞υ⁻φΣυ

Empuje la cantidad restante a la lista.

Ｅυ⎇ιＩιω

Convierta la lista a cadena, pero use la cadena vacía en lugar de cero.

Jalea , 28 bytes

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

Un programa completo que imprime el resultado (al revés, como se ha permitido).

7ȷ$n>59$$10^{15}$ se construye 5-tuplas y luego se filtra, entre las cuales elegir)

¿Cómo?

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

Ramita , 126 bytes

¡Este fue un desafío realmente divertido!

Este código crea una macro que debe importarse.

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

Para importarlo, solo haz esto:

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

Esto debería funcionar.

Puede probarlo en https://twigfiddle.com/t4dfgy
Aviso : debido a que la página elimina espacios en blanco, me vi obligado a agregar un- al final de la línea, para demostrar que está produciendo el número correcto de líneas.

En una instalación regular, solo vería las nuevas líneas sin problemas.

Perl 6 , 62 bytes

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

Pruébalo en línea!

Un bloque de código anónimo que toma una cadena y devuelve una lista de enteros, con Nilo una lista vacía ( []) en lugar de0 s.

Explicación:

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

Pruébalo en línea!

-11 bytes gracias a @titus
-9 bytes porque todo es una cadena

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

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

Pruébalo en línea!

-3 bytes gracias a FrownyFrog

Otro método conceptualmente agradable que es un poco más largo pero garantiza una distribución perfectamente uniforme sobre todas las posibilidades, según el método aquí :

J , 53 bytes

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

Pruébalo en línea!

PowerShell , 115 105 98 bytes

^{-17 bytes gracias a mazzy}

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

Pruébalo en línea!

Un golf de la encantadora respuesta de Edwin . Si te gusta esto, vótalo.

Ruby , 62 55 bytes

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

Pruébalo en línea!

Las pruebas están limitadas a 0-99 grados, porque las lámparas de lava podrían ser peligrosas a temperaturas más altas: