Puzzling에 대한이 질문 에서 Gamow 가 정의한 Monday numbers 는 다음 세 가지 특성을 가진 양의 정수 N 입니다.

• N 의 10 진수 표현은 숫자 0을 포함하지 않습니다.
• N 의 십진수 표현은 두 자리 숫자를 포함하지 않습니다
• N 은 십진수로 나타나는 모든 숫자 D 로 나눌 수 있습니다.

이것들은 대안 적으로 OEIS에서 Lynch-Bell 번호 로 알려져있다 .

예 :

• 15이 둘로 나누어입니다으로 월요일 번호입니다 1및 5만족 다른 두 가지 조건
• 16는로 나눌 수 없기 때문에 아닙니다 6.
• 22조건 1과 3을 만족하지만 조건 2에 실패하기 때문에 숫자 는 아닙니다.

다음은 월요일에 시작한 25 개의 숫자 목록입니다 (총 548 개).

12 34 5678 9 12 15 24 36 48124126128132135162168168175184216248

여기서 문제는 1에서 9867312까지 (월드 번호의 전체 시퀀스를 생성하는 가장 짧은 코드 를 작성하는 것 입니다.

코드는 입력을받지 않아야하며, 구분 기호를 선택하여 출력을 STDOUT 또는 이와 동등한 것으로해야합니다. 모든 일반적인 코드 골프 규칙이 적용되며 표준 허점 은 금지됩니다.

리더 보드

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>

젤리 , 8 바이트

ȷ7Dg⁼QƲƇ

8 분 안에 로컬로 실행됩니다.

온라인으로 사용해보십시오! (6 자리 이하의 숫자를 찾도록 수정)

작동 원리

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

파이썬 2, 85 바이트

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

목록을 인쇄합니다.

기본적으로 이전 과제에 대한 두 가지 답변을 결합하고 있습니다.

• 숫자를 각 자릿수로 나눌 수 있는지 확인

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

  (FryAmTheEggman에게 이것을 상기시켜 주셔서 감사합니다).

• 모든 십진수가 고유한지 확인

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

조건을 더 잘 결합하여 1 바이트 절약 xsot 덕분에.

펄, 61 47 바이트

46 바이트 코드 + 1 바이트 명령 줄 매개 변수

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

용법:

perl -l entry.pl

설명

/(.).*\1|0/ 테스트 대상 숫자에 중복 문자가 포함되어 있거나 0이 있으면 1을 반환합니다.

s/./$_%$&/rge각 숫자를 테스트중인 숫자 %의 숫자로 대체합니다. 예를 들어 15-> 00, 16-> 04 (16 % 6 = 4이므로)입니다. 즉, 모든 자릿수로 나눌 수있는 입력은 모두 0으로 구성되며 그렇지 않은 경우 자릿수> 0을 포함합니다. 이것을 숫자로 취급하기 위해, 우리는 * 1이며, 이는 테스트중인 숫자가 모든 블록으로 나눌 수있는 경우이 블록에 대해 0을 리턴하고 그렇지 않으면> 0을 리턴 함을 의미합니다.

이 두 문장과 인쇄물을 '또는'으로 분리하여 처음 두 조건 중 하나가> 0을 반환하면 조건이 일치하고 표현식의 후속 부분이 평가되지 않습니다. 이전의 두 조건이 모두 0 인 경우에만 인쇄가 실행됩니다. -l플래그는 각 인쇄 후 새 줄을 추가 보장합니다.

피스, 22 21

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

1 바이트의 불필요한 포맷을 골라 낸 Jakube에게 감사드립니다.

이 CW 답변 에서 관련 질문에 큰 영향을 받았습니다 .

I는 결과의 페이스트가 여기 가 인쇄시 개행 분리에서, 지금은 파이썬리스트로서 출력한다.

7보다 작은 숫자를 사용하지 않으면 온라인으로 시도 하지 않는 것이 좋습니다 .이 링크에서 2로 설정했습니다.

에서 필터 1에 10^7-1있는 필요한 모든 값을 포함한다. 이 버전은 목록을 만들 수없는 경우 메모리 오류를 일으킬 수 있습니다. 파이썬 3 S^T7과 유사 list(range(1,10**7))하지만 (나에게 잘 작동합니다). 그렇다면 다음을 시도해보십시오.

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

월요일 첫 번째 548 개의 숫자를 찾습니다. 이것은 또한 try-catch 블록을 사용하는 0대신 숫자 에서 s 를 확인하는 다른 방법을 보여줍니다 .3. 이 버전의 크레딧은 전적으로 Jakube에게 있습니다. (온라인 인터프리터에게는 여전히 속도가 느려집니다)

GS2 , 20 19 바이트

gs2는 인쇄 가능한 ASCII chracter뿐만 아니라 광범위한 바이트를 사용합니다. 내 솔루션을 16 진수로 제시합니다.

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

여기 몇 가지 설명이 있습니다. gs2는 스택 기반 언어이므로 변수가 없습니다. (4 개의 레지스터를 제외하고 하나는 여기서 사용합니다)

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

파이썬 3 132 128 114 111 104 바이트

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

월요일 번호는 548입니다.

APL, 44 39 37 바이트

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

언 골프 드 :

{
 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

Moris Zucca 덕분에 7 바이트가 절약되었습니다!

TI-BASIC, 60 59 바이트

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

∟D수학 및 사용하여 생성 숫자리스트 인 randIntNoRep(명령 (모든 정수 사이의 임의의 순열 1및 1+int(log(X논리합). 모든 조건이 충족되는지 확인하기 위해 약간 복잡한 문장 체인을 사용합니다.

   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(

숫자 제로 숫자를 반복 한 숫자를 실패하기 위해, 나는과 제로 대체 2X하기 때문에, X에 의해 결코 나눌 수있다 2X.

특별한 경우 1 ~ 9 ( ΔList(하나의 요소 목록 오류 때문에 ) If네 번째 줄 의 문을 사용 하여 다섯 번째 줄의 검사를 건너 뛰고 자동으로 X≤9를 모두 표시합니다 .

출력 번호는 개행으로 구분됩니다.

매스 매 티카 105

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

• IntegerDigits깨진다 n, 그 자리의 목록에 i.
• FreeQ[i,0] 목록에 0이 없는지 확인합니다.
• Length[i]==Length[Union[i]] 반복되는 숫자가 없는지 확인합니다.
• And@@(Divisible[n,#]&/@i)각 숫자가의 제수인지 확인합니다 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, 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, 163824, 163824, 163824, 163824, 163824, 163824, 163824 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216384, 218736, 219384 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, 324168, 324168, 324168, 324168, 318168 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 367248, 376824, 381264, 381624, 382416, 384192, 384216, 384216 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 431928, 432168, 432768, 432816, 436128, 438192 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 498312, 612384, 613248 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 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 843192, 843216, 843912, 846312, 849312, 861432 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941832, 943128, 948312, 976248, 978264, 981432, 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 2138976, 2189376, 2317896, 2789136, 279368, 28179, 2796883, 279680 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, 6719731, 6719328928, 6719328928 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392, 7863912, 7891632, 7892136, 7916328, 8916832, 7921368976976 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 97872, 9723632 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9238617 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, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9238617 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, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}

Length[%]

548

하스켈, 77 바이트

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

사용 예 (처음 20 자리) :

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]

작동 방식 : 1에서 9 ^ 9까지의 모든 숫자를 반복하고 조건을 확인하십시오. 현재 숫자 x는 문자열 show x목록 ( )으로 바뀌어 문자 목록으로 작동합니다.

R, 99 바이트

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

약간 덜 골프 :

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

펄, 90 75 70 바이트

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

CJam, 25 바이트

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

온라인으로 사용해보십시오 . 온라인 링크는 10,000 개로 만 실행됩니다. 충분히 인내한다면 온라인으로 끝낼 지 확신 할 수 없습니다. 오프라인 버전의 CJam으로 테스트하지는 않았지만 종료 될 것으로 예상됩니다.

설명:

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

내가 golved한지 오래되었으므로 바이트 수를 줄이려면 몇 가지 트릭을 잊었을 것입니다. 내가 생각할 때 개선 될 것입니다 ... 지금 :

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

언 골프 드 :

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,126812 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 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,7921332,7921368 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 바이트

이것은 Thomas Kwa의 답변을 비교적 사소한 편집 이지만 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

내 주요 변경 사항은에서 생성 된 모든 숫자 목록에 0 이 있음 randIntNoRep(1,을 randIntNoRep(0,의미합니다.

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

이제 모든 자릿수에 0이 있으므로 나머지 수의 합에 영향을줍니다. 일반적으로 나머지의 합은 0이지만 이제 여분의 0이 있으면 분열 테스트가 실패합니다.
이에 대응하기 위해로 변경 2Xnot(했습니다 Xnot(. 2는 원래 0에서 테스트 실패를 만들기 위해 존재했지만 이제는 0으로 전달됩니다. 그러나 숫자에 0이 포함 된 숫자는 이제min(ΔList(∟D 0이됩니다 (목록에 2 개 이상의 0이 있으므로).이 변경으로 인해 추가 숫자가 테스트를 통과하지 않습니다.

이 방법의 이점은 숫자 1-9에서 생성 된 "두 자리"가 ΔList(있으므로 오류가 발생하지 않으므로 한 자리 숫자의 특수 조건을 제거 할 수 있다는 것입니다.

05AB1E , 30 22 21 18 14 13 12 9 바이트

@Enigma 및 @ Mr.Xcoder 의 도움과 격려 덕분에 -9 바이트 . 제가 아직 30 세일 때 이미 12 바이트 솔루션을 염두에두고 있었지만 대부분 스스로 알아볼 수있게 해주셔서 감사합니다.이 도전에서 05AB1E에 대해 많은 것을 배웠습니다! @Grimy
덕분에 -3 바이트

7°LʒÐÑÃÙQ

온라인으로 시도하십시오 ( 60 초 후 시간 초과를 방지하기 위해 10 ⁷ 대신 10 ³ 미만의 숫자 만 출력 함 ).

설명:

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)

이전 12 개월 버전 (최초의 05AB1E 답변 중 하나) :
참고 : 기존 버전의 05AB1E에서만 작동합니다.

7°LʒÐSÖPsDÙQ*

온라인으로 시도하십시오 ( 60 초 후 시간 초과를 방지하기 위해 10 ⁷ 대신 10 ³ 미만의 숫자 만 출력 함 ).

설명:

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)

줄리아, 88 바이트

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

이것은 1에서 최대 Lynch-Bell 번호까지 모든 숫자를 가져 와서 Lynch-Bell 번호까지만 필터링합니다.

언 골프 드 :

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

print(join(lynch, " "))

파이썬 2, 101 바이트

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

print인터프리터에서 96을 얻기 위해 생략 할 수 있습니다 6**9. 가장 큰 월요일 숫자는 7 자리에 불과하지만 8 자리이므로 사용됩니다.9**9 시간이 오래 걸리고 6 ** 9는 10 초 정도 걸립니다.

펄, 97 바이트

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

실행하는 데 시간이 걸리지 만 필요한 출력이 생성 1e3됩니다. 더 빠른 예 를 보려면로 변경하십시오 !

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)

그리고 더 읽기 쉬운 형식으로 :

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$ 하여 월요일 숫자인지 확인합니다. 각 숫자는 문자열로 변환되어 숫자를 개별적으로 처리 할 수 ​​있습니다.

점검 사항은 다음과 같습니다.

1. 먼저 중복이 있는지 확인하십시오. 배열을 정렬하여 연속 자릿수의 차이가 0이면 중복이 있습니다.

   diff(sort(a))
   

2. 0이 없는지 확인하십시오. 0의 ASCII는 48이므로 모든 숫자가 같지 않은지 확인합니다.

   a~=48
   

3. 모든 자릿수로 나눌 수 있는지 확인하십시오. 각 숫자로 나눌 때 (ASCII에서 10 진수로 변환하여 -48로) 나머지가 0인지 확인합니다.

   ~mod(n,a-48)
   

마지막으로 우리는 all() 검사가 하고 쉼표로 구분 된 출력 문자열에 추가합니다.

MATLAB에는 STDOUT이 없으므로 대신 다음을 사용하여 결과 문자열을 인쇄합니다 disp()

이 코드는 느립니다! 나는 월요일의 모든 숫자를 올바르게 찾는 지 확인하기 위해 여전히 실행 중이지만 지금까지는 좋아 보입니다.

최신 정보:

코드 실행이 완료되었습니다. 다음을 인쇄합니다.

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

이 코드를 입력으로 사용 하여이 코드를 실행하면 :

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

예일 548.

루비, 79

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

정규 표현식을 사용하면 더 흥미롭지 만 약간 더 긴 솔루션 :

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

각각의 경우, 우리는 문자열이 십진 정수인 것처럼 루비의 문자열 반복 기능을 사용 ?1.upto(?9*7)합니다.1.upto(9999999).map(&:to_s).each . 모듈로 연산자를 사용하여 문자열을 0이 아닌 각 숫자에 조인하고 결과를 평가하여 분 산성을 확인합니다.

보너스 Ruby 1.8 솔루션 ( -l적절한 출력을 위해 플래그 필요 ) :

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

1.8은 블록 반복자가 전역 변수가되도록 허용했습니다. $_문자열 연산을위한 암시 적 수신자로 지정 합니다. 또한 배열을 정규 표현식에보다 쉽게 ​​삽입 할 수 있습니다. 1.8에서는으로 /[#{[1,2]}]/평가됩니다 /[12]/.

핍 , 25 바이트

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

각 숫자를 자체 줄에 출력합니다. 이것은 약 10 분 동안 실행되었으며 지금까지 984312까지 얻었지만 정확하다고 확신합니다.(편집 : 몇 시간 후 ... 코드가 완성되어 548 개가 모두 생성되었습니다.)

다음은 파이썬과 유사한 의사 코드 변환입니다.

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

그만큼 #=운영자는 길이 두 반복 가능 객체를 비교한다. 수있는 경우 UNI Q의 UE 문자는 a문자의 수와 동일하다a , 더 반복이 없습니다.

각 숫자로 나눌 수있는 검사는 내 Pip 예제 프로그램 중 하나입니다. 나는 초기 도전 을 본 후에 그것을 썼다 . 그러나 언어가 질문보다 새로운 것이기 때문에 그것을 게시하지 않았다. 그렇지 않으면 8 바이트에서 그 질문에 대한 답이 될 것입니다. 단계별 설명은 다음과 같습니다.

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

자바 스크립트 (ES6), 106 90 83 바이트

아이들, 집에서 시도하지 마십시오. JS는 정규식을 사용하여 1 ~ 1 천만에서 모든 정수의 모든 숫자를 반복하는 전망에 만족하지 않을 것입니다.

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

첫 번째 정규식 (@Jarmex로 소품)은 true숫자에 중복 숫자 나 0이 포함되어 있으면 반환 합니다. 이 경우 false프로그램은 초로 이동하여 각 숫자 j를i%j . 모든 자릿수로 나눌 수 있으면 결과는 모두 0이며,이 경우로 이동합니다 console.log(i).

제안을 환영합니다!

자바 스크립트 (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)

0 또는 반복 숫자에 대한 정규 표현식 테스트. 그런 다음 모든 숫자에 대해 0이 아닌 모듈로를 찾아 숫자 배열을 검사합니다.

다음 은 최대 7 자리 숫자에 대한 설명입니다.

루비, 130 바이트

... 공백을 계산하지 않습니다

프로그래밍에 익숙하지 않고 참여하고 싶었습니다.

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 바이트

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

예뻐요 :

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

각 후보 에 대해 비트 단위로 본 자릿수를 추적하면서 리틀 엔디안 순서로 i자릿수 a를 반복합니다 m. 루프가 완료되면 모든 자릿수가 고려 i되고 0이나 반복되는 자릿수가 표시되지 않으므로 인쇄하십시오. 그렇지 않으면 외부 루프를 계속하기 위해 일찍 종료됩니다.

CJam, 34 바이트

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

루아, 129 바이트

순수한 자릿수 크 런칭을위한 문자열 접근 방식을 피했습니다. (이 이론을 테스트 할 것이지만 Lua 문자열 처리는 다른 언어와 비교하여 매우 장황합니다.)

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 바이트

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}

END대신에 사용하면 97로 줄일 수 있습니다BEGIN 있지만 실제 출력을 시작하려면 Ctrl-D를 눌러 입력이 없다는 신호를 보내야합니다.

BEGIN또는 대신에 아무것도 쓰지 않으면 94로 줄일 수 END있지만, 리턴 키를 한 번 눌러 입력해야 할 수도 있습니다.

단순히 각 숫자의 자릿수를 넘어 기준이 충족되는지 테스트합니다.

i ~ 0 : 숫자에`0`이 포함되어 있습니까? -> 쓰레기
i % (d = a [j]) : 숫자를 현재 숫자로 나눌 수 없습니까? -> 쓰레기
id * 10 ^ (lj) ~ d : 숫자에서 현재 숫자를 제거했습니다.
                  : 여전히 포함되어 있습니까? -> 쓰레기

Core 2 Duo에서 종료하는 데 140 초가 걸립니다.

젤리 , 11 바이트

9œ!ṖẎgḌ$ƑƇḌ

이것은 2 주 된 œ!원자를 사용합니다 . 실제로 TIO에서 실행하기에 충분히 빠릅니다.

온라인으로 사용해보십시오!

작동 원리

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.