Introdução:

Acho que todo mundo sabe o que é uma lâmpada de lava, mas, caso não saiba:

^{(Fonte da imagem)}

São basicamente tubos de vidro que contêm cera em um líquido translúcido. A parte inferior é aquecida quando a lâmpada é acesa, causando uma alteração na densidade e, portanto, a cera flutua para o topo. Quando esfria, cai novamente, causando o efeito que vemos acima.

Geralmente, leva de 45 a 60 minutos para que a base da lâmpada aumente a temperatura alta o suficiente para mudar a cera sólida para cera líquida (se a lâmpada estiver localizada em uma área à temperatura ambiente).

Mais informações na Wikipedia, que também é usada como fonte para alguns dos textos acima.

Desafio:

Dado um número inteiro positivo nindicando a quantidade de minutos que passaram desde que ligamos a Lava Lamp, produza um estado aleatório da Lava Lamp com base em números inteiros em cinco níveis.

Para este desafio, diremos que a lâmpada de lava contém 1000 unidades de cera no total e temos cinco níveis em que a cera pode estar.

1) Se nestiver abaixo de 45, a lâmpada de lava ainda está esquentando, portanto a saída será de quatro linhas vazias 1000na parte inferior:

1000

2) Se nestiver na faixa, [45, 60)a Lava Lamp aumentou a temperatura o suficiente para a cera se movimentar, mas ainda não está muito alta. A cera pode atingir até e incluindo o terceiro nível.
3) Se nfor 60superior ou superior, a cera pode estar em qualquer um dos cinco níveis.

Portanto, considerando o número inteiro positivo ncomo entrada, produziremos um estado aleatório com as três regras acima em mente.

Aqui estão alguns exemplos de saídas:

Saídas possíveis para qualquer um nque seja >= 45:

523
106
371

913

87

Saídas possíveis para qualquer um nque seja >= 60:

73
113
312
5
497

284
55
637

24

Saída constante para nisso é <= 44(e saída possível para qualquer n):

1000

Regras do desafio:

• Pode haver linhas vazias, mesmo que o nível acima dele não esteja vazio.
• Apenas 0não é permitido em nenhuma linha. Em vez disso, deve estar vazio.
• A saída é um pouco flexível. Você tem permissão para gerar uma lista / matriz de seqüências de caracteres / objetos em vez de um resultado delimitado por nova linha, como acima. A razão pela qual digo strings / objetos é devido à regra acima. Uma linha vazia deve ser "", null, [], etc, mas não pode ser 0ou um número inteiro negativo (nem pode ser false) (Ie ["", "", 913, "", 87]para n >= 45). Você também pode reverter a saída (ou seja, em 1000\n\n\n\nvez de \n\n\n\n1000ou em [87, null, 913, null, null]vez de [null, null, 913, null, 87]).
• Os números devem ser inteiros. Podem ser decimais com o 0valor decimal, mas nenhum dos números deve ter dígitos decimais e os números inteiros devem sempre somar exatamente 1000.
• Todas as saídas aleatórias possíveis com base em ndevem ter uma chance diferente de zero.
• É permitida uma nova linha à direita (portanto, existem seis linhas de saída).

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

MathGolf , 21 20 bytes

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

Experimente online!

Esta é a minha primeira resposta no meu novo idioma. Baseei minha solução na solução 05AB1E da Emigna, mas usei alguns recursos interessantes do MathGolf para torná-lo um pouco mais curto.

Explicação

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

Experimente online!

Retorna uma lista invertida (primeiro em baixo)

Versão inspirada na resposta do stackoverflow nos comentários (é mais provável que edgecases):

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

Experimente online!

JavaScript (ES6), 78 bytes

Retorna uma matriz invertida onde os níveis vazios são preenchidos com um espaço.

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

Experimente online!

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 graças a @ Giuseppe

Experimente online!

Explicação (não destruída):

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

Experimente online!

Atualização : Corrigido um bug no original. Fundido na função auxiliar, reduzindo 15 bytes adicionais.

Atualização 2 : -25 bytes graças ao ErikF.

Atualização 3 : -1 byte, graças ao 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

Guardou um byte graças a Adnan . Guardou
outro byte graças a Kevin Cruijssen .

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

Experimente online!

Explicação

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

Experimente online!

A solução de 83 bytes ( (n/15-2|0)*s<4) é reservada primeiro porque eu preciso verificar se há mais n.

UPDATE: Sim, (n/15-2|0)*s<4não funcionou, porque para maiores, nporque ngrandes o suficiente fazem com que a soma não atinja 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))?:"","
";

Execute como pipe -Rou experimente online .

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

Experimente online!

Então, eu finalmente encontrei um caminho mais curto para obter uma semente aleatória do que importar System._Unsafe, System.Timee usando toInt(accUnsafe time)...
E o menino é verdadeiramente no espírito do codegolf - Incorporação de uma chamada para C, ignorando o tipo de estado do mundo normalmente usado para garantir a avaliação ordem de tais coisas.

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

Experimente online!

É tendencioso para colocar mais cera perto do topo, mas é teoricamente possível que qualquer arranjo legal de cera apareça.

edit: 4 bytes foram salvos por @KevinCruijssen

Em Java legível por 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{''}}

Experimente online!

-2 bytes por @Kevin Cruijssen
-4 bytes removendo o opcional Get-verb
-20 bytes diminuindo o loop e removendo espaços

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.

Experimente online!

Usando o método de embalagem em caixas pelo TFeld . Imprime a linha inferior primeiro com uma nova linha à direita.

Parece que o FPC não tem problemas com random(0) , então eu tenho alguns acréscimos incomuns 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.

Experimente online!

Carvão , 37 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｆ²Ｆ²

Loop duas vezes, duas vezes. Alternativamente, eu poderia ter inteiro dividido o índice do loop por 2 para a mesma contagem de bytes.

‹³⁺ι÷Ｉθ¹⁵

Se o índice externo mais um décimo quinto da temperatura for superior a três ...

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

... empurre um número inteiro aleatório até e incluindo 1000 - a soma até o momento. Infelizmente, o carvão vegetal não pode calcular a soma de uma lista vazia, por isso tenho que substituir a string vazia.

⊞υ⁻φΣυ

Empurre a quantidade restante para a lista.

Ｅυ⎇ιＩιω

Converta a lista em string, mas use a string vazia em vez de zero.

Geléia , 28 bytes

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

Um programa completo imprimindo o resultado (de cabeça para baixo, como foi permitido).

Experimente online! - isto é alterado para usar em7vez deȷ(1000) porque a implementação é lenta no golfe! (...para$n>59$ uma lista de $10^{15}$ 5 tuplas são criadas e depois filtradas, a partir da qual escolher)

Quão?

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

Galho , 126 bytes

Este foi realmente um desafio divertido!

Este código cria uma macro que precisa ser importada.

{%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 importá-lo, faça o seguinte:

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

Isso deve fazer o truque.

Você pode experimentá-lo em https://twigfiddle.com/t4dfgy
Aviso : devido à página remover espaços em branco, fui forçado a adicionar um- no final da linha, para provar que está produzindo o número correto de linhas.

Em uma instalação regular, você apenas veria as novas linhas sem problemas.

Perl 6 , 62 bytes

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

Experimente online!

Um bloco de código anônimo que pega uma string e retorna uma lista de números inteiros, com Nilou uma lista vazia ( []) no lugar de 0s.

Explicação:

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

Experimente online!

-11 bytes graças a @titus
-9 bytes porque tudo é uma string

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

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

Experimente online!

-3 bytes graças ao FrownyFrog

Outro método conceitualmente interessante, que é um pouco mais longo, mas garante uma distribuição perfeitamente uniforme em todas as possibilidades, de acordo com o método aqui :

J , 53 bytes

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

Experimente online!

PowerShell , 115 105 98 bytes

^{-17 bytes graças ao mazzy}

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

Experimente online!

Um golfe da adorável resposta de Edwin . Se você gosta disso, faça um voto positivo.

Ruby , 62 55 bytes

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

Experimente online!

Os testes são limitados a 0-99 graus, porque as lâmpadas de lava podem ser perigosas em temperaturas mais altas: