Introduction:

Je pense que tout le monde sait ce qu'est une lampe à lave, mais au cas où ils ne le feraient pas:

^{(Source de l'image)}

Ce sont essentiellement des tubes en verre qui contiennent de la cire dans un liquide translucide. La partie inférieure est chauffée lorsque la lampe est allumée, provoquant un changement de densité et donc la cire flotte vers le haut. Quand il se refroidit, il retombe, provoquant l'effet que nous voyons ci-dessus.

Il faut généralement environ 45 à 60 minutes pour que la base de la lampe augmente à une température suffisamment élevée pour changer la cire solide en cire liquide (si la lampe est située dans une zone à température ambiante).

Plus d'informations sur Wikipedia, qui est également utilisé comme source pour une partie du texte ci-dessus.

Défi:

Étant donné un entier positif nindiquant le nombre de minutes qui se sont écoulées depuis que nous avons allumé la lampe à lave, affichez un état aléatoire de la lampe à lave sur la base d'entiers à cinq niveaux.

Pour ce défi, nous dirons que la lampe à lave contient au total 1000 unités de cire, et nous avons cinq niveaux où la cire peut être.

1) Si nest inférieur à 45, la lampe à lave chauffe toujours, donc la sortie sera de quatre lignes vides avec 1000en bas:

1000

2) Si nest dans la plage, [45, 60)la lampe à lave a suffisamment augmenté en température pour que la cire puisse se déplacer, mais pas encore très haut. La cire peut atteindre jusqu'au troisième niveau inclus.
3) Si nc'est 60ou plus, la cire peut être à l'un des cinq niveaux.

Donc, étant donné l'entier positif nen entrée, nous afficherons un état aléatoire avec les trois règles ci-dessus à l'esprit.

Voici quelques exemples de sorties:

Sorties possibles pour tout ce nqui est >= 45:

523
106
371

913

87

Sorties possibles pour tout ce nqui est >= 60:

73
113
312
5
497

284
55
637

24

Sortie constante pour ncela <= 44(et sortie possible pour tout n):

1000

Règles du défi:

• Il peut y avoir des lignes vides, même si le niveau supérieur n'est pas vide.
• Ce 0n'est pas autorisé sur aucune ligne. Doit être vide à la place.
• La sortie est quelque peu flexible. Vous êtes autorisé à générer une liste / un tableau de chaînes / objets au lieu d'un résultat délimité par une nouvelle ligne comme ci-dessus. La raison pour laquelle je dis des chaînes / objets est due à la règle ci-dessus. Une ligne vide doit être "", null, [], etc., mais ne peut pas être 0ou un entier négatif (ne peut - il être false) (Ie ["", "", 913, "", 87]pour n >= 45). Vous êtes également autorisé à inverser la sortie (c'est- 1000\n\n\n\nà- dire au lieu de \n\n\n\n1000ou à la [87, null, 913, null, null]place de [null, null, 913, null, 87]).
• Les nombres doivent tous être des entiers. Il peut s'agir de décimales avec 0comme valeur décimale, mais aucun des nombres ne doit avoir de chiffres décimaux et les nombres entiers doivent toujours correspondre exactement 1000.
• Toutes les sorties aléatoires possibles basées sur ndevraient avoir une chance non nulle de se produire.
• Une nouvelle ligne de fin (il y a donc six lignes de sortie) est autorisée.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

MathGolf , 21 20 octets

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

Essayez-le en ligne!

Ceci est ma première réponse dans ma nouvelle langue. J'ai basé ma solution sur la solution 05AB1E d'Emigna, mais j'ai utilisé quelques fonctionnalités intéressantes de MathGolf pour la raccourcir un peu.

Explication

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 octets

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

Essayez-le en ligne!

Renvoie une liste inversée (en bas en premier)

Version inspirée de la réponse de stackoverflow dans les commentaires (les cas de figure sont plus probables):

Python 2 , 129 octets

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

Essayez-le en ligne!

JavaScript (ES6), 78 octets

Renvoie un tableau inversé où les niveaux vides sont remplis d'un espace.

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

Essayez-le en ligne!

Commenté

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 octets

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

-1 octet grâce à @Giuseppe

Essayez-le en ligne!

Explication (non golfée):

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 octets

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

Essayez-le en ligne!

Mise à jour : correction d'un bug dans l'original. Fusionné dans la fonction d'assistance, réduisant ainsi 15 octets supplémentaires.

Mise à jour 2 : -25 octets grâce à ErikF.

Mise à jour 3 : -1 octet grâce à plafondcat.

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 octets

Enregistré un octet grâce à Adnan .
Un autre octet enregistré grâce à Kevin Cruijssen .

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

La solution de 83 octets ( (n/15-2|0)*s<4) est réservée en premier car j'ai besoin de vérifier pour une plus grande n.

MISE À JOUR: Oui, cela (n/15-2|0)*s<4n'a pas fonctionné parce que pour plus grand, ncar nsuffisamment grand, la somme ne parvient pas à atteindre 1000.

PHP, 92 octets

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

Exécuter en tant que pipe avec -Rou l' essayer en ligne .

Nettoyer , 215 octets

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

Essayez-le en ligne!

Donc , je l' ai finalement trouvé un chemin plus court pour obtenir une graine aléatoire que l' importation System._Unsafe, System.Timeet en utilisant toInt(accUnsafe time)...
Et le garçon est - il vraiment dans l'esprit de codegolf - l' intégration d' un appel à C, en ignorant le type d'état mondial normalement utilisé pour assurer l'évaluation ordre de ces choses.

Java (JDK 10) , 121 117 113 111 octets

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

Essayez-le en ligne!

Cela tend à mettre plus de cire près du sommet, mais il est théoriquement possible que tout arrangement juridique de cire apparaisse.

edit: 4 octets ont été enregistrés par @KevinCruijssen

En Java lisible par l'homme:

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

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

Essayez-le en ligne!

-2 octets par @Kevin Cruijssen
-4 octets en supprimant le verbe optionnel
-20 octets en raccourcissant la boucle et en supprimant les espaces

Pascal (FPC) , 192 190 octets

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.

Essayez-le en ligne!

Utilisation de la méthode d'emballage dans les bacs par TFeld . Imprime la première ligne du bas avec une nouvelle ligne de fin.

Il semble que FPC n'ait pas de problèmes avec random(0), j'ai donc des ajouts inhabituels là-bas.

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.

Essayez-le en ligne!

Fusain , 37 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆ²Ｆ²

Boucle deux fois, deux fois. Alternativement, je pourrais avoir un entier divisé l'index de boucle par 2 pour le même nombre d'octets.

‹³⁺ι÷Ｉθ¹⁵

Si l'indice extérieur plus un quinzième de la température est supérieur à trois ...

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

... puis poussez un entier aléatoire jusqu'à 1000 inclusivement - la somme jusqu'à présent. Malheureusement, Charcoal ne peut pas calculer la somme d'une liste vide, je dois donc remplacer la chaîne vide à la place.

⊞υ⁻φΣυ

Poussez le montant restant dans la liste.

Ｅυ⎇ιＩιω

Convertissez la liste en chaîne, mais utilisez la chaîne vide au lieu de zéro.

Gelée , 28 octets

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

Un programme complet imprimant le résultat (à l'envers, comme cela a été autorisé).

Essayez-le en ligne! - ceci est modifié à utiliser7plutôt queȷ(1000) parce que la mise en œuvre est lente au goût du golf! (...pour$n>59$ une liste de $10^{15}$ 5 tuples sont construits puis filtrés, parmi lesquels choisir)

Comment?

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

Brindille , 126 octets

C'était un défi vraiment amusant!

Ce code crée une macro qui doit être importée.

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

Pour l'importer, faites simplement ceci:

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

Cela devrait faire l'affaire.

Vous pouvez l'essayer sur https://twigfiddle.com/t4dfgy
Remarque : En raison de la suppression des espaces blancs de la page, j'ai été obligé d'ajouter un -à la fin de la ligne, pour prouver qu'il génère le nombre correct de lignes.

Sur une installation régulière, vous ne verriez que les nouvelles lignes sans problème.

Perl 6 , 62 octets

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

Essayez-le en ligne!

Un bloc de code anonyme qui prend une chaîne et renvoie une liste d'entiers, avec Nilou une liste vide ( []) à la place de 0s.

Explication:

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

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

Essayez-le en ligne!

-11 octets grâce à @titus
-9 octets car tout est une chaîne

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

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

Essayez-le en ligne!

-3 octets grâce à FrownyFrog

Une autre méthode conceptuellement agréable qui est un peu plus longue mais garantit une distribution parfaitement uniforme sur toutes les possibilités, selon la méthode ici :

J , 53 octets

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

Essayez-le en ligne!

PowerShell , 115 105 98 octets

^{-17 octets grâce à mazzy}

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

Essayez-le en ligne!

Un golf de la charmante réponse d' Edwin . Si vous aimez ça, votez pour lui.

Rubis , 62 55 octets

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

Essayez-le en ligne!

Les tests sont limités à 0-99 degrés, car les lampes à lave peuvent être dangereuses à des températures plus élevées: