Okej, więc wczoraj był drugi dzień Bożego Narodzenia, a moi (dziadkowie) rodzice i ja mieliśmy grę w „sjoelen”, jak to się nazywa w Holandii. Wewnętrzny programista pojawił się we mnie, ale właśnie gdy otrzymałem odpowiedź, zgubiłem ją. Chcę, żebyś to przerobił.

Zasady:

Masz drewnianą deskę, sjoelbak , z 4 pudełkami, każde z własnym numerem. Kiedy schijf (obiekt przypominający krążek) wejdzie w jedno z pudeł, otrzymasz punkty powyżej tego pudełka.

Kiedy we wszystkich 4 polach jest schijf , nie dostajesz 10, ale dostajesz 20 punktów.

Przykład:

Od lewej do prawej: 3 5 4 3
Każde pudełko ma co najmniej 3 schijven (liczba mnoga schijf ), czyli 20 * 3 = 60 punktów.

Wartości wynikowe: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 punktów.

Co daje w sumie 60 + 10 = 70 punktów.

Dane wejściowe:
Ilość schijven od lewej do prawej, tj. „4 5 4 5”, [4,5,4,5], „4 \ n5 \ n4 \ n5”, cokolwiek chcesz.

Wynik:
liczba punktów, tj. 84, jako wynik, zmienna, zwrot lub na szczycie stosu, cokolwiek chcesz.

Jak w każdym kodzie golfowym, nie można używać zewnętrznych skryptów, a kod z najmniejszą liczbą bajtów wygrywa.

PS: Jak zapewne zauważyliście, jestem Holendrem. Edytuj ewentualne błędy gramatyczne.

CJam, 23 21 20 bajtów

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

Może uda mi się pograć w golfa kilka bajtów.

Dane wejściowe są jak

[3 5 4 3]

Wynik jest wynikiem

70

Jak to działa

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

Algorytm

• Ponieważ zmieniłem liczbę schijvenów w prawo, kolejność punktacji teraz się zmienia [1 2 3 4].
• Co więcej, wykorzystując fakt 1 + 2 + 3 + 4 = 10, że po prostu dodam do każdego minimalną wspólną schijven, aby uzyskać efekt 10wyniku bonusowego .
• Teraz, gdy zmniejszam, początkowo mam na stosie 2 elementy, pierwszy, który ignoruję, ma wynik 1każdego z nich, a następnie mnożę drugi z 2i dodajemy go do pierwszego. W następnej iteracji otrzymuję bieżącą sumę i punktację 3schijven. I tak dalej.

Wypróbuj online tutaj

Piet, 240 (30 * 8) kodeksów, 138 zawierających rzeczywisty kod

Rozmiar kodu 10, dla lepszej widoczności

Przykłady testowe:

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

Wyświetlanie przepływu:

Używanie własnego skrótu do łatwiejszej obsługi i kompaktowego wyświetlacza. Pokazuje ogólny przebieg programu, a nie dokładne lokalizacje kodów.

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

Pełne wyjaśnienie:

      (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

Zapisz obraz i wypróbuj go w tym internetowym tłumaczu Piet:

PietDev online Tłumacz Piet

APL (Dyalog Classic) , 16 13 12 bajtów

-3 dzięki @ Adám

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

Wypróbuj online!

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

1⌽ obróć 1 w lewo

+\ sumy częściowe

+/ suma

Mathematica, 38 32 23 20 bajtów

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

(Z pomocą Swish )

Użyj, przyczepiając dane wejściowe do końca:

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

70

Alternatywne (36 bajtów):

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

R, 41 40 znaków

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

Stosowanie:

> 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

W ostatnim przykładzie, ajest wektorem 3 5 4 3, a-bto 0 2 1 0, które rozmnażają się wektor 2 3 4 1daje zatem 0 6 4 0które przyłączają 5*bdając 15 21 19 15( 5*bzawraca się do każdego elementu dodanego wektora, a tym samym skuteczne dodawanie 4*5*b), który w końcu Podsumowując, dając w ten sposób 70.

JavaScript (ES6), 93 47 bajtów

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

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

Jak to działa: funkcja szuka najmniejszej liczby w argumentach i mnoży ją przez 10(nie za pomocą 20) i dodaje resztę wyniku. 20Aby kontynuować obliczanie , nie jest konieczne pomnożenie i odjęcie części od wyniku.

Dzięki edc65 za udostępnianie ulepszeń!

Bez golfa:

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

Pyth , 15 lat

sm*hd+@QtdhSQUQ

Dane wejściowe powinny być oddzielone przecinkami na STDIN, np

3,5,4,3

Wykorzystuje tę samą sztuczkę, którą stosowało wiele innych rozwiązań, polegającą na dodawaniu minimum do każdego elementu, aby uwzględnić premię. Minimum znajduje się hSQw powyższym kodzie. Aby uwzględnić mnożenie przez 2, 3, 4 i 1, odwzorowuję d na liście [0,1,2,3] i mnożę element (dl) wejścia przez d + 1. Zatem -1-ty element jest mnożony przez 1, zero przez 2, pierwszy przez 3, a drugi przez 4. Następnie sumuję.

J, 23 22 znaków

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

Przykład:

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

Wypróbuj tutaj.

(23 długo jednoznaczne określenie funkcji: v=:3 :'+/+/\.3|.y+<./y')

Struś v0.1.0 , 48 41 znaków _⁽ zdecydowanie _{^{za długo)}}

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

Jest to po prostu to samo, co stara wersja poniżej, z tym wyjątkiem, że zamiast używać @do obracania całego stosu, zamiast tego używa się )\+(prawych wujów).

Stara wersja:

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

Odkryłem dwa błędy w moim nowo wdrożonym języku, opatrzone adnotacjami w poniższym opisie. (Język jest obecnie bardzo, bardzo podobny do Golfscript, więc jeśli znasz Golfscript, powinien być dość łatwy do odczytania.

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

Oczekuje danych wejściowych jako tablicy na STDIN, ponieważ jestem klamką i zapomniałem zaimplementować We / Wy w wersji 0.1.0.

Rozwiązanie prawdziwego problemu w Strusiu jest fajne, ponieważ pokazuje mi dokładnie, o ile więcej rzeczy muszę dodać do języka: D

Python 2, 43 bajty

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

Zainspirowany odpowiedzią @ user2487951.

Jagl Alpha 1.2 - 20 bajtów

Dane wejściowe są w formacie standardowym (3 4 5 6), dane wyjściowe pozostają na stosie:

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

Oczekiwanie na odpowiedź oryginalnego plakatu na temat formatu wyjściowego. Ponieważ dane wejściowe są określone jako „cokolwiek chcesz” , założę, że moje dane wejściowe mogą być tablicą na górze stosu. Teraz pobiera dane wejściowe na standardowe wejście.

Wyjaśnienie:

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

zamiast usuwać minimalną liczbę z pozostałych i dodawać dodatkowe 20s, dodaje to dodatkowe 10dla minimalnej liczby.

Matlab, 27

Zajęło mi trochę czasu, aby zrozumieć, że jest to gra dla jednego gracza. Za pomocą anonimowej funkcji

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

który jest wywoływany za pomocą wektora wiersza

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

Java, 84 bajty

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

Mam pomysł, że można to jeszcze pograć w golfa, ale na razie to tyle.

Wywołaj za pomocą A(new int[]{3,5,4,3}), dane wyjściowe są zwracane jako int (PonieważSystem.out.println() podwoiłoby bajty)

Bez golfa

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 bajty

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

Odczytuje dane wejściowe ze standardowego wejścia w formacie [3 5 4 3]. Zapisuje wyjście na standardowe wyjście. (Jeśli przyjmowanie danych wejściowych jako tablicy na stosie jest dozwolone, wiodące~ może zostać pominięta dla 21 bajtów).

Wykorzystuje to nieco inną strategię niż rozwiązania CJam / Pyth / itp. Najpierw buduję tablicę z 2 kopiami pierwszej wartości wejściowej, 3 drugiej, 4 trzeciej i jednej czwartej. Następnie sortuję tę tablicę, wyciągam najmniejszy element, mnożę go przez 11 i sumuję z innymi elementami.

Python 2, 51

Nieinspirowane, ale krótkie:

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

Więcej python:

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

Julia, 48 35 znaków

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

w zwartej formie przydziału:

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

Przykład:

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

JavaScript, 97 bajtów

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

Chciałem zobaczyć, jak potoczy się rekurencja i chociaż zdecydowanie nie jest to najkrótsza odpowiedź, czułem, że dobrze się to potoczyło.

a*b*c*d: Pobiera wartości wejściowe i wyszukuje iloczyn wszystkich z nich, i ocenia to jako wyrażenie boolowskie dla wbudowanej instrukcji if. Zwróci false, jeśli co najmniej jedna z wartości ma wartość 0, a true dla dowolnej innej wartości.

20+f(--a,--b,--c,--d): Jeśli zwraca true, funkcja zwraca 20 (dla zestawu schijven ) plus rekurencyjne wywołanie funkcji dla wszystkich wartości minus jeden (aby usunąć ten zestaw schijven ). W ten sposób rekurencyjnie przechodzi przez pętlę, aż co najmniej jedno z pudeł będzie puste.

a*2+b*3+c*4+dPo co najmniej jednym polu jest puste, uruchomiona zostanie inna część instrukcji inline if. Zwraca tylko punkty za pozostałe schijven w polach.

Tak więc na końcu wszystkie 20-punktowe zestawy schijvenów , a punkty końcowe są sumowane i zwracane z funkcji, dając odpowiedź.

Haskell 42 znaki

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

HPPPL (język programowania HP Prime), 58 57 bajtów

* Między 10 a min nie jest konieczne, więc go usunąłem.

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

HPPPL to język programowania kalkulatora graficznego HP Prime / CAS.

Przykładowe przebiegi:

Jeśli nie musi to być program, to można go zrealizować w 40 39 bajtów jednowierszowych:

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

Staq, 72 znaki

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

Przykładowy przebieg:

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

3
5
4
3
70

Execution complete.
>

Staq ma dwa ładunki, jeden aktywny, jeden pasywny. |Polecenie przełącza aktywnego stosu na bierne i vice versa.

Wszystko pomiędzy nawiasami klamrowymi definiuje funkcję, pierwsza litera po nawiasie otwierającym jest nazwą funkcji, reszta do nawiasu zamykającego jest samą funkcją. Możliwe są funkcje zastępujące, rekurencyjne i zagnieżdżone. {aii}zdefiniuje funkcję a , która dwukrotnie zwiększy górę stosu. Każde kolejne wystąpienie akodu zostanie zastąpione przez ii.

Komentarze wewnątrz proramów Staq: &dodaje zero na szczycie stosu, [instruuje wskaźnik, aby przeskoczył do odpowiedniego, ]jeśli wierzchołek stosu wynosi zero, xusuwa najwyższą wartość na stosie. Tak więc komentarze można zapisać w kodzie w postaci&[here is a comment]x

Objaśnienie (również wykonywalne):

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

Program wykorzystuje jeden stos (początkowo aktywny) do obliczenia 2a + 3b + 4c + d, a drugi stos (początkowo pasywny) do obliczenia 10-krotności minimum wartości wejściowych. Następnie oba wyniki są sumowane i wyświetlane.

PowerShell dla Windows , 48 47 bajtów

^{-1 bajt dzięki mazzy}

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

Wypróbuj online!