De que lado devo servir?
Introdução
No Tênis, o sacador alterna sacando do lado esquerdo ou direito da quadra a cada ponto, começando pela direita. É possível descobrir de que lado sacar naquele ponto apenas com base na pontuação; se houver um número par de pontos, você sacará à direita e, após um número ímpar de pontos, à esquerda. A pontuação no tênis funciona da seguinte maneira:
Points | Corresponding Call
|
0 | Love
1 | 15
2 | 30
3 | 40
Quando um jogador marca 4 pontos, ele ganha o jogo. Se o resultado estiver empatado em 40-40, a decisão é "Deuce" em vez de "40-40" ou "40 all". No Deuce, o ponto subsequente é chamado de "Vantagem [x]" ou "Ad [x]", onde x é o jogador que marcou. Se o jogador oposto marcar em seguida, o placar retorna para Deuce, mas se o mesmo jogador marcar novamente, ele ganha.
O desafio
Sua tarefa é escrever uma função que obtém a pontuação e retorna um valor verdadeiro ou falso. A entrada pode ser uma string contendo a chamada ou uma lista contendo as pontuações. Love, Deuce e Ad devem ser strings, mas o resto das chamadas também podem ser de qualquer tipo numérico. Deuce pode ser representado por uma lista de singleton contendo "Deuce" ou uma lista com "Deuce" e outro valor de sua escolha. Você pode escolher qual lado corresponde a verdadeiro e falso, mas deve especificar qual corresponde a qual lado em sua resposta . As pontuações serão separadas por um hífen, exceto no caso de Deuce em que será simplesmente "Deuce". Para vantagem, a pontuação será "Ad-40" ou "40-Ad".
Ganhando
Este é o código de golfe, então a pontuação é o número de bytes em sua função e a resposta com a menor pontuação vence. Falhas padrão são proibidas.
Casos de teste
Love-Love | True
Love-15 | False
Love-30 | True
Love-40 | False
15-Love | False
15-15 | True
15-30 | False
15-40 | True
30-Love | True
30-15 | False
30-30 | True
30-40 | False
40-Love | False
40-15 | True
40-30 | False
Deuce | True
Ad-40 | False
40-Ad | False
Esses casos de teste são exaustivos, ou seja, essa lista representa todas as entradas possíveis e sua saída correspondente. Usei True para a direita e False para a esquerda.
Respostas
Retina 0.8.2 , 7 bytes
M`4|5
1
Experimente online! O link inclui casos de teste. Saídas 0para a direita e 1para a esquerda. Explicação:
M`[45]
O número de 4s e 5s ...
1
... deve ser igual a 1 se o saque está à esquerda.
Perl 5 (-p), 17 , 11 , 10 bytes
-6 usando a solução de Neil, -1 graças ao reordenamento de Dom Hastings
$_=1^y;45;
Experimente online!
0 para falso, <> 0 para verdadeiro
Python 2 , 26 bytes
Recebe entrada no mesmo formato dos casos de teste. A saída é invertida, 1para os casos falsey e 0para os verdadeiros. A saída normal seria 1 byte a mais com um -preprended.
lambda s:hash(s)*199%421%2
Experimente online!
Haskell , 29 bytes
odd.sum.map(mod 882.fromEnum)
Experimente online!
Uma função anônima que recebe uma chamada hifenizada e retorna Trueou False, assim como nos casos de teste.
Nota: parece que estamos pegando os valores "mod 882", mas na verdade em Haskell mod 882está a função \$y \mapsto (882 \bmod y)\$. (Isto é: é parcialmente aplicado mod x y.)
Haskell , 28 bytes
f s=[1|c<-s,elem c"45"]==[1]
Experimente online!
O método de Neil do Implement para verificar se a string tem exatamente um 4 ou 5. Conjunto de testes de Lynn .
Haskell não tem uma maneira legal de contar os elementos que satisfazem uma propriedade. Poderíamos fazer isso filter(`elem`"45"), mas parece muito longo verificar se a lista resultante é um único elemento ou se é um de "4"ou "5".
Usamos uma compreensão de lista para fazer uma lista com um 1para cada personagem que está dentro "45"e ver se terminamos com a lista [1]. Qualquer valor pode ser usado no lugar 1daqui, incluindo sele mesmo.
Gelatina , 6 bytes
OP%25Ḃ
Um Link monádico que aceita uma lista de caracteres que cede 1se servindo da direita ou 0se servindo da esquerda.
Experimente online!
Quão?
OP%25Ḃ - Link: list of characters e.g. "15-30"
O - ordinals [49,53,45,51,48]
P - product 286085520
25 - twenty-five 25
% - modulo 20
Ḃ - modulo-2 0
Também 6 bytes usando a observação de Neil (resultado invertido):
f⁾45LḂ - Link: list of characters, S
⁾45 - list of characters = "45"
f - filter (S) keep (those characters)
L - length -> 0, 1, or 2; but only 1 when serving from the left
Ḃ - modulo-2
Raku , 12 bytes
{1-m:g/1|4/}
Experimente online!
Uma função anônima que retorna zero para a esquerda e diferente de zero para a direita. Isso usa a observação de Neil de que deve haver exatamente um 1ou 4para que seja o saque do lado esquerdo.
Pyth , 10 bytes
%%CSz287 2
Experimente online!
Explicação, um pouco diferente dos outros aqui ...
%%CSz287 2
Sz - Sort the input string, (so that Love-15 and 15-Love provide the same string)
CSz - Get the 256 base int value of the string.
% ^ 287 - Modulo that number by 287
% ^ 2 - Return whether that number is odd or even.
Scala , 30 29 bytes
_.matches("[^45]*[45][^45]*")
Experimente online!
Minha solução usa falso para direita e verdadeiro para esquerda.
- -1 Graças a Jo-King ♦ !
JavaScript (ES6), 26 bytes
Usar o método de @Neil economiza mais 4 bytes.
Espera uma string. Retorna 0 para a esquerda ou 1 para a direita .
s=>s.split(/4|5/).length%2
Experimente online!
JavaScript (ES6), 30 bytes
Espera um par de pontuações de cordas (ou um singleton para Deuce). Retorna 0 para a direita ou 1 para a esquerda .
a=>parseInt(a.join`2`,36)%31%2
Experimente online!
JavaScript (ES6), 34 bytes
Espera uma string. Retorna 0 para a esquerda ou 1 para a direita .
s=>parseInt(s[0]+s[3]+s[5],35)%3%2
Experimente online!
Quão?
Olhar para o 1 ° e 4 ° caracteres fornece informações suficientes, exceto se a pontuação for Love-X, nesse caso, precisamos olhar também para o 6 ° personagem. Para tornar as coisas mais fáceis, apenas olhamos para essas 3 posições em todos os casos e fazemos o hash.
Abaixo está um resumo do processo para cada entrada possível.
input | s[0]+s[3]+s[5] | parsed as base-35 | mod 3 | mod 2
-------------+----------------+-------------------+-------+-------
"Love-Love" | "LeL" | 26236 | 1 | 1
"Love-15" | "Le1" | 26216 | 2 | 0
"Love-30" | "Le3" | 26218 | 1 | 1
"Love-40" | "Le4" | 26219 | 2 | 0
"15-Love" | "1Lv" | 1991 | 2 | 0
"15-15" | "11undefined" | 2906423713803553 | 1 | 1
"15-30" | "13undefined" | 3064054991147303 | 2 | 0
"15-40" | "14undefined" | 3142870629819178 | 1 | 1
"30-Love" | "3Lv" | 4441 | 1 | 1
"30-15" | "31undefined" | 8423518420834803 | 0 | 0
"30-30" | "33undefined" | 8581149698178553 | 1 | 1
"30-40" | "34undefined" | 8659965336850428 | 0 | 0
"40-Love" | "4Lv" | 5666 | 2 | 0
"40-15" | "41undefined" | 11182065774350428 | 1 | 1
"40-30" | "43undefined" | 11339697051694176 | 0 | 0
"Deuce" | "Dcundefined" | 36875963981381680 | 1 | 1
"Ad-40" | "A4undefined" | 27969796811459804 | 2 | 0
"40-Ad" | "4Aundefined" | 11891406522397304 | 2 | 0
Jelly , 7 bytes
Ṣ“Œọ‘ḥḂ
Experimente online! (o rodapé testa o programa em todas as entradas possíveis)
Toma de entrada sob a forma de uma lista de cadeias, por exemplo ["Love","15"], ["40","Ad"], ou ["Deuce"]. Produz 0 ou 1, no sentido oposto da tabela de casos de teste na questão (ou seja, 0 = direita, 1 = esquerda).
Isso está usando quase a mesma ideia das outras respostas: simplesmente encontramos uma função hash que mapeia cada entrada possível para a saída correta. A fim de tornar mais provável que uma função hash selecionada aleatoriamente produzisse o resultado correto (reduzindo, portanto, o número de bytes necessários para especificar qual função hash queremos), a lista de entrada é classificada antes de fazer o hash (reduzindo assim quase pela metade o número de casos que precisamos combinar; uma pontuação de X - Y sempre produz a mesma resposta que uma pontuação de Y - X ).
Não houve nenhuma habilidade na seleção da função hash; havia uma probabilidade de 2 a 12 de que qualquer função de hash funcionasse, o que é bastante alto, então simplesmente tentei as funções de hash integradas do Jelly na ordem da configuração mais curta para a mais longa e escolhi a primeira que funcionou. Esta é a função hash [19,221]. Como configurar a função hash para produzir booleanos exigiria uma string de configuração substancialmente maior, eu apenas usei o formato de saída padrão (este gera números na faixa de 1 a 221) e peguei o bit menos significativo da saída como minha saída.
Explicação
Ṣ“Œọ‘ḥḂ
Ṣ Sort {the input list}
ḥ Hash {the sorted list}, with configuration
“Œọ‘ [19, 221] (compressed representation)
Ḃ Take the least significant bit of the output
Bash , 20 bytes
[[ $[$1] = *[14]* ]]
Experimente online!
No Bash, qualquer variável não definida tem 0 pol $[arithmetic mode]. Um teste rápido revelou que se a entrada foi avaliada no modo aritmético, o seguinte padrão emerge:
Result: 0 10 -10 15 -15 25 -25 30 -30 40 -40
Side: R L L L L R R R R L L
Assim, se o resultado aritmético contém 1 ou 4, é um serviço esquerdo, caso contrário, é um serviço direito.
Husk , 9 bytes
%2`%25Πmc
Experimente online!
O mesmo método da resposta de Jonathan Allan.
Lote, 32 bytes
@set/an=(%1)/10%%3^&1
@echo %n%
Recebe entrada na linha de comando e dá saída 1para serviços à esquerda e 0para servidores à direita. Explicação: Com base na resposta de @ GammaFunction, realizando uma avaliação aritmética na entrada e assumindo que as variáveis Love, Ade Deucenão estão definidas e, portanto, são zero, o dígito das dezenas do resultado é 1ou 4para serve à esquerda e 0, 2ou 3para serve à direita . Isso é então reduzido ainda mais via módulo com 3e bit a bit e com 1para produzir o resultado desejado.
Carvão , 9 bytes
⁼¹ＬΦθ№45ι
Experimente online! O link é para a versão detalhada do código. A saída é um booleano Charcoal, onde -(Verdadeiro) significa que você serve à esquerda e a saída vazia (Falso) significa que você serve à direita. Explicação:
Φθ Filter input where
№45ι Literal string `45` contains character
Ｌ Length
⁼¹ Equals literal `1`
Implicitly print
Mais longo que Retina, suspiro ... (encontrei várias formulações para 9 bytes, mas nenhuma mais curta que não tivesse erros.)
05AB1E , 6 bytes
45S¢O≠
Porto de @Neil 's resposta Retina , por isso certifique-se de upvote-lo !!
Experimente online ou verifique todos os casos de teste .
Explicação:
45S # Push 45, and convert it to a list of digits: [4,5]
¢ # Count both of those in the (implicit) input-string
O # Take the sum of this pair of counts
≠ # And check that it's NOT equal to 1
# (after which the result is output implicitly)
MathGolf , 7 bytes
▒$ε*N%¥
Porto da resposta Jelly de @JonathanAllan , então certifique-se de votar nele !!
Experimente online.
Explicação:
▒ # Convert the (implicit) input-string to a list of characters
$ # Convert each character to its codepoint integer
ε* # Take the product of this list (reduce by multiplication)
N% # Modulo-25
¥ # Modulo-2
# (after which the entire stack joined together is output implicitly as result)