Números de segunda-feira , tal como definido por Gamow em esta pergunta sobre a intrigante, são números inteiros positivos N com as três propriedades seguintes:

• A representação decimal de N não contém o dígito 0
• A representação decimal de N não contém nenhum dígito duas vezes
• N é divisível por cada dígito D que ocorre em sua representação decimal

Observe que eles são conhecidos alternativamente, no OEIS, como números de Lynch-Bell .

Exemplos:

• 15é um número de segunda-feira, como é divisível por ambos 1e 5e satisfaz as outras duas condições
• 16não é, porque não é divisível por 6.
• O número 22não é, porque, embora satisfaça as condições 1 e 3, falha na condição 2.

Aqui está a lista dos primeiros 25 números de segunda-feira para você começar (existem 548 no total):

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

O desafio aqui é escrever o código mais curto que gere a sequência completa dos números de segunda-feira, de 1 a 9867312 (comprovado nessa questão como o maior possível).

Seu código não deve receber entrada e a saída deve ser STDOUT ou equivalente, com a sua escolha de delimitador. Todas as regras usuais de código de golfe se aplicam, e as brechas padrão são proibidas.

Entre os melhores

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

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

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

Geléia , 8 bytes

ȷ7Dg⁼QƲƇ

É executado localmente em menos de oito minutos.

Experimente online! (modificado para encontrar números com seis dígitos ou menos)

Como funciona

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

Imprime uma lista.

Basicamente, estou combinando duas das minhas respostas aos desafios anteriores:

• Verificando se um número é divisível por cada um de seus dígitos

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

  (obrigado a FryAmTheEggman por me lembrar disso).

• Determinar se todos os dígitos decimais são exclusivos

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

Graças ao xsot por 1 byte economizado, combinando melhor as condições.

Perl, 61 47 bytes

Código de 46 bytes + parâmetro da linha de comando de 1 byte.

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

Uso:

perl -l entry.pl

Explicação

/(.).*\1|0/ retorna 1 se o número em teste contiver um caractere duplicado ou um 0

s/./$_%$&/rgesubstitui cada dígito pelo valor do número em teste% do dígito. Por exemplo, 15 -> 00, 16 -> 04 (porque 16% 6 = 4). Isso significa que qualquer entrada que é divisível por todos os seus dígitos consistirá em todos os 0s, caso contrário, conterá um dígito> 0. Para tratar isso como um número, nós * 1, o que significa que qualquer número em teste retornará 0 para este bloco se for divisível por todos os seus dígitos, caso contrário> 0.

Ao separar essas duas instruções e a impressão com 'ou', se uma das duas primeiras condições retornar> 0, a condição corresponderá e as partes subsequentes da expressão não serão avaliadas. Se e somente se as duas condições anteriores forem 0, a impressão será executada. O -lsinalizador garante adicionar uma nova linha após cada impressão.

Pyth, 22 21

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

Agradecimentos a Jakube por jogar 1 byte de formatação desnecessária.

Fortemente inspirado por esta resposta da CW à pergunta relacionada.

Eu tenho uma pasta do resultado aqui , a partir de quando ela imprimiu uma nova linha separada, agora ela é impressa como uma lista python.

Eu recomendaria não experimentá-lo on-line, a menos que você use um número menor que 7 ... Defini-o como 2 neste link.

Filtros 1para 10^7-1que abrange todos os valores necessários. Esta versão pode causar um erro de memória se não conseguir fazer a lista S^T7, semelhante ao list(range(1,10**7))python 3 (no entanto, funciona bem para mim). Se sim, você pode tentar:

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

Que encontra os primeiros 548 números de segunda-feira. Isso também demonstra outra maneira de verificar os 0s no número, em vez de substituí-los por .3isso, usa um bloco try-catch. O crédito para esta versão vai inteiramente para Jakube. (Observe que isso ainda é muito lento para o intérprete on-line)

GS2 , 20 19 bytes

O gs2 usa uma ampla gama de bytes, não apenas caracteres ascii imprimíveis. Vou apresentar minha solução em hexadecimal.

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

Aqui está uma explicação. gs2 é uma linguagem baseada em pilha, portanto não há variáveis. (além de 4 registros, um dos quais eu uso aqui)

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

Existem 548 números de segunda-feira.

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

Economizou 7 bytes graças a 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

∟Dé a lista de dígitos, que é gerada usando matemática e o randIntNoRep(comando (permutação aleatória de todos os números inteiros entre 1e 1+int(log(Xinclusive). Eu uso uma cadeia de instruções um pouco complicada para verificar se todas as condições são atendidas:

   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(

Para falhar números com dígitos repetidos ou zero, substituo zeros por 2X, porque Xnunca é divisível por 2X.

No caso especial 1 ~ 9 (porque ΔList(em uma lista de erros de um elemento), uso a Ifinstrução na quarta linha para pular a verificação na quinta linha, exibindo automaticamente todos os X≤9.

Os números de saída são separados por novas linhas.

Mathematica 105

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

• IntegerDigits termina n em uma lista de seus dígitos i,.
• FreeQ[i,0] verifica se não há zeros na lista.
• Length[i]==Length[Union[i]] verifica se não há dígitos repetidos.
• And@@(Divisible[n,#]&/@i)verifica se cada dígito é um divisor de n.

{1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 24, 36, 48, 124, 126, 128, 132, 135, 162, 168, 168, 175, 184, 216, 248 , 264, 312, 315, 324, 384, 396, 412, 432, 612, 624, 648, 672, 728, 735, 784, 816, 824, 864, 964, 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, 3168, 3195, 3216, 3264, 3276, 3492, 3612, 3624 , 3648, 3816, 3864, 3915, 3924, 4128, 4172, 4236, 4368, 4392, 4632, 4872, 4896, 4932, 4968, 6132, 6192, 6312, 6324, 6384, 6432, 6912, 6984, 8136, 8496 , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12768, 12864, 13248, 13824, 13896, 13968, 14328, 14728, 14832, 16248, 16824, 17248 , 18264, 18432, 18624, 18936, 19368, 21384, 21648, 21784, 21864, 23184, 24168, 24816, 26184, 27384, 28416, 29736, 31248, 31824, 31896, 31968, 32184, 34128, 36792,37128, 37296, 37926, 38472, 39168, 39816, 41328, 41832, 42168, 42816, 43128, 43176, 46128, 46872, 48216, 48312, 61248, 61824, 62184, 64128, 68712, 72184, 73164, 73248 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 98136, 123948, 123864 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 162384, 163248, 163824 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216384, 218736, 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 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 367248, 376824, 381264, 381624, 382416, 384192 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 431928, 432168, 432768, 432816, 432768, 432868, 432768, 432868 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 49831212 61238 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, 732426, 783216, 732432, 783216, 732432 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 843192, 843216, 841212, 843216, 843212 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941832, 943128, 948312 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 2138976, 2189376, 2817896, 2738976 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867193 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861313, 7863939 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 961732, 9283176, 96173278 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 71282167, 7612986, 7812, 76129, 39123 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 91717 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, 71282167, 7612986, 7812, 76129, 39123 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 91717 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, 9126136, 981237}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9126136, 981237}

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]

Exemplo de uso (os 20 primeiros números):

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]

Como funciona: itere sobre todos os números de 1 a 9 ^ 9 e verifique as condições. O número atual xé transformado em sua representação de seqüência de caracteres ( show x) para operar como uma lista de caracteres.

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

Um pouco menos golfe:

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>},`

Experimente online . Observe que o link online é executado apenas para 10.000. Não tenho certeza se isso terminaria online se você for paciente o suficiente. Ele não foi testado com a versão offline do CJam, mas espero que seja finalizado.

Explicação:

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

Já faz um tempo desde que eu me envolvi, então provavelmente esqueci alguns truques para diminuir o número de bytes. Vai melhorar quando penso neles ... Por enquanto:

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,1296,132,1162,1162,132,1642,132,1642,132,1642,132,1642,132,1642,132,1642,14 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,163284,1643232,164328,1493232,1323264,1323248,1638,1323248,1638,132848,1638,132328,14388 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,21638,21638,216332,216384,218316,24 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,348212,3,3198,3481212,349128,348912,349128,348912,349128,348812 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391848,391824,392184,394128,412368,413928,416328,416832,418392,413832,418392,419832,4193232,419832,494 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,492136,4831332,482136,4781332,482136,4781332,482136,478632 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,631248,631824,632184,634128,63184,634128,63184,634128,63184,634128,63184,632128,63184,63128,63184,632 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783284,768432,783216,789264,796824,813264,813624,814392,814632,8234,28 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,987 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,279198,278191393,29197 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,619191919287 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,781616,79216,7861668,7861668,781616688 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

Esta é uma edição relativamente pequena da resposta de Thomas Kwa , mas a estou enviando como uma nova resposta, porque ouvi dizer que ele deu uma recompensa por jogar suas respostas no 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

Minha principal mudança é de randIntNoRep(1,para randIntNoRep(0,o que significa que agora haverá zero em todas as listas de dígitos geradas.

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

Como agora existe um zero em cada conjunto de dígitos, isso afeta a soma dos restantes. Normalmente, a soma dos restantes é 0, mas agora, a presença de um zero extra causa uma falha no nosso teste de divisibilidade.
Para combater isso, mudei 2Xnot(para Xnot(. O 2 estava lá originalmente para fazer o teste falhar em 0, mas agora passa em zero. Números que contêm zero em seus dígitos, no entanto, agora têm ummin(ΔList(∟D zero de qualquer maneira (já que há 2 ou mais zeros em suas listas), portanto, essa alteração não faz com que outros números passem no teste.

A vantagem desse método é que, como agora existem "dois dígitos" produzidos a partir do número 1-9, a ΔList(função não produz um erro, o que nos permite livrar-nos de uma condição especial para números de um dígito.

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

-9 bytes graças à ajuda e incentivo do @Enigma e @ Mr.Xcoder . Obrigado por me deixar descobrir principalmente, mesmo que você já tivesse uma solução de 12 bytes quando eu ainda tinha 30 anos. Aprendi muito sobre o 05AB1E com esse desafio!
-3 bytes graças a @Grimy

7°LʒÐÑÃÙQ

Experimente online (gera apenas os números abaixo de 10 ^{3 em} vez de 10 ⁷ para evitar um tempo limite após 60 segundos).

Explicação:

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)

Versão anterior de 12 bytes (uma das minhas primeiras respostas 05AB1E):
NOTA: Funciona apenas na versão herdada de 05AB1E.

7°LʒÐSÖPsDÙQ*

Experimente online (gera apenas os números abaixo de 10 ^{3 em} vez de 10 ⁷ para evitar um tempo limite após 60 segundos).

Explicação:

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

Isso simplesmente pega todos os números de 1 até o maior número da Lynch-Bell e os filtra apenas para os números da Lynch-Bell.

Ungolfed:

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

print(join(lynch, " "))

Python 2, 101 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`)]

Você pode omitir o valor printdo intérprete em 96. Usado, 6**9pois possui 8 dígitos, enquanto o maior número de segunda-feira tem apenas 7 dígitos, algo como 9**9provavelmente levaria muito tempo, 6 ** 9 leva apenas 10 segundos.

Perl, 97 bytes

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

Demora um pouco para ser executado, mas produz a saída necessária, mude para 1e3para um exemplo mais rápido!

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)

E em um formato mais legível:

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$ e verifica se eles são um número de segunda-feira. Cada número é convertido em uma sequência para que os dígitos possam ser tratados individualmente.

As verificações são as seguintes:

1. Primeiro verifique se há duplicatas. Classificando a matriz, se a diferença entre os dígitos consecutivos for zero, haverá duplicatas

   diff(sort(a))
   

2. Verifique se existem zeros. O ASCII para 0 é 48, portanto, verificamos que todos os dígitos não são iguais a isso.

   a~=48
   

3. Verifique se é divisível por todos os seus dígitos. Verificamos que o restante ao dividir por cada dígito (convertido de ASCII para decimal, portanto -48) é zero.

   ~mod(n,a-48)
   

Finalmente, garantimos que all() as verificações sejam verdadeiras e, em caso afirmativo, anexamos a uma sequência de saída separada por vírgula.

MATLAB não tem STDOUT, então, em vez disso, imprimo a sequência de resultados no final usando disp()

Este código é LENTO! Ainda o estou executando para garantir que ele encontre todos os números de segunda-feira corretamente, mas que esteja bom até agora.

Atualizar:

Código concluído em execução. Imprime o seguinte:

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

E se você executar esse código com isso como entrada:

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

Anos 548.

Ruby, 79

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

Solução mais interessante, mas um pouco mais longa, com uma regex:

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

Em cada caso, estamos usando a capacidade do Ruby para iterar sobre as strings como se fossem números decimais: ?1.upto(?9*7)é equivalente a 1.upto(9999999).map(&:to_s).each. Juntamos a string a cada dígito diferente de zero usando o operador modulo e avaliamos o resultado para verificar a divisibilidade.

Solução bônus Ruby 1.8 (requer -lsinalizador para saída adequada):

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

1.8 permitiu que o iterador de bloco fosse uma variável global. Atribuir a $_torna o receptor implícito para operações de string. Também podemos interpolar matrizes na expressão regular com mais facilidade: no 1.8, /[#{[1,2]}]/avalia para /[12]/.

Pip , 25 bytes

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

Produz cada número em sua própria linha. Isso está em execução há cerca de 10 minutos e chegou a 984312 até agora, mas tenho certeza de que está correto.(Editar: Algumas horas depois ... o código terminou, gerou todos os 548 deles.)

Aqui está uma versão em pseudocódigo do tipo Python:

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

O #=operador compara dois iterables pelo comprimento. Se o número de caracteres em Uni Que afor o mesmo que o número de caracteres ema , não haverá repetições.

A verificação divisível por cada dígito é de um dos meus programas de exemplo do Pip. Escrevi depois de ver o desafio anterior , mas não o publiquei porque o idioma era mais novo que a pergunta. Caso contrário, com 8 bytes, seria a resposta vencedora para essa pergunta. Aqui está uma explicação passo a passo:

      ^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

Crianças, não tente fazer isso em casa; JS não ficará satisfeito com a perspectiva de fazer um loop por todos os dígitos de todo número inteiro, de um a dez milhões com um regex.

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

O primeiro regex (adota @Jarmex) retorna truese o número contiver dígitos ou zeros duplicados. Se isso acontecer false, o programa passará para o segundo, que substitui cada dígito jpor i%j. O resultado é todos os zeros, se for divisível por todos os dígitos; nesse caso, ele passa para console.log(i).

Sugestões são bem-vindas!

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)

O teste regexp para 0 ou dígitos repetidos. Em seguida, a matriz de dígitos é verificada procurando um módulo diferente de zero para qualquer dígito.

Aqui está a explicação do máximo de 7 dígitos.

Ruby, 130 bytes

... sem contar espaço em branco

Novo na programação, só queria participar

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

Mais bonito:

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

Para cada candidato i, iteramos seus dígitos ana ordem little-endian, acompanhando os dígitos vistos nos bits de m. Se o loop for concluído, todos os dígitos são fatores ie não vimos zeros ou dígitos repetidos; portanto, imprima-o; caso contrário, sairemos cedo para continuar o loop externo.

CJam, 34 bytes

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

Lua, 129 bytes

Evitei a abordagem de strings por pura digitação de dígitos, que parece um pouco mais rápida e provavelmente me salvou alguns bytes também. (Vou testar essa teoria, mas o manuseio de strings de Lua é bem detalhado, comparado a outras línguas.)

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}

Eu poderia reduzir isso para 97 se eu usasse em ENDvez deBEGIN , mas então você teria que pressionar Ctrl-D para iniciar a saída real, sinalizando que não haverá entrada.

Eu poderia reduzi-lo a 94 mesmo se não escrevesse nada em vez de BEGINou END, mas então você teria que pressionar a tecla de retorno uma vez para iniciá-lo, o que poderia ser contado como entrada.

Ele simplesmente passa os dígitos de cada número e testa se os critérios são atendidos.

i ~ 0: número contém um `0`? -> lixo
i% (d = a [j]): número não divisível pelo dígito atual? -> lixo
id * 10 ^ (lj) ~ d: removi o dígito atual do número, mas ele
                  : ainda contém? -> lixo

Demora 140 segundos para terminar no meu Core 2 Duo.

Gelatina , 11 bytes

9œ!ṖẎgḌ$ƑƇḌ

Isso usa o œ!átomo de duas semanas . Na verdade, rápido o suficiente para rodar no TIO.

Experimente online!

Como funciona

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.