Ok, ontem foi o segundo dia de Natal e meus pais e eu tivemos um jogo de "sjoelen", como é chamado na Holanda. O programador interno surgiu em mim, mas justamente quando eu tive a resposta, eu a perdi. Eu quero que você refaça isso.

As regras:

Você tem uma prancha de madeira, um sjoelbak , com 4 caixas, cada uma com seu próprio número. Quando um schijf (um objeto parecido com um disco) entra em uma das caixas, você obtém os pontos acima dessa caixa.

Quando há um schijf nas quatro caixas, você não recebe 10, mas recebe 20 pontos.

Exemplo:

Da esquerda para a direita: 3 5 4 3
Cada caixa tem pelo menos 3 schijven (plural de schijf ), ou seja, 20 * 3 = 60 pontos.

Valores resultantes: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 pontos.

O que totaliza 60 + 10 = 70 pontos.

A entrada:
a quantidade de schijven da esquerda para a direita, ou seja, "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", o que você quiser.

A saída:
a quantidade de pontos, ou seja, 84, como saída, variável, retorno ou no topo da pilha, o que você quiser.

Como em todo e qualquer código de golfe, você não pode usar scripts externos e o código com o mínimo de bytes vence.

PS: Como você já deve ter notado, sou holandês. Sinta-se livre para editar possíveis erros gramaticais.

CJam, 23 21 20 bytes

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

Talvez eu consiga jogar alguns bytes com isso.

Entrada é como

[3 5 4 3]

Saída é a pontuação

70

Como 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

• Desde que mudei à direita o número de schijven, a ordem de pontuação agora se torna [1 2 3 4].
• Além disso, usando o fato de que 1 + 2 + 3 + 4 = 10 , simplesmente adiciono o mínimo schijven comum a cada um para obter o efeito da 10pontuação de bônus .
• Agora, quando reduzo, recebo 2 elementos inicialmente na pilha, o primeiro que ignoro é o que possui uma pontuação de 1cada um, depois multiplico o segundo 2e o adiciono primeiro. Na próxima iteração, recebo a soma atual e escore 3schijven. E assim por diante.

Experimente online aqui

Piet, 240 (30 * 8) codéis, 138 contendo código real

Codel tamanho 10, para melhor visibilidade

Exemplos de teste:

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

Exibição de fluxo:

Usando minha própria abreviação para facilitar o manuseio e a tela compacta. Ele mostra o fluxo geral do programa, não os locais exatos dos codéis.

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

Explicação 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

Salve a imagem e experimente-a neste interpretador Piet online:

PietDev online Piet intérprete

APL (Dyalog Classic) , 16 13 12 bytes

-3 graças a @ Adám

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

Experimente online!

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

1⌽ gire 1 para a esquerda

+\ somas parciais

+/ soma

Mathematica, 38 32 23 20 bytes

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

(Com a ajuda de swish )

Use alinhavando a entrada até o fim:

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

70

Alternativo (36 bytes):

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

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

No último exemplo, aé vetor 3 5 4 3, a-bé 0 2 1 0, com o qual multiplicamos vetor 2 3 4 1, dando assim o 0 6 4 0que adicionamos com5*b dando 15 21 19 15( 5*bsendo reciclado para cada membro do vetor adicionado, portanto adicionando efetivamente 4*5*b), que finalmente somamos, dando assim 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

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

Como funciona: a função procura o menor número nos argumentos e multiplica isso por 10(não com 20) e adiciona o restante da pontuação. Não é necessário multiplicar por20 e subtrair partes da pontuação para continuar o cálculo.

Obrigado a edc65 por compartilhar melhorias!

Sem golfe:

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

Pitão , 15

sm*hd+@QtdhSQUQ

A entrada deve ser separada por vírgula no STDIN, por exemplo

3,5,4,3

Isso usa o mesmo truque que muitas outras soluções usaram, de adicionar o mínimo a cada elemento para contabilizar o bônus. O mínimo está hSQno código acima. Para explicar a multiplicação por 2, 3, 4 e 1, mapeio d sobre a lista [0,1,2,3] e multiplico o (dl) ésimo elemento da entrada por d + 1. Assim, o -1º elemento é multiplicado por 1, o zeroth por 2, o primeiro por 3 e o segundo por 4. Então eu somar.

J, 23 22 caracteres

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

Exemplo:

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

Experimente aqui.

(23 longa definição de função explícita: v=:3 :'+/+/\.3|.y+<./y')

Ostrich v0.1.0 , 48 41 caracteres _{^{(muito longo)}}

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

É simplesmente o mesmo que a versão antiga abaixo, exceto que, em vez de usar @para girar a pilha inteira,)\+ (desconsulta à direita) é usado.

Versão antiga:

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

Na verdade, descobri dois bugs na minha linguagem recém-implementada, anotada na descrição abaixo. No momento, o idioma é muito, muito parecido com o Golfscript; portanto, se você conhece o Golfscript, deve ser bastante fácil de ler.

.$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 entrada como uma matriz no STDIN, porque sou uma maçaneta e esqueci de implementar a E / S na v0.1.0.

Resolver um problema real em Ostrich é bom, porque mostra exatamente quanto mais coisas eu preciso adicionar ao idioma: D

Python 2, 43 bytes

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

Inspirado na resposta de @ user2487951.

Jagl Alpha 1.2 - 20 bytes

A entrada está no formato stdin (3 4 5 6), a saída é deixada na pilha:

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

Aguardando uma resposta do pôster original sobre o formato de saída. Como a entrada é especificada como "o que você quiser" , assumirei que minha entrada pode ser uma matriz no topo da pilha. Agora recebe entrada no stdin.

Explicação:

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

em vez de remover o número mínimo do restante e adicionar 20s adicionais , isso adiciona mais 10ao número mínimo.

Matlab, 27

Demorei um pouco para entender que é um jogo para um jogador. Com a ajuda da função anônima

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

que é chamado com vetor de linha

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

Eu tenho a idéia de que isso pode ser jogado ainda mais, mas é isso por enquanto.

A chamada com A(new int[]{3,5,4,3}), a saída é retornada como int (porqueSystem.out.println() duplicaria os bytes)

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*+{+}*

Lê a entrada de stdin, no formato [3 5 4 3]. Grava a saída em stdout. (Se a entrada como uma matriz na pilha for permitida, a liderança ~poderá ser omitida, totalizando 21 bytes.)

Isso usa uma estratégia um pouco diferente das soluções CJam / Pyth / etc.: primeiro construo uma matriz com 2 cópias do primeiro valor de entrada, 3 do segundo, 4 do terceiro e um do quarto. Então eu ordeno esse array, retiro o menor elemento, multiplico por 11 e somado com os outros elementos.

Python 2, 51

Sem inspiração, mas curto:

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

Mais pitônico:

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

Julia, 48. 35 caracteres

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

na forma de atribuição compacta:

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

Exemplo:

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

Eu queria ver como a recursão acabaria e, embora definitivamente não seja a resposta mais curta, eu senti que acabou bem.

a*b*c*d: Pega os valores de entrada e localiza o produto de todos eles e avalia isso como uma expressão booleana para uma instrução if inline. Isso retornará falso se um ou mais dos valores for 0 e verdadeiro para qualquer outro valor.

20+f(--a,--b,--c,--d): Se retornar true, a função retornará 20 (para o conjunto schijven ) mais a chamada recursiva da função para todos os valores menos um (para remover esse conjunto schijven ). Dessa forma, ele percorrerá recursivamente até que pelo menos uma das caixas esteja vazia.

a*2+b*3+c*4+dDepois de pelo menos uma caixa vazia, a outra parte da instrução if inline será executada. Apenas retorna os pontos para o schijven restante nas caixas.

Assim, no final, todos os conjuntos de schijven de 20 pontos e os pontos remanescentes são somados e retornados da função, produzindo a resposta.

Haskell 42 chars

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

HPPPL (Linguagem de programação HP Prime), 58. 57 bytes

O * entre 10 e min não é necessário, então eu o removi.

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

HPPPL é a linguagem de programação da calculadora gráfica em cores HP Prime / CAS.

Exemplo é executado:

Se não precisa ser um programa, é realizável em um 40. 39 bytes de uma linha:

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

Staq, 72 caracteres

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

Exemplo de execução:

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

3
5
4
3
70

Execution complete.
>

O Staq possui duas pilhas, uma ativa e uma passiva. O |comando alterna a pilha ativa para passiva e vice-versa.

Tudo entre chaves define uma função, a primeira letra após a chave de abertura é o nome da função, o restante até a chave de fechamento é a própria função. É possível substituir funções, recursão e funções aninhadas. {aii}definiria uma função a que incrementaria o topo da pilha duas vezes. Todas as seguintes instâncias do acódigo serão substituídas por ii.

Comentários dentro dos pré- requisitos do Staq: &adiciona zero no topo da pilha, [instrui o ponteiro a pular para o correspondente ]se o topo da pilha for zero, xexclui o valor mais alto da pilha. Portanto, os comentários podem ser escritos no código na forma de&[here is a comment]x

Explicação (também executável):

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

O programa usa uma pilha (inicialmente ativa) para calcular 2a + 3b + 4c + d, e a segunda pilha (inicialmente passiva) para calcular 10 vezes o mínimo dos valores de entrada. Em seguida, ambos os resultados são resumidos e exibidos.

PowerShell para Windows , 48 47 bytes

^{-1 byte graças a mazzy}

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

Experimente online!