好的，昨天是圣诞节的第二天，我和我的（祖父母）父母玩了一场名为“ sjoelen”的游戏，在荷兰被称为“ sjoelen”。内部程序员出现在我的脑海中，但是当我得到答案时，我就把它弄丢了。我要你重做。

规则：

您有一块木板，一个sjoelbak，有4个盒子，每个盒子都有自己的编号。当schijf（类似冰球的物体）进入其中一个框时，您会获得该框上方的分数。

当所有四个盒子中都有一个schijf时，您得不到10分，但得20分。

例：

从左至右：3 5 4 3
每个框具有至少3个schijven（复数的schijf），使得是20×3 = 60分。

结果值：0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10点。

总共60 + 10 = 70分。

输入：从左到右
的schijven量，即“ 4 5 4 5”，[4、5、4、5]，“ 4 \ n5 \ n4 \ n5”，无论您喜欢什么。

输出：
任意数量的点数，即84，作为输出，变量，返回或在堆栈顶部。

就像在每个代码中一样，您不能使用外部脚本，而字节数最少的代码将获胜。

PS：您可能已经注意到，我是荷兰人。随时编辑可能的语法错误。

CJam，23 21 20字节

q~_$0=f+1m>{X):X*+}*

我也许可以打几个字节。

输入就像

[3 5 4 3]

输出是分数

70

怎么运行的

q~                         "Read the input and evaluate into an array";
  _$0=                     "Copy the array, sort it and get the minimum number";
                           "This minimum is the number of common schijven";
      f+                   "Increment each of the schijven by the common schijven number"; 
        1m>                "Take 1 element from the end of the array and put";
                           "it in the beginning";
           {      }*       "Reduce the elements of the array based on this block";
            X):X           "Increment and update the value of X (initially 1)";
                *          "Multiply the number of schijven with X";
                 +         "Add it to current score";

算法

• 由于我已经右移了schijven的数量，所以分数顺序变为[1 2 3 4]。
• 而且，利用的事实1 + 2 + 3 + 4 = 10，我只需将最小的通用schijven加到每个schijven上，即可获得奖金10积分的效果。
• 现在，当我减少时，我最初将2个元素放在堆栈中，第一个元素，我忽略的是1每个元素都有分数的元素，然后将第二个元素与之相乘2并将其加到第一个元素上。在下一个迭代中，我得到当前的总和和分数3schijven。等等。

在这里在线尝试

Piet，240（30 * 8）个编解码器，包含实际代码的138

Codel大小10，以提高可见度

测试示例：

D:\codegolf\npiet-1.3a-win32>npiet sjoelen_point_count_cs10.png
? 3
? 5
? 4
? 3
70
D:\codegolf\npiet-1.3a-win32>npiet sjoelen_point_count_cs10.png
? 4
? 5
? 4
? 5
84

流量显示：

使用我自己的简写，以便于处理和紧凑显示。它显示了一般的程序流程，而不是代码的确切位置。

NOP ADD DIV GRT DUP INC END
 0   +   /   >   =   c   ~
PSH SUB MOD PTR ROL OUN
 X   -   %   #   @   N
POP MUL NOT SWI INN OUC
 ?   *   !   $   n   C

1X!nnnn=5X2X@=5X2X@=5X2X@=5X1X@**
       0                        *
       0       @+5X1X@1X-4X1X@  !
       0       -             0  !
       0       X1!X1X6+*==X40000#  <--pointer if top of stack=1 (all boxes full,
       0                     0  2      add 20 points, decrement count for all boxes)
       0000-X1@X1X2-X1@X1X3-X1  X  |  pointer if top of stack=0 (not all boxes full,
                                *  V   add 2a+3b+4c+d)
           ~N++++*X4@X2X3*X3@X1X2

完整说明：

      (score=0)  a   b   c   d
      1 PSH NOT INN INN INN INN

      ..... sort and duplicate the numbers .....
**1** DUP 5 PSH 2 PSH ROL DUP 5 PSH 2 PSH ROL DUP 5 PSH 2 PSH ROL DUP 5 PSH 1 PSH ROL

      ( a*b*c*d ) (convert to boolean) 1 if all boxes are full, 0 if at least one box is empty
      MUL MUL MUL NOT NOT

      change direction if 1 (**2**)
      go straight ahead if 0 (**3**)
      PTR

      ( compress 20=4*4+4 )       (0-1=-1/ neg. roll) score+20
**2** 4 PSH DUP DUP MUL ADD 6 PSH 1 PSH NOT 1 PSH SUB ROL ADD

      (put score back to bottom of stack) ... a=a-1, b=b-1, c=c-1, d=d-1 ...
      5 PSH 1 PSH ROL 1 PSH SUB 4 PSH 1 PSH ROL 1 PSH SUB 3 PSH
      1 PSH ROL 1 PSH SUB 2 PSH 1 PSH ROL 1 PSH SUB

      loop to **1**

      (   a*2   )               (   b*3   )               (  c*4  )
**3** 2 PSH MUL 2 PSH 1 PSH ROL 3 PSH MUL 3 PSH 2 PSH ROL 4 PSH MUL

      +2a +3b +d +score
      ADD ADD ADD ADD

      output score
      OUN

保存图像并在此在线Piet解释器中进行尝试：

PietDev在线Piet口译员

APL（Dyalog Classic），16 13 12字节

-3感谢@Adám

(+/+\)1⌽⌽+⌊/

在线尝试！

⌽+⌊/ 反向（arg）+最小（arg）

1⌽ 向左旋转1

+\ 部分和

+/ 和

Mathematica，38 32 23 20字节

(#+Min@#).{2,3,4,1}&

（在swish的帮助下）

通过将输入附加到末尾来使用：

(#+Min@#).{2,3,4,1}&@{3,5,4,3}

70

备用（36个字节）：

20*Min@#+Total[(#-Min@#)*{2,3,4,1}]&

R，41 40个字符

b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))

用法：

> b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
1: 4 5 4 5
5: 
Read 4 items
[1] 84
> b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
1: 3 5 4 3
5: 
Read 4 items
[1] 70

在最后一个示例中，ais vector 3 5 4 3，a-bis 0 2 1 0，我们将其与vector相乘，2 3 4 1从而得到给定的值0 6 4 0，然后再给定5*b给定值15 21 19 15（5*b被累加到所添加vector的每个成员中，从而有效地相加4*5*b），最后求和，从而得出给定70。

JavaScript（ES6），93 47字节

s=(a,b,c,d)=>10*Math.min(a,b,c,d)+a*2+b*3+c*4+d

用法： s(1, 2, 3, 4)

工作原理：该函数在参数中寻找最小的数字，然后将其乘以10（而不是20），然后加上其余的分数。不必乘以20分数并减去分数即可继续计算。

感谢edc65分享改进！

未打高尔夫球：

function score(a, b, c, d) {
    return 10 * Math.min(a, b, c, d) + a * 2 + b * 3 + c * 4 + d;
}

珀斯 15

sm*hd+@QtdhSQUQ

输入应在STDIN上用逗号分隔，例如

3,5,4,3

这使用了许多其他解决方案所使用的相同技巧，即在每个元素中增加最小值以说明奖金。最小值hSQ在上面的代码中。为了考虑乘以2、3、4和1，我将d映射到列表[0,1,2,3]，然后将输入的第（dl）个元素乘以d + 1。因此，第-1个元素乘以1，第0个元素乘以2，第一个元素乘以3，第二个元素乘以4。然后求和。

J，23 22个字符

   (+/ .*&2 3 4 1@(+<./))

例：

   test =. 3 5 4 3
   (+/ .*&2 3 4 1@(+<./)) test
70

在这里尝试。

（23长期明确的功能定义：v=:3 :'+/+/\.3|.y+<./y'）

鸵鸟v0.1.0，48 41个字符_{^{（的时间太长）}}

.$0={}/:n;{n-}%)\+1:i;{i*i):i;}%{+}*20n*+

这与下面的旧版本完全相同，除了使用（right uncons）而不是@旋转整个堆栈)\+。

旧版：

.$0={}/:n;{n-}%{}/{4@}3*1:i;]{i*i):i;}%{+}*20n*+

我实际上在我的新实现语言中发现了两个错误，在以下描述中进行了注释。（该语言目前与Golfscript非常非常相似，因此，如果您知道Golfscript，它应该很容易阅读。

.$0=   get min value (for the *20 thingy)
{}/    *actually* get min value (BUG: `array number =' returns a single-element array...)
:n;    store as n
{n-}%  subtract this value from all array elements
{}/    dump array onto stack
{4@}3* rotate stack so that instead of 2 3 4 1, multipliers are 1 2 3 4
       (BUG: negative rotations don't work)
1:i;   set i (the multiplier) to 1
]{i*   multiply each array element by i
i):i;  increment i
}%     (do the previous 2 lines over each array element)
{+}*   add up all the array elements
20n*+  add 20*n (the min value we got in line 1)

期望将输入作为STDIN上的数组输入，因为我是门把手，却忘记了在v0.1.0中实现I / O。

在Ostrich解决一个实际问题很好，因为它向我展示了我到底需要向语言添加多少东西：D

Python 2，43个字节

lambda i:i[1]-i[3]+2*(sum(i)+i[2]+5*min(i))

受@ user2487951的答案启发。

Jagl Alpha 1.2-20字节

输入格式为标准输入(3 4 5 6)，输出保留在堆栈中：

T~dqZ*S1 5r]%{U*}/b+

等待原始海报关于输出格式的响应。由于输入被指定为“随心所欲”，因此我将假设我的输入可以是堆栈顶部的数组。现在接受标准输入。

说明：

T~                            Get input from stdin and evaluate
  dqZ*                      Duplicate, get minimum, and multiply that by 10
      S1 5r]                Swap (so array is on top), push range 1-5 exclusive, and rotate
            %{U*}/          Zip arrays together, and multiply each pair
                  b+P       Get the sum of that, add the common minimum, and print

哈斯克尔，40岁

g l@[a,b,c,d]=2*a+3*b+4*c+d+10*minimum l

而不是从其余部分中删除最小数目并添加其他20s，而是为最小数目增加了其他10数目。

Matlab，27岁

花了我一段时间才了解这是单人游戏。借助匿名功能

f=@(N)N*[2;3;4;1]+10*min(N)

用行向量调用

f([3 5 4 3]) == 70
f([7 7 9 7]) == 148

Java，84个字节

int A(int[]a){int m=9;for(int i:a)m=i<m?i:m;return 10*m+a[3]+2*a[0]+3*a[1]+4*a[2];}

我认为这可以继续进行下去，但是目前为止。

用调用A(new int[]{3,5,4,3})，输出以int返回（因为System.out.println()这将使字节增加一倍）

不打高尔夫球

int getScore(int[] input){
    int min=9;

    for(int x:input) {
        if(x<min){
            min=x;
        }
    }

    return 10*min + 2*input[0] + 3*input[1] + 4*input[2] + 1*input[3];
}

GolfScript，22个字节

~3,{1$>~;}%+$(11*+{+}*

从stdin读取输入，格式为[3 5 4 3]。将输出写入stdout。（如果允许将输入作为堆栈上的数组，则~可以省略前导，总共21个字节。）

这使用了与CJam / Pyth等解决方案略有不同的策略：我首先构建一个数组，其中包含第一个输入值的2个副本，第二个输入值的3个，第三个输入值的4个和第四个输入值的四个。然后，我对该数组进行排序，取出最小的元素，将其乘以11，然后将其与其他元素相加。

Python 2，51

不受启发，但简短：

l=input()
print l[0]*2+l[1]*3+l[2]*4+l[3]+10*min(l)

更多pythonic：

l=input()
print sum(map(lambda x,y:x*y,l,[2,3,4,1]))+10*min(l)

朱莉娅 48 35个字符

function p(m);sum([2 3 4 1].*m)+10minimum(m);end

紧凑分配形式：

p(m)=sum([2 3 4 1].*m)+10minimum(m)

例：

julia> p([3 5 4 3])
70

Javascript，97个字节

a=prompt().split(" "),b=Math.min.apply(1,a);alert(20*b+2*(a[0]-b)+3*(a[1]-b)+4*(a[2]-b)+(a[3]-b))

Javascript，ES6、57

f=(a,b,c,d)=>a*b*c*d?20+f(--a,--b,--c,--d):a*2+b*3+c*4+d

我想看看递归结果如何，虽然绝对不是最短的答案，但我觉得结果很好。

a*b*c*d：它采用输入值并找到所有值的乘积，并将其作为内联if语句的布尔表达式求值。如果一个或多个值是0，则返回false；对于其他任何值，则返回true。

20+f(--a,--b,--c,--d)：如果返回true，则该函数将返回20（对于schijven集），然后对该函数的递归调用将减去所有值减一（删除该schijven集）。这样，它将递归循环，直到至少一个框为空。

a*2+b*3+c*4+d在至少一个框为空之后，将运行内联if语句的else部分。它只返回框中剩余的schijven的积分。

因此，最后将所有20个点的schijven集和剩余的点求和并从函数中返回，从而得出答案。

Haskell 42个字符

f l=10*minimum l+sum(zipWith(*)[2,3,4,1]l)

HPPPL（HP Prime编程语言）， 58 57个字节

*不需要介于10和min之间的*，因此我将其删除。

EXPORT s(m)
BEGIN
return sum([2,3,4,1].*m)+10min(m);
END;

HPPPL是HP Prime彩色图形计算器/ CAS的编程语言。

示例运行：

如果不必一定是程序，那么就可以在 40 39字节单行代码：

m:=[3,5,4,3];sum([2,3,4,1].*m)+10min(m)

Staq，72个字符

't't't't{aii*XX}$&iia$&ia$&a+XX+XX+|{mxx}{lxX}{k>?m!l}kkk&iiqi&ii*s*t|+:

示例运行：

Executing D:\codegolf\Staq\sjoelen codegolf.txt

3
5
4
3
70

Execution complete.
>

Staq有两个堆栈，一个为主动，一个为被动。该|命令将主动堆栈切换为被动堆栈，反之亦然。

花括号之间的所有内容都定义了一个函数，左括号之后的第一个字母是函数名称，直到右括号之前的其余字母都是函数本身。可以覆盖函数，递归和嵌套函数。{aii}将定义一个函数a，该函数将增加堆栈顶部两次。a代码中的以下所有实例都将替换为ii。

Staq prorams 内部的注释： &在堆栈顶部添加零，如果堆栈顶部为零，则[指示指针跳转到相应的指针]，x删除堆栈上的最高值。因此，注释可以以以下形式写入代码&[here is a comment]x

说明（也是可执行的）：

'                                      &[input number]x
 t                                     &[copy top of active stack to passive stack]x
  t't't                                &[input next three numbers and copy them to the passive stack]x
       {aii*XX}                        &[define function a (increment twice, multiply the two topmost values, then delete the second value on the stack twice)]x
               $                       &[move top value to the bottom of the stack]x
                &ii                    &[put zero on top of the stack, incremment twice]x
                   a                   &[function a]x
                    $&ia$&a
                           +           &[put sum of the two topmost values on top of the stack]x
                            XX         &[delete second stack value, twice]x
                              +XX+
                                  |    &[switch active/passive stack]x
{mxx}                                  &[define function m: delete two topmost stack values]x
     {lxX}                             &[define function l: delete topmost stack value, then delete second value of remaining stack]x
          {k>?m!l}                     &[define function k: boolean top > second value? put result on top of the stack, if top>0 then execute m, if top = 0 then execute l]x
                  kkk&ii
                        q              &[put square of top value on top of the stack]x
                         i&ii
                             *         &[multiply two topmost values and put result on top of the stack]x
                              s        &[move bottom stack value to the top]x
                               *t|+
                                   :   &[output result]x

https://esolangs.org/wiki/Staq

该程序使用一个堆栈（最初是主动的）来计算2a + 3b + 4c + d，使用第二个堆栈（最初是被动的）来计算最小输入值的10倍。然后将两个结果汇总并显示。

Windows PowerShell，48 47字节

^{-1字节感谢mazzy}

$args|%{$a+=++$i%4*$_+$_}
$a+10*($args|sort)[0]

在线尝试！