Générer des numéros de lundi

35

Les nombres de lundi , tels que définis par Gamow dans cette question sur Puzzling, sont des entiers positifs N avec les trois propriétés suivantes:

  • La représentation décimale de N ne contient pas le chiffre 0
  • La représentation décimale de N ne contient aucun chiffre deux fois
  • N est divisible par chaque chiffre D apparaissant dans sa représentation décimale

Notez que ceux-ci sont également connus, dans l’OEIS, sous les numéros de Lynch-Bell .

Exemples:

  • 15est un nombre de lundi, car il est divisible par les deux 1et 5et satisfait aux deux autres conditions
  • 16n'est pas, car ce n'est pas divisible par 6.
  • Le nombre 22n'est pas, car s'il répond aux conditions 1 et 3, il échoue à la condition 2.

Voici la liste des 25 premiers numéros du lundi pour vous aider à démarrer (il y a un total de 548):

1 2 3 4 5 6 7 8 9 12 15 24 36 48 124 126 128 132 135 162 168 175 184 216 248

Le défi consiste ici à écrire le code le plus court qui génère la séquence complète des nombres du lundi, de 1 à 9867312 (prouvé sur cette question comme étant le plus grand possible).

Votre code ne doit prendre aucune entrée et la sortie doit être au format STDOUT ou équivalent, avec le délimiteur de votre choix. Toutes les règles habituelles de code-golf s'appliquent et les échappements standards sont interdits.

Classement

AdmBorkBork
la source
5
Connexes
FryAmTheEggman le
1
Aussi appelé numéros de Lynch-Bell .
Geobits
@ Geobits Merci - je ne pouvais pas le trouver sur OEIS pour une raison quelconque.
AdmBorkBork
8
Vous auriez dû poster ce défi hier ...
mbomb007
2
@ mbomb007 J'aurais - je n'ai pas vu la question de Gamow avant ce matin!
AdmBorkBork

Réponses:

1

Gelée , 8 octets

ȷ7Dg⁼QƲƇ

Fonctionne localement en moins de huit minutes.

Essayez-le en ligne! (modifié pour trouver des nombres de six chiffres ou moins)

Comment ça marche

ȷ7Dg⁼QƲƇ  Main link. No arguments.

ȷ7        Set the return value to 10**7.
       Ƈ  Comb; promote 10**7 to [1, ..., 10**7], then keep only those n in the range
          for which the link to the left returns a truthy value.
      Ʋ     Combine the four links to the left into a monadic chain.
  D           Decimal; yield n's digit array in base 10.
   g          Take the GCD of each digit and n.
     Q        Yield the unique digits of n.
    ⁼         Test both results for equality.
Dennis
la source
16

Python 2, 85 octets

print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]

Imprime une liste.

Je combine essentiellement deux de mes réponses aux défis précédents:

Merci à xsot pour 1 octet économisé en combinant mieux les conditions.

Xnor
la source
Vous pouvez enregistrer un octet:print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]
xsot le
11

Perl, 61 47 octets

Code de 46 octets + paramètre de ligne de commande de 1 octet.

/(.).*\1|0/||1*s/./$_%$&/rge||print for 1..1e7

Usage:

perl -l entry.pl

Explication

/(.).*\1|0/ renvoie 1 si le nombre en cours de test contient un caractère en double ou un 0

s/./$_%$&/rgeremplace chaque chiffre par la valeur du nombre sous test% du chiffre. Par exemple, 15 -> 00, 16 -> 04 (parce que 16% 6 = 4). Cela signifie que toute entrée qui est divisible par tous ses chiffres sera composée de tous les 0, sinon elle contiendra un chiffre> 0. Afin de traiter cela comme un nombre, nous * 1, ce qui signifie que tout nombre en test renverra 0 pour ce bloc s'il est divisible par tous ses chiffres, sinon> 0.

En séparant ces deux instructions et l'empreinte avec 'ou', si l'une des deux premières conditions renvoie> 0, la condition correspond et les parties suivantes de l'expression ne seront pas évaluées. Si et seulement si les deux conditions précédentes sont 0, l'impression sera exécutée. Le -ldrapeau permet d’ajouter une nouvelle ligne après chaque impression.

Jarmex
la source
Très agréable. Vous pouvez économiser quelques octets en le rendant Perl 5.10 et en utilisant sayau lieu de print+ -l:-)
xebtl
Merci pour la suggestion! Je pensais qu'il say fallait d'abord une déclaration explicite ?
Jarmex
@Jarmex J'ai peut-être commencé la tradition de la prise gratuite use feature 'say'ou use 5.012gratuite - je mentionne toujours le moment où je le fais, et personne ne l'a jamais contestée. J'ai vu quelques autres faire la même chose :)
hobbs
2
@hobbs Cette réponse à la méta indique "Le consensus jusqu'à présent sur SO était ici:" le -M5.010, le cas échéant, est gratuit "".
xebtl
2
Utilisation mapet sayréduction à 43: essayez-le en ligne!
Xcali
10

Pyth, 22 21

f&.{`T!f%T|vY.3`TS^T7

Merci à Jakube pour avoir joué 1 octet de format inutile.

Fortement inspiré par cette réponse CW à la question connexe.

J'ai un collage du résultat ici , à partir du moment où il a imprimé la nouvelle ligne séparée, maintenant il est imprimé sous forme de liste pythonique.

Je recommanderais de ne pas l' essayer en ligne, sauf si vous utilisez un nombre inférieur à 7 ... Je l'ai défini sur 2 dans ce lien.

Filtres de 1à 10^7-1qui couvre toutes les valeurs nécessaires. Cette version peut provoquer une erreur de mémoire si elle ne peut pas faire la liste S^T7, ce qui est similaire à list(range(1,10**7))Python 3 (Cependant, cela fonctionne très bien pour moi). Si oui, vous pouvez essayer:

.f&.{`Z.x!s%LZjZT0548

Qui trouve les 548 premiers numéros du lundi. Cela montre également un autre moyen de rechercher les 0s dans le nombre, au lieu de les remplacer par .3ceci, utilise un bloc try-catch. Le mérite de cette version va entièrement à Jakube. (Notez que cela est encore beaucoup à ralentir pour l'interprète en ligne)

FryAmTheEggman
la source
1
Voici une solution différente: .f&.{`Z.x!s%LZjZT0548il est un peu plus rapide (4x - 5x) que votre approche While-loop et n’a également que 21 octets de longueur.
Jakube
1
@Jakube Backticks est une douleur dans les commentaires, n'est-ce pas? : P Merci quand même!
FryAmTheEggman le
Umm .. votre solution ne semble pas fonctionner .. Dans votre lien TIO dans la gamme allant jusqu'à 100, cela indique 55, 66, 77, 88, 99tous les nombres avec des chiffres dupliqués ..
Kevin Cruijssen
1
@KevinCruijssen Malheureusement, Pyth a été mis à jour tellement de fois depuis que j'ai écrit ce post, je ne trouve pas ce qui a changé. Vous pouvez voir dans la pâte que cela fonctionnait clairement auparavant. Je pense que cela a peut-être .{été changé, car le remplacer par {Isemble marcher.
FryAmTheEggman
@FryAmTheEggman Ah, je n'avais pas vu la pâte. Cela fait effectivement presque trois ans, alors rien d'étonnant à ce que les choses aient changé. +1 dans ce cas, car la pâte prouve que cela a fonctionné. :)
Kevin Cruijssen
9

GS2 , 20 19 octets

GS2 utilise une large gamme d’octets, pas seulement des caractères ASCII imprimables. Je présenterai ma solution en hexadécimal.

17 7d 2f 24 65 f1 c8 24 d8 62 e9 65 f4 24 40 90 71 f3 54

Voici quelques explications. gs2 est un langage basé sur la pile, donc il n'y a pas de variables. (mis à part 4 registres, dont l'un est utilisé ici)

17         # push constant 7
7d         # 10 raised to the power
2f         # create an array of numbers from 1 to n

    24     # get digits of number into array
    65     # calculate product of array
f1         # filter array by previous block of 2 instructions

    c8     # save top of stack to register a
    24     # get digits of number into array
        d8 # tuck register a under top of stack
        62 # boolean divisibility test 
    e9     # map array using previous block of 2 instructions
    65     # calculate product of array
f4         # filter array by previous block of 5 instructions 

    24     # get digits of number into array
    40     # duplicate top of stack
    90     # remove duplicates from array
    71     # test equality
f3         # filter array by previous block of 4 instructions
54         # show contents of array separated by line breaks
récursif
la source
8

Python 3, 132 128 114 111 111 104 octets

i=0
while i<1e8:
 j=str(i)
 if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j):print(i)
 i+=1

Il y a 548 numéros de lundi.

Zach Gates
la source
1
Pourriez-vous utiliser 1e8au lieu de même 9**9?
Dom Hastings le
Supprimer l'espace dans '0' not. En outre, i%int(k)==0peut probablement être i%int(k)<1?
mbomb007
Merci. Je ne voulais pas rajouter ça. @ Mbomb007
Zach Gates
Vous pouvez utiliser j=`i`.
mbomb007
Pour un autre usage -6if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j)
lirtosiast
7

APL, 44 39 37 octets

{0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)⍎¨⍕⍵:⍵⋄⍬}¨⍳1e7

Ungolfed:

{
 x ← ⍎¨⍕⍵⋄                    ⍝ Define x to be a vector of the digits of ⍵
 0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)x:   ⍝ No zeros, all digits divide ⍵, all unique?
 ⍵⋄⍬                          ⍝ If so, return the input, otherwise null
}¨⍳1e7                        ⍝ Apply to the integers 1..1E7

Sauvegardé 7 octets grâce à Moris Zucca!

Alex A.
la source
J'aime APL. C'est pourquoi.
Conor O'Brien
Je pense que vous pouvez jouer au golf en utilisant des trains de fonctions, en économisant 5 octets: {0 = + / (| ∘⍵, 0∘∊, ≠ ⍴∘∪) x ← ⍎⍎⍎:} ¨⍳ 1e7
Moris Zucca
@ MorisZucca Génial, merci pour la suggestion!
Alex A.
Je viens de voir que sous cette forme x ← n'est plus nécessaire, donc 2 octets supplémentaires enregistrés! :-)
Moris Zucca
@ MorisZucca Vous êtes une machine à golf APL! Merci encore!
Alex A.
6

TI-BASIC, 60 59 octets

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(1,1+int(log(X->D
SortA(∟D
If X>9
If not(max(remainder(X,Ans+2Xnot(Ansmin(ΔList(∟D
Disp X
End

∟Dest la liste des chiffres générée à l'aide de math et de la randIntNoRep(commande (permutation aléatoire de tous les entiers compris entre 1et 1+int(log(X). J'utilise une chaîne d'énoncés légèrement compliquée pour vérifier si toutes les conditions sont remplies:

   min(ΔList(∟D        ;Zero if repeated digit, since ∟D was sorted ascending
Ans                    ;Multiplies the unsorted copy of ∟D by the minimum from above
                       ;(Lists are different dimensions; we can't elementwise AND)
                       ;Will contain a 0 if there's a 0 digit or a repeated digit
      not(             ;If there's a zero,
Ans+2X                 ;Add 2X to that pos. in the list, failing the test:

    max(remainder(X,   ;Zero iff all digits divide X and 2X wasn't added
not(

Pour échouer les nombres qui ont des chiffres répétés ou zéro chiffre, je remplace les zéros 2X, car Xn'est jamais divisible par 2X.

Pour les cas spéciaux 1 ~ 9 (parce ΔList(que les erreurs d'une liste à un élément), j'utilise l' Ifinstruction de la quatrième ligne pour ignorer le contrôle de la cinquième ligne, affichant automatiquement tout X≤9.

Les numéros de sortie sont séparés par des nouvelles lignes.

lirtosiast
la source
5

Mathematica 105

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]
  • IntegerDigitsdécompose nen une liste de ses chiffres, i.
  • FreeQ[i,0] vérifie s'il n'y a pas de zéros dans la liste.
  • Length[i]==Length[Union[i]] vérifie qu'il n'y a pas de chiffres répétés.
  • And@@(Divisible[n,#]&/@i)vérifie que chaque chiffre est un diviseur de n.

{1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 24, 36, 48, 124, 126, 128, 132, 135, 162, 168, 175, 216, 248 , 264, 312, 315, 324, 384, 396, 412, 432, 612, 624, 648, 672, 728, 735, 784, 816, 824, 864, 936, 1236, 1248, 1296, 1326, 1326, 1362, 1362 , 1395, 1632, 1692, 1764, 1824, 1926, 1935, 1962, 2136, 2184, 2196, 2316, 2316, 2336, 2416, 2916, 3126, 3162, 3196, 3216, 3264, 3276, 3492, 3692, 3612, 3624 , 3648, 3816, 3864, 3964, 3915, 3924, 4128, 4172, 4236, 4368, 4392, 4632, 4872, 4896, 4932, 4932, 4968, 6132, 6192, 6324, 6384, 6432, 6912, 6912, 6984, 6984, 8136, 8496 , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12748, 12764, 13248, 13896, 13968, 14688, 14728, 14828, 14828, 14824, 16248, 16248, 16248, 16824, 17248 , 18264, 18432, 18624, 18936, 19368, 21384, 21648, 21784, 21864, 23184, 24168, 24816, 26184, 26384, 28416, 29736, 31248, 31824, 31896, 31968, 31186, 32184, 34128,37128, 37296, 37926, 38472, 39168, 39816, 41328, 41832, 42168, 42816, 43128, 43176, 46128, 46872, 48216, 48312, 61248, 61824, 62184, 62184, 64184, 64128, 68184, 73184, 7384, 8244 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 84192, 89136, 89712, 91376, 91476, 91728, 92736, 93168, 91316, 9386, 123848, 123648, 123648, 123848 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 133624, 143928, 146328, 143832, 143832, 143832, 163832, 16388, 16388, 16388, 16388, 16388, 16388, 16348, 16388, 16388, 16388, 16388, 16388, 14368, 16388, 16248 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 19488, 194322, 198432, 213648, 213864, 213964, 213984, 213884, 213836, 21384 231864, 231984, 234168, 234816, 236184, 238416, 239184, 241368, 243168, 243768, 243816, 247968, 248136,248976, 261384, 263184, 273168, 281736, 283416, 284136, 291384, 293184, 297864, 312648, 31284, 314928, 316248, 318244, 318244, 319824, 302824, 302824, 3229 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 3412128, 361824, 361872, 362184, 364128, 364728, 367288, 367248, 361224, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 324, 32 324, 32 324, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 341212, 341224) 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418322, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428136, 428136, 428136, 428 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483672, 483912, 486312, 489312, 491328, 493128, 3 pièces 613872, 614328, 614832, 618432, 621384, 623184, 623784,627984, 631248, 631824, 632184, 634128, 634872, 641328, 641832, 643128, 648312, 671828, 671432, 684312, 689472, 732648, 732816, 742896, 742828, 763384, 73261400, 803414, 803414, 803414 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841692, 841692, 842136, 853m 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 913128, 913432, 913432, 912384, 913384 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923868, 1936872, 1982736, 2137968, 2138968, 2138976, 2138976, 2138976, 2138376 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 36197, 3678192, 3712968, 3768912, 3796128, 381676, 3867192, 3869712, 3927168, 3928168 6893712, 6913872, 6971328, 6971832, 7168392, 71986, 7231896, 7291368, 7329168, 7361928, 7392168, 7378216, 7815138, 7896138, 7896138, 7896138, 7896138 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176832, 9176326, 92178136, une chambre à coucher et une suite 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 697828, 6971328, 6971832, 7168392, 7198696, à la place de l'article 7, article 7, article 7, article 7, article 1 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8196362, 8219736, 8312976, 8367912, 8127368, en bas de la chambre, le premier, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 697828, 6971328, 6971832, 7168392, 7198696, à la place de l'article 7, article 7, article 7, article 7, article 1 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8196362, 8219736, 8312976, 8367912, 8127368, en bas de la chambre, le premier, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 972368, 9723168, 978166, 372806, 33, 973, 33, 97, 8, 7, 6, 7, 7, 6, 78796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 972368, 9723168, 978166, 372806, 33, 973, 33, 97, 8, 7, 6, 7, 7, 6, 7

Length[%]

548

DavidC
la source
Je pense il y a un moyen de Mathematica pour obtenir un grand nombre en moins d' octets, comme 9^9ou 1e8ou quelque chose
FryAmTheEggman
Je suis surpris que Mathematica ne possède pas de fonction intégrée pour cela ;-). Belle astuce avec le Unionpour vérifier les doublons.
AdmBorkBork
@FryAmTheEggman, Vous avez raison en ce qui concerne Mathematica, qui autorise 9 ^ 9. Mais cela ne renverrait-il pas plus de 548 numéros de lundi?
DavidC
Comme indiqué dans la question, il n'y a pas de nombre possible de lundi supérieur à celui indiqué comme limite supérieure.
FryAmTheEggman le
5

Haskell, 77 octets

[x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

Exemple d'utilisation (les 20 premiers chiffres):

take 20 $ [x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

[1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162]

Comment ça marche: parcourez tous les nombres de 1 à 9 ^ 9 et vérifiez les conditions. Le nombre actuel xest transformé en sa représentation sous forme de chaîne ( show x) pour qu'il fonctionne comme une liste de caractères.

nimi
la source
5

R, 99 octets

for(n in 1:1e8){i=1:nchar(n);if(all(table(d<-(n%%10^i)%/%10^(i-1))<2)&!0%in%d&all(!n%%d))cat(n,"")}

Un peu moins joué au golf:

for(n in 1:1e8){
    i = 1:nchar(n)
    d = (n%%10^i)%/%10^(i-1) # Digits of n
    if(all(table(d)<2) # No digits is present more than once 
      & !0%in%d        # 0 is not one of the digits
      & all(!n%%d))    # All digits are divisors of n
    cat(n,"")
    }
planificateur
la source
5

Perl, 90 75 70 octets

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7
steve
la source
1
Ahhh, j’ai manqué l’astuce de vérification de la dupe, sympa. Pouvez-vous économiser davantage avec un modificateur de déclaration while et une impression ternaire?
Dom Hastings
@DomHastings merci, maintenant plus joué avec votre suggestion
steve
Nice, je pense que vous pouvez enregistrer un peu plus aussi bien, que vous n'avez pas besoin ^et $autour de 0votre grep, vous pouvez remplacer le &&devant s/./avec un seul &et je pense que la dernière |0est inutile (bien que seulement testé la mise à 1e3. ..). Bien et vraiment battu mon score! :)
Dom Hastings
1
@DomHastings merci, jusqu'à 70 avec vos conseils de golf.
steve
Arrêtez-vous un peu plus en vous débarrassant du grep (inutile - la correspondance de motif le gère sans grep) et en réorganisant le reste sur une carte: essayez-le en ligne!
Xcali
4

CJam, 25 octets

1e7{_Ab__&0-_@=@@f%1b>},`

Essayez-le en ligne . Notez que le lien en ligne ne fonctionne qu'à 10 000. Je ne sais pas si cela se terminerait en ligne si vous êtes assez patient. Il ne l'a pas testé avec la version hors ligne de CJam, mais je m'attends à ce qu'elle se termine.

Explication:

1e7     Upper limit.
{       Start filter loop.
  _Ab     Copy and convert to list of decimal digits.
  __&     Intersect list with itself to remove duplicates.
  0-      Remove zero.
  _       Make a copy of unique non-zero digits. Will use these as divisors.
  @=      Compare unique non-zero digits to all digits. Must be true for Monday numbers.
  @@      Rotate original number and list of non-zero digits to top.
  f%      Remainders of original number with all non-zero digits.
  1b      Sum up the remainders. Since they all must be zero for Monday numbers,
          their sum must be zero.
  >       Check that first part of condition was 1, and sum of remainders 0.
},      End filter loop.
`       Convert resulting list to string.
Reto Koradi
la source
4

C #, 230 227

Cela fait longtemps que je n’ai pas réussi à résoudre le problème, j’ai probablement oublié quelques astuces pour obtenir le décompte approximatif. Je vais améliorer quand je pense à eux ... Pour l'instant:

using System.Linq;class P{static void Main(){System.Console.Write(string.Join(",",Enumerable.Range(0,1<<24).Where(i=>{var s=i.ToString();return!s.Contains('0')&&s.Length==s.Distinct().Count()&&s.All(x=>i%(48-(int)x)==0);})));}}

Ungolfed:

using System.Linq;
class P
{
    static void Main()
    {
        System.Console.Write(                                       //Output...
            string.Join(                                            //...all results...
                ",",                                                //...comma separated...
                Enumerable.Range(0, 1<<24)                          //...from 0 to 16777216...
                    .Where(i => {                                   //...where...
                        var s = i.ToString();                       //...the digits as char array (what we usually call a string)...
                        return !s.Contains('0')                     //...for which none of the digits is 0...
                            && s.Length == s.Distinct().Count()     //...and the number of distinct digits equals the total number of digits (e.g. all unique)...
                            && s.All(x => i % (48 - (int)x) == 0);  //...and the number is divisible by each of the digits (after 'ASCII-correction')
                    })
            )
        );
    }
}

1, 3, 4, 5, 5, 7, 8, 8, 12, 12, 5, 4, 5, 4, 6, 4, 5, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3274,3612,3624,3648,3816,3864,3915,3924, 4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,4132,6192,6312,6324,6384,6412,6984,8136,8496,8736,9126,9135,9162,9216, 9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,162424,17248,18264,18432,18624,18624,18624,18624 21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31896,31968,32184,34128,36792,3712,37296,37926,38472,39168,39816,41328, 41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632 81232 81432 81624 81936 82416 84216 84312 84672,87192,8913,89712,91368,91476,91728,92716,93168,93816,98136,123648,123648,12384,123984, 124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148141481414814814814814148 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,192384,193248,193824,194328, 194832, 198432,219648,213864,21481419 231864,231984,23168338283168283168288 312984,314928,316248,316824,31864,318624,319248,319824,321648,321864,321984,324168,3248,3418,3344,329184,341928,321648,321864,32184,3348,3348,334183,34403,3440 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,3912,33818,392184,394128,412368,413928,416328,416832,418394,4198,4188,419819 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,4,41313,4,4181832,463128,468312,469728,478296,47124,481313,413 483216,483672,483912,486312,489312,492828,49184,493128,498312,612384,613248,613824,613872,61432834144456484126488128,698312612812 641328,641832,643128,648312,672828,671832,681432,684312,689472,732648,732816,74896,746928,76238432881616,789264,796824,813264,813624814414414414414414414814414 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843212,846312,849312,861432,864312,864364,871432,894312897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872, 13309613928,1382976,1679328,1679832,1687392,1738296,186396,1863792,186392,196398139 3186792,3187296,3196872,32719816838298176,3619728,3812838968968968936928836828738829638829638829638719628728397389368398368398398398398368 6893712,6913872,6971328,697183281623919732896182913687329168,73619287392168,73982166,7839128,7829136,7839216878131613839138398398398398398398398398398398398398398398398398398396396 8163792 8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,96178,9683,9671812,9723168,9781632,978213,981237,9812376,9867312

RobIII
la source
peut (int) 1e7 être 1 << 24?
lirtosiast
@ThomasKwa Oui, ça peut l'être. Effectivement. Merci!
RobIII
4

TI-BASIC, 55 53 octets

La réponse de Thomas Kwa est relativement mineure , mais je la soumets comme une nouvelle réponse, car j'avais entendu dire qu'il avait mis une prime à jouer pour jouer ses réponses à TI-BASIC.

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(0,1+int(log(X->D
SortA(∟D
If not(sum(remainder(X,Ans+Xnot(Ansmin(ΔList(∟D
Disp X
End

Ma principale modification va de randIntNoRep(1,à randIntNoRep(0,signifiant qu’il y aura désormais un zéro dans chaque liste de chiffres générée.

number  |  randIntNoRep  |  digits  |  sorted
9       |  1,0           |  9,0     |  0,9
102     |  3,1,0,2       |  1,2,0,0 |  0,0,1,2

Puisqu'il y a maintenant un zéro dans chaque ensemble de chiffres, cela affecte la somme des restes. Normalement, la somme des restes est 0, mais à présent, la présence d'un zéro supplémentaire entraîne l'échec de notre test de divisibilité.
Pour contrer cela, j'ai changé 2Xnot(pour Xnot(. Le 2 était à l'origine là pour faire échouer le test à 0, mais maintenant, il passe à zéro. Les nombres qui contiennent un zéro dans leurs chiffres, cependant, ont maintenant un min(ΔList(∟Dzéro de toute façon (car il y a 2 zéros ou plus dans leurs listes), de sorte que cette modification ne fera en sorte que les numéros supplémentaires ne passent pas le test.

L'avantage de cette méthode est que, puisqu'il y a maintenant "deux chiffres" produits à partir du nombre 1-9, la ΔList(fonction ne génère pas d'erreur, ce qui nous permet de supprimer une condition spéciale pour les nombres à un chiffre.

PhiNotPi
la source
4

05AB1E , 30 22 21 18 14 13 12 9 octets

-9 octets grâce à l'aide et aux encouragements de @Enigma et @ Mr.Xcoder . Merci de m'avoir laissé résoudre le problème moi-même, même si vous aviez déjà en tête une solution de 12 octets quand j'avais encore 30 ans. J'ai beaucoup appris sur 05AB1E grâce à ce défi!
-3 octets grâce à @Grimy

7°LʒÐÑÃÙQ

Essayez-le en ligne (affiche uniquement les nombres inférieurs à 10 3 au lieu de 10 7 pour éviter un délai d'attente supérieur à 60 secondes).

Explication:

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (truthy) remain:
    Ð      #  Triplicate the current number
     Ñ     #  Get the divisors of this number
           #   i.e. 128 → [1,2,4,8,16,32,64,128]
           #   i.e. 1210 → [1,2,5,10,11,22,55,110,121,242,605,1210]
      Ã    #  Only keep those digits/numbers in the original number (which is checked in
           #  order, so it will only keep the digits and ignores the later numbers)
           #   i.e. 128 → 128
           #   i.e. 1210 → 121
       Ù   #  Uniquify the number, removing any duplicated digits
           #   i.e. 128 → 128
           #   i.e. 121 → 12
        Q  #  Check if the number is unchanged after this
           #   i.e. 128 and 128 → 1 (truthy)
           #   i.e. 1210 and 12 → 0 (falsey)

Version précédente de 12 octets (une de mes toutes premières réponses 05AB1E):
Remarque: ne fonctionne que dans la version héritée de 05AB1E.

7°LʒÐSÖPsDÙQ*

Essayez-le en ligne (affiche uniquement les nombres inférieurs à 10 3 au lieu de 10 7 pour éviter un délai d'attente supérieur à 60 secondes).

Explication:

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (true) remain:
    Ð      #  Triplicate the current number N
     Ù     #  Remove all duplicated digits of the second N
           #   i.e. 1210 → 120
      Q    #  Check if the last two numbers are still the same (1 or 0 as result)
    *      #  Multiply this result with remaining third number from the triplication
     D     #  Duplicate this number, so we have two again
      S    #  Separate all the digits of the second one
           #   i.e. 128 → ['1', '2', '8']
       Ö   #  Check if (the second) N is divisible by each of its digits
           #   i.e. 128 and ['1', '2', '8'] → [1, 1, 1]
           #   (NOTE: If the number contains a '0', it won't error on division by 0,
           #          but instead return the number N itself in the list)
           #   i.e. 105 and ['1', '0', '5'] → [1, 105, 1]
        P  #  Take the product of this list (if the divisible test for one
           #  of the digits was 0, this will be 0 as well)
           #   i.e. [1, 1, 1] → 1
           #   i.e. [1, 105, 1] → 105 (only 1 is truthy in 05AB1E)
Kevin Cruijssen
la source
Votre réponse s'imprime 297, ce qui ne correspond pas à la séquence des numéros de Lynch-Bell.
M. Xcoder
@ Mr.Xcoder Sigh .. Avait quelque chose de plus long au début pour vérifier si un nombre est divisible par tous ses chiffres, mais a imaginé qu'un tel défi existait. Il semble que cette réponse soit donc également invalide .. Et ici, Enigma et vous parlez de réponses de 12 à 15 octets alors que ma réponse de 30 octets ne fonctionne même pas, lol .. Existe-t-il un tutoriel quelque part? ; p
Kevin Cruijssen
1
9 octets:7°LʒÐÑÃÙQ
Grimmy
@Grimy Une de mes toutes premières réponses à 05AB1E. :) Belle approche!
Kevin Cruijssen
3

Julia, 88 octets

print(join(filter(i->(d=digits(i);0d&&d==unique(d)&&all(j->i%j<1,d)),1:9867312)," "))

Cela prend simplement tous les nombres de 1 au plus grand nombre Lynch-Bell et les filtre en fonction des seuls nombres Lynch-Bell.

Ungolfed:

lynch = filter(i -> (d = digits(i);
                     0  d &&
                     d == unique(d) &&
                     all(j -> i % j == 0, d)),
               1:9867312)

print(join(lynch, " "))
Alex A.
la source
3

Python 2, 101 octets

print[i for i in range(6**9)if'0'not in`i`and len(set(`i`))==len(`i`)and all(i%int(k)==0for k in`i`)]

Vous pouvez omettre le printdans l'interpréteur jusqu'à 96. Utilisé 6**9puisqu'il s'agit de 8 chiffres alors que le plus grand numéro du lundi n'est que de 7 chiffres, quelque chose comme cela 9**9prendrait probablement beaucoup de temps, 6 ** 9 ne prend qu'environ 10 secondes.

Rohcana
la source
As pointed out on a couple of questions 1e7 is shorter than both
Holloway
@Trengot 1e7 is a float, range takes integers.
Rohcana
Very true. Hadn't thought of that
Holloway
3

Perl, 97 bytes

print+($n=$_,$/)x(!/0/&(y///c==grep{2>eval"$n=~y/$_//"}/./g)&&y///c==grep!($n%$_),/./g)for 1..1e7

Takes a while to run, but produces the required output, change to 1e3 for a quicker example!

Dom Hastings
la source
I'm not in a position to try this at the moment but, instead of y///c==grep{2>eval"$n=~y/$_//"}/./g, could you use something along the lines of !/(.).*\1/?
msh210
@msh210 Almost certainly! I think that would be my default now, but changing this would only end up making it closer to steve's or Jarmex's answers, which are far superior! Thanks for taking a look though!
Dom Hastings
3

MATLAB, 100

o=49;for n=2:1e7 a=num2str(n);if all([diff(sort(a)) a~=48 ~mod(n,a-48)]) o=[o ',' a];end;end;disp(o)

And in a more readable format:

o=49;  %1 is always in there, so add the ASCII value. This prevents there being a ',' prefixed.
for n=2:1e7 
    a=num2str(n);
    if (all([diff(sort(a)) a~=48 ~mod(n,a-48)]))
        o=[o ',' a];
    end
end
disp(o)

Basically this counts through every number between 1 and 1×107 and checks if they are a Monday number. Each number is converted to a string so that the digits can be dealt with individually.

The checks are as follows:

  1. First check if there are any duplicates. By sorting the array, if the difference between any consecutive digits is zero, then there are duplicates

    diff(sort(a))
    
  2. Check if there are any zeros. The ASCII for 0 is 48, so we check that all digits are not equal to that.

    a~=48
    
  3. Check if it is divisible by all its digits. We check that the remainder when dividing by each digit (converted from ASCII to decimal, hence -48) is zero.

    ~mod(n,a-48)
    

Finally we make sure that all() the checks are true, and if so we append it to a comma separated output string.

MATLAB has no STDOUT, so instead I print the result string at the end using disp()


This code is SLOW! I am still running it to make sure that it correctly finds all the Monday numbers, but looks good so far.

Update:

Code finished running. It prints the following:

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,315,324,384,396,412,432,612,624,648,672,728,735,784,816,824,864,936,1236,1248,1296,1326,1362,1368,1395,1632,1692,1764,1824,1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924,4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216,9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368,21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328,41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984,124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328,164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648,231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864,312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248,361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368,423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192,483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872,641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416,824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872,1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983176,3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731928,6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,8123976,8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312

Which if you run this code with that as the input:

nums = length(strsplit(stdout,','))

Yeilds 548.

Tom Carpenter
la source
3

Ruby, 79

?1.upto(?9*7){|s|a=s.chars;a.uniq!||a.any?{|x|x<?1||0<eval([s,x]*?%)}||puts(s)}

More interesting but slightly longer solution with a regex:

?1.upto(?9*7){|s|s[/(.).*\1|[0#{(1..9).map{|*x|x*eval([s,x]*?%)}*''}]/]||puts(s)}

In each case, we're using Ruby's ability to iterate over strings as though they were decimal integers: ?1.upto(?9*7) is equivalent to 1.upto(9999999).map(&:to_s).each. We join the string to each nonzero digit using the modulo operator, and eval the result, to check for divisibility.

Bonus Ruby 1.8 solution (requires -l flag for proper output):

'1'.upto('9'*7){|$_|~/(.).*\1|[0#{(1..9).map{|*x|x*eval("#$_%#{x}")}}]/||print}

1.8 allowed the block iterator to be a global variable. Assigning to $_ makes it the implicit receiver for string operations. We also get to interpolate arrays into the regular expression more easily: in 1.8, /[#{[1,2]}]/ evaluates to /[12]/.

histocrat
la source
Now that Ruby 2.4 has a digits function on integers, you can save bytes from the eval hack since you aren't operating on strings any more! 63 bytes.
Value Ink
3

Pip, 25 bytes

Fa,t**7Ia#=UQa&0=$+a%^aPa

Outputs each number on its own line. This has been running for about 10 minutes and gotten up to 984312 so far, but I'm pretty sure it's correct. (Edit: Couple hours later... code finished, generated all 548 of 'em.)

Here's a Python-esque pseudocode rendition:

for a in range(10**7):
  if lengthEqual(a, set(a)) and 0 == sum(a%d for d in digits(a)):
    print(a)

The #= operator compares two iterables by length. If the number of UniQue characters in a is the same as the number of characters in a, there are no repeats.

The divisible-by-each-digit check is from one of my Pip example programs. I wrote it after seeing the earlier challenge, but didn't post it there because the language was newer than the question. Otherwise, at 8 bytes, it would be the winning answer to that question. Here's a step-by-step explanation:

      ^a   Split num into an array of its digits
    a%     Take num mod each of those digits; if a digit is zero, the result will be nil
  $+       Sum the resulting list (note: summing a list containing nil results in nil!)
0=         Iff the sum equals 0, return 1 (true); otherwise (>0 or nil), return 0 (false)
DLosc
la source
This is a pretty neat language! Nice to see something other than stack-based golfing.
AdmBorkBork
1
@TimmyD If you want to see non-stack based golfing, there tends to be quite a bit of Pyth around.
Reto Koradi
@RetoKoradi But if you want to see non-stack-based golfing with infix operators, Pip is for you. ;^)
DLosc
Couple hours later It's a good thing performance isn't taken into account.
Holloway
3

Javascript (ES6), 106 90 83 bytes

Kids, don't try this at home; JS will not be happy with the prospect of looping through every digit of every integer from one to ten million with a regex.

for(i=0;i<1e7;i++)/(.).*\1|0/.test(i)||+`${i}`.replace(/./g,j=>i%j)||console.log(i)

The first regex (props to @Jarmex) returns true if the number contains duplicate digits or zeroes. If this turns out false, the program move on to the second, which replaces each digit j with i%j. The result is all zeroes if it's divisible by all of it's digits, in which case it moves on to console.log(i).

Suggestions welcome!

ETHproductions
la source
3

JavaScript (ES6), 76

/* Answer below. For testing purpose, redirect consoloe.log */ console.log=x=>document.write(x+' ')

for(i=0;i++<1e7;)/0|(.).*\1/.test(i)||[...i+''].some(d=>i%d)||console.log(i)

The regexp test for 0 or repeated digits. Then the digits array is checked looking for a non-zero modulo for any digit.

here is the explanation of the 7 digit max.

edc65
la source
3

Ruby, 130 bytes

... not counting whitespace

New to programming,just wanted to participate

c=0
(0..10**7).each do |x| 
  a=x.to_s.split('')
  c+=1 if !a.include?('0')&& a.uniq!.eql?(nil)&&a.all?{|y| x.modulo(y.to_i).zero?} 
end
p c
skeezy_D
la source
2
Welcome to PPCG! Check out some additional Tips for Ruby to help get that code length down.
AdmBorkBork
3

C, 122 bytes

i,j,m,a;void f(){for(i=1;i<1e8;++i){for(m=0,j=i;j;j/=10){a=j%10;if(!a||m&(1<<a)||i%a)goto n;m|=1<<a;}printf("%d ",i);n:;}}

Prettier:

i,j,m,a;
void f()
{
    for (i=1; i<1e8; ++i){
        for (m=0, j=i;  j;  j/=10) {
            a = j%10;
            if (!a || m&(1<<a) || i%a)
                goto n;
            m|=1<<a;
        }
        printf("%d ",i);
    n:;
    }
}

For each candidate i, we iterate its digits a in little-endian order, keeping track of seen digits in the bits of m. If the loop completes, then all digits are factors of i and we saw no zeros or repeated digits, so print it, otherwise we exit early to continue the outer loop.

Toby Speight
la source
Good to the the goto command being used.
Shaun Bebbers
2

CJam, 34 bytes

1e7{_:TAb___&=\{T\T)e|%}%:+!**},N*
Lynn
la source
2

Lua, 129 bytes

I've eschewed the string approach for pure digit-crunching, which seems a bit speedier and probably saved me some bytes as well. (I'll have test that theory, but Lua string handling is pretty verbose compared to some other languages.)

for i=1,1e7 do t={[0]=1}j=i while j>0 do c=j%10 if t[c]or i%c>0 then break end t[c]=1 j=(j-c)/10 if j==0 then print(i)end end end
criptych stands with Monica
la source
2

gawk, 99 bytes

BEGIN{for(;8>(l=split(++i,a,_));printf f?f=_:i RS)for(j in a)f=i~0||i%(d=a[j])||i-d*10^(l-j)~d?1:f}

I could reduce that to 97 if I would use END instead of BEGIN, but then you would have to press Ctrl-D to start the actual output, signalling that there will be no input.

I could reduce it to even 94 if I would write nothing instead of BEGIN or END, but then you would have to press the return key once to start it, which could be counted as input.

It simply goes over the digits of each number and tests if the criteria are met.

i~0               :  number contains a `0`?                          -> trash
i%(d=a[j])        :  number not divisible by current digit?          -> trash
i-d*10^(l-j)~d    :  I removed the current digit from the number yet it
                  :  still contains it?                              -> trash

Takes 140 seconds to terminate on my Core 2 Duo.

Cabbie407
la source
2

Jelly, 11 bytes

9œ!ṖẎgḌ$ƑƇḌ

This uses the two-week old œ! atom. Actually fast enough to run on TIO.

Try it online!

How it works

9œ!ṖẎgḌ$ƑƇḌ  Main link. No arguments.

9            Set the return value to 9.
   R         Pop; yield [1, ..., 8].
 œ!          Promote 9 to [1, ..., 9] and generate all permutations of length k,
             each k in the right argument [1, ..., 8].
    Ẏ        Tighten; dump all digit lists in a single array.
         Ƈ   Comb; keep only digit lists for which the link to the left returns 1.
        Ƒ      Fixed; return 1 iff calling the link to the left returns its argument.
       $         Combine the two links to the left into a monadic chain.
      Ḍ            Undecimal; convert the digit list into an integer.
     g             Take the GCD of each digit and the integer.
Dennis
la source