Bien, ayer fue el segundo día de Navidad y mis (abuelos) padres y yo tuvimos un juego de "sjoelen", como se llama en los Países Bajos. El programador interno apareció en mí, pero justo cuando tuve la respuesta, la perdí. Quiero que lo vuelvas a hacer.

Las normas:

Tienes una tabla de madera, un sjoelbak , con 4 cajas, cada una con su propio número. Cuando un schijf (un objeto parecido a un disco) entra en una de las casillas, obtienes los puntos sobre esa casilla.

Cuando hay un schijf en las 4 casillas, no obtienes 10 pero obtienes 20 puntos.

Ejemplo:

De izquierda a derecha: 3 5 4 3
Cada cuadro tiene al menos 3 schijven (Plural de schijf ), por lo que es 20 * 3 = 60 puntos.

Valores resultantes: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 puntos.

Lo que hace un total de 60 + 10 = 70 puntos.

La entrada:
la cantidad de schijven de izquierda a derecha, es decir, "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", lo que quieras.

La salida:
la cantidad de puntos, es decir, 84, como salida, variable, retorno o en la parte superior de la pila, lo que quieras.

Como en todos y cada uno de los códigos de golf, no puede usar secuencias de comandos externas y el código con la menor cantidad de bytes gana.

PD: Como ya habrás notado, soy holandés. Siéntase libre de editar posibles errores gramaticales.

CJam, 23 21 20 bytes

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

Podría ser capaz de jugar un par de bytes de esto.

La entrada es como

[3 5 4 3]

La salida es el puntaje

70

Cómo funciona

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

Algoritmo

• Como he cambiado correctamente el número de schijven, el orden de puntuación ahora se convierte [1 2 3 4].
• Además, usando el hecho de que 1 + 2 + 3 + 4 = 10, simplemente agrego el mínimo común schijven a cada uno para obtener el efecto de la 10puntuación de bonificación .
• Ahora, cuando reduzco, obtengo 2 elementos inicialmente en la pila, el primero, que ignoro es el que tiene una puntuación de 1cada uno, luego multiplico el segundo con 2y lo agrego al primero. En la siguiente iteración, obtengo la suma actual y el puntaje 3schijven. Y así.

Pruébalo en línea aquí

Piet, 240 codeles (30 * 8), 138 que contienen código real

Codel tamaño 10, para una mejor visibilidad.

Ejemplos de prueba:

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

Pantalla de flujo:

Usando mi propia taquigrafía para un manejo más fácil y una pantalla compacta. Muestra el flujo general del programa, no las ubicaciones exactas de los códeles.

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

Explicación completa:

      (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

Guarde la imagen y pruébela en este intérprete en línea de Piet:

PietDev en línea Intérprete de Piet

APL (Dyalog Classic) , 16 13 12 bytes

-3 gracias a @ Adám

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

Pruébalo en línea!

⌽+⌊/ inversa (arg) + min (arg)

1⌽ rotar 1 a la izquierda

+\ sumas parciales

+/ suma

Mathematica, 38 32 23 20 bytes

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

(Con ayuda de swish )

Use al agregar la entrada al final:

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

70

Alternativo (36 bytes):

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

R, 41 40 caracteres

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

Uso:

> 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

En el último ejemplo, aes vector 3 5 4 3, a-bes 0 2 1 0, que multiplicamos con vector 2 3 4 1, dando 0 6 4 0lo que agregamos con 5*bdar 15 21 19 15( 5*bsiendo reciclado para cada miembro del vector agregado, por lo tanto, agregando efectivamente 4*5*b), que finalmente sumamos, dando así 70.

JavaScript (ES6), 93 47 bytes

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

Uso: s(1, 2, 3, 4)

Cómo funciona: la función busca el número más pequeño en los argumentos, y lo multiplica por 10(no con 20) y agrega el resto de la puntuación. No es necesario multiplicar 20y restar partes de la puntuación para continuar el cálculo.

¡Gracias a edc65 por compartir mejoras!

Sin golf:

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

Pyth , 15

sm*hd+@QtdhSQUQ

La entrada se debe dar separada por comas en STDIN, p. Ej.

3,5,4,3

Esto usa el mismo truco que muchas otras soluciones han usado, de agregar el mínimo a cada elemento para dar cuenta de la bonificación. El mínimo está hSQen el código anterior. Para tener en cuenta la multiplicación por 2, 3, 4 y 1, mapeo d sobre la lista [0,1,2,3], y multiplico el elemento (dl) th de la entrada por d + 1. Por lo tanto, el elemento -1 se multiplica por 1, el cero por 2, el primero por 3 y el segundo por 4. Luego sumo.

J, 23 22 caracteres

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

Ejemplo:

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

Pruébalo aquí.

(23 larga definición de función explícita: v=:3 :'+/+/\.3|.y+<./y')

Avestruz v0.1.0 , 48 41 caracteres _{^{(demasiado largo)}}

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

Esto es simplemente lo mismo que la versión anterior a continuación, excepto que en lugar de usar @para rotar toda la pila, )\+se usa en su lugar (descomprimir a la derecha).

Versión antigua:

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

De hecho, he descubierto dos errores en mi lenguaje recientemente implementado, anotado en la descripción a continuación. (Actualmente, el lenguaje es muy, muy similar a Golfscript, por lo que si conoce Golfscript debería ser bastante fácil de leer.

.$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)

Espera la entrada como una matriz en STDIN, porque soy un pomo y olvidé implementar E / S en v0.1.0.

Resolver un problema real en Avestruz es bueno, porque me muestra exactamente cuántas cosas más necesito agregar al idioma: D

Python 2, 43 bytes

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

Inspirado por la respuesta de @ user2487951.

Jagl Alpha 1.2 - 20 bytes

La entrada está en formato estándar (3 4 5 6), la salida se deja en la pila:

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

Esperando una respuesta del póster original sobre el formato de salida. Como la entrada se especifica como "lo que quieras" , voy a suponer que mi entrada puede ser una matriz en la parte superior de la pila. Ahora toma entrada en stdin.

Explicación:

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

Haskell, 40

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

en lugar de eliminar el número mínimo del resto y agregar más 20 s , esto agrega más 10para el número mínimo.

Matlab, 27

Me llevó un tiempo entender que es un juego para un jugador. Con la ayuda de la función anónima

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

que se invoca con el vector fila

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

Java, 84 bytes

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

Tengo la idea de que esto se puede jugar más, pero esto es todo por ahora.

Llamar con A(new int[]{3,5,4,3}), la salida se devuelve como int (porque System.out.println()duplicaría los bytes)

Sin golf

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 bytes

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

Lee la entrada de stdin, en el formato [3 5 4 3]. Escribe la salida en stdout. (Si se permite tomar la entrada como una matriz en la pila, ~se puede omitir el inicio para un total de 21 bytes).

Esto utiliza una estrategia algo diferente a las soluciones de CJam / Pyth / etc.: primero construyo una matriz con 2 copias del primer valor de entrada, 3 del segundo, 4 del tercero y uno del cuarto. Luego clasifico esta matriz, extraigo el elemento más pequeño, lo multiplico por 11 y lo sumo con los otros elementos.

Pitón 2, 51

Sin inspiración, pero corto:

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

Más pitónico:

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

Julia 48 35 caracteres

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

en forma de asignación compacta:

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

Ejemplo:

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

Javascript, 97 bytes

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

Quería ver cómo resultaría la recursión, y aunque definitivamente no es la respuesta más corta, sentí que resultó bien.

a*b*c*d: Toma los valores de entrada y encuentra el producto de todos ellos, y los evalúa como una expresión booleana para una instrucción if en línea. Esto devolverá falso si uno o más de los valores son 0, y verdadero para cualquier otro valor.

20+f(--a,--b,--c,--d): Si devuelve verdadero, la función devuelve 20 (para el conjunto schijven ) más la llamada recursiva de la función para todos los valores menos uno (Para eliminar ese conjunto schijven ). De esta manera, recorrerá recursivamente hasta que al menos uno de los cuadros esté vacío.

a*2+b*3+c*4+dDespués de que al menos un cuadro esté vacío, la otra parte de la instrucción if inline se ejecutará. Simplemente devuelve los puntos para el schijven restante en las cajas.

Así, al final, todos los conjuntos de schijven de 20 puntos , y los puntos restantes se resumen y devuelven de la función, produciendo la respuesta.

Haskell 42 caracteres

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

HPPPL (lenguaje de programación HP Prime), 58 57 bytes

El * entre 10 y min no es necesario, así que lo eliminé.

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

HPPPL es el lenguaje de programación para la calculadora gráfica de color HP Prime / CAS.

Ejecuciones de ejemplo:

Si no tiene que ser un programa, entonces es realizable en un 40 39 bytes de una línea:

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

Staq, 72 caracteres

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

Ejemplo de ejecución:

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

3
5
4
3
70

Execution complete.
>

Staq tiene dos pilas, una activa y otra pasiva. El |comando cambia la pila activa a pasiva y viceversa.

Todo entre llaves se define una función, la primera letra después de la llave de apertura es el nombre de la función, el resto hasta la llave de cierre es la función misma. Las funciones de anulación, recursión y funciones anidadas son posibles. {aii}definiría una función a que incrementaría la parte superior de la pila dos veces. Cada siguiente instancia de aen el código será reemplazada por ii.

Comentarios dentro de los programas de Staq: &agrega un cero en la parte superior de la pila, [indica al puntero que salte al correspondiente ]si la parte superior de la pila es cero, xelimina el valor más alto en la pila. Por lo tanto, los comentarios se pueden escribir en el código en forma de&[here is a comment]x

Explicación (también ejecutable):

'                                      &[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

El programa usa una pila (inicialmente activa) para calcular 2a + 3b + 4c + d, y la segunda pila (inicialmente pasiva) para calcular 10 veces el mínimo de los valores de entrada. Luego, ambos resultados se resumen y se muestran.

PowerShell para Windows , 48 47 bytes

^{-1 byte gracias a mazzy}

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

Pruébalo en línea!