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

var QUESTION_ID=59014,OVERRIDE_USER=42963;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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.

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:

• Vérifier si un nombre est divisible par chacun de ses chiffres

  lambda n:any(n%(int(d)or.3)for d in`n`)<1 

  (merci à FryAmTheEggman de me l'avoir rappelé).

• Déterminer si tous les chiffres décimaux sont uniques

  lambda n:10**len(set(`n`))>n

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

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.

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)

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

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.

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!

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.

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

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.

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,"")
    }

Perl, 90 75 70 octets

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7

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.

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

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.

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 ³ au lieu de 10 ⁷ 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 ³ au lieu de 10 ⁷ 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)

Julia, 88 octets

print(join(filter(i->(d=digits(i);0∉d&&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, " "))

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.

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!

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\times10^7$ 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.

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]/.

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)

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!

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.

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

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.

CJam, 34 bytes

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

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

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.

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.