Okay, quindi ieri è stato il 2 ° giorno di Natale e io e i miei (nonni) genitori abbiamo fatto una partita a "sjoelen", come si chiama nei Paesi Bassi. Il programmatore interiore è venuto in me, ma proprio quando ho avuto la risposta, l'ho persa. Voglio che lo rifai.

Le regole:

Hai una tavola di legno, un sjoelbak , con 4 scatole, ognuna con il proprio numero. Quando uno schijf (un oggetto simile a un disco) va in una delle caselle si ottengono i punti sopra quella casella.

Quando c'è uno schijf in tutte e 4 le caselle, non ottieni 10 ma ottieni 20 punti.

Esempio:

Da sinistra a destra: 3 5 4 3
Ogni casella ha almeno 3 schijven (plurale di schijf ) in modo che sia 20 * 3 = 60 punti.

Valori risultanti: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 punti.

Il che fa un totale di 60 + 10 = 70 punti.

L'input:
la quantità di schijven da sinistra a destra, ovvero "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", qualunque cosa tu voglia.

L'output:
la quantità di punti, ovvero 84, come output, variabile, return o in cima allo stack, qualunque cosa tu voglia.

Come in ogni codice golf, non è possibile utilizzare script esterni e il codice con il minor numero di byte vince.

PS: Come avrai già notato, sono olandese. Sentiti libero di modificare i possibili errori grammaticali.

CJam, 23 21 20 byte

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

Potrei essere in grado di giocare a golf a un paio di byte da questo.

L'input è come

[3 5 4 3]

L'output è il punteggio

70

Come funziona

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

• Da quando ho spostato il numero di schijven, l'ordine del punteggio ora diventa [1 2 3 4].
• Inoltre, utilizzando il fatto che 1 + 2 + 3 + 4 = 10, aggiungo semplicemente il minimo comune schijven a ciascuno per ottenere l'effetto del 10punteggio bonus .
• Ora, quando riduco, ottengo 2 elementi inizialmente in pila, il primo, che ignoro è quello con un punteggio di 1ciascuno, quindi moltiplico il secondo con 2e lo aggiungo al primo. Nella prossima iterazione, ottengo la somma e il punteggio 3attuali schijven. E così via.

Provalo online qui

Piet, 240 (30 * 8) codici, 138 contenenti il ​​codice attuale

Dimensione del codice 10, per una migliore visibilità

Esempi di test:

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

Visualizzazione del flusso:

Uso della mia stenografia per una gestione più semplice e un display compatto. Mostra il flusso generale del programma, non le posizioni esatte dei codici.

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

Spiegazione 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

Salva l'immagine e provala in questo interprete Piet online:

Interprete PietDev online

APL (Dyalog Classic) , 16 13 12 byte

-3 grazie a @ Adám

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

Provalo online!

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

1⌽ ruota 1 a sinistra

+\ somme parziali

+/ somma

Mathematica, 38 32 23 20 byte

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

(Con l'aiuto di Swish )

Utilizzare virando all'input fino alla fine:

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

70

Alternativo (36 byte):

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

R, 41 40 caratteri

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

Nell'ultimo esempio, aè vettore 3 5 4 3, a-bè 0 2 1 0, che moltiplichiamo con il vettore 2 3 4 1dando così 0 6 4 0ciò che aggiungiamo con il 5*bdare 15 21 19 15( 5*bessendo riciclato per ogni membro del vettore aggiunto, quindi aggiungendo effettivamente 4*5*b), che infine sommiamo, dando così 70.

JavaScript (ES6), 93 47 byte

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)

Come funziona: la funzione cerca il numero più piccolo negli argomenti e lo moltiplica per 10(non con 20) e aggiunge il resto del punteggio. Non è necessario moltiplicare 20e sottrarre parti dal punteggio per continuare il calcolo.

Grazie a edc65 per la condivisione dei miglioramenti!

Un-giocato a 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

All'input deve essere data la virgola separata su STDIN, ad es

3,5,4,3

Questo utilizza lo stesso trucco utilizzato da molte altre soluzioni, ovvero l'aggiunta del minimo a ciascun elemento per tenere conto del bonus. Il minimo è hSQnel codice sopra. Per tenere conto della moltiplicazione per 2, 3, 4 e 1, mappo d sull'elenco [0,1,2,3] e moltiplico l'elemento (dl) th dell'input per d + 1. Pertanto, l'1 ° elemento viene moltiplicato per 1, lo zeroth per 2, il primo per 3 e il secondo per 4. Quindi riassumo.

J, 23 22 caratteri

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

Esempio:

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

Provalo qui.

(23 lungo definizione di funzione esplicito: v=:3 :'+/+/\.3|.y+<./y')

Struzzo v0.1.0 , 48 41 caratteri _{^{(troppo lungo)}}

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

Questo è semplicemente lo stesso della versione precedente qui sotto, tranne per il fatto che invece di usare @per ruotare l'intero stack, )\+viene usato (uncons destro).

Vecchia versione:

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

In realtà ho scoperto due bug nella mia lingua implementata di recente, annotati nella descrizione qui sotto. (La lingua è attualmente molto, molto simile a Golfscript, quindi se conosci Golfscript dovrebbe essere abbastanza facile da leggere.

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

Si aspetta input come array su STDIN, perché sono un doorknob e ho dimenticato di implementare l'I / O in v0.1.0.

Risolvere un problema reale in Struzzo è bello, perché mi mostra esattamente quante altre cose devo aggiungere alla lingua: D

Python 2, 43 byte

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

Ispirato dalla risposta di @ user2487951.

Jagl Alpha 1,2 - 20 byte

L'input è in formato stdin (3 4 5 6), l'output viene lasciato nello stack:

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

In attesa di una risposta dal poster originale sul formato di output. Dato che l'input è specificato come "qualunque cosa ti piaccia" , suppongo che il mio input possa essere un array in cima allo stack. Ora accetta input su stdin.

Spiegazione:

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 anni

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

invece di rimuovere il numero minimo dal resto e aggiungere ulteriori 20s, questo aggiunge ulteriore 10per il numero minimo.

Matlab, 27

Mi ci è voluto un po 'per capire che si tratta di un gioco per giocatore singolo. Con l'aiuto di una funzione anonima

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

che viene invocato con il vettore riga

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

Java, 84 byte

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

Ho l'idea che si possa giocare ancora a golf, ma questo è tutto per ora.

Chiama con A(new int[]{3,5,4,3}), l'output viene restituito come int (Perché System.out.println()raddoppierebbe i byte)

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 byte

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

Legge l'input da stdin, nel formato [3 5 4 3]. Scrive l'output su stdout. (Se è consentito accettare l'input come un array nello stack, il lead ~può essere omesso per un totale di 21 byte.)

Questo utilizza una strategia in qualche modo diversa rispetto alle soluzioni CJam / Pyth / ecc.: Per prima cosa costruisco un array con 2 copie del primo valore di input, 3 del secondo, 4 del terzo e uno del quarto. Quindi ordino questo array, estraggo l'elemento più piccolo, lo moltiplico per 11 e lo somma con gli altri elementi.

Python 2, 51

Non ispirato, ma breve:

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

Più pitonico:

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

Julia, 48 35 caratteri

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

in forma compatta:

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

Esempio:

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

Javascript, 97 byte

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

Volevo vedere come sarebbe risultata la ricorsione e, sebbene non sia sicuramente la risposta più breve, mi è sembrato che fosse andata bene.

a*b*c*d: Accetta i valori di input e trova il prodotto di tutti loro e lo valuta come espressione booleana per un'istruzione if inline. Ciò restituirà false se uno o più dei valori è 0 e vero per qualsiasi altro valore.

20+f(--a,--b,--c,--d): Se restituisce true, la funzione restituisce 20 (per il set schijven ) più la chiamata ricorsiva della funzione per tutti i valori meno uno (per rimuovere quel set schijven ). In questo modo si ripeterà in modo ricorsivo fino a quando almeno una delle caselle è vuota.

a*2+b*3+c*4+dDopo almeno una casella vuota, l'altra parte dell'istruzione if inline verrà eseguita. Restituisce solo i punti per il rimanente schijven nelle caselle.

Quindi, alla fine, tutti i 20 punti schijven vengono impostati e i punti di richiamo vengono sommati e restituiti dalla funzione, producendo la risposta.

Haskell 42 caratteri

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

HPPPL (HP Prime Programming Language), 58 57 byte

Il * tra 10 e min non è necessario, quindi l'ho rimosso.

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

HPPPL è il linguaggio di programmazione per la calcolatrice grafica / CAS HP Prime a colori.

Esempi di esecuzione:

Se non deve essere un programma, è realizzabile in a 40 39 byte a linea singola:

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

Staq, 72 caratteri

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

Esempio di esecuzione:

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

3
5
4
3
70

Execution complete.
>

Staq ha due pile, una attiva e una passiva. Il |comando imposta lo stack attivo su passivo e viceversa.

Tutto tra parentesi graffe definisce una funzione, la prima lettera dopo la parentesi graffa di apertura è il nome della funzione, il resto fino a quando la parentesi graffa di chiusura è la funzione stessa. Sono possibili funzioni di override, ricorsione e nidificate. {aii}definirebbe una funzione a che aumenterebbe due volte la parte superiore dello stack. Ogni seguente istanza di anel codice verrà sostituita da ii.

Commenti all'interno dei proram di Staq: &aggiunge uno zero in cima allo stack, [indica al puntatore di saltare al corrispondente ]se la parte superiore dello stack è zero, xelimina il valore più alto nello stack. Quindi, i commenti possono essere scritti nel codice sotto forma di&[here is a comment]x

Spiegazione (anche eseguibile):

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

Il programma utilizza uno stack (inizialmente attivo) per calcolare 2a + 3b + 4c + d e il secondo stack (inizialmente passivo) per calcolare 10 volte il minimo dei valori di input. Quindi entrambi i risultati vengono riassunti e visualizzati.

PowerShell per Windows , 48 47 byte

^{-1 byte grazie a mazzy}

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

Provalo online!