D'accord, hier était donc le 2ème jour de Noël et mes (grands) parents et moi avons fait une partie de "sjoelen", comme on l'appelle aux Pays-Bas. Le programmeur interne est venu en moi, mais juste au moment où j'ai eu la réponse, je l'ai perdue. Je veux que tu le refasses.

Les règles:

Vous avez une planche en bois, un sjoelbak , avec 4 boîtes, chacune avec son propre numéro. Lorsqu'un schijf (un objet ressemblant à une rondelle) entre dans l'une des cases, vous obtenez les points au-dessus de cette case.

Quand il y a un schijf dans les 4 cases, vous n'obtenez pas 10 mais vous obtenez 20 points.

Exemple:

De gauche à droite: 3 5 4 3
Chaque case a au moins 3 schijven (Pluriel de schijf ) soit 20 * 3 = 60 points.

Valeurs résultantes: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 points.

Ce qui fait un total de 60 + 10 = 70 points.

L'entrée:
la quantité de schijven de gauche à droite, c'est-à-dire "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", comme vous voulez.

La sortie:
Le nombre de points, soit 84, comme sortie, variable, retour ou au sommet de la pile, comme vous voulez.

Comme dans chaque golf de code, vous ne pouvez pas utiliser de scripts externes et le code avec le moins d'octets gagne.

PS: Comme vous l'avez peut-être déjà remarqué, je suis néerlandais. N'hésitez pas à modifier les éventuelles erreurs de grammaire.

CJam, 23 21 20 octets

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

Je pourrais peut-être jouer au golf à quelques octets.

L'entrée est comme

[3 5 4 3]

La sortie est le score

70

Comment ça marche

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

Algorithme

• Puisque j'ai décalé à droite le nombre de schijven, l'ordre des scores devient maintenant [1 2 3 4].
• De plus, en utilisant le fait que 1 + 2 + 3 + 4 = 10, j'ajoute simplement le schijven commun minimum à chacun pour obtenir l'effet du 10score bonus .
• Maintenant, quand je réduis, j'obtiens initialement 2 éléments sur la pile, le premier, que j'ignore est celui avec un score de 1chacun, puis je multiplie le second avec 2et je l'ajoute au premier. Dans l'itération suivante, j'obtiens la somme actuelle et 3je marque schijven. Etc.

Essayez-le en ligne ici

Piet, 240 (30 * 8) codels, 138 contenant le code réel

Codel taille 10, pour une meilleure visibilité

Exemples de tests:

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

Affichage du débit:

Utiliser ma propre sténographie pour une manipulation plus facile et un affichage compact. Il montre le déroulement général du programme, pas les emplacements exacts des codels.

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

Explication complète:

      (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

Enregistrez l'image et essayez-la dans cet interprète Piet en ligne:

Interprète PietDev en ligne Piet

APL (Dyalog Classic) , 16 13 12 octets

-3 grâce à @ Adám

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

Essayez-le en ligne!

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

1⌽ tourner 1 vers la gauche

+\ sommes partielles

+/ somme

Mathematica, 38 32 23 20 octets

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

(Avec l'aide de swish )

Utilisez en collant l'entrée jusqu'à la fin:

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

70

Alternatif (36 octets):

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

R, 41 40 caractères

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

Usage:

> 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

Dans le dernier exemple, aest vecteur 3 5 4 3, a-best 0 2 1 0, que nous multiplions par vecteur 2 3 4 1donnant ainsi 0 6 4 0que nous ajoutons par 5*bdonner 15 21 19 15( 5*bétant recyclé pour chaque membre du vecteur ajouté, donc en ajoutant effectivement 4*5*b), que nous additionnons finalement, donnant ainsi 70.

JavaScript (ES6), 93 47 octets

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

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

Comment ça marche: la fonction recherche le plus petit nombre dans les arguments, et multiplie cela par 10(pas avec 20) et ajoute le reste du score. Il n'est pas nécessaire de multiplier 20et de soustraire des parties de la partition pour continuer le calcul.

Merci à edc65 pour partager les améliorations!

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

Les entrées doivent être séparées par une virgule sur STDIN, par exemple

3,5,4,3

Cela utilise la même astuce que de nombreuses autres solutions ont utilisé, d'ajouter le minimum à chaque élément pour tenir compte du bonus. Le minimum est hSQdans le code ci-dessus. Pour tenir compte de la multiplication par 2, 3, 4 et 1, je mappe d sur la liste [0,1,2,3] et multiplie le (dl) e élément de l'entrée par d + 1. Ainsi, le -1ème élément est multiplié par 1, le zéro par 2, le premier par 3 et le second par 4. Alors je résume.

J, 23 22 caractères

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

Exemple:

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

Essayez ici.

(23 longue définition de fonction explicite: v=:3 :'+/+/\.3|.y+<./y')

Autruche v0.1.0 , 48 41 caractères _{^{(beaucoup trop long)}}

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

C'est tout simplement la même chose que l'ancienne version ci-dessous, sauf qu'au lieu d'utiliser @pour faire pivoter la pile entière, )\+(à droite) est utilisé à la place.

Ancienne version:

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

J'ai en fait découvert deux bugs dans mon tout nouveau langage implémenté, annotés dans la description ci-dessous. (Le langage est actuellement très, très similaire à Golfscript, donc si vous connaissez Golfscript, il devrait être assez facile à lire.

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

Attend l'entrée en tant que tableau sur STDIN, car je suis une poignée de porte et j'ai oublié d'implémenter les E / S dans la version 0.1.0.

Résoudre un problème réel dans Ostrich est bien, car cela me montre exactement combien de choses supplémentaires je dois ajouter à la langue: D

Python 2, 43 octets

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

Inspiré par la réponse de @ user2487951.

Jagl Alpha 1.2 - 20 octets

L'entrée est au format stdin (3 4 5 6), la sortie est laissée sur la pile:

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

En attente d'une réponse de l'affiche originale sur le format de sortie. Puisque l'entrée est spécifiée comme "ce que vous voulez" , je vais supposer que mon entrée peut être un tableau en haut de la pile. Prend maintenant une entrée sur stdin.

Explication:

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

au lieu de supprimer le nombre minimum du reste et d'ajouter des 20s supplémentaires , cela ajoute supplémentaire 10pour le nombre minimum.

Matlab, 27

Il m'a fallu un certain temps pour comprendre qu'il s'agissait d'un jeu solo. Avec l'aide de la fonction anonyme

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

qui est invoqué avec le vecteur ligne

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

Java, 84 octets

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

J'ai l'idée que cela peut être joué plus loin, mais c'est tout pour l'instant.

Appelez avec A(new int[]{3,5,4,3}), la sortie est retournée en tant qu'int (car System.out.println()doublerait les octets)

Ungolfed

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 octets

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

Lit l'entrée de stdin, au format [3 5 4 3]. Écrit la sortie dans stdout. (Si la prise de l'entrée en tant que tableau sur la pile est autorisée, l'interlignage ~peut être omis pour un total de 21 octets.)

Cela utilise une stratégie quelque peu différente de celle des solutions CJam / Pyth / etc.: je construis d'abord un tableau avec 2 copies de la première valeur d'entrée, 3 de la seconde, 4 de la troisième et une de la quatrième. Ensuite, je trie ce tableau, je retire le plus petit élément, le multiplie par 11 et le additionne avec les autres éléments.

Python 2, 51

Inspiré, mais court:

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

Plus pythonique:

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

Julia, 48 35 caractères

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

sous forme compacte de cession:

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

Exemple:

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

Javascript, 97 octets

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

Je voulais voir comment la récursion se passerait, et bien que ce ne soit certainement pas la réponse la plus courte, j'avais l'impression que cela s'était bien passé.

a*b*c*d: Il prend les valeurs d'entrée et trouve le produit de chacune d'entre elles, et l'évalue comme une expression booléenne pour une instruction if en ligne. Cela retournera false si une ou plusieurs des valeurs est 0, et vrai pour toute autre valeur.

20+f(--a,--b,--c,--d): S'il renvoie vrai, la fonction renvoie 20 (pour l' ensemble schijven ) plus l'appel récursif de la fonction pour toutes les valeurs moins un (pour supprimer cet ensemble schijven ). De cette façon, il bouclera récursivement jusqu'à ce qu'au moins une des cases soit vide.

a*2+b*3+c*4+dAprès au moins une case vide, la partie else de l'instruction inline if s'exécutera. Il renvoie simplement les points pour le schijven restant dans les cases.

Ainsi, à la fin, tous les ensembles de 20 points de Schijven , et les points de renvoi sont résumés et renvoyés par la fonction, produisant la réponse.

Haskell 42 caractères

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

HPPPL (HP Prime Programming Language), 58 57 octets

Le * entre 10 et min n'est pas nécessaire, je l'ai donc supprimé.

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

HPPPL est le langage de programmation pour la calculatrice graphique couleur HP Prime / CAS.

Exemple fonctionne:

S'il ne doit pas nécessairement s'agir d'un programme, il est réalisable dans un 40 39 octets à une ligne:

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

Staq, 72 caractères

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

Exemple d'exécution:

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

3
5
4
3
70

Execution complete.
>

Staq a deux piles, une active et une passive. La |commande bascule la pile active sur passive et vice versa.

Tout entre les accolades définit une fonction, la première lettre après l'accolade ouvrante est le nom de la fonction, le reste jusqu'à l'accolade fermante est la fonction elle-même. Les fonctions écrasantes, récursives et imbriquées sont possibles. {aii}définirait une fonction a qui incrémenterait le haut de la pile deux fois. Chaque instance suivante de adans le code sera remplacée par ii.

Commentaires à l'intérieur des prorams Staq: &ajoute un zéro en haut de la pile, [demande au pointeur de passer au correspondant ]si le haut de la pile est nul, xsupprime la valeur la plus élevée de la pile. Ainsi, les commentaires peuvent être écrits dans le code sous la forme de&[here is a comment]x

Explication (également exécutable):

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

Le programme utilise une pile (initialement active) pour calculer 2a + 3b + 4c + d, et la deuxième pile (initialement passive) pour calculer 10 fois le minimum des valeurs d'entrée. Les deux résultats sont ensuite résumés et affichés.

PowerShell pour Windows , 48 47 octets

^{-1 octet grâce à mazzy}

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

Essayez-le en ligne!