Okay, gestern war der 2. Weihnachtstag und meine (Groß-) Eltern und ich spielten "Sjoelen", wie es in den Niederlanden heißt. Der innere Programmierer kam auf mich zu, aber als ich die Antwort hatte, verlor ich sie. Ich möchte, dass du es neu erstellst.

Die Regeln:

Sie haben ein Holzbrett, einen Sjoelbak , mit 4 Kisten, jede mit einer eigenen Nummer. Wenn ein Schijf ( ein puckartiges Objekt) in eines der Kästchen kommt, erhält man die Punkte über diesem Kästchen.

Wenn in allen 4 Kisten ein Schijf vorhanden ist, erhält man nicht 10, sondern 20 Punkte.

Beispiel:

Von links nach rechts: 3 5 4 3
Jede Schachtel hat mindestens 3 Schijven (Plural von Schijf ), dh 20 * 3 = 60 Punkte.

Resultierende Werte: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 Punkte.

Das ergibt insgesamt 60 + 10 = 70 Punkte.

Die Eingabe:
Die Menge an Schijven von links nach rechts, dh "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", was auch immer Sie möchten.

Die Ausgabe:
Die Anzahl der Punkte, dh 84, als Ausgabe, Variable, Rückgabe oder oben auf dem Stapel, ganz wie Sie möchten.

Wie bei jedem Codegolf können Sie keine externen Skripte verwenden und der Code mit den wenigsten Bytes gewinnt.

PS: Wie Sie vielleicht schon bemerkt haben, bin ich Holländer. Fühlen Sie sich frei, um mögliche Grammatikfehler zu bearbeiten.

CJam, 23 21 20 Bytes

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

Ich könnte in der Lage sein, ein paar Bytes davon zu spielen.

Eingabe ist wie

[3 5 4 3]

Output ist die Punktzahl

70

Wie es funktioniert

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

Algorithmus

• Da ich die Anzahl der Schijven nach rechts verschoben habe, wird die Punktereihenfolge jetzt [1 2 3 4].
• Darüber hinaus 1 + 2 + 3 + 4 = 10addiere ich einfach die minimalen gemeinsamen Schijven zu jedem einzelnen, um den Effekt der Bonuspunktzahl zu 10erzielen.
• Wenn ich nun reduziere, bekomme ich zunächst 2 Elemente auf den Stapel, das erste, das ich ignoriere, ist das mit der Punktzahl von 1jedem, dann multipliziere ich das zweite mit 2und addiere es zum ersten. In der nächsten Iteration bekomme ich die aktuelle Summe und 3schijven Punktzahl . Und so weiter.

Probieren Sie es hier online aus

Piet, 240 (30 * 8) Codels, 138 mit aktuellem Code

Codel Größe 10, für eine bessere Sichtbarkeit

Testbeispiele:

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

Durchflussanzeige:

Ich benutze meine eigene Kurzschrift für eine einfachere Handhabung und ein kompaktes Display. Es zeigt den allgemeinen Programmablauf, nicht die genauen Positionen der 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

Vollständige Erklärung:

      (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

Speichern Sie das Bild und probieren Sie es in diesem Online-Piet-Interpreter aus:

PietDev online Piet Dolmetscher

APL (Dyalog Classic) , 16 13 12 Bytes

-3 danke an @ Adám

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

Probieren Sie es online!

⌽+⌊/ Rückwärts (arg) + Min (arg)

1⌽ 1 nach links drehen

+\ Teilsummen

+/ Summe

Mathematica, 38 32 23 20 Bytes

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

(Mit Hilfe von Swish )

Verwenden Sie, indem Sie die Eingabe bis zum Ende anheften:

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

70

Alternative (36 Byte):

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

R 41 40 Zeichen

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

Verwendung:

> 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

Im letzten Beispiel aist vector 3 5 4 3, a-bis 0 2 1 0, das wir mit vector multiplizieren, 2 3 4 1so dass 0 6 4 0wir addieren und 5*bgeben 15 21 19 15( 5*brecycelt für jedes Mitglied des hinzugefügten Vektors, also effektiv addieren 4*5*b), was wir schließlich summieren und so geben 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

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

So funktioniert es: Die Funktion sucht in den Argumenten nach der kleinsten Zahl und multipliziert diese mit 10(nicht mit 20) und addiert den Rest der Punktzahl. Es ist nicht erforderlich, 20Teile von der Partitur zu multiplizieren und zu subtrahieren, um die Berechnung fortzusetzen.

Vielen Dank an edc65 für das Teilen von Verbesserungen!

Nicht golfen:

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

Die Eingabe sollte durch Kommas getrennt auf STDIN erfolgen, z

3,5,4,3

Dies verwendet den gleichen Trick, den viele andere Lösungen angewendet haben, nämlich das Minimum zu jedem Element hinzuzufügen, um den Bonus zu berücksichtigen. Das Minimum steht hSQim obigen Code. Um die Multiplikation mit 2, 3, 4 und 1 zu berücksichtigen, ordne ich d der Liste [0,1,2,3] zu und multipliziere das (dl) -te Element der Eingabe mit d + 1. Das -1te Element wird also mit 1 multipliziert, das nullte mit 2, das erste mit 3 und das zweite mit 4. Dann summiere ich.

J, 23 22 Zeichen

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

Beispiel:

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

Probieren Sie es hier aus.

(23 lang explizite Funktionsdefinition: v=:3 :'+/+/\.3|.y+<./y')

Strauß v0.1.0 , 48 41 Zeichen _{^{(viel zu lang)}}

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

Dies ist einfach die gleiche wie die alte Version unten, mit der Ausnahme, dass anstelle des Drehens @des gesamten Stapels )\+(rechte Uncon) stattdessen verwendet wird.

Alte Version:

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

Ich habe tatsächlich zwei Fehler in meiner neu implementierten Sprache entdeckt, die in der folgenden Beschreibung kommentiert sind. (Die Sprache ist derzeit sehr, sehr ähnlich zu Golfscript. Wenn Sie also Golfscript kennen, sollte es ziemlich einfach zu lesen sein.

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

Erwartet Eingaben als Array in STDIN, da ich ein Türknauf bin und vergessen habe, E / A in Version 0.1.0 zu implementieren.

Das Lösen eines tatsächlichen Problems in Ostrich ist nett, weil es mir genau zeigt, wie viel mehr Dinge ich zur Sprache hinzufügen muss: D

Python 2, 43 Bytes

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

Inspiriert von der Antwort von @ user2487951.

Jagl Alpha 1,2 - 20 Bytes

Die Eingabe erfolgt im Format stdin (3 4 5 6), die Ausgabe bleibt im Stapel:

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

Warten auf eine Antwort vom Originalposter zum Ausgabeformat. Da die Eingabe als "Was auch immer Sie möchten" angegeben ist , gehe ich davon aus, dass meine Eingabe ein Array oben im Stapel sein kann. Übernimmt nun die Eingabe von stdin.

Erläuterung:

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

Anstatt die Mindestanzahl aus dem Rest zu entfernen und zusätzliche 20s hinzuzufügen, wird die Mindestanzahl hinzugefügt 10.

Matlab, 27

Ich habe eine Weile gebraucht, um zu verstehen, dass es sich um ein Einzelspielerspiel handelt. Mit Hilfe der anonymen Funktion

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

welches mit dem Zeilenvektor aufgerufen wird

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

Ich habe die Idee, dass dies weiter golfen werden kann, aber das ist es fürs Erste.

Aufruf mit A(new int[]{3,5,4,3}), Ausgabe wird als int zurückgegeben (weil System.out.println()sich die Bytes verdoppeln würden)

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 Bytes

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

Liest die Eingabe von stdin im Format [3 5 4 3]. Schreibt die Ausgabe in stdout. (Wenn die Eingabe als Array auf dem Stapel zulässig ist, ~kann der Zeilenabstand für insgesamt 21 Bytes weggelassen werden.)

Dies verwendet eine etwas andere Strategie als die CJam / Pyth / etc.-Lösungen: Ich erstelle ein Array mit 2 Kopien des ersten Eingabewerts, 3 der zweiten, 4 der dritten und einer der vierten. Dann sortiere ich dieses Array, ziehe das kleinste Element heraus, multipliziere es mit 11 und summiere es mit den anderen Elementen.

Python 2, 51

Einfallslos, aber kurz:

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

Pythonischer:

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

Julia, 48 35 Zeichen

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

in kompakter Auftragsform:

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

Beispiel:

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

Ich wollte sehen, wie sich eine Rekursion entwickeln würde, und obwohl dies definitiv nicht die kürzeste Antwort ist, hatte ich das Gefühl, dass es sich als gut herausgestellt hat.

a*b*c*d: Es nimmt die Eingabewerte und findet das Produkt von allen und wertet es als Booleschen Ausdruck für eine Inline-if-Anweisung aus. Dies gibt false zurück, wenn einer oder mehrere der Werte 0 ist, und true für jeden anderen Wert.

20+f(--a,--b,--c,--d): Wenn true zurückgegeben wird, gibt die Funktion 20 (für die Schijven- Menge) plus den rekursiven Aufruf der Funktion für alle Werte minus eins zurück (um diese Schijven- Menge zu entfernen ). Auf diese Weise wird rekursiv durchgeschleift, bis mindestens eines der Kästchen leer ist.

a*2+b*3+c*4+dNachdem mindestens ein Feld leer ist, wird der else-Teil der Inline-if-Anweisung ausgeführt. Es werden nur die Punkte für die verbleibenden Schijven in den Feldern zurückgegeben.

Somit am Ende alle 20 Punkt schijven Sets, und die Punkte zurückverwiesen werden aufsummiert und von der Funktion zurückgegeben, um die Antwort zu erzeugen.

Haskell 42 Zeichen

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

HPPPL (HP Prime Programming Language), 58 57 Bytes

Das * zwischen 10 und min ist nicht notwendig, deshalb habe ich es entfernt.

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

HPPPL ist die Programmiersprache für den HP Prime Color Graphing Calculator / CAS.

Beispiel läuft:

Wenn es kein Programm sein muss, dann ist es in a realisierbar 40 39 Bytes einzeilig:

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

Staq, 72 Zeichen

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

Beispiellauf:

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

3
5
4
3
70

Execution complete.
>

Staq hat zwei Stapel, einen aktiven und einen passiven. Der |Befehl schaltet den aktiven Stack auf passiv und umgekehrt.

Alles zwischen geschweiften Klammern definiert eine Funktion, der erste Buchstabe nach der öffnenden Klammer ist der Funktionsname, der Rest bis die schließende Klammer die Funktion selbst ist. Überschreibende Funktionen, Rekursion und verschachtelte Funktionen sind möglich. {aii}würde eine Funktion a definieren , die die Oberseite des Stapels zweimal erhöht. Jede folgende Instanz von aim Code wird durch ersetzt ii.

Kommentare in Staq- Programmen: Fügt &eine Null oben auf dem Stapel hinzu, [weist den Zeiger an, zur entsprechenden Stelle zu springen, ]wenn die Oberseite des Stapels Null ist, und xlöscht den obersten Wert auf dem Stapel. So können Kommentare in Form von in den Code geschrieben werden&[here is a comment]x

Erklärung (auch ausführbar):

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

Das Programm verwendet einen Stapel (anfangs aktiv), um 2a + 3b + 4c + d zu berechnen, und den zweiten Stapel (anfangs passiv), um das 10-fache des Minimums der Eingabewerte zu berechnen. Dann werden beide Ergebnisse aufsummiert und angezeigt.

PowerShell für Windows , 48 - 47 Byte

^{-1 Byte dank mazzy}

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

Probieren Sie es online!