介绍：

我想每个人都知道熔岩灯是什么，但万一他们不知道：

^{（图片来源）}

它们基本上是在半透明液体中包含蜡的玻璃管。打开灯时，底部会被加热，从而导致密度变化，因此蜡会浮到顶部。冷却后，它会再次掉落，从而产生我们上面看到的效果。

灯的底座通常需要大约45-60分钟的时间才能升高到足以将固体蜡变为液体蜡的温度（如果灯位于室温下的区域）。

有关Wikipedia的更多信息，该信息也用作上述某些文本的来源。

挑战：

给定一个正整数n，该值指示自从我们打开熔岩灯以来经过的分钟数，请基于五个级别的整数输出熔岩灯的随机状态。

对于此挑战，我们将说熔岩灯总共包含1000单位蜡，并且我们可以将蜡置于5个级别。

1）如果n低于45，熔岩灯仍在加热，因此输出将是四个空行，1000底部是：

1000

2）如果熔岩灯的温度n在此范围内，则[45, 60)其温度升高到足以使蜡移动的程度，但还没有很高。蜡可以达到并包括第三级。
3）如果n为60或更高，则蜡的含量可以为五个级别中的任何一个。

因此，给定正整数n作为输入，我们将牢记上述三个规则来输出随机状态。

以下是一些示例输出：

可能的输出n是>= 45：

523
106
371

913

87

可能的输出n是>= 60：

73
113
312
5
497

284
55
637

24

常量输出n是<= 44（以及任何可能的输出n）：

1000

挑战规则：

• 即使上面的级别不为空，也可以有空行。
• 只是0不允许在任何行上。应该为空。
• 输出有些灵活。您可以输出字符串/对象的列表/数组，而不是上述的以换行符分隔的结果。我说字符串/对象的原因是由于上述规则。一个空行应""，null，[]等，但不能是0或负整数（也不能被false）（即["", "", 913, "", 87]用于n >= 45）。您还可以反转输出（即，1000\n\n\n\n代替\n\n\n\n1000或[87, null, 913, null, null]代替[null, null, 913, null, 87]）。
• 这些数字都应该是整数。可以是带有0十进制值的小数，但是这些数字都不能包含任何十进制数字，并且整数应始终精确地相加1000。
• 基于的所有可能的随机输出n都应该有非零的发生机会。
• 允许尾随换行符（因此有六行输出）。

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于您的答案，因此您可以使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，强烈建议为您的答案添加说明。

MathGolf，21 20字节

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

在线尝试！

这是我用新语言的第一个答案。我的解决方案基于Emigna的05AB1E解决方案，但是使用了MathGolf的一些巧妙功能使其变得更短一些。

说明

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字节

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

在线尝试！

返回反向列表（从下至上）

受注释中的stackoverflow 答案启发的版本（更有可能是边缘情况）：

Python 2，129字节

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

在线尝试！

JavaScript（ES6），78个字节

返回一个反向数组，其中空的级别用空格填充。

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

在线尝试！

已评论

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字节

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

-1字节感谢@Giuseppe

在线尝试！

说明（无胶体）：

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个字节

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

在线尝试！

更新：修复了原始错误。融合在辅助函数中，减少了额外的15个字节。

更新2：-25字节，感谢ErikF。

更新3：-1字节，感谢ceilingcat。

德戈尔夫

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字节

多亏了Adnan，节省了一个字节。
感谢Kevin Cruijssen保存了另一个字节。

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

在线尝试！

说明

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字节

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

在线尝试！

(n/15-2|0)*s<4首先保留83字节的解决方案（），因为我需要检查是否更大n。

更新：是的，(n/15-2|0)*s<4没有用，n因为n太大，因为足够大会使总和无法达到1000。

PHP，92字节

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

与管道一起运行-R或在线尝试。

干净，215字节

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

在线尝试！

所以，我终于找到了一个更短的方式来获得比进口随机种子System._Unsafe，System.Time并用toInt(accUnsafe time)...
和男孩是真心codegolf的精神-嵌入到C的呼叫时，忽视正常使用，保证了评价的世态型这样的事情的顺序。

的Java（JDK 10） ，121个 117 113 111字节

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

在线尝试！

它倾向于在顶部放置更多的蜡，但是从理论上讲，任何合法的蜡排列都可能出现。

编辑：@KevinCruijssen保存了4个字节

在人类可读的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，188162字节

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

在线尝试！

@Kevin Cruijssen -2字节-通过缩短 循环并删除空格
来删除可选的Get-verb
-20字节-4字节

帕斯卡（FPC），192190字节

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.

在线尝试！

用TFeld装箱装箱法。首先打印底行，后跟换行符。

FPC似乎没有问题random(0)，因此我在其中添加了一些异常内容。

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.

在线尝试！

木炭，37字节

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

在线尝试！链接是详细版本的代码。说明：

Ｆ²Ｆ²

循环两次，两次。或者，对于相同的字节数，我可以用整数将循环索引除以2。

‹³⁺ι÷Ｉθ¹⁵

如果外部指数加上温度的十五分之一大于三...

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

...然后将一个随机整数推至并包括1000-到目前为止的总和。不幸的是，木炭无法计算空列表的总和，因此我不得不替换为空字符串。

⊞υ⁻φΣυ

将剩余金额推入列表。

Ｅυ⎇ιＩιω

将列表转换为字符串，但使用空字符串而不是零。

果冻，28个字节

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

完整程序打印结果（允许的情况下，上下颠倒）。

在线尝试！-更改为使用，7而不是ȷ（1000），因为实现速度在高尔夫球运动上很慢！（...对于$n>59$ 的清单 $10^{15}$ 先创建5元组，然后过滤，然后从中选择）

怎么样？

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

嫩枝，126字节

这实际上是一个有趣的挑战！

这段代码创建了一个必须导入的宏。

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

要导入它，只需执行以下操作：

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

这应该可以解决问题。

您可以在https://twigfiddle.com/t4dfgy上尝试使用它。
注意：由于该页面删除了空格，我被迫-在行尾添加a ，以证明其输出的行数正确。

在常规安装中，您只会看到换行而没有问题。

Perl 6，62个字节

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

在线尝试！

匿名代码块，它接收一个字符串并返回一个整数列表，用Nil或空列表（[]）代替0s。

说明：

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

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

在线尝试！

@titus
-9个字节，因此-11个字节，因为一切都是字符串

J，^{56 55 54 48 43} 40字节

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

在线尝试！

-3字节归功于FrownyFrog

另一种在概念上不错的方法，该方法要长一些，但可以确保按照以下方法在所有可能性上实现完全均匀的分配：

J，53字节

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

在线尝试！

PowerShell中，115个 105 98字节

^{-17字节感谢mazzy}

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

在线尝试！

所述的高尔夫球Edwin的可爱答案。如果您喜欢这个，请给他投票。

红宝石，62 55字节

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

在线尝试！

测试限于0-99度，因为熔岩灯可能很危险在更高的温度下：