¿De qué lado debo servir?
Introducción
En tenis, el servidor alterna su servicio en el lado izquierdo o en el lado derecho de la cancha en cada punto, comenzando por el derecho. Es posible determinar de qué lado servir para ese punto solo en función del puntaje; si ha habido un número par de puntos, saca a la derecha, y después de un número impar de puntos, a la izquierda. La puntuación en el tenis funciona de la siguiente manera:
Points | Corresponding Call
|
0 | Love
1 | 15
2 | 30
3 | 40
Una vez que un jugador anota 4 puntos, gana el juego. Si la puntuación está empatada en 40-40, la llamada es "Deuce" en lugar de "40-40" o "40 todos". En Deuce, el siguiente punto se denomina "Ventaja [x]" o "Ad [x]", donde x es el jugador que anotó. Si el jugador opuesto anota a continuación, la puntuación vuelve a Deuce, pero si el mismo jugador vuelve a marcar, gana.
El reto
Su tarea es escribir una función que tome la puntuación y devuelva un valor verdadero o falso. La entrada puede ser una cadena que contenga la llamada o una lista que contenga las puntuaciones. Love, Deuce y Ad deben ser cadenas, pero el resto de las llamadas también pueden ser de cualquier tipo numérico. Deuce puede estar representado por una lista de singleton que contiene "Deuce" o una lista con "Deuce" y otro valor de su elección. Puede elegir qué lado corresponde a la verdad y la falsedad, pero debe especificar cuál corresponde a qué lado en su respuesta . Las puntuaciones estarán separadas por un guión, excepto en el caso de Deuce en el que será simplemente "Deuce". Para obtener ventaja, la puntuación será "Ad-40" o "40-Ad".
Victorioso
Esto es código de golf, por lo que la puntuación es el número de bytes en su función y gana la respuesta con la puntuación más baja. Las lagunas legales estándar están prohibidas.
Casos de prueba
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
Estos casos de prueba son exhaustivos, es decir, esa lista representa cada entrada posible y su salida correspondiente. Usé Verdadero para la derecha y Falso para la izquierda.
Respuestas
Retina 0.8.2 , 7 bytes
M`4|5
1
¡Pruébelo en línea! El enlace incluye casos de prueba. Salidas 0para derecha e 1izquierda. Explicación:
M`[45]
El número de 4 y 5 ...
1
... debe ser igual a 1 si el servicio es por la izquierda.
Perl 5 (-p), 17 , 11 , 10 bytes
-6 usando la solución de Neil, -1 gracias al reordenamiento de Dom Hastings
$_=1^y;45;
¡Pruébelo en línea!
0 para falso, <> 0 para verdadero
Python 2 , 26 bytes
Toma la entrada en el mismo formato que los casos de prueba. La salida se invierte, 1para casos falsos y 0verdaderos. La salida normal sería 1 byte más larga con un -archivo.
lambda s:hash(s)*199%421%2
¡Pruébelo en línea!
Haskell , 29 bytes
odd.sum.map(mod 882.fromEnum)
¡Pruébelo en línea!
Una función anónima que toma una llamada con guión y devuelve Trueo False, como en los casos de prueba.
Nota: parece que estamos tomando valores "mod 882", pero en realidad en Haskell mod 882está la función \$y \mapsto (882 \bmod y)\$. (Es decir: se aplica parcialmente mod x y).
Haskell , 28 bytes
f s=[1|c<-s,elem c"45"]==[1]
¡Pruébelo en línea!
Implemente el método de Neil para comprobar que la cadena tiene exactamente un 4 o 5. Conjunto de pruebas de Lynn .
Haskell no tiene una buena forma de contar los elementos que satisfacen una propiedad. Podríamos hacerlo filter(`elem`"45"), pero parece demasiado largo para comprobar que la lista resultante es un solo elemento, o comprobar que es uno de "4"o "5".
Usamos una lista de comprensión para hacer una lista con un 1para cada carácter que está dentro "45"y verificamos si terminamos con la lista [1]. Cualquier valor podría usarse en lugar de 1aquí, incluido él smismo.
Gelatina , 6 bytes
OP%25Ḃ
Un Link monádico que acepta una lista de personajes que cede 1si sirve desde la derecha o 0si sirve desde la izquierda.
¡Pruébelo en línea!
¿Cómo?
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
También 6 bytes usando la observación 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/}
¡Pruébelo en línea!
Una función anónima que devuelve cero para la izquierda y distinto de cero para la derecha. Esto usa la observación de Neil de que debe haber exactamente uno 1o 4que sea el servicio del lado izquierdo.
Pyth , 10 bytes
%%CSz287 2
¡Pruébelo en línea!
Explicación, un poco diferente a los demás aquí ...
%%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]*")
¡Pruébelo en línea!
Mi solución usa falso para la derecha y verdadero para la izquierda.
- -1 ¡Gracias a Jo-King ♦ !
JavaScript (ES6), 26 bytes
El uso del método de @ Neil ahorra 4 bytes más.
Espera una cuerda. Devuelve 0 para la izquierda o 1 para la derecha .
s=>s.split(/4|5/).length%2
¡Pruébelo en línea!
JavaScript (ES6), 30 bytes
Espera un par de puntajes de cuerda (o un singleton para Deuce). Devuelve 0 para la derecha o 1 para la izquierda .
a=>parseInt(a.join`2`,36)%31%2
¡Pruébelo en línea!
JavaScript (ES6), 34 bytes
Espera una cuerda. Devuelve 0 para la izquierda o 1 para la derecha .
s=>parseInt(s[0]+s[3]+s[5],35)%3%2
¡Pruébelo en línea!
¿Cómo?
Observar el primer y cuarto carácter proporciona suficiente información, excepto si la puntuación es, Love-Xen cuyo caso también debemos mirar el sexto carácter. Para facilitar las cosas, solo observamos estas 3 posiciones en todos los casos y las codificamos.
A continuación se muestra un resumen del proceso para cada posible entrada.
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
Gelatina , 7 bytes
Ṣ“Œọ‘ḥḂ
¡Pruébelo en línea! (el pie de página prueba el programa en todas las entradas posibles)
Toma de entrada en forma de una lista de cadenas, por ejemplo ["Love","15"], ["40","Ad"]o ["Deuce"]. Salidas 0 o 1, en el sentido opuesto de la tabla de casos de prueba en la pregunta (es decir, 0 = derecha, 1 = izquierda).
Esto utiliza la misma idea que las otras respuestas: simplemente encontramos una función hash que asigna cada entrada posible a la salida correcta. Para que sea más probable que una función hash seleccionada al azar produzca el resultado correcto (por lo tanto, reduciendo el número de bytes necesarios para especificar qué función hash queremos), la lista de entrada se ordena antes de hash (por lo tanto, casi reduce a la mitad el número de casos que necesitamos hacer coincidir; una puntuación de X - Y siempre produce la misma respuesta que una puntuación de Y - X ).
No hubo ninguna habilidad en la selección de la función hash; había una probabilidad de 2 a 12 de que una función hash determinada funcionara, lo cual es bastante alto, así que simplemente probé las funciones hash integradas de Jelly en orden de la configuración más corta a la más larga, y elegí la primera que funcionó. Esta es la función hash [19,221]. Debido a que configurar la función hash para generar booleanos requeriría una cadena de configuración sustancialmente más grande, solo usé el formato de salida predeterminado (este genera números en el rango 1… 221) y tomé el bit menos significativo de la salida como mi salida.
Explicación
Ṣ“Œọ‘ḥḂ
Ṣ 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]* ]]
¡Pruébelo en línea!
En Bash, las variables no configuradas son 0 pulg $[arithmetic mode]. Una prueba rápida reveló que si la entrada se evaluó en modo aritmético, surge el siguiente patrón:
Result: 0 10 -10 15 -15 25 -25 30 -30 40 -40
Side: R L L L L R R R R L L
Por lo tanto, si el resultado aritmético contiene un 1 o un 4, es un servicio por la izquierda, de lo contrario es un servicio por la derecha.
Cáscara , 9 bytes
%2`%25Πmc
¡Pruébelo en línea!
El mismo método que la respuesta de Jonathan Allan.
Lote, 32 bytes
@set/an=(%1)/10%%3^&1
@echo %n%
Toma entrada en la línea de comando y salidas 1para servicios a la izquierda y 0para servicios a la derecha. Explicación: Basado en la respuesta de @ GammaFunction, al realizar una evaluación aritmética en la entrada y suponiendo que las variables Love, Ady no Deuceestán configuradas y, por lo tanto, son cero, el dígito de las decenas del resultado es 1o 4para servicios a la izquierda y 0, 2o 3para servicios a la derecha . Esto luego se reduce aún más mediante módulo con 3y bit a bit y con 1para producir el resultado deseado.
Carbón , 9 bytes
⁼¹ＬΦθ№45ι
¡Pruébelo en línea! El enlace corresponde a la versión detallada del código. La salida es un booleano Charcoal, donde -(Verdadero) significa que sirve a la izquierda y la salida vacía (Falso) significa que sirve a la derecha. Explicación:
Φθ Filter input where
№45ι Literal string `45` contains character
Ｌ Length
⁼¹ Equals literal `1`
Implicitly print
Más largo que Retina, suspiro ... (Encontré varias formulaciones para 9 bytes, pero ninguna más corta que no tuviera errores).
05AB1E , 6 bytes
45S¢O≠
Respuesta de Port of @Neil 's Retina , ¡así que asegúrate de votarlo!
Pruébelo en línea o verifique todos los casos de prueba .
Explicación:
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%¥
Puerto de la respuesta de Jelly de @JonathanAllan , ¡así que asegúrate de votarlo!
Pruébelo en línea.
Explicación:
▒ # 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)