Calcule los puntos en un juego "sjoelen"

31

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.

Un _sjoelbak_ con _schijven_
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.

Charlie
fuente
¿La salida tiene que ser estándar o puede ser una función de retorno o el elemento restante que queda en la pila (para un lenguaje basado en pila)?
globby
@globby puede ser todo
Charlie
Creo que sjoelen es leuk!
Mark Knol
1
¿Hay un límite en el número de schijf en cada cuadro?
The_Basset_Hound
@BassetHound Obtienes 30 schijven por ronda, por lo que 30 en los 4 equivalen a 120 puntos. Es posible, pero no el mejor puntaje (7 en total = 140, + 2 en 4 = 148)
Charlie

Respuestas:

8

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í

Optimizador
fuente
Menos bytes (hasta ahora), aceptados. Gracias por la explicación.
Charlie
@ Charlie ¿Por qué aceptas una respuesta tan rápido? Es mejor esperar 1-2 semanas antes de aceptar una respuesta.
ProgramFOX
8

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

Codel tamaño 10, para una mejor visibilidad.

Piet: recuento de puntos sjoelen

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

ML
fuente
Una respuesta de Piet ^. ^
The_Basset_Hound
¡Por supuesto! Intento agregar respuestas de Piet siempre que sea manejable;)
ML
7

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}]&
kukac67
fuente
Tr[(# + Min@#) {2, 3, 4, 1}] &
swish
@swish ¡Qué listo!
kukac67
1
Esa es toda la función. No necesita agregar 20*Min@#, puede deshacerse de él reemplazando menos con más, porque convenientemente 2+3+4+1==10.
swish
@swish ¡Oh! Eso es aun mejor. Pero no puedo entender por qué eso funciona.
kukac67
2
@swish Bueno, gracias por toda la ayuda, pero deberías haber publicado tu propia respuesta. : D
kukac67
7

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.

plannapus
fuente
40 bytes:b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
Alex A.
5

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;
}
ProgramFOX
fuente
1
Use 10 con min, no es necesario restar (función s (a, b, c, d) {return 10 * Math.min (a, b, c, d) + a * 2 + b * 3 + c * 4 + d;})
edc65
1
Y en ES6:S=(a,b,c,d)=>10*Math.min(a,b,c,d)+a*2+b*3+c*4+d
edc65
@ edc65 Impresionante, gracias!
ProgramFOX
5

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.

isaacg
fuente
5

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')

randomra
fuente
¿Por qué no solo +/2 3 4 1*(+<./)?
swish
@swish Prefiero escribir funciones completas aunque no fue un requisito aquí. Publícalo / agrégalo si quieres.
randomra
¿Qué tal 2 3 4 1+/ .×]+<./?
Adám
4

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

Pomo de la puerta
fuente
Buena suerte con tu idioma, hasta ahora se ve bien;)
Charlie
4

Python 2, 43 bytes

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

Inspirado por la respuesta de @ user2487951.

isaacg
fuente
Buen algoritmo! Para un programa completo, también necesita entradas e imprimir declaraciones.
user2487951
1
@ user2487951 Uno de los medios de salida permitidos fue "return", por lo que si bien este no es un programa completo, es una respuesta válida.
isaacg
3

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
globby
fuente
La primera respuesta es aceptada, publicación editada para dejarlo claro
Charlie
@Optimizer punto tomado. Editado
globby
3

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.

orgulloso Haskeller
fuente
Buena solución Sin embargo, ..4*c+d..
3

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
zabalajka
fuente
1
Creo que generalmente se acepta alrededor de estas partes dejar caer f=2 bytes menos. La función se almacena en la ansvariable en su lugar.
BrainSteel
1
[2:4,1]eliminará 2 bytes si la entrada es un vector de columna.
Sanchises
2

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];
}
Charlie
fuente
2

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.

Ilmari Karonen
fuente
2

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)
usuario2487951
fuente
Si la entrada es [3,5,4,3], ¿devolverá 70?
Charlie
Sí, lo hace en ambos casos. Y devuelve 84 para [4,5,4,5].
usuario2487951
2

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
ML
fuente
2

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))
SuperJedi224
fuente
1

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.

Skycon
fuente
1

Haskell 42 caracteres

f l=10*minimum l+sum(zipWith(*)[2,3,4,1]l)
HEGX64
fuente
Codifique la suma expresamente: f l@[a,b,c,d]=10*minimum l+2*a+3*b+4*c+d- ahorra 2 caracteres
MtnViewMark
1

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:

Captura de pantalla HPPPL del programa de conteo de puntos sjoelen

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)
ML
fuente
1

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.

ML
fuente