Число понеділка , як визначено Ґамовим у цьому запитанні щодо Загадкового голосування, - це додатні цілі N із трьома трьома властивостями:

• Десяткове представлення N не містить цифри 0
• Десяткове представлення N не містить жодної цифри двічі
• N ділиться на кожну цифру D, яка виникає в її десятковому поданні

Зауважте, що в OEIS вони також відомі як номери Lynch-Bell .

Приклади:

• 15це число понеділка, так як це ділиться на так 1і 5і задовольняє інші дві умови
• 16ні, тому що це не ділиться на 6.
• Число 22немає, тому що, хоча воно відповідає умовам 1 і 3, воно не відповідає умові 2.

Ось список перших 25 номерів понеділка для початку роботи (всього 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

Завдання тут полягає в тому, щоб написати найкоротший код, який генерує повну послідовність чисел понеділка, від 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ƲƇ

Працює локально за вісім хвилин.

Спробуйте в Інтернеті! (модифіковано для пошуку чисел із шістьма цифрами чи менше)

Як це працює

ȷ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 байт

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

Завдяки xsot за 1 байт збережено, поєднуючи умови краще.

Perl, 61 47 байт

46 байт-код + 1 байт-параметр командного рядка.

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

Використання:

perl -l entry.pl

Пояснення

/(.).*\1|0/ повертає 1, якщо тестоване число містить дублюючий символ або 0

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 байт непотрібного форматування.

Сильно натхненний цією відповіддю CW на відповідне запитання.

У мене є паста з результатом тут , з моменту , коли він надрукований переклад рядка відокремили, тепер друкує як віщий список.

Я б не рекомендував пробувати його в Інтернеті, якщо ви не використовуєте число менше 7 ... Я встановив його на 2 у цьому посиланні.

Фільтри з 1до 10^7-1якої охоплює всі необхідні значення. Ця версія може спричинити помилку в пам'яті, якщо вона не може скласти список S^T7, який схожий на list(range(1,10**7))python 3 (Однак для мене це добре працює). Якщо так, ви можете спробувати:

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

Який знаходить перші 548 числа понеділка. Це також демонструє інший спосіб перевірити наявність 0s у кількості, замість того, щоб замінити їх .3цим, використовує блок-пробний блок. Заслуга за цю версію повністю припадає на Jakube. (Зверніть увагу, що для інтерпретатора в Інтернеті це ще дуже повільно)

GS2 , 20 19 байт

gs2 використовує широкий діапазон байтів, а не лише друкуючі символи ascii. Я представляю своє рішення в шістнадцятковому.

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

Python 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

Збережено 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] перевіряє, чи немає в списку нулів.
• 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, 73264, 73248 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 98136, 123648, 123864, 123864, 123864, 123864 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 162384, 163248, 163848, 163824 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216384, 218736, 218736, 218736, 218736, 218736, 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, 321648, 321864, 321864, 321864, 321864, 321864 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 367248, 376824, 381264, 381624, 382412, 382412, 382412, 382412, 382412, 382416, 382412, 382412, 382412, 382412, 382412, 382412, 382412, 382416, 382412, 382412, 382412, 382412, 382412, 382416, 382412, 382416, 382412, 382412, 382412, 382412, 382412 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 431928, 432168, 432768, 432816, 432816, 432816, 436, 432816, 436, 432816, 436, 416 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 498312, 613812, 498312, 498312, 498312, 498312, 498312, 498312, 498312, 498312, 498312, 498312, 498312, 498312 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, 78686464, 7683864, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768464, 768864 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 843192, 843216, 843912, 843216, 843912, 843912, 843912, 843912, 843912, 843912, 843912, 843912, 843912, 843912, 843912, 843912 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941832, 943128, 948312, 948312, 948312, 948312, 948312 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 2138976, 2189376, 2317896, 2768, 2717, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 2768, 276889, 276889, 27689 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867192, 3869712, 3927168, 3928176, 6139728, 6379129, 6379129, 6379129,, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861122, 786, 3961, 786, 3961, 7861 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176, 9283176 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176328, 9176178, 9176178, 9176817, 9176817, 9176837 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, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216, 7398216 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176328, 9176178, 9176178, 9176817, 9176817, 9176837 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, 981212, 9782136, 981212128796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 981212, 9782136, 98121212

Length[%]

548

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

Perl, 90 75 70 байт

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

CJam, 25 байт

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

Спробуйте в Інтернеті . Зауважте, що онлайн-посилання працює лише до 10000. Я не впевнений, чи закінчиться він онлайн, якщо ви досить терплячі. Він не перевіряв його з офлайн-версією 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

Минув час, коли я позолотився, тому, напевно, забув кілька хитрощів, щоб знизити рахунок. Поліпшується, коли я думаю про них ... Поки що:

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,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 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384, 244 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,3646412,, 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,3612 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,44 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,, 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634868, 64 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,81643232191932, 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, 23 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2831976298269176177298269166177187318262, 23731976, 177, 279, 269, 268, 268 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

TI-BASIC, 55 53 байти

Це відносно незначна редакція відповіді Томаса Ква , але я подаю це як нову відповідь, тому що я чув, що він дав щедрість за те, що він відповів 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

Моя основна зміна полягає 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, але тепер наявність додаткового нуля викликає один збій нашого тесту на подільність.
Щоб протидіяти цьому, я змінився 2Xnot(на Xnot(. Спочатку 2 були для того, щоб тест не вдався до 0, але тепер він проходить у нулі. Однак цифри, що містять нуль у своїх цифрах, мають: amin(ΔList(∟D у будь-якому випадку нуль (оскільки в їх списках є 2 або більше нулів), тому ця зміна не призводить до тестування додаткових чисел.

Користь цього методу полягає в тому, що, оскільки тепер існує число «дві цифри», отримані з числа 1-9, ΔList(функція не видає помилок, що дозволяє нам позбутися особливої ​​умови для одноцифрових чисел.

05AB1E , 30 22 21 18 14 13 12 9 байт

-9 байт завдяки допомозі та заохоченню @Enigma та @ Mr.Xcoder . Дякую, що дозволили мені здебільшого розібратися в цьому, хоча ви вже мали на увазі 12-байтове рішення, коли мені було ще 30 років. Дізналися багато про 05AB1E з цього завдання!
-3 байти завдяки @Grimy

7°LʒÐÑÃÙQ

Спробуйте в Інтернеті (виводить лише цифри нижче 10 ³ замість 10 ^7, щоб запобігти затримці через 60 секунд).

Пояснення:

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*

Спробуйте в Інтернеті (виводить лише цифри нижче 10 ³ замість 10 ^7, щоб запобігти затримці через 60 секунд).

Пояснення:

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

Python 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оскільки це 8 цифр, тоді як найбільше число понеділка становить лише 7 цифр, щось подібне 9**9, ймовірно, займе багато часу, 6 ** 9 займає лише 10 секунд.

Perl, 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. Спочатку перевірте, чи є дублікати. Сортувавши масив, якщо різниця між будь-якими послідовними цифрами дорівнює нулю, то є дублікати

   diff(sort(a))
   

2. Перевірте, чи є нулі. ASCII для 0 дорівнює 48, тому ми перевіряємо, чи всі цифри не рівні.

   a~=48
   

3. Перевірте, чи воно розділяється за всіма його цифрами. Перевіряємо, що залишок при діленні на кожну цифру (перетворену з ASCII в десяткову, отже -48) дорівнює нулю.

   ~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,','))

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

У кожному випадку ми використовуємо здатність Ruby перебирати рядки так, ніби вони були десятковими цілими числами: ?1.upto(?9*7)еквівалентно 1.upto(9999999).map(&:to_s).each. Ми приєднуємо рядок до кожної ненульової цифри за допомогою оператора модуля і оцінюємо результат, щоб перевірити на подільність.

Рішення Bonus 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 ем.)

Ось видання псевдокода Python-esque:

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

#=Оператор порівнює два ітеріруемих по довжині. Якщо кількість символів Uni Que 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)

Javascript (ES6), 106 90 83 байт

Діти, не намагайтеся цього вдома; JS не буде задоволений перспективою прокручування кожної цифри кожного цілого числа від одного до десяти мільйонів за допомогою регулярного вираження.

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

Перший регулярний вираз (реквізит до @Jarmex) повертається, trueякщо число містить повторювані цифри або нулі. Якщо це виявиться false, програма переходить до другої, яка замінює кожну цифру jна i%j. Результат - це всі нулі, якщо він ділиться всіма його цифрами, і в цьому випадку він переходить до console.log(i).

Пропозиції Ласкаво просимо!

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)

Тест повторного відліку для 0 або повторних цифр. Потім перевіряється масив цифр, шукаючи ненульовий модуль для будь-якої цифри.

ось пояснення 7-значний макс.

Ruby, 130 bytes

... не рахуючи пробілів

Новачок у програмуванні, просто хотів брати участь

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.