Golf une carte de golf
Étant donné une distance en mètres sous forme d'entier \$60\le d \le 260\$, renvoie le nombre de clubs pouvant être utilisés selon le tableau arbitraire suivant, où les deux \$min\$et \$max\$ sont inclusifs:
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
Remarques
Les noms des clubs sont donnés à titre indicatif.
Bien entendu, le choix du club dépend de plusieurs autres paramètres. Par exemple, le Sand Wedge est conçu pour s'échapper d'un bunker de sable. Mais aux fins de ce défi, seule la distance compte.
C'est sans aucun doute un défi de code-golf .
Exemple
Pour \$d=130\$, nous pouvons choisir 6 fer , 7 fer , 8 fer ou 9 fer , donc la réponse attendue est \$4\$.
Cas de test
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 sous forme de listes:
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
Réponses
code machine x86-16, 47 42 octets
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 ..........
Référencement:
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
Fonction appelable, l' entrée ddans DX, la production BL.
Pas de compression (les données ne sont 24 22 octets en binaire de toute façon) juste une comparaison de table.
Edit: D'énormes accessoires pour @SE - arrêtez de tirer les bons pour réorganiser la liste et éliminer le besoin de compenser la dvaleur, économisant 5 octets !
Le programme de test s'exécute:
Autre version, 50 octets
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
Ceci est fortement inspiré par la réponse de Jonathan Allan . Celui - ci utilise une table de valeurs doù le nombre de clubs transitions soit +1ou -1, et un binaire correspondant nombre magique d' 0x5556doù 1indique un changement positif et 0indique un changement négatif.
Malheureusement, cela n'aide pas beaucoup ici car l'encodage de la table d'origine est de 24 octets contre les 22 transitions plus le nombre magique de 3 octets, donc c'est vraiment plus grand. C'était amusant d'essayer cependant!
Python 3 , 71 octets
lambda n:sum(a<=n/5<=b for a,b in zip(b'($" ',b'4/*(%" '))
Essayez-le en ligne!
Les chaînes d'octets contiennent des non imprimables, leur forme échappée est b'($" \x1e\x1c\x1a\x18\x16\x13\x10\x0c'et b'4/*(%" \x1e\x1c\x1a\x17\x12'.
Python 3 , 71 octets
lambda n:sum(b>n-a*5>-1for a,b in zip(b'($" ',b'=8))$ $$ '))
Essayez-le en ligne!
Python 3.8 , 90 86 octets
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}])
Essayez-le en ligne!
La dernière condition peut également être écrite a%10<1<a/10<7,a==90avec la même longueur.
Gelée , 25 octets
“Ḳœẹ“rɓ?’ḃ5×5“ZO‘;"Ä⁸>§I‘
Un programme complet qui imprime le résultat (ou un lien monadique qui renvoie une liste à un seul élément).
Essayez-le en ligne! Ou voir la suite de tests .
Comment?
Pour toute entrée valide, dans \$[60,260]\$nous pouvons utiliser au moins un club. Pour tout métrage donné, en \$[61,260]\$, nous pouvons utiliser le même club, un de plus ou un de moins que ce que nous aurions pu faire pour un mètre de moins. Le code ci-dessous encode les métrages auxquels le nombre de clubs disponibles augmente et ceux auxquels le nombre de clubs disponibles diminue et l'utilise pour calculer le résultat.
“Ḳœẹ“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 octets
1#.1=(59 90+/\@,|:5*2+4#.inv 2424834 3408207)I."1]
Essayez-le en ligne!
-5 octets grâce à xash
Encode les listes sous forme de nombres en base 4, reconstruit, puis utilise l'index d'intervalle I.pour compter le nombre de plages dans lesquelles l'entrée se situe.
R , 77 76 72 octets
Edit: -4 octets grâce à 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))
Essayez-le en ligne!
Solution assez naïve, mais bénéficie de la vectorisation automatique de R et de son :opérateur de séquence.
Python 3 , 180 155 153 97 88 octets
lambda n:sum(a<=chr(n)<b for a,b in zip('<P_nx ª´È','[t¡«ºÉÓìą'))
Essayez-le en ligne!
K (oK) , 85 82 octets
Solution:
{+/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*
Essayez-le en ligne!
Explication:
Décidément naïf; très probable que ce soit une mauvaise approche. Bien joli golf par ngn pour simplifier la logique de comparaison! .
{+/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
Supplémentaire:
- -3 octets grâce à
ngn
Python 3 , 105 octets
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]
Essayez-le en ligne!
Explication: Une simple force brute pour stocker la liste des réponses et imprimer l'index requis.
Charbon , 44 octets
ＮθＩΣＥ¹²⁻›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
Essayez-le en ligne! Le lien est vers la version verbeuse du code. Réponse de Port of @ JonathanAllen. Explication:
Ｎθ
Entrée d.
ＩΣＥ¹²⁻
Cartographiez les 12 clubs et imprimez la somme des résultats exprimés en chaîne de prise des différences entre ...
›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι
... dcomparé à 59ajouté aux 5fois la somme numérique du préfixe de la chaîne compressée 43322222224, et ...
›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
... dpar rapport à 90ajouté aux 5fois la somme numérique du préfixe de la chaîne compressée 53222233235.
Réponse précédente de 48 octets:
ＮθＩΣＥＩ⪪”)¶∧!✂η}⌊⍘⪫⪫⊕#<e⌊W[qＹ9¤…”²∧›θ⁻×⁵ι﹪κ²⊖⊗﹪κ²
Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication: Les distances de fin et de départ des 12 clubs sont divisées à partir d'une chaîne compressée d'entiers de 12 à 52 qui sont multipliés par 5. dest comparée à eux tous, marquant 1pour des distances plus grandes ou égales en positions impaires et -1pour des distances plus grandes en paires positions et le total final est imprimé.
Python 3 ,
62
60 octets
lambda d:sum(b//25<=b%25+23-d/5<=7for b in b'BUNSWYQ+-}')+1
Essayez-le en ligne!
Il y a un caractère invisible (sur Stack Exchange) \x18à la fin de la chaîne.
Je pense qu'il est possible d'obtenir des taux de compression plus agressifs dans la plupart des non-esolangs.
Pour vous inciter un peu, voici mes propres scores en Python et Node.
Je dévoilerai les deux extraits de code ci-dessous dès qu'une réponse plus courte ou tout aussi longue sera publiée (ou mise à jour) dans l'une ou l'autre langue, ou à 14h00 UTC le vendredi 21 août 2020 dans le cas peu probable où aucune réponse de ce type ne serait publiée d'ici là.
EDIT (2020-08-19): Félicitations à @flornquake pour avoir été le premier à publier une réponse Python en dessous de 70 octets, en utilisant une idée similaire à la mienne mais en la poussant un peu plus loin pour un total de 62 octets!
Python 3.8 (pré-version) , 70 octets
lambda d,n=12:sum((n:=n+x//8-4)<=d/5<=n+x%8+6for x in b' A980001225F')
Essayez-le en ligne!
JavaScript (Node.js) , 74 octets
d=>Buffer(' A980001225F').map(x=>t-=d/5<(n+=x-32>>3)|d/5>n+x%8+6,n=t=12)|t
Essayez-le en ligne!
Perl 5 , 70 octets
Le premier octet de la chaîne est ajouté en \x##notation pour faciliter les tests, mais est un octet littéral.
$_=grep"@F">=($k+=(ord>>4)*5)&"@F"<=$k+(15&ord)*5,"\xc6G76&&&'((+L"=~/./g
Stocke les détails de chaque club (divisés par 5) sous forme d'octet où les quatre premiers bits sont la différence entre le début de la plage précédente et le début de celle-ci, et les quatre seconds bits sont la différence entre le début de cette plage et la 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
Essayez-le en ligne!
C (gcc) , 83 75 octets
(tous les caractères ne s'affichent pas correctement lors de l'échange de pile, mais sont corrects dans TIO)
*i;c;f(d){c=0;for(i=L"ÈĄ´ëªÒ ȹª xn_Ps<Z";*i;c+=d/ *i++&*i++/d);d=c;}
Essayez-le en ligne!
Io , 89 octets
method(a," \"$("asList select(i,v,v at(0)<=a/5and a/5<=" \"%(*/4"at(i))size)
Essayez-le en ligne!
Pyth , 36 octets
s/RC-QTrV"2FUdnx ª¾""Qjy¡°¿Éâû
Essayez-le en ligne!
Explication
"... # 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 octets
-10 octets: appliqué -9 aux plages et entrée après division plutôt que de diviser seulement par 10 (inspiré par d'autres réponses, compris pourquoi cela en valait la peine après avoir observé ma plage / 10 nombres)
-15 octets grâce aux améliorations d'Arnauld
-5 octets grâce aux améliorations supplémentaires 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
Essayez-le en ligne!
Solution assez naïve mais je n'étais pas à l'aise d'essayer des méthodes plus complexes utilisées dans d'autres réponses (sans oublier que je ne sais pas si elles sont même possibles / valent la peine de jouer au golf dans JS!). Je prendrai volontiers des conseils / améliorations, cependant.
Non minimisé et expliqué (légèrement obsolète mais explique toujours le processus global):
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 octets
38 octets
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z"Ç2ôε.SOÄ2‹}O
Je suis mauvais en compression: (Le mieux que j'aurais pu penser est de convertir chaque nombre en caractère ASCII.
Explication:
"ÈĄ´ëªÒ È–¹Œª‚ 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 :)
Essayez-le en ligne!
36 octets (merci à @ovs)
"ÈĄ´ëªÒ ȹª xn_Ps<Z"Ç2ôε-P(d}O
En utilisant la -P(dcarte interne, qui soustrayera la paire avec l'entrée, le produit (les valeurs hors plage seront positives), puis appliquez negativeavec (et vérifiez si la valeur est non négative en utilisant d.
Essayez-le en ligne!
> <> , 51 octets
"Çɳº©«Ÿ¡•—‹ƒwÓmt^ìO["1&{:})${:}(*&+&55*0l3)?.&n;
(contient 7 non imprimables)
Essayez-le en ligne!
Puisqu'il y a au moins 1 club pour chaque entrée, on peut réorganiser les plages pour se débarrasser d'une plage, ce qui a l'avantage supplémentaire de supprimer la partie "260" qui est à peine en dehors de la plage d'un octet.
Desmos , 106 octets:
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\})
Afficher le graphique en ligne
Supprimez f(d)=et soustrayez 5 octets si vous êtes d'accord avec l'utilisation d'un curseur comme entrée.
APL, 52 45 50 octets:
{+⌿1=(↓12 2⍴⎕ucs'Èą´ìªÓ ɺ«¡xn_Pt<[')∘.⍸⍵}
Essayez-le en ligne!