Golf um gráfico de golfe
Dada uma distância em metros como um inteiro \$60\le d \le 260\$, retorne o número de clubes que podem ser usados de acordo com a seguinte tabela arbitrária, onde ambos \$min\$e \$max\$ são 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
Os nomes dos clubes são fornecidos apenas para informação.
Claro, a escolha do clube depende de vários outros parâmetros. Por exemplo, o Sand Wedge foi projetado para escapar de um depósito de areia. Mas, para os fins deste desafio, apenas a distância importa.
Este é, sem dúvida, um desafio de golfe de código .
Exemplo
Para \$d=130\$, podemos escolher 6-iron , 7-iron , 8-iron ou 9-iron , então a resposta esperada é \$4\$.
Casos de teste
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
Ou 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
Respostas
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 ..........
Listagem:
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
Função chamável, entrada dem DX, saída em BL.
Sem compressão (os dados são apenas 24 22 bytes em binário de qualquer maneira) apenas uma comparação de tabela.
Edit: adereços enormes para @SE - pare de disparar os mocinhos para reorganizar a lista e eliminar a necessidade de compensar o dvalor, economizando 5 bytes !
O programa de teste é executado:
Versão 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
Isso é fortemente inspirado pela resposta de Jonathan Allan . Isso usa uma tabela de valores de donde o número de clubes muda +1ou -1, e um número mágico binário correspondente de 0x5556donde a 1indica uma mudança positiva e 0indica uma mudança negativa.
Infelizmente, isso não ajuda muito aqui, já que a codificação da tabela original é de 24 bytes versus as 22 transições mais o número mágico de 3 bytes, então é realmente maior. Foi divertido tentar!
Python 3 , 71 bytes
lambda n:sum(a<=n/5<=b for a,b in zip(b'($" ',b'4/*(%" '))
Experimente online!
As strings de byte contêm alguns não imprimíveis, sua forma de escape é b'($" \x1e\x1c\x1a\x18\x16\x13\x10\x0c'e 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))$ $$ '))
Experimente online!
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}])
Experimente online!
A última condição também pode ser escrita a%10<1<a/10<7,a==90com o mesmo comprimento.
Jelly , 25 bytes
“Ḳœẹ“rɓ?’ḃ5×5“ZO‘;"Ä⁸>§I‘
Um programa completo que imprime o resultado (ou um Link monádico que retorna uma lista de um único elemento).
Experimente online! Ou veja o conjunto de testes .
Como?
Para qualquer entrada válida, em \$[60,260]\$podemos usar pelo menos um clube. Para qualquer jarda dada, em \$[61,260]\$, podemos usar o mesmo, um a mais ou um taco a menos do que poderíamos usar com um metro a menos. O código abaixo codifica as jardas em que o número de tacos disponíveis aumenta e aquelas em que o número de tacos disponíveis diminui e usa isso para calcular o 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]
Experimente online!
-5 bytes graças ao xash
Codifica listas como números na base 4, reconstrói e usa o índice de intervalo I.para contar em quantos intervalos a entrada se enquadra.
R , 77 76 72 bytes
Editar: -4 bytes graças 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))
Experimente online!
Solução bastante ingênua, mas se beneficia da vetorização automática de R e de seu :operador de sequência.
Python 3 , 180 155 153 97 88 bytes
lambda n:sum(a<=chr(n)<b for a,b in zip('<P_nx ª´È','[t¡«ºÉÓìą'))
Experimente online!
K (ok) , 85 82 bytes
Solução:
{+/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*
Experimente online!
Explicação:
Decididamente ingênuo; altamente provável que esta seja uma abordagem ruim. Embora bom golfe por ngn para simplificar a lógica de comparação! .
{+/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 graças 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]
Experimente online!
Explicação: Uma força bruta simples para armazenar a lista de respostas e imprimir o índice necessário.
Carvão , 44 bytes
ＮθＩΣＥ¹²⁻›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
Experimente online! O link é para a versão detalhada do código. Porta da resposta de @JonathanAllen. Explicação:
Ｎθ
Entrada d.
ＩΣＥ¹²⁻
Mapeie os 12 clubes e imprima a soma dos resultados lançados em uma sequência de tirar as diferenças entre ...
›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι
... dcomparado com 59adicionado a 5vezes a soma digital do prefixo da string compactada 43322222224, e ...
›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
... dcomparado com 90adicionado a 5vezes a soma digital do prefixo da string compactada 53222233235.
Resposta anterior de 48 bytes:
ＮθＩΣＥＩ⪪”)¶∧!✂η}⌊⍘⪫⪫⊕#<e⌊W[qＹ9¤…”²∧›θ⁻×⁵ι﹪κ²⊖⊗﹪κ²
Experimente online! O link é para a versão detalhada do código. Explicação: As distâncias final e inicial dos 12 tacos são divididas a partir de uma sequência comprimida de inteiros de 12 a 52 que são multiplicados por 5. dé comparada a todos eles, pontuando 1para distâncias maiores ou iguais em posições ímpares e -1para distâncias maiores em pares posições e o total final é impresso.
Python 3 ,
62
60 bytes
lambda d:sum(b//25<=b%25+23-d/5<=7for b in b'BUNSWYQ+-}')+1
Experimente online!
Há um caractere invisível (no Stack Exchange) \x18no final da string.
Eu acho que é possível alcançar taxas de compressão mais agressivas na maioria dos não-esolangs.
Como um pequeno incentivo, aqui estão minhas próprias pontuações em Python e Node.
Desvendarei ambos os trechos de código abaixo assim que uma resposta mais curta ou igualmente longa for postada (ou atualizada) em qualquer um dos idiomas ou às 14h UTC na sexta-feira, 21 de agosto de 2020, no improvável evento de que essa resposta não seja publicada até então.
EDIT (2020-08-19): Parabéns a @flornquake por ser o primeiro a postar uma resposta Python abaixo de 70 bytes, usando uma ideia semelhante à minha, mas levando-a um passo adiante para um total de 62 bytes!
Python 3.8 (pré-lançamento) , 70 bytes
lambda d,n=12:sum((n:=n+x//8-4)<=d/5<=n+x%8+6for x in b' A980001225F')
Experimente online!
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
Experimente online!
Perl 5 , 70 bytes
O primeiro byte na string é adicionado em \x##notação para facilitar o teste, mas é um byte literal.
$_=grep"@F">=($k+=(ord>>4)*5)&"@F"<=$k+(15&ord)*5,"\xc6G76&&&'((+L"=~/./g
Armazena os detalhes de cada clube (dividido por 5) como um byte onde os primeiros quatro bits são a diferença do início do intervalo anterior e o início deste, e os segundos quatro bits são a diferença entre o início deste intervalo e o fim.
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
Experimente online!
C (gcc) , 83 75 bytes
(nem todos os caracteres são exibidos corretamente na troca de pilha, mas estão corretos no TIO)
*i;c;f(d){c=0;for(i=L"ÈĄ´ëªÒ ȹª xn_Ps<Z";*i;c+=d/ *i++&*i++/d);d=c;}
Experimente online!
Io , 89 bytes
method(a," \"$("asList select(i,v,v at(0)<=a/5and a/5<=" \"%(*/4"at(i))size)
Experimente online!
Pyth , 36 bytes
s/RC-QTrV"2FUdnx ª¾""Qjy¡°¿Éâû
Experimente online!
Explicação
"... # 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: aplicado -9 a intervalos e entrada após divisão, em vez de apenas dividir por 10 (inspirado em outras respostas, entendi por que valeu a pena depois de observar meu intervalo / 10 números)
-15 bytes graças às melhorias de Arnauld
-5 bytes graças às novas melhorias 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
Experimente online!
Solução bastante ingênua, mas não me senti confortável tentando métodos mais complexos usados em outras respostas (sem mencionar que não tenho certeza se eles são possíveis / vale a pena jogar golfe com JS!). No entanto, ficarei feliz em aceitar conselhos / melhorias.
Não minimizado e explicado (um pouco desatualizado, mas ainda explica o processo geral):
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
Eu não sou bom em compactar :( O melhor que eu poderia imaginar é converter cada número em um caractere ASCII.
Explicação:
"ÈĄ´ëªÒ È–¹Œª‚ 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 :)
Experimente online!
36 bytes (graças a @ovs)
"ÈĄ´ëªÒ ȹª xn_Ps<Z"Ç2ôε-P(d}O
Usando o -P(dmapa interno, que subtrairá o par com a entrada, produza-o (valores fora do intervalo serão positivos), aplique negativecom (e verifique se o valor não é negativo usando d.
Experimente online!
> <> , 51 bytes
"Çɳº©«Ÿ¡•—‹ƒwÓmt^ìO["1&{:})${:}(*&+&55*0l3)?.&n;
(contém 7 não imprimíveis)
Experimente online!
Uma vez que há pelo menos 1 clube para cada entrada, pode-se reorganizar os intervalos para se livrar de um intervalo, o que tem o benefício adicional de remover a parte "260" que está apenas fora do intervalo de um 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 online
Exclua f(d)=e subtraia 5 bytes se quiser usar um controle deslizante como entrada.
APL, 52 45 50 bytes:
{+⌿1=(↓12 2⍴⎕ucs'Èą´ìªÓ ɺ«¡xn_Pt<[')∘.⍸⍵}
Experimente online!