Calcular os pontos em um jogo "sjoelen"

31

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.

Um _sjoelbak_ com _schijven_
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.

Charlie
fonte
A saída precisa ser stdout ou pode ser um retorno de função ou o item restante deixado na pilha (para um idioma baseado na pilha)?
globby
@globby Pode ser tudo #
Charlie
Eu acho que sjoelen é leuk!
precisa
1
Existe um limite para o número de schijf em cada caixa?
The_Basset_Hound
@BassetHound Você recebe 30 schijven por rodada, então 30 nos 4 é igual a 120 pontos. É possível, mas não a melhor pontuação (7 no total = 140, + 2 em 4 = 148)
Charlie

Respostas:

8

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

Optimizer
fonte
Menos bytes (até agora), aceitos. Obrigada pelo esclarecimento.
27414 Charlie
@Charlie Por que você aceita uma resposta tão rapidamente? É melhor esperar 1-2 semanas antes de aceitar uma resposta.
ProgramFOX
8

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

Codel tamanho 10, para melhor visibilidade

Piet: contagem de pontos sjoelen

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

ML
fonte
Uma resposta Piet ^. ^
The_Basset_Hound
Claro! Eu tento adicionar respostas do Piet sempre que possível;)
ML
7

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}]&
kukac67
fonte
Tr[(# + Min@#) {2, 3, 4, 1}] &
swish
@swish Tão esperto!
kukac67
1
Essa é toda a função. Você não precisa adicionar 20*Min@#, você pode se livrar dele substituindo menos por mais, porque convenientemente 2+3+4+1==10.
swish
@swish Oh! Isso é ainda melhor. Mas não consigo entender por que isso funciona?
kukac67
2
@swish Bem, obrigado por toda a ajuda, mas você deveria ter postado sua própria resposta. : D
kukac67
7

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.

plannapus
fonte
40 bytes:b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
Alex A.
5

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;
}
ProgramFOX
fonte
1
Use 10 com min, sem necessidade de subtrair (função s (a, b, c, d) {return 10 * Math.min (a, b, c, d) + a * 2 + b * 3 + c * 4 + d;})
edc65 27/12/14
1
E no ES6:S=(a,b,c,d)=>10*Math.min(a,b,c,d)+a*2+b*3+c*4+d
edc65
@ edc65 Impressionante, obrigado!
precisa
5

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.

isaacg
fonte
5

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')

randomra
fonte
Por que não apenas +/2 3 4 1*(+<./)?
swish
@swish Prefiro escrever funções completas, embora não seja um requisito aqui. Poste / adicione-o, se desejar.
randomra
Que tal 2 3 4 1+/ .×]+<./?
Adám 11/07
4

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

Maçaneta da porta
fonte
Boa sorte com seu idioma, parece bom até agora;)
Charlie
4

Python 2, 43 bytes

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

Inspirado na resposta de @ user2487951.

isaacg
fonte
Bom algoritmo! Para um programa completo, você também precisa de instruções de entrada e impressão.
user2487951
1
@ user2487951 Um dos meios de saída permitidos foi "return", portanto, embora este não seja um programa completo, é uma resposta válida.
Isaacg
3

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
globby
fonte
A primeira resposta é aceita, a publicação foi editada para deixar claro #
Charlie
@Optimizer point taken. Editado.
globby
3

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.

orgulhoso haskeller
fonte
Ótima solução. Você se misturar a ordem, porém, ele deve ser..4*c+d..
3

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
zabalajka
fonte
1
Eu acho que é geralmente aceito em torno dessas partes deixar cair f=por 2 bytes a menos. A função é armazenada na ansvariável.
BrainSteel
1
[2:4,1]reduzirá 2 bytes se a entrada for vetor de coluna.
Sanchises
2

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];
}
Charlie
fonte
2

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.

Ilmari Karonen
fonte
2

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)
user2487951
fonte
Se a entrada for [3,5,4,3], isso retornará 70?
29414 Charlie
Sim, nos dois casos. E retorna 84 para [4,5,4,5].
usar o seguinte comando
2

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
ML
fonte
2

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))
SuperJedi224
fonte
1

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.

skycon
fonte
1

Haskell 42 chars

f l=10*minimum l+sum(zipWith(*)[2,3,4,1]l)
HEGX64
fonte
Código a soma expressamente: f l@[a,b,c,d]=10*minimum l+2*a+3*b+4*c+d- salva 2 caracteres
MtnViewMark
1

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:

Captura de tela HPPPL do programa de contagem de pontos sjoelen

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)
ML
fonte
1

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.

ML
fonte