À l'aide du tableau suivant ( source ), écrivez du code qui prend les noms de deux planètes et renvoie la distance entre elles:
+-------------------+---------------+
| Planets | Distance (km) |
+-------------------+---------------+
| Mercury -> Venus | 50290000 |
| Venus -> Earth | 41400000 |
| Earth -> Mars | 78340000 |
| Mars -> Jupiter | 550390000 |
| Jupiter -> Saturn | 646270000 |
| Saturn -> Uranus | 1448950000 |
| Uranus -> Neptune | 1627450000 |
| Neptune -> Pluto | 1405380000 |
+-------------------+---------------+
Exemples, entrée puis sortie:
Mercury, Mars
170030000
Neptune, Jupiter
-3722670000
Earth, Earth
0
Notez le signe négatif là-bas, car Jupiter précède Neptune. Ce sont aussi tous des entiers.
Pluton n'a pas à être inclus (principalement en raison d'une orbite étrange qui rend difficile la détermination de la distance - cette distance donnée est mon propre calcul, mais comme Pluton est désormais célèbre ...).
Par distances entre les planètes, je veux dire des orbites - je ne m'attends pas à une date et à savoir où elles sont.
C'est le golf de code, le code le plus court gagne.
Mercury, Mars -> 170030000.0
?Réponses:
CJam,
545144 octetsEssayez-le en ligne dans l' interpréteur CJam .
Idée
Nous utilisons une fonction de hachage simple pour identifier les huit planètes. En considérant chaque nom comme le tableau de ses points de code, en les convertissant de la base 26 en entier et en prenant le résultat modulo 93 puis modulo 8, Mercure , Vénus , Terre , etc. mapper en 2 , 4 , 0 , 1 , 3 , 5 , 6 et 7 .
Maintenant, nous choisissons un point situé à 320 000 km derrière Neptune et calculons les distances des huit planètes jusqu'à ce point. Après avoir laissé tomber quatre zéros à la fin et réorganisé les planètes pour qu'elles correspondent aux 8 index d'en haut, nous obtenons le tableau
qui, si nous codons chaque entier en base 70, donne ce qui suit:
En se rappelant que deux chiffres adjacents
(A B)
peuvent être remplacés par((A-1) (B+70))
, nous pouvons modifier le tableau ci-dessus afin que tous les entiers puissent être encodés en caractères ASCII imprimables:Code
la source
Python 2,
149147142138128123119 OctetsUtilise simplement une simple recherche pour déterminer les distances à utiliser :) Cela définit une fonction anonyme, donc pour l'utiliser, vous devrez lui donner un nom.
Merci à Sp3000 pour les idées qui ont sauvé un tas d'octets!
Indenté correctement et légèrement non golfé pour plus de lisibilité:
Appelez comme ça:
la source
Prolog,
190174151 octetsMerci à Fatalize pour ses conseils.
la source
s(A, B, R)
au lieu d'écrireR
? Rien n'est spécifié pour les sorties, donc un retour de prédicat devrait convenir.g
pourg(A,X):-sub_atom(A,2,2,_,B),member(B:X,[rc:0,nu:5029,rt:9169,rs:17003,pi:72042,tu:136669,an:281564,pt:444309]).
et supprimer tous les faits pour les planètes. C'est moins cool que=..
mais il est plus court pour obtenir un mappage de valeur-cléJavaScript (ES6),
115110 bytesIl s'agit d'une fonction anonyme, vous devrez donc la stocker dans une variable (
f=...; f("Earth", "Mercury")
) ou l'utiliser comme expression entre parenthèses ((...)("Earth", "Mercury")
.Cette chaîne en désordre est les deux premières lettres de chaque planète, suivies de la distance de cette planète à Mercure (divisée par 10000, pour économiser de l'espace). La fonction intérieure
g
fait ce qui suit:k
),k[0]+k[1]
),Ea(\d*)
),1e4
) et renvoie le résultat.En soustrayant une distance de Mercure de l'autre, nous obtenons la distance entre les planètes.
la source
btoa
ont des points de code inférieurs à 256, donc ISO 8859-1 codera chaque caractère en utilisant un seul octet.Java,
274272264 octets (inclut Pluton!)Entrée sortie:
Espacé et tabulé:
la source
int
etint[]
sur une seule ligne si le tableau vient en dernier: Likeint i=0,j=1,k[]={};
10000
par1e4
.e > w
vous pouvez couper un caractère en utilisant l'opérateur va à:while(e-->w)
qui est de 12 caractères, au lieu defor(;e--!=w;)
13.Python, 118 octets
n
est une fonction qui renvoie la distance de Mercure.La chaîne
"VeEaMaJuSaUrNe"
est les deux premiers caractères de tous les noms de planète sauf Mercure .find
ne peut pas trouver Mercure et retournera donc -1. -1/2 est toujours -1 donc c'est le dernier élément du tuple, qui est 0.Code de test simple:
la source
APL,
979585 octetsCela crée une fonction dyadique sans nom qui prend la planète d'origine comme argument de gauche et la planète de destination comme droite.
Vous pouvez l' essayer en ligne !
la source
J-- , 226 octets
Je ne pense pas que cela compte car je faisais le langage pendant que la question était en suspens, mais c'était surtout un test de la façon dont je pouvais compresser le code Java. Ceci est totalement et complètement basé sur la réponse de DeadChex .
Voici comment l'utiliser:
la source
Pyth -
5953 octetsEncode la distance en points de code unicode.
La recherche de nom est plutôt cool car elle tourne en boucle. Merci à @Dennis d'avoir suggéré l'index 14 comme recherche sans collision!
Essayez-le ici en ligne .
la source
Bash, 140 octets
la source
CoffeeScript,
183180 octetsNon minifié:
la source
Rubis, 168 octets
Il est conçu comme un script à exécuter à partir de la ligne de commande, donc utilise
ARGV
. Courir commela source
Haskell,
160158157 octetsExemple d'utilisation:
Comment ça marche: je définis un nouveau type de données
P
où les noms des constructeurs sont les noms des planètes. Je l'ai également mis dans laEnum
classe, c'est-à-dire que j'obtiens un mappage aux entiers viafromEnum
(dans l'ordre de définition, en commençant parMercury
->0
). Cet entier peut être utilisé comme index pour la liste des distances.Edit: @Kritzefitz a trouvé deux octets à enregistrer et @Alchymist un autre. Merci!
la source
fromEnum x
et enregistrer deux octets.Julia,
206203190 octetsCela crée une fonction sans nom qui accepte deux chaînes et renvoie un entier. Pour l'appeler, donnez-lui un nom.
Non golfé + explication:
la source
Java,
257228 octetsstatic long d(String...s){...}
résout le défi. L'entrée requiert des noms de planètes correspondant exactement aux noms des constantes de l'énumération. J'adore la façon dont java fournit une méthode de conversion chaîne en énumération pour moi <3Usage:
Z.d("Mercury","Pluto")
résultats5848470000
Z.d("Pluto","Mercury")
résultats-5848470000
Z.d("Uranus","Neptune")
résultats1627450000
Z.d("Mars","Pluto")
résultats5678440000
la source
Macro préprocesseur C (gcc) , 146 octets
Essayez-le en ligne!
la source