Golf un gráfico de golf
Dada una distancia en metros como un entero \$60\le d \le 260\$, devuelva el número de palos que se pueden utilizar de acuerdo con el siguiente cuadro arbitrario, donde ambos \$min\$y \$max\$ son inclusivos:
club | min | max
----------------+-----+-----
Driver | 200 | 260
3-wood | 180 | 235
5-wood | 170 | 210
3-iron | 160 | 200
4-iron | 150 | 185
5-iron | 140 | 170
6-iron | 130 | 160
7-iron | 120 | 150
8-iron | 110 | 140
9-iron | 95 | 130
Pitching Wedge | 80 | 115
Sand Wedge | 60 | 90
Notas
Los nombres de los clubes se proporcionan únicamente a título informativo.
Por supuesto, la elección del club depende de varios otros parámetros. Por ejemplo, el Sand Wedge está diseñado para escapar de un búnker de arena. Pero para los propósitos de este desafío, solo importa la distancia.
Sin duda, este es un desafío de código de golf .
Ejemplo
Para \$d=130\$, Podemos elegir hierro 6 , 7-hierro , hierro 8 o 9 de hierro , por lo que la respuesta esperada es \$4\$.
Casos de prueba
Input Output
60 1
79 1
80 2
93 1
105 2
110 3
116 2
129 3
130 4
200 4
201 3
235 2
260 1
O como listas:
Input : 60, 79, 80, 93, 105, 110, 116, 129, 130, 200, 201, 235, 260
Output: 1, 1, 2, 1, 2, 3, 2, 3, 4, 4, 3, 2, 1
Respuestas
código de máquina x86-16, 47 42 bytes
00000000: be14 01b3 01b1 0bad 3ad0 7205 3ad4 7701 ........:.r.:.w.
00000010: 43e2 f4c3 505a 5feb 6e73 78d2 8282 8c8c C...PZ_.nsx.....
00000020: 9696 a0a0 aaaa b4b9 c8c8 ..........
Listado:
BE 0114 MOV SI, OFFSET CHART ; SI point to distance chart
B3 01 MOV BL, 1 ; start counter at 1
B1 0B MOV CL, 11 ; loop 11 clubs
SCORE_LOOP:
AD LODSW ; load AL = min, AH = max
3A D0 CMP DL, AL ; is d less than min?
72 05 JB DONE ; if so, continue
3A D4 CMP DL, AH ; is d greater than max?
77 01 JA DONE ; if so, continue
43 INC BX ; otherwise increment counter
DONE:
E2 F4 LOOP SCORE_LOOP ; loop through end of chart
C3 RET ; return to caller
CHART DB 80,90,95,235,110,115,120,210,130,130,140,140
DB 150,150,160,160,170,170,180,185,200,200
Función Callable, la entrada den DX, en la producción BL.
Sin compresión (los datos son solo 24 22 bytes en binario de todos modos) solo una comparación de tabla.
Editar: Enormes accesorios para @SE: deje de despedir a los buenos por reorganizar la lista y eliminar la necesidad de compensar el dvalor, ¡ahorrando 5 bytes !
El programa de prueba se ejecuta:
Versión alternativa, 50 bytes
BB 0501 MOV BX, 0501H ; init counter to 1 in BL and
BF 556D MOV DI, 0556DH ; magic number to 0x5556D in BH:DI
BE 011C MOV SI, OFFSET CHART ; SI point to transition table
B1 16 MOV CL, 22 ; loop 22 transitions
SCORE_LOOP:
AC LODSB ; load AL = next transition
3A C2 CMP AL, DL ; is d less than?
77 0B JA EXIT ; if not, end
D0 EF SHR BH, 1 ; cascade bit shift high word into CF
D1 DF RCR DI, 1 ; bit shift lsb into CF
43 INC BX ; increment counter
72 02 JC NEXT ; if CF was a 1, continue to next
4B DEC BX ; otherwise subtract 2
4B DEC BX
NEXT:
E2 F0 LOOP SCORE_LOOP ; keep looping
EXIT:
C3 RET
CHART DB 80,91,95,110,116,120,130,131,140,141,150,151,160,161,170,171,180,186,200,201,211,236
Esto está fuertemente inspirado en la respuesta de Jonathan Allan . Esto utiliza una tabla de valores de ddonde el número de clubes transiciones ya sea +1o -1, y una correspondiente binario número mágico de 0x5556ddonde un 1indica un cambio positivo y 0indica un cambio negativo.
Desafortunadamente, esto no ayuda mucho aquí, ya que la codificación de la tabla original es de 24 bytes frente a las 22 transiciones más el número mágico de 3 bytes, por lo que en realidad es más grande. ¡Fue divertido intentarlo!
Python 3 , 71 bytes
lambda n:sum(a<=n/5<=b for a,b in zip(b'($" ',b'4/*(%" '))
¡Pruébelo en línea!
Las cadenas de bytes contienen algunos no imprimibles, su forma de escape es b'($" \x1e\x1c\x1a\x18\x16\x13\x10\x0c'y b'4/*(%" \x1e\x1c\x1a\x17\x12'.
Python 3 , 71 bytes
lambda n:sum(b>n-a*5>-1for a,b in zip(b'($" ',b'=8))$ $$ '))
¡Pruébelo en línea!
Python 3.8 , 90 86 bytes
lambda x:-~sum([79<x<91,94<x<236,-1<(a:=x-110)<6,9<a<101,69<a<76,a/10in{2,3,4,5,6,9}])
¡Pruébelo en línea!
La última condición también se puede escribir a%10<1<a/10<7,a==90con la misma longitud.
Gelatina , 25 bytes
“Ḳœẹ“rɓ?’ḃ5×5“ZO‘;"Ä⁸>§I‘
Un programa completo que imprime el resultado (o un enlace monádico que devuelve una lista de un solo elemento).
¡Pruébelo en línea! O vea la suite de pruebas .
¿Cómo?
Para cualquier entrada válida, en \$[60,260]\$podemos utilizar al menos un club. Para cualquier yardaje dado, en \$[61,260]\$, podemos usar el mismo, uno más o un palo menos de lo que podríamos haber hecho con una yarda menos. El siguiente código codifica las yardas en las que aumenta la cantidad de palos disponibles y aquellas en las que disminuye la cantidad de palos disponibles y lo usa para calcular el resultado.
“Ḳœẹ“rɓ?’ḃ5×5“ZO‘;"Ä⁸>§I‘ - Main Link: integer, Y e.g. 129
“Ḳœẹ“rɓ?’ - list of (two) base-250 integers = [11132965,7226564]
ḃ5 - convert to bijective base five -> [[5,3,2,2,2,2,3,3,2,5],[3,3,2,2,2,2,2,2,2,4]]
×5 - multiply by five -> [[25,15,10,10,10,10,15,15,10,25],[15,15,10,10,10,10,10,10,10,20]]
“ZO‘ - list of code-page indices = [90,79]
" - zip with:
; - concatenation -> [[90,25,15,10,10,10,10,15,15,10,25],[79,15,15,10,10,10,10,10,10,10,20]]
Ä - Cumulative values -> [[90,115,130,140,150,160,170,185,200,210,235],[79,94,109,119,129,139,149,159,169,179,199]]
⁸> - is Y greater than (those)? -> [[1,1,0,0,0,0,0,0,0,0,0],[1,1,1,1,0,0,0,0,0,0,0]]
§ - sums -> [2,4]
I - deltas -> [2]
‘ - increment -> [3]
- implicit print -> "3"
J , 63 58 55 50 bytes
1#.1=(59 90+/\@,|:5*2+4#.inv 2424834 3408207)I."1]
¡Pruébelo en línea!
-5 bytes gracias a xash
Codifica listas como números en base 4, reconstruye y luego usa el índice de intervalo I.para contar en cuántos de los rangos se encuentra la entrada.
R , 77 76 72 bytes
Editar: -4 bytes gracias a Robin Ryder
sum((d=scan()/10-9)>=c(11,9:2,.5,-1,d)&d<=c(d,14.5,12,11,9.5,8:4,2.5,0))
¡Pruébelo en línea!
Solución bastante ingenua, pero se beneficia de la vectorización automática de R y su :operador de secuencia.
Python 3 , 180 155 153 97 88 bytes
lambda n:sum(a<=chr(n)<b for a,b in zip('<P_nx ª´È','[t¡«ºÉÓìą'))
¡Pruébelo en línea!
K (OK) , 85 82 bytes
Solución:
{+/z=x|y&z}.(-3 -1 .5 2 3 4 5 6 7 8 9 11;0 2.5 4 5 6 7 8 9.5 11 12 14.5 17),-9+.1*
¡Pruébelo en línea!
Explicación:
Decididamente ingenuo; Es muy probable que este sea un mal enfoque. ¡Aunque bonito golf por ngn para simplificar la lógica de comparación! .
{+/z=x|y&z}.(-3 -1 .5 2 3 4 5 6 7 8 9 11;0 2.5 4 5 6 7 8 9.5 11 12 14.5 17),-9+.1* / the solution
.1* / multiply input by 0.1
-9+ / subtract 9 from input
, / append to
(-3 -1 .5 2 3 4 5 6 7 8 9 11;0 2.5 4 5 6 7 8 9.5 11 12 14.5 17) / club stats
{ }. / call lambda with multiple args
y&z / min of input and min distance
x| / max compared to max distance
z= / is input the same?
+/ / sum up
Extra:
- -3 bytes gracias a
ngn
Python 3 , 105 bytes
lambda n,a=[1],b=[2],c=[3],d=[4]:(a*20+b*11+a*4+b*15+c*6+b*4+c+(c*9+d)*6+d*5+c*14+d+c*10+b*25+a*25)[n-60]
¡Pruébelo en línea!
Explicación: Una simple fuerza bruta para almacenar la lista de respuestas e imprimir el índice requerido.
Carbón , 44 bytes
ＮθＩΣＥ¹²⁻›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
¡Pruébelo en línea! El enlace corresponde a la versión detallada del código. Puerto de la respuesta de @ JonathanAllen. Explicación:
Ｎθ
Entrada d.
ＩΣＥ¹²⁻
Mapee los 12 clubes e imprima la suma de los resultados emitidos a la cadena de tomar las diferencias entre ...
›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι
... dcomparado con 59sumado a 5veces la suma digital del prefijo de la cadena comprimida 43322222224, y ...
›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
... dcomparado con 90sumado a 5veces la suma digital del prefijo de la cadena comprimida 53222233235.
Respuesta anterior de 48 bytes:
ＮθＩΣＥＩ⪪”)¶∧!✂η}⌊⍘⪫⪫⊕#<e⌊W[qＹ9¤…”²∧›θ⁻×⁵ι﹪κ²⊖⊗﹪κ²
¡Pruébelo en línea! El enlace corresponde a la versión detallada del código. Explicación: Las distancias final e inicial de los 12 palos se separan de una cadena comprimida de números enteros del 12 al 52 que se multiplican por 5. dse compara con todos ellos, anotando 1distancias mayores o iguales en posiciones impares y -1distancias mayores en posiciones pares. posiciones y se imprime el total final.
Python 3 ,
62
60 bytes
lambda d:sum(b//25<=b%25+23-d/5<=7for b in b'BUNSWYQ+-}')+1
¡Pruébelo en línea!
Hay un carácter invisible (en Stack Exchange) \x18al final de la cadena.
Creo que es posible lograr relaciones de compresión más agresivas en la mayoría de las no esololangs.
Como pequeño incentivo, aquí están mis propias puntuaciones en Python y Node.
Revelaré ambos fragmentos de código a continuación tan pronto como se publique (o actualice) una respuesta más corta o igualmente larga en cualquiera de los idiomas, o a las 2 p.m. UTC del viernes 21 de agosto de 2020 en el improbable caso de que no se publique dicha respuesta para entonces.
EDITAR (2020-08-19): ¡ Felicitaciones a @flornquake por ser el primero en publicar una respuesta de Python por debajo de 70 bytes, usando una idea similar a la mía pero empujándola un paso más allá para un total de 62 bytes!
Python 3.8 (versión preliminar) , 70 bytes
lambda d,n=12:sum((n:=n+x//8-4)<=d/5<=n+x%8+6for x in b' A980001225F')
¡Pruébelo en línea!
JavaScript (Node.js) , 74 bytes
d=>Buffer(' A980001225F').map(x=>t-=d/5<(n+=x-32>>3)|d/5>n+x%8+6,n=t=12)|t
¡Pruébelo en línea!
Perl 5 , 70 bytes
El primer byte de la cadena se agrega en \x##notación para facilitar la prueba, pero es un byte literal.
$_=grep"@F">=($k+=(ord>>4)*5)&"@F"<=$k+(15&ord)*5,"\xc6G76&&&'((+L"=~/./g
Almacena los detalles de cada club (dividido por 5) como un byte donde los primeros cuatro bits son la diferencia entre el inicio del rango anterior y el inicio de este, y los segundos cuatro bits son la diferencia entre el inicio de este rango y el fin.
start end => / 5 => binary #
--------------------------------------------
60 90 => 12 6 => 11000110 # counter starts at 0
80 115 => 4 7 => 00100100 # counter is 12 from before so we only need an extra 4
95 130 => 3 7 => 00110111
110 140 => 3 6 => 00110110
¡Pruébelo en línea!
C (gcc) , 83 75 bytes
(no todos los caracteres se muestran correctamente en el intercambio de pila, pero son correctos en TIO)
*i;c;f(d){c=0;for(i=L"ÈĄ´ëªÒ ȹª xn_Ps<Z";*i;c+=d/ *i++&*i++/d);d=c;}
¡Pruébelo en línea!
Io , 89 bytes
method(a," \"$("asList select(i,v,v at(0)<=a/5and a/5<=" \"%(*/4"at(i))size)
¡Pruébelo en línea!
Pyth , 36 bytes
s/RC-QTrV"2FUdnx ª¾""Qjy¡°¿Éâû
¡Pruébelo en línea!
Explicación
"... # String literal with end of ranges minus 10 as characters
"..." # String literal with start of ranges minus 10 as characters
rV # Generate the ranges
/R # Count occurrences of
C-QT # input minus 10 converted to a characters (based on ascii value)
# in each of the ranges
s # sum
JavaScript (V8) , 142 132 117 113 bytes
-10 bytes: se aplicó -9 a los rangos y la entrada después de la división en lugar de dividir solo por 10 (inspirado en otras respuestas, entendí por qué valió la pena después de observar mi rango / 10 números)
-15 bytes gracias a las mejoras de Arnauld
-5 bytes gracias a las mejoras adicionales de Shaggy
d=>[11,17,9,14.5,8,12,7,11,6,9.5,...'58473625',.5,4,-1,2.5,-3,t=0].map((e,i,r)=>t+=++i%2&d>=e&d<=r[i],d=d/10-9)|t
¡Pruébelo en línea!
Una solución bastante ingenua, pero no me sentía cómodo intentando métodos más complejos utilizados en otras respuestas (¡sin mencionar que no estoy seguro de si son posibles / vale la pena jugar al golf en JS!). Sin embargo, aceptaré con mucho gusto consejos / mejoras.
No minificado y explicado (un poco desactualizado, pero aún explica el proceso general):
f = (distance) => {
// divide input by 10 and subtract 9 since the hardcoded ranges are shorter when those operations are done.
distance = distance / 10 - 9
// hardcoded ranges divided by 10 then subtracted 9 to save bytes (probably can be done better).
// Will be used in pairs, only processing even indexes and using i & i+1
//ranges = [20,26,18,23.5,17,21,16,20,15,18.5,14,17,13,16,12,15,11,14,9.5,13,8,11.5,6,9] // /10
//ranges = [14,20,12,17.5,11,15,10,14,9,12.5,8,11,7,10,6,9,5,8,3.5,7,2,5.5,0,3] // /10 -6
ranges = [11,17,9,14.5,8,12,7,11,6,9.5,5,8,4,7,3,6,2,5,0.5,4,-1,2.5,-3,0] // /10 -9 (winner! inspired by other answers)
// .map used as .reduce
ranges.map((e, i)=> { // e: current element, i: current index
totalValidClubs += ( // increment total 'valid' counter if within range
i%2 == 1 ? 0 : // skip odd indexes, will use i & i+1 on even indexes only
distance>=e && distance<=ranges[i+1] ? 1 : 0) // if even index and distance is between ranges[i] & [i+1] (inclusive), increment by 1.
}, totalValidClubs=0); // initialize valid club counter as 0
return totalValidClubs;
}
05AB1E , 38 36 bytes
38 bytes
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z"Ç2ôε.SOÄ2‹}O
Soy malo comprimiendo :( Lo mejor que se me ocurrió es convertir cada número en un carácter ASCII.
Explicación:
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z"Ç2ôε.SOÄ2‹}O
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z" Ranges of clubs as ASCII chars
Ç Convert to values
2ô Split into chunks of two
ε } Map on pairs
.S -1 if lower than input, 1 if greater, 0 it equal
O Sum the result of the pair
Ä Absolute value
2‹ Is it lower than 2? (The only cases the absolute value is 2 are when the input is out of range)
O Now we have list of 0 and 1 for each range. Sum it up :)
¡Pruébelo en línea!
36 Bytes (gracias a @ovs)
"ÈĄ´ëªÒ ȹª xn_Ps<Z"Ç2ôε-P(d}O
Usando el -P(dmapa interno, que restará el par con la entrada, produzca (los valores fuera de rango serán positivos), luego aplique negativecon (y verifique si el valor no es negativo usando d.
¡Pruébelo en línea!
> <> , 51 bytes
"Çɳº©«Ÿ¡•—‹ƒwÓmt^ìO["1&{:})${:}(*&+&55*0l3)?.&n;
(contiene 7 imprimibles)
¡Pruébelo en línea!
Dado que hay al menos 1 club para cada entrada, uno puede reorganizar los rangos para deshacerse de un rango, lo que tiene el beneficio adicional de eliminar la parte "260" que está apenas fuera del rango de un byte.
Desmos , 106 bytes:
f(d)=total(\left\{join([18...11],[9.5,8,6,20])*10<=d<=[47,42,40,37,34,32,30,28,26,23,18,52]*5:1,0\right\})
Ver gráfico en línea
Elimine f(d)=y reste 5 bytes si está de acuerdo con usar un control deslizante como entrada.
APL, 52 45 50 bytes:
{+⌿1=(↓12 2⍴⎕ucs'Èą´ìªÓ ɺ«¡xn_Pt<[')∘.⍸⍵}
¡Pruébelo en línea!