Montagszahlen , wie von Gamow in dieser Frage über Rätsel definiert, sind positive ganze Zahlen N mit den folgenden drei Eigenschaften:

• Die Dezimaldarstellung von N enthält nicht die Ziffer 0
• Die Dezimaldarstellung von N enthält keine doppelte Ziffer
• N ist durch jede Ziffer D teilbar , die in ihrer Dezimaldarstellung vorkommt

Beachten Sie, dass diese im OEIS alternativ als Lynch-Bell-Nummern bezeichnet werden .

Beispiele:

• 15ist ein Montag - Nummer, wie sie durch beide teilbar ist 1und 5und erfüllt die beiden anderen Bedingungen
• 16ist nicht, weil es nicht teilbar ist durch 6.
• Die Zahl 22ist nicht, da sie die Bedingungen 1 und 3 erfüllt, die Bedingung 2 jedoch nicht erfüllt.

Hier ist die Liste der ersten 25 Montagszahlen, mit denen Sie beginnen können (es gibt insgesamt 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

Die Herausforderung hierbei besteht darin , den kürzesten Code zu schreiben, der die vollständige Sequenz der Montagszahlen von 1 bis 9867312 generiert (wobei sich bei dieser Frage als der größtmögliche erwiesen hat).

Ihr Code sollte keine Eingabe und die Ausgabe sollte STDOUT oder ein gleichwertiges Zeichen sein, wobei Sie das Trennzeichen auswählen. Es gelten alle üblichen Code-Golf-Regeln und Standard -Regelungslücken sind verboten.

Bestenliste

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>

Gelee , 8 Bytes

ȷ7Dg⁼QƲƇ

Läuft vor Ort in weniger als acht Minuten.

Probieren Sie es online! (Geändert, um Zahlen mit sechs oder weniger Ziffern zu finden.)

Wie es funktioniert

ȷ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 Bytes

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

Druckt eine Liste.

Grundsätzlich kombiniere ich zwei meiner Antworten auf frühere Herausforderungen:

• Prüfen, ob eine Zahl durch jede ihrer Ziffern teilbar ist

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

  (Danke an FryAmTheEggman, der mich daran erinnert hat).

• Bestimmen Sie, ob alle Dezimalstellen eindeutig sind

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

Dank xsot für 1 Byte gespart durch die Kombination der Bedingungen besser.

Perl, 61 47 Bytes

46 Byte Code + 1 Byte Befehlszeilenparameter.

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

Verwendung:

perl -l entry.pl

Erläuterung

/(.).*\1|0/ Gibt 1 zurück, wenn die zu testende Nummer ein doppeltes Zeichen oder eine 0 enthält

s/./$_%$&/rgeErsetzt jede Ziffer durch den Wert der zu testenden Zahl% der Ziffer. Zum Beispiel 15 -> 00, 16 -> 04 (da 16% 6 = 4). Dies bedeutet, dass jede Eingabe, die durch alle Ziffern teilbar ist, aus allen Nullen besteht, andernfalls enthält sie eine Ziffer> 0. Um dies als Zahl zu behandeln, geben wir * 1 zurück, was bedeutet, dass eine zu testende Zahl für diesen Block 0 zurückgibt, wenn sie durch alle ihre Ziffern teilbar ist, andernfalls> 0.

Wenn Sie diese beiden Anweisungen und den Ausdruck durch 'oder' trennen und eine der beiden ersten Bedingungen> 0 zurückgibt, stimmt die Bedingung überein, und die nachfolgenden Teile des Ausdrucks werden nicht ausgewertet. Wenn und nur wenn beide vorherigen Bedingungen 0 sind, wird der Druck ausgeführt. Das -lFlag stellt sicher, dass nach jedem Druck eine neue Zeile eingefügt wird.

Pyth, 22 21

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

Vielen Dank an Jakube für das Abschlagen von 1 Byte unnötiger Formatierung.

Stark inspiriert von dieser CW-Antwort auf die verwandte Frage.

Ich habe eine Paste des Ergebnisses hier , von dem Zeitpunkt an, an dem es als Zeilenvorschub getrennt gedruckt wurde, jetzt als Python-Liste.

Ich würde empfehlen , es nicht online zu versuchen, es sei denn, Sie verwenden eine Zahl kleiner als 7 ... Ich habe es in diesem Link auf 2 gesetzt.

Filter von 1bis 10^7-1die alle notwendigen Werte abdecken. Diese Version kann einen Speicherfehler verursachen, wenn die Liste nicht erstellt werden kann S^T7, ähnlich wie list(range(1,10**7))in Python 3 (funktioniert jedoch bei mir einwandfrei). Wenn ja, könnten Sie versuchen:

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

Womit die ersten 548 Montagszahlen gefunden werden. Dies zeigt auch eine andere Möglichkeit, die 0s in der Nummer zu überprüfen , anstatt sie durch .3einen Try-Catch-Block zu ersetzen . Dank für diese Version geht ganz an Jakube. (Beachten Sie, dass dies für den Online-Dolmetscher immer noch viel zu langsam ist.)

GS2 , 20 bis 19 Bytes

gs2 verwendet eine Vielzahl von Bytes, nicht nur druckbare ASCII-Zeichen. Ich werde meine Lösung in hex präsentieren.

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

Hier ist eine Erklärung. gs2 ist eine stapelbasierte Sprache, daher gibt es keine Variablen. (abgesehen von 4 Registern, von denen ich hier eins benutze)

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 Bytes

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

Es gibt 548 Montagszahlen.

APL, 44 39 37 Bytes

{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

7 Bytes gespart dank Moris Zucca!

TI-BASIC, 60 59 Bytes

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

∟Dist die Liste der Ziffern, die mit math und dem randIntNoRep(Befehl generiert wird (zufällige Permutation aller ganzen Zahlen zwischen 1und 1+int(log(Xeinschließlich). Ich benutze eine etwas komplizierte Anweisungskette, um zu prüfen, ob alle Bedingungen erfüllt sind:

   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(

Um Zahlen mit wiederholten Ziffern oder mit Nullen zu versagen, ersetze ich Nullen durch 2X, da diese Xniemals durch teilbar sind 2X.

Für den Sonderfall 1 ~ 9 (weil ΔList(bei einer Liste mit einem Element Fehler aufgetreten sind ) verwende ich die IfAnweisung in der vierten Zeile, um die Prüfung in der fünften Zeile zu überspringen und automatisch alle X≤9 anzuzeigen.

Die Ausgabenummern werden durch Zeilenumbrüche getrennt.

Mathematica 105

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

• IntegerDigitsaufbricht n, in eine Liste ihrer Ziffern i.
• FreeQ[i,0] prüft, ob die Liste keine Nullen enthält.
• Length[i]==Length[Union[i]] prüft, ob es keine wiederholten Ziffern gibt.
• And@@(Divisible[n,#]&/@i)prüft, ob jede Ziffer ein Teiler von ist 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, 724 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 98136, 123648, 1238 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 162384, 163248, 1638 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216384, 218736, 219 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, 329824 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 36716248, 376824, 381264, 3816244, 38 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428716, 431928, 432168, 432786, 431928 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 61338 613872, 614328, 614832, 618432, 621384, 623184, 623784,627984, 631248, 631824, 632184, 634128, 634872, 641328, 641832, 643128, 648312, 671328, 671832, 681432, 684312, 689472, 732648, 732816, 74264646, 746928, 762384, 71664647832 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 843192, 843216314, 842136, 843 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941832, 9431282, 9714323 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 211789976, 2189376, 2317896, 288913 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867192, 3869712, 3927168, 6328176, 6139728, 63798, 6328 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392, 7836192 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9217816, 9278136, 9283116, 9731213816 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613613, 7813, 7392168 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 92173796 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, 7398216, 7613613, 7813, 7392168 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 92173796 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, 988796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 98

Length[%]

548

Haskell, 77 Bytes

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

Anwendungsbeispiel (die ersten 20 Zahlen):

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]

So funktioniert es: iteriere über alle Zahlen von 1 bis 9 ^ 9 und überprüfe die Bedingungen. Die aktuelle Nummer xwird in ihre Zeichenfolgendarstellung ( show x) umgewandelt, um sie als Liste von Zeichen zu bearbeiten.

R, 99 Bytes

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

Etwas weniger Golf gespielt:

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 Bytes

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

CJam, 25 Bytes

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

Probieren Sie es online aus . Beachten Sie, dass der Online-Link nur zu 10.000 ausgeführt wird. Ich bin mir nicht sicher, ob es online enden würde, wenn Sie geduldig genug sind. Es wurde nicht mit der Offline-Version von CJam getestet, aber ich gehe davon aus, dass es beendet wird.

Erläuterung:

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

Es ist schon eine Weile her, dass ich golfen habe, also habe ich wahrscheinlich ein paar Tricks vergessen, um den Bytecount zu senken. Wird sich verbessern, wenn ich an sie denke ...

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,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,1296326,136236,236 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,16324816 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,2187364 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,28464,3126,291384,293184,2978126 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,31928,342168,3428169126128,348192,3482169128 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,41863232 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,48163282 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832618432,621384,623184,623784,632184,631248,631824,632184,634 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,8194 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,8912,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312976248,978264,91432,984312,1289736,17268 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,28196,283196,279 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,61397289129128,638728 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,78392167861392,7863912,7891632786139 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 Bytes

Dies ist eine relativ geringfügige Änderung von Thomas Kwas Antwort , aber ich sende sie als neue Antwort ein, weil ich gehört habe, dass er das Golfen seiner TI-BASIC-Antworten mit einer Prämie belegt hat .

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

Meine Hauptänderung ist von zu randIntNoRep(1,zu randIntNoRep(0,bedeuten, dass es jetzt eine Null in jeder erzeugten Liste der Stellen gibt.

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

Da jetzt in jedem Ziffernsatz eine Null steht, wirkt sich dies auf die Summe der Reste aus. Normalerweise ist die Summe der Reste 0, aber jetzt führt das Vorhandensein einer zusätzlichen Null zu einem Fehlschlag unseres Teilbarkeitstests.
Um dem entgegenzuwirken, wechselte ich 2Xnot(zu Xnot(. Die 2 war ursprünglich da, um den Test bei 0 fehlschlagen zu lassen, aber jetzt geht es bei Null. Zahlen, deren Ziffern eine Null enthalten, haben jetzt min(ΔList(∟Dsowieso eine Null (da ihre Listen 2 oder mehr Nullen enthalten), sodass diese Änderung nicht dazu führt, dass zusätzliche Zahlen den Test bestehen.

Der Vorteil dieser Methode besteht darin, dass die Funktion, da jetzt "zwei Ziffern" aus der Zahl 1-9 erzeugt werden, ΔList(keinen Fehler erzeugt, wodurch wir eine spezielle Bedingung für einstellige Zahlen beseitigen können.

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

-9 byte dank der hilfe und ermutigung von @Enigma und @ Mr.Xcoder . Vielen Dank, dass ich es größtenteils selbst herausfinden durfte, obwohl ich bereits mit 30 Jahren eine 12-Byte-Lösung im Sinn hatte. Ich habe viel über 05AB1E aus dieser Herausforderung gelernt!
-3 Bytes dank @Grimy

7°LʒÐÑÃÙQ

Probieren Sie es online aus (gibt nur Zahlen unter 10 ³ statt 10 ^{7 aus} , um eine Zeitüberschreitung nach 60 Sekunden zu vermeiden).

Erläuterung:

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)

Vorherige 12-Byte-Version (eine meiner allerersten 05AB1E-Antworten):
HINWEIS: Funktioniert nur in der älteren Version von 05AB1E.

7°LʒÐSÖPsDÙQ*

Probieren Sie es online aus (gibt nur Zahlen unter 10 ³ statt 10 ^{7 aus} , um eine Zeitüberschreitung nach 60 Sekunden zu vermeiden).

Erläuterung:

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 Bytes

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

Dies nimmt einfach alle Zahlen von 1 bis zur größten Lynch-Bell-Zahl und filtert sie nur bis zu den Lynch-Bell-Zahlen.

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 Bytes

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

Sie können das printim Interpreter weglassen , um 96 zu erhalten. Verwendet, 6**9da es 8 Stellen ist, während die größte Montagszahl nur 7 Stellen ist, so etwas 9**9würde wahrscheinlich lange dauern, 6 ** 9 dauert nur ungefähr 10 Sekunden.

Perl, 97 Bytes

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

Dauert eine Weile laufen, aber erzeugt die erforderliche Leistung, Veränderung 1e3für ein schnelleres Beispiel!

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)

Und in einem besser lesbaren 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)

$1$$1\times10^7$

Die Prüfungen sind wie folgt:

1. Überprüfen Sie zunächst, ob Duplikate vorhanden sind. Wenn durch Sortieren des Arrays die Differenz zwischen aufeinanderfolgenden Ziffern Null ist, gibt es Duplikate

   diff(sort(a))
   

2. Überprüfen Sie, ob es Nullen gibt. Der ASCII-Wert für 0 ist 48, daher prüfen wir, ob nicht alle Ziffern gleich sind.

   a~=48
   

3. Prüfen Sie, ob es durch alle Ziffern teilbar ist. Wir überprüfen, ob der Rest beim Teilen durch jede Ziffer (konvertiert von ASCII zu Dezimalzahl, daher -48) Null ist.

   ~mod(n,a-48)
   

Schließlich stellen wir sicher, dass all()die Prüfungen wahr sind, und hängen sie an eine durch Kommas getrennte Ausgabezeichenfolge an.

MATLAB hat kein STDOUT, also drucke ich stattdessen die Ergebniszeichenfolge am Ende mit disp()

Dieser Code ist LANGSAM! Ich führe es immer noch aus, um sicherzustellen, dass es alle Montagszahlen korrekt findet, aber es sieht bis jetzt gut aus.

Aktualisieren:

Der Code wurde ausgeführt. Es wird Folgendes gedruckt:

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

Was, wenn Sie diesen Code mit dem als Eingabe ausführen:

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

Yeilds 548.

Rubin, 79

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

Interessantere, aber etwas längere Lösung mit Regex:

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

In jedem Fall verwenden wir Rubys Fähigkeit, Strings zu durchlaufen, als wären es Dezimalzahlen: ?1.upto(?9*7)entspricht 1.upto(9999999).map(&:to_s).each. Wir verbinden die Zeichenkette mit jeder Ziffer ungleich Null unter Verwendung des Modulo-Operators und werten das Ergebnis aus, um die Teilbarkeit zu überprüfen.

Bonus Ruby 1.8 Lösung ( -lFlag für korrekte Ausgabe erforderlich ):

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

1.8 erlaubte dem Blockiterator, eine globale Variable zu sein. Durch das Zuweisen von $_wird es zum impliziten Empfänger für Zeichenfolgenoperationen. Wir können Arrays auch leichter in den regulären Ausdruck interpolieren: in 1.8 /[#{[1,2]}]/ergibt sich /[12]/.

Pip , 25 Bytes

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

Gibt jede Nummer in einer eigenen Zeile aus. Dies hat ungefähr 10 Minuten gedauert und ist bis jetzt auf 984312 aufgestiegen, aber ich bin mir ziemlich sicher, dass es richtig ist. (Edit: Paar Stunden später ... Code fertig, alle 548 von ihnen generiert.)

Hier ist eine Python-ähnliche Pseudocode-Wiedergabe:

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

Der #=Operator vergleicht zwei Iterablen nach ihrer Länge. Wenn die Anzahl der Uni Que Zeichen in adie gleiche wie die Anzahl der Zeichen in ist a, gibt es keine Wiederholungen.

Die durch jede Ziffer teilbare Prüfung stammt aus einem meiner Pip-Beispielprogramme. Ich habe es geschrieben, nachdem ich die frühere Herausforderung gesehen hatte , aber es dort nicht gepostet, weil die Sprache neuer war als die Frage. Andernfalls wäre es bei 8 Bytes die beste Antwort auf diese Frage. Hier ist eine schrittweise Erklärung:

      ^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

Kinder, versuchen Sie das nicht zu Hause. JS wird sich nicht über die Aussicht freuen, mit einem regulären Ausdruck jede Ziffer einer ganzen Zahl von eins bis zehn Millionen zu durchlaufen.

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

Der erste reguläre Ausdruck (Requisiten an @Jarmex) gibt zurück, truewenn die Nummer doppelte Ziffern oder Nullen enthält. Wenn sich herausstellt false, geht das Programm zur zweiten weiter, die jede Ziffer jdurch ersetzt i%j. Das Ergebnis sind alle Nullen, wenn es durch alle Ziffern teilbar ist. In diesem Fall geht es weiter zu console.log(i).

Vorschläge willkommen!

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)

Der Regexp-Test für 0 oder wiederholte Ziffern. Dann wird das Ziffernarray überprüft, um nach einem Modulo ungleich Null für eine beliebige Ziffer zu suchen.

hier ist die erklärung der 7 stelligen max.

Ruby, 130 Bytes

... ohne Leerzeichen

Neu in der Programmierung, wollte nur teilnehmen

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

Schöner:

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

Für jeden Kandidaten iiterieren wir seine Ziffern ain Little-Endian-Reihenfolge und verfolgen die angezeigten Ziffern in den Bits von m. Wenn die Schleife abgeschlossen ist, sind alle Ziffern Faktoren von iund wir haben keine Nullen oder wiederholten Ziffern gesehen. Drucken Sie sie also aus. Andernfalls verlassen wir die Schleife vorzeitig, um die äußere Schleife fortzusetzen.

CJam, 34 Bytes

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

Lua, 129 Bytes

Ich habe den String-Ansatz für reines Knacken von Ziffern vermieden, was etwas schneller zu sein scheint und mir wahrscheinlich auch ein paar Bytes erspart hat. (Ich werde diese Theorie testen lassen, aber der Umgang mit Lua-Strings ist im Vergleich zu einigen anderen Sprachen ziemlich ausführlich.)

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}

Ich könnte das auf 97 reduzieren, wenn ich ENDstattdessen verwenden würdeBEGIN , aber dann müsste man Strg-D drücken, um die eigentliche Ausgabe zu starten, was signalisiert, dass es keine Eingabe geben wird.

Ich könnte es sogar auf 94 reduzieren, wenn ich nichts anstelle von BEGINoder schreiben würde END, aber dann müsste man die Eingabetaste einmal drücken, um es zu starten, was als Eingabe gezählt werden könnte.

Es geht einfach über die Ziffern jeder Zahl und prüft, ob die Kriterien erfüllt sind.

i ~ 0: Zahl enthält eine `0`? -> Müll
i% (d = a [j]): Zahl nicht durch aktuelle Ziffer teilbar? -> Müll
id * 10 ^ (lj) ~ d: Ich habe die aktuelle Ziffer von der Nummer noch entfernt
                  : enthält es noch? -> Müll

Bei meinem Core 2 Duo dauert die Beendigung 140 Sekunden.

Jelly , 11 Bytes

9œ!ṖẎgḌ$ƑƇḌ

Dies verwendet das zwei Wochen alte œ!Atom. Eigentlich schnell genug, um mit TIO zu laufen.

Probieren Sie es online!

Wie es funktioniert

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.