Séquence:
- Nous commençons à
1. - Nous ajoutons d'abord la valeur indexée 1 actuelle au nombre précédent de la séquence.
- Ensuite, nous appliquons les opérations mathématiques suivantes dans l'ordre si elles s'appliquent à cette valeur actuelle:
- Divisible par
2? => Addition - Divisible par
3? => Soustraction - Divisible par
4? => (Addition ET) Multiplier - Pas divisible par ni
2,3ni4? -> Continuer avec le résultat actuel
- Divisible par
Production:
Sortez les 100 premiers nombres de cette séquence:
1, 1, 21, 25, 30, 216, 223, 223, 2169, 2179, 2190, 2202, 2215, 2215, 2245, 2261, 2295, 2295, 2333, 2353, 2395, 2417, 56649, 56649, 56699, 56725, 1533033, 1533061, 1533090, 45993600, 45993631, 45993631, 1517792001, 1517792035, 1517792070, 1517792106, 1517792143, 1517792143, 1517792221, 1517792261, 1517792343, 1517792343, 1517792429, 1517792473, 1517792563, 1517792609, 71336257041, 71336257041, 71336257139, 71336257189, 3638149121841, 3638149121893, 3638149121946, 196460052588000, 196460052588055, 196460052588055, 11198222997525633, 11198222997525691, 11198222997525750, 11198222997525810, 11198222997525871, 11198222997525871, 11198222997525997, 11198222997526061, 11198222997526191, 11198222997526191, 11198222997526325, 11198222997526393, 11198222997526531, 11198222997526601, 795073832824398753, 795073832824398753, 795073832824398899, 795073832824398973, 59630537461829934225, 59630537461829934301, 59630537461829934378, 4651181922022734887568, 4651181922022734887647, 4651181922022734887647, 376745735683841525912529, 376745735683841525912611, 376745735683841525912694, 376745735683841525912778, 376745735683841525912863, 376745735683841525912863, 376745735683841525913037, 376745735683841525913125, 376745735683841525913303, 376745735683841525913303, 376745735683841525913485, 376745735683841525913577, 376745735683841525913763, 376745735683841525913857, 35790844889964944961834465, 35790844889964944961834465, 35790844889964944961834659, 35790844889964944961834757, 3543293644106529551221660545, 3543293644106529551221660645
Voici les 10 premiers chiffres de la séquence avec explication:
// Starting number of the sequence:
1
// 1 (previous number in the sequence)
// + 2 (current index in 1-indexed sequence)
// = 3 -> 3 - 2 (3 is divisible by 3, so we subtract the current index 2)
// = 1
1
// 1 (previous number in the sequence)
// + 3 (current index in 1-indexed sequence)
// = 4 -> 4 + 3 (4 is divisible by 2, so we first add the current index 3)
// = 7 -> 7 * 3 (and 4 is also divisible by 4, so we then also multiply the current index 3)
// = 21
21
// 21 (previous number in the sequence)
// + 4 (current index in 1-indexed sequence)
// = 25 (25 is not divisible by 2, 3 nor 4)
25
// 25 (previous number in the sequence)
// + 5 (current index in 1-indexed sequence)
// = 30 -> 30 + 5 (30 is divisible by 2, so we first add the current index 5)
// = 35 -> 35 - 5 (and 30 is also divisible by 3, so we then also subtract the current index 5)
// = 30
30
// 30 (previous number in the sequence)
// + 6 (current index in 1-indexed sequence)
// = 36 -> 36 + 6 (36 is divisible by 2, so we first add the current index 6)
// = 42 -> 42 - 6 (and 36 is also divisible by 3, so we then also subtract the current index 6)
// = 36 -> 36 * 6 (and 36 is also divisible by 4, so we then also multiply the current index 6)
// = 216
216
// 216 (previous number in the sequence)
// + 7 (current index in 1-indexed sequence)
// = 223 (223 is not divisible by 2, 3 nor 4)
223
// 223 (previous number in the sequence)
// + 8 (current index in 1-indexed sequence)
// = 231 -> 231 - 8 (231 is divisible by 3, so we subtract the current index 8)
// = 223
223
// 223 (previous number in the sequence)
// + 9 (current index in 1-indexed sequence)
// = 232 -> 232 + 9 (232 is divisible by 2, so we first add the current index 9)
// = 241 -> 241 * 9 (and 232 is also divisible by 4, so we then also multiply the current index 9)
// = 2169
2169
// 2169 (previous number in the sequence)
// + 10 (current index in 1-indexed sequence)
// 2179 (2179 is not divisible by 2, 3 nor 4)
2179
Règles du défi:
- Si votre langue ne prend en charge rien de plus grand que 2 31 -1, vous pouvez continuer la séquence jusqu'à ce maximum (donc les 46 premiers chiffres, jusqu'à - et y compris -
1,517,792,609). - Le format de sortie est flexible. Vous pouvez renvoyer un tableau ou une liste, une chaîne séparée par des espaces, des virgules, etc. Votre appel.
Règles générales:
- C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation. - Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
- Les failles par défaut sont interdites.
- Si possible, veuillez ajouter un lien avec un test pour votre code.
- Veuillez également ajouter une explication si nécessaire.
code-golf
sequence
number-theory
division
Kevin Cruijssen
la source
la source
Réponses:
05AB1E ,
2423 octets-1 octet grâce à Kevin Crujissen
Essayez-le en ligne!
Explication:
la source
UXpouvoir le supprimer, mais je ne peux pas. Je me retrouve également à 24 octets car il commence à la0place de1. Je l'ai maintenant augmenté avant le moment, mais ensuite nous devons boucler les101temps au lieu de100.. Ah bien.UXune horreur. J'ai essayé de se débarrasser de celui - ci pendant un certain temps et a fini avec un groupe de 24 et 25 variations:1тF=NÌ©+DÑ3L>Ãv®…-*+yè.V,1тL>v=y+©3F®NÌÖiy…+-*Nè.V... Je ne l' ai pas envisager d' utiliser la variable compteur, ce qui est intéressant.тFau lieu deƵ0µ. J'ai édité ça dans, merci! (PS: il devrait vraiment y avoir un seul octet¼¾...)¼¾serait bien, bien que pour être honnête, je ne l'utilise presque jamais comme ça. L'intégré à un octet que je préfère le plus en ce moment est une deuxième©®variable qui ne saute pas. Peut-être à partir d'une chaîne vide""comme vous l'avez mentionné dans un autre défi auparavant.R,
858279767270 octetsnon golfé:
Merci à @rturnbull d'avoir souligné que je peux utiliser
(!z%%3)au lieu de(z%%3<1)vérifier les modules, et que la définition d'zun se produit lors de sa première utilisation.Détourné 3-4 caractères en abusant de l'extension vectorielle: la réponse a commencé à l'origine
s=1:56...mais nous n'avons pas besoin de le faire, la longueur dessera allongée au besoin.Sauvegardé 3 octets de plus en remplaçant la dernière condition par un appel à la
"if"fonction (oui, c'est une fonction appropriée dans R!)Enregistré 4 octets de plus en remplaçant
sparT, qui est une valeur intrinsèque égale àTRUEqui est également égale à1. Je l'ai réalisé en même temps que @rturnbull (honnête!)Cela souffre de quelques problèmes numériques une fois que nous dépassons 2 ^ 52, mais je ne peux rien y faire --- R ne peut utiliser que des
doubletypes pour des nombres supérieurs à2^31-1, mais ils stockent des entiers jusqu'à 2 ^ 52 exactement. Ainsi, je ne suis autorisé à sortir que les 56 premiers termes (le dernier terme qui est «droit»), ce qui économise un octet sur le cas de 100 longueurs.Voici la sortie de la version 56:
la source
1,517,792,609). ", Mais ceci de s'applique également pour des nombres différents de 32 bits. Si R ne peut pas gérer quelque chose de plus grand, alors les 56 premiers chiffres sont tout à fait corrects. Et oui, si vous le savez ne peut jamais aller au- dessus de 56, vous pouvez changer le100pour56enregistrer un octet.z%%2<1(et ainsi de suite) en!z%%2abusant de la conversion de type implicite.!ne pas battre%%, mais apparemment c'est le cas!Tet l'utiliser à la place des, ce qui vous permet de supprimer les=1;, d'économiser quatre autres octets. Il est possible de replier la définition dezdans la définition des[i](enfin,T[i]maintenant), comme ceci:, ceT[i]=((z=i+T[i-1])+ ...qui signifie que vous pouvez perdre les accolades, économisant ainsi plus d'octets. EDIT: Oh, je vois que vous avez fait l'Taffaire pendant que j'écrivais mon commentaire! Les grands esprits pensent de la même façon, disent-ils.Python 3,
8278767472 octetsProduction:
Les suggestions sont les bienvenues!
la source
whileboucle et réorganisez l'arithmétique pour -2 .05AB1E ,
343130 octetsEssayez-le en ligne!
Explication
la source
Python 2, 76 octets
Implémentation assez standard, je pense qu'en utilisant une instruction exec plutôt qu'une boucle while, vous avez économisé environ 2 octets. Une méthode récursive peut être plus courte, j'imagine que xnor apparaîtra bientôt;)
Si j'utilisais les mises à jour que TheNumberOne a découvert, je serais à 69 octets (mais alors je copierais)
Production:
la source
JavaScript,
7563 octetsUne autre version:
Les deux s'arrêtent à l'index 57 (indexé 0) car c'est à ce moment-là que la sortie dépasse la taille de numéro sécurisée de JavaScript (2 53 - 1). Il s'avère qu'une boucle est bien plus courte qu'une fonction récursive, même avec ES6:
Celui-ci renvoie un tableau des 57 premiers éléments.
la source
mapversion pour être complète et elle a également cadencé à 75 octets.Brain-Flak
476 466 462 456446 octetsEnregistré 6 octets grâce à Wheat Wizard
Essayez-le en ligne!
C'est vraiment lent. TIO ne peut pas gérer les 100 nombres entiers (la limite semble être 22 ou 23). Ainsi, cet exemple ne génère que les 20 premiers, mais le code fonctionnerait également pour 100.
Brève explication:
la source
({}<>[({})]<>)(<()>)peut être remplacé par(<({}<>[({})]<>)>)Java 7, 316 octets
Code non testé et testé:
Essayez-le ici.
Production:
la source
C #, 120 octets
Tout comme aucune personne sensée ne jouerait au golf à Java, aucune personne sensée ne devrait jouer au golf en C #! Mais vissez ça, je voulais voir ce que je peux faire. La
1Mconversionfest une décimale qui a suffisamment de précision pour cette réponse sans que j'aie à écriredecimal. De plus, l'incrémentation sur place économise quelques octets sur ma réponse Python. au bout du compte, il reste encore 50 octets de plus.Voici la version la plus lisible (et exécutable):
la source
whileforfor(int n=1;n<101;)void k(){for(decimal f=1,d,n=1;n<101;)Console.WriteLine(f=((d=++n+f)+n*((d%2<1?1:0)-(d%3<1?1:0)))*(d%4<1?n:1));}Lot, 110 octets
Utilise la formule @ETHproductions, mais a été légèrement modifiée car Batch n'en a pas
?:. Le lot utilise des entiers signés 32 bits, de sorte que les boucles s'arrêtent à 46.la source
Perl, 75 octets
Le code génère chaque valeur sur une nouvelle ligne et calcule les 100 valeurs.
la source
-Mbigint, aucune parenthèse autour du1..100, et!($a%2)*$_au lieu de($a%2?0:$_)(même poura%3..) devrait économiser quelques octets;)Haskell,
7064 octetsscanl1(#)[1..100]renvoie la liste avec les 100 premiers éléments. Un octet de moins si je peux rester dans la plage 2 ^ 31 (->[1..46]).scanl1est commefoldl1mais recueille les résultats intermédiaires dans une liste. Les tests de divisibilité se font via la fonction d'aide%qui renvoie0^0 = 1si divisible et0^x = 0sinon.la source
J, 46 octets
Applique la méthode décrite dans le défi.
Usage
La commande supplémentaire
(,.~#\)est utilisée pour ajouter des indices à chaque valeur.la source
Perl 6 , 62 octets
Essayez-le en ligne!
VRAIMENT dû travailler pour que mon nombre d'octets soit inférieur à celui des autres solutions autres que celles du golf.
la source