Liczby poniedziałkowe , zgodnie z definicją Gamow w tym pytaniu dotyczącym zagadek, są dodatnimi liczbami całkowitymi N o następujących trzech właściwościach:

• Dziesiętna reprezentacja N nie zawiera cyfry 0
• Dziesiętna reprezentacja N nie zawiera żadnej cyfry dwukrotnie
• N jest podzielna przez każdą cyfrę D występującą w postaci dziesiętnej

Należy zauważyć, że są one alternatywnie znane w OEIS jako numery Lynch-Bell .

Przykłady:

• 15jest liczbą poniedziałek, jak to jest podzielna przez obie 1i 5i spełnia pozostałe dwa warunki
• 16nie jest, ponieważ nie można go podzielić 6.
• Liczba 22nie jest, ponieważ chociaż spełnia warunki 1 i 3, nie spełnia warunku 2.

Oto lista pierwszych 25 liczb poniedziałkowych na początek (jest ich łącznie 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

Wyzwanie polega tutaj na napisaniu najkrótszego kodu, który generuje pełną sekwencję liczb poniedziałkowych, od 1 do 9867312 (udowodnione w tym pytaniu jako największe z możliwych).

Twój kod nie powinien pobierać żadnych danych wejściowych, a dane wyjściowe powinny mieć wartość STDOUT lub równoważną, z wybranym ogranicznikiem. Obowiązują wszystkie zwykłe zasady gry w golfa, a luki standardowe są zabronione.

Tabela liderów

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>

Galaretka , 8 bajtów

ȷ7Dg⁼QƲƇ

Działa lokalnie w mniej niż osiem minut.

Wypróbuj online! (zmodyfikowany w celu znalezienia liczb zawierających sześć cyfr lub mniej)

Jak to działa

ȷ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 bajtów

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`)]

Drukuje listę.

Zasadniczo łączę dwie moje odpowiedzi na poprzednie wyzwania:

• Sprawdzanie, czy liczba jest podzielna przez każdą z jej cyfr

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

  (dzięki FryAmTheEggman za przypomnienie mi o tym).

• Sprawdź, czy wszystkie cyfry dziesiętne są unikalne

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

Dzięki xsot za 1 bajt zaoszczędzony dzięki lepszemu połączeniu warunków.

Perl, 61 47 bajtów

46 bajtów kodu + 1 bajtowy parametr wiersza poleceń.

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

Stosowanie:

perl -l entry.pl

Wyjaśnienie

/(.).*\1|0/ zwraca 1, jeśli testowany numer zawiera zduplikowany znak lub 0

s/./$_%$&/rgezastępuje każdą cyfrę wartością testowanego numeru% cyfry. Na przykład 15 -> 00, 16 -> 04 (ponieważ 16% 6 = 4). Oznacza to, że każde wejście, które można podzielić przez wszystkie jego cyfry, będzie składać się ze wszystkich zer, w przeciwnym razie będzie zawierać cyfrę> 0. Aby potraktować to jako liczbę, my * 1, co oznacza, że ​​każdy testowany numer zwróci 0 dla tego bloku, jeśli jest podzielny przez wszystkie jego cyfry, w przeciwnym razie> 0.

Po oddzieleniu tych dwóch instrukcji i wypisania znakiem „lub”, jeśli którykolwiek z pierwszych dwóch warunków zwróci> 0, warunek zostanie dopasowany, a kolejne części wyrażenia nie będą oceniane. Jeśli i tylko wtedy, gdy oba poprzednie warunki są równe 0, wydruk zostanie wykonany. -lFlagi zapewnia, aby dodać nową linię po każdym wydruku.

Pyth, 22 21

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

Dzięki Jakube za grę w golfa z 1 bajta niepotrzebnego formatowania.

Mocno zainspirowany tą odpowiedzią CW na powiązane pytanie.

Mam pasty wyniku tutaj , od kiedy to wydrukowane nowej linii oddzielone, teraz drukuje jako lista pythonic.

Polecam nie wypróbowywać go online chyba że użyjesz liczby mniejszej niż 7 ... Ustawiłem go na 2 w tym linku.

Filtry 1na 10^7-1który obejmuje wszystkie niezbędne wartości. Ta wersja może powodować błąd pamięci, jeśli nie może utworzyć listy S^T7, która jest podobna do tej list(range(1,10**7))w Pythonie 3 (jednak działa dla mnie dobrze). Jeśli tak, możesz spróbować:

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

Który znajduje pierwsze 548 poniedziałkowych liczb. Pokazuje to także inny sposób sprawdzenia 0s w numerze, zamiast zamiany na .3to używa bloku try-catch. Uznanie dla tej wersji należy w całości do Jakube. (Zauważ, że wciąż jest o wiele za dużo dla tłumacza online)

GS2 , 20 19 bajtów

gs2 używa szerokiej gamy bajtów, a nie tylko drukowalnych znaków ascii. Przedstawię moje rozwiązanie w formie heksadecymalnej.

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

Oto wyjaśnienie. gs2 jest językiem stosowym, więc nie ma zmiennych. (oprócz 4 rejestrów, z których jednego używam tutaj)

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 104 bajtów

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

Istnieje 548 poniedziałkowych liczb.

APL, 44 39 37 bajtów

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

Nie golfowany:

{
 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

Zaoszczędź 7 bajtów dzięki Morisowi Zucca!

TI-BASIC, 60 59 bajtów

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

∟Dto lista cyfr, która jest generowana za pomocą matematyki i randIntNoRep(polecenia (losowa permutacja wszystkich liczb całkowitych między 1i 1+int(log(Xwłącznie). Używam nieco skomplikowanego łańcucha instrukcji, aby sprawdzić, czy wszystkie warunki są spełnione:

   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(

Aby odrzucić liczby, które mają powtarzające się cyfry lub cyfry zerowe, zastępuję zera cyframi 2X, ponieważ Xnigdy nie jest podzielna przez 2X.

W przypadku specjalnym 1 ~ 9 (ponieważ ΔList(w przypadku błędów na liście jednego elementu) używam Ifinstrukcji w czwartym wierszu, aby pominąć kontrolę w piątym wierszu, automatycznie wyświetlając wszystkie X≤9.

Liczby wyjściowe są oddzielone znakami nowej linii.

Mathematica 105

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]

• IntegerDigitsrozpada się nna listę swoich cyfr i.
• FreeQ[i,0] sprawdza, czy na liście nie ma zer.
• Length[i]==Length[Union[i]] sprawdza, czy nie ma powtarzających się cyfr.
• And@@(Divisible[n,#]&/@i)sprawdza, czy każda cyfra jest dzielnikiem n.

{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, 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 98136, 12364884, 123864, 12364884, 123864 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 162384, 163248, 163824, 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216384, 218736, 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, 3216488, 32864 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 367248, 376824, 381264, 38162419 382416 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 431928, 432168432, 432168 432 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 4983 6 612 8244, 6138 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, 768432, 783216 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 843192, 8432168, 841212, 843216, 841212 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941832, 943128, 948312, 94 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 2138976, 2189376, 2317896 278, 28689637, 278913 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867192, 3869712, 3927168, 3928176, 6139728, 6377128, 6377128, 6377128, 6377128, 6379128, 6377128, 6377128, 6377128, 6379128, 6379128, 6379128, 6379128, 6377128, 3671988 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 786139216168, 798 792 328, 793 886 896, 7861392, 78639 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9323176, 9323176, 963398, 9632 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 739886816, 76398166398 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 91763288, 9176328, 91768 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 739886816, 76398166398 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 91763288, 9176328, 91768 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 98128796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812

Length[%]

548

Haskell, 77 bajtów

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

Przykład użycia (pierwsze 20 liczb):

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]

Jak to działa: iteruj po wszystkich liczbach od 1 do 9 ^ 9 i sprawdź warunki. Bieżąca liczba xjest zamieniana na jej ciąg znaków ( show x), aby działał na niej jako lista znaków.

R, 99 bajtów

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

Nieco mniej golfa:

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 bajtów

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

CJam, 25 bajtów

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

Wypróbuj online . Pamiętaj, że link internetowy działa tylko do 10 000. Nie jestem pewien, czy skończy się on online, jeśli będziesz wystarczająco cierpliwy. Nie przetestował tego w wersji offline CJam, ale spodziewam się, że to się skończy.

Wyjaśnienie:

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.

DO#, 230 227

Minęło trochę czasu, odkąd grałem, więc prawdopodobnie zapomniałem kilku sztuczek, aby obniżyć liczbę bajtów. Poprawi się, gdy o nich pomyślę ... Na razie:

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);})));}}

Nie golfowany:

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,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,124,1296,1326,1362,1368,139. 1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,381 363864,3915,3924, 4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,849, 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,163841642481684,1634,3828,483. 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,34896,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,468312469728,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,9843121289736,1293768,1369872, 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,36. 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719198,671986,6719198,68 198,389712,6391728,6719198,68 198,389712,6391728,6719198,68 198,389712,6391728,6719198,68 198,389712,6391728,6719198,68 198,389712,6391728,6719198,68 198,389712,6391728,6719 198,28 198,3897 12,6391728,67 19 198,28 198,3897 12,639 1738, 1968, 388,19, 36, 97, 19, 38, 38, 19, 38, 96, 19, 38. 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,66,1688,792, 789,13839,792, 7839136,7916328,7916832,792. 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

TI-BASIC, 55 53 bajtów

To stosunkowo niewielka edycja odpowiedzi Thomasa Kwy , ale przesyłam ją jako nową odpowiedź, ponieważ słyszałem, że wystawił nagrodę na golfa jego Ti-BASIC odpowiedzi.

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

Moją główną zmianą jest od randIntNoRep(1,do, randIntNoRep(0,co oznacza, że ​​będzie teraz zero na każdej generowanej liście cyfr.

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

Ponieważ w każdym zestawie cyfr jest teraz zero, wpływa to na sumę pozostałych. Zwykle suma pozostałych wynosi 0, ale teraz obecność dodatkowego zera powoduje jedno niepowodzenie naszego testu podzielności.
Aby temu przeciwdziałać, zmieniłem 2Xnot(na Xnot(. 2 było pierwotnie po to, aby test zakończył się niepowodzeniem przy 0, ale teraz przechodzi do zera. Liczby, które zawierają zero w swoich cyfrach, teraz jednak mają min(ΔList(∟Dzero (ponieważ na ich listach znajdują się 2 lub więcej zer), więc ta zmiana nie powoduje, że dodatkowe liczby przechodzą test.

Zaletą tej metody jest to, że ponieważ są teraz „dwie cyfry” produkowane z liczby 1-9, ΔList(funkcja nie generuje błędu, co pozwala nam pozbyć się specjalnego warunku dla liczb jednocyfrowych.

05AB1E , 30 22 21 18 14 13 12 9 bajtów

-9 bajtów dzięki pomocy i zachętom @Enigma i @ Mr.Xcoder . Dzięki, że w większości udało mi się to rozgryźć, mimo że miałeś już na myśli 12-bajtowe rozwiązanie, kiedy miałem jeszcze 30 lat. Z tego wyzwania wiele się nauczyłem o 05AB1E!
-3 bajty dzięki @Grimy

7°LʒÐÑÃÙQ

Wypróbuj online (wypisuje tylko liczby poniżej 10 ³ zamiast 10 ^7, aby zapobiec przekroczeniu limitu czasu po 60 sekundach).

Wyjaśnienie:

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)

Poprzednia 12 bajtowa wersja (jedna z moich pierwszych odpowiedzi 05AB1E):
UWAGA: Działa tylko w starszej wersji 05AB1E.

7°LʒÐSÖPsDÙQ*

Wypróbuj online (wypisuje tylko liczby poniżej 10 ³ zamiast 10 ⁷ aby zapobiec przekroczeniu limitu czasu po 60 sekundach).

Wyjaśnienie:

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 bajtów

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

To po prostu bierze wszystkie liczby od 1 do największego numeru Lynch-Bell i filtruje je tylko do liczb Lynch-Bell.

Nie golfowany:

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 bajtów

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`)]

Możesz pominąć printw tłumaczu dostać się do 96. Używany, 6**9ponieważ jest to 8 cyfr, podczas gdy największy numer w poniedziałek to tylko 7 cyfr, coś takiego 9**9prawdopodobnie zabrałoby dużo czasu, 6 ** 9 zajmuje tylko około 10 sekund.

Perl, 97 bajtów

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

Uruchomienie zajmuje trochę czasu, ale generuje wymagany wynik, zmień na 1e3na szybszy przykład!

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)

I w bardziej czytelnym formacie:

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)

Zasadniczo liczy się każda liczba pomiędzy $1$ i $1\times10^7$i sprawdza, czy są to numery poniedziałkowe. Każda liczba jest konwertowana na ciąg, dzięki czemu cyfry można traktować indywidualnie.

Kontrole są następujące:

1. Najpierw sprawdź, czy są jakieś duplikaty. Sortując tablicę, jeśli różnica między dowolnymi kolejnymi cyframi wynosi zero, to są duplikaty

   diff(sort(a))
   

2. Sprawdź, czy są jakieś zera. ASCII dla 0 wynosi 48, więc sprawdzamy, czy wszystkie cyfry nie są równe.

   a~=48
   

3. Sprawdź, czy jest podzielna przez wszystkie cyfry. Sprawdzamy, czy reszta przy dzieleniu przez każdą cyfrę (konwertowaną z ASCII na dziesiętną, a więc -48) wynosi zero.

   ~mod(n,a-48)
   

Na koniec upewniamy się, że all()kontrole są prawdziwe, a jeśli tak, to dołączamy je do ciągu wyjściowego oddzielonego przecinkami.

MATLAB nie ma STDOUT, więc zamiast tego wypisuję ciąg wyników na końcu za pomocą disp()

Ten kod jest WOLNY! Nadal go uruchamiam, aby upewnić się, że poprawnie odnajduje wszystkie numery poniedziałkowe, ale na razie wygląda dobrze.

Aktualizacja:

Kod został zakończony. Drukuje następujące:

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

Co jeśli uruchomisz ten kod z tym jako danymi wejściowymi:

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

Bardziej interesujące, ale nieco dłuższe rozwiązanie z wyrażeniem regularnym:

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

W każdym przypadku używamy zdolności Ruby do iteracji po ciągach znaków, tak jakby były liczbami całkowitymi dziesiętnymi: ?1.upto(?9*7)jest równoważne 1.upto(9999999).map(&:to_s).each. Łączymy ciąg z każdą niezerową cyfrą za pomocą operatora modulo i sprawdzamy wynik, aby sprawdzić podzielność.

Bonusowe rozwiązanie Ruby 1.8 (wymaga -lflagi do poprawnego wydruku):

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

1.8 pozwoliło iteratorowi bloku być zmienną globalną. Przypisanie $_sprawia, że ​​jest niejawnym odbiornikiem operacji na łańcuchach. Łatwiej też interpolujemy tablice do wyrażenia regularnego: w 1.8 /[#{[1,2]}]/ewaluuje do /[12]/.

Pip , 25 bajtów

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

Wysyła każdą liczbę w osobnym wierszu. Działało to od około 10 minut i do tej pory osiągnęło 984312, ale jestem pewien, że jest poprawne. (Edycja: Kilka godzin później ... kod zakończony, wygenerowano wszystkie 548 z nich.)

Oto interpretacja pseudokodu w języku Python:

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

#=Operatora porównuje dwa iterables długością. Jeżeli liczba Uni Qznaków w ue ajest taka sama jak liczba znaków a, nie ma powtórzeń.

Sprawdzian podzielny według każdej cyfry pochodzi z jednego z moich przykładowych programów Pip. Napisałem go po obejrzeniu wcześniejszego wyzwania , ale nie opublikowałem go tam, ponieważ język był nowszy niż pytanie. W przeciwnym razie przy 8 bajtach byłaby to zwycięska odpowiedź na to pytanie. Oto wyjaśnienie krok po kroku:

      ^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 bajtów

Dzieci, nie próbujcie tego w domu; JS nie będzie zadowolony z perspektywy przechodzenia przez każdą cyfrę każdej liczby całkowitej od jednego do dziesięciu milionów z wyrażeniem regularnym.

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

Pierwsze wyrażenie regularne (rekwizyty do @Jarmex) zwraca, truejeśli liczba zawiera zduplikowane cyfry lub zera. Jeśli okaże się false, przejście programu do drugiego, który zastępuje każdą cyfrę jz i%j. Wynik to wszystkie zera, jeśli jest podzielny przez wszystkie cyfry, w którym to przypadku przechodzi do console.log(i).

Sugestie mile widziane!

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.