Các số thứ hai , như được xác định bởi Gamow trong câu hỏi này trên Puzzling, là các số nguyên dương N với ba thuộc tính sau:

• Biểu diễn thập phân của N không chứa chữ số 0
• Biểu diễn thập phân của N không chứa bất kỳ chữ số nào hai lần
• N chia hết cho mỗi chữ số D xuất hiện trong biểu diễn thập phân của nó

Lưu ý rằng những số này được biết đến thay thế, trong OEIS, dưới dạng số Lynch-Bell .

Ví dụ:

• 15là một con số thứ hai, vì nó chia hết cho cả hai 1và 5và thỏa mãn hai điều kiện khác
• 16là không, bởi vì nó không chia hết cho 6.
• Số 22này là không, bởi vì mặc dù nó thỏa mãn điều kiện 1 và 3, nhưng nó không thành công với điều kiện 2.

Đây là danh sách 25 số thứ Hai đầu tiên để bạn bắt đầu (có tổng cộng 548):

1 2 3 4 5 6 7 8 9 12 15 24 36 48 124 126 128 132 135 162 168 175 175 184 216 248

Thách thức ở đây là viết mã ngắn nhất tạo ra chuỗi đầy đủ các số thứ Hai, từ 1 đến 9867312 (được chứng minh trên câu hỏi đó là lớn nhất có thể).

Mã của bạn sẽ không có đầu vào và đầu ra phải là STDOUT hoặc tương đương, với sự lựa chọn của bạn là dấu phân cách. Tất cả các quy tắc golf-code thông thường được áp dụng và Lỗ hổng Tiêu chuẩn đều bị cấm.

Bảng xếp hạng

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>

Thạch , 8 byte

ȷ7Dg⁼QƲƇ

Chạy địa phương trong dưới tám phút.

Hãy thử trực tuyến! (sửa đổi để tìm số có sáu chữ số trở xuống)

Làm thế nào nó hoạt động

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

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

In một danh sách.

Về cơ bản, tôi đang kết hợp hai câu trả lời của mình cho các thử thách trước đây:

• Kiểm tra nếu một số chia hết cho mỗi chữ số của nó

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

  (cảm ơn FryAmTheEggman đã nhắc nhở tôi về điều này).

• Xác định xem tất cả các chữ số thập phân là duy nhất

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

Nhờ xsot cho 1 byte được lưu bằng cách kết hợp các điều kiện tốt hơn.

Perl, 61 47 byte

Mã 46 byte + 1 tham số dòng lệnh.

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

Sử dụng:

perl -l entry.pl

Giải trình

/(.).*\1|0/ trả về 1 nếu bài kiểm tra số có chứa một ký tự trùng lặp hoặc 0

s/./$_%$&/rgethay thế mỗi chữ số bằng giá trị của% dưới kiểm tra số chữ số. Ví dụ: 15 -> 00, 16 -> 04 (vì 16% 6 = 4). Điều này có nghĩa là bất kỳ đầu vào nào chia hết cho tất cả các chữ số của nó sẽ bao gồm tất cả 0, nếu không nó sẽ chứa một chữ số> 0. Để coi đây là một số, chúng tôi * 1, có nghĩa là bất kỳ bài kiểm tra số nào sẽ trả về 0 cho khối này nếu nó chia hết cho tất cả các chữ số của nó, nếu không> 0.

Bằng cách tách hai câu lệnh này và bản in bằng 'hoặc', nếu một trong hai điều kiện đầu tiên trả về> 0, thì điều kiện khớp và các phần tiếp theo của biểu thức sẽ không đánh giá. Nếu và chỉ khi cả hai điều kiện trước là 0, thì bản in sẽ thực thi. Các -lcờ đảm bảo để thêm một dòng mới sau mỗi lần in.

Kim tự tháp, 22 21

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

Cảm ơn Jakube vì đã bỏ đi 1 byte định dạng không cần thiết.

Lấy cảm hứng mạnh mẽ từ câu trả lời CW này cho câu hỏi liên quan.

Tôi có một dán kết quả ở đây , từ khi nó in dòng mới tách ra, bây giờ nó in dưới dạng một danh sách pythonic.

Tôi khuyên bạn không nên thử trực tuyến trừ khi bạn sử dụng số nhỏ hơn 7 ... Tôi đã đặt nó thành 2 trong liên kết này.

Bộ lọc từ 1để 10^7-1bao gồm tất cả các giá trị cần thiết. Phiên bản này có thể gây ra lỗi bộ nhớ nếu không thể tạo danh sách S^T7, tương tự như list(range(1,10**7))trong python 3 (Tuy nhiên, nó hoạt động tốt với tôi). Nếu vậy, bạn có thể thử:

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

Mà tìm thấy 548 số thứ hai đầu tiên. Điều này cũng cho thấy một cách khác để kiểm tra số 0s, thay vì thay thế chúng bằng .3cách sử dụng khối thử bắt. Tín dụng cho phiên bản này hoàn toàn thuộc về Jakube. (Lưu ý rằng điều này vẫn còn nhiều chậm đối với trình thông dịch trực tuyến)

GS2 , 20 19 byte

gs2 sử dụng một loạt các byte, không chỉ các bộ thu thập ascii có thể in được. Tôi sẽ trình bày giải pháp của tôi trong hex.

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

Đây là một số lời giải thích. gs2 là một ngôn ngữ dựa trên ngăn xếp, vì vậy không có biến. (ngoài 4 thanh ghi, một trong số đó tôi sử dụng ở đây)

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 byte

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

Có 548 số thứ hai.

APL, 44 39 37 byte

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

Ung dung:

{
 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

Đã lưu 7 byte nhờ Moris Zucca!

TI-BASIC, 60 59 byte

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

∟Dlà danh sách các chữ số, được tạo bằng toán học và randIntNoRep(lệnh (hoán vị ngẫu nhiên của tất cả các số nguyên giữa 1và 1+int(log(Xbao gồm). Tôi sử dụng một chuỗi các câu lệnh hơi phức tạp để kiểm tra xem tất cả các điều kiện có được thỏa mãn hay không:

   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(

Để không thành công các số có chữ số lặp lại hoặc chữ số 0, tôi thay thế số không bằng 2X, vì Xkhông bao giờ chia hết cho 2X.

Đối với trường hợp đặc biệt 1 ~ 9 (vì ΔList(trong lỗi danh sách một thành phần) tôi sử dụng Ifcâu lệnh ở dòng thứ tư để bỏ qua kiểm tra ở dòng thứ năm, tự động hiển thị tất cả X≤9.

Các số đầu ra được phân tách bằng dòng mới.

Toán học 105

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

• IntegerDigitschia nthành một danh sách các chữ số của nó , i.
• FreeQ[i,0] kiểm tra xem không có số không trong danh sách.
• Length[i]==Length[Union[i]] kiểm tra rằng không có chữ số lặp lại.
• And@@(Divisible[n,#]&/@i)kiểm tra rằng mỗi chữ số là một ước của 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, 36 , 3648, 3816, 3864, 3915, 3924, 4128, 4172, 4236, 4368, 4392, 4632, 4872, 4896, 4932, 4968, 6132, 6192, 6312, 6324, 6384, 6432, 6912, 6984, 81 , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12768, 12864, 13248, 13824, 13896, 13968, 14328, 14728, 14832, 16248, 16848 , 18264, 18432, 18624, 18936, 19368, 21384, 21648, 21784, 21864, 23184, 24168, 24816, 26184, 27384, 28416, 29736, 31248, 31824, 31896, 31968, 32184, 3437128, 37296, 37926, 38472, 39168, 39816, 41328, 41832, 42168, 42816, 43128, 43176, 46128, 46872, 48216, 48312, 61248, 61824, 62184, 64128, 68712, 7212 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 9, 12 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 1438 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213648, 2138 231864, 231984, 234168, 234816, 236184, 238416, 239184, 241368, 243168, 243768, 243816, 247968, 248136,248976, 261384, 263184, 273168, 281736, 283416, 284136, 291384, 293184, 297864, 8318418, 32186, 32186, 348128, 341816, 348912, 349128, 368192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 367248, 376824, 367248 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 4319 , 4, 6, 6, 3, năm năm năm 613872, 614328, 614832, 618432, 621384, 623184, 623784,, 6, 6 : 8, 8 , 9 1: 2937816, 2978136, 2983176,Xê 10 Đang diễn ra. Đang diễn ra 9812376, 9867312}, 7, 7 Đang diễn ra 9617832, 9678312, 9718632, 9723168, Muff632, 9782136, 9812376, 9867312}, 7, 7 Đang diễn ra 9617832, 9678312, 9718632, 9723168, Muff632, 9782136, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 972316128796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 97231612

Length[%]

548

Haskell, 77 byte

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

Ví dụ sử dụng (20 số đầu tiên):

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]

Cách thức hoạt động: lặp qua tất cả các số từ 1 đến 9 ^ 9 và kiểm tra các điều kiện. Số hiện tại xđược chuyển thành biểu diễn chuỗi ( show x) để hoạt động trên đó dưới dạng danh sách các ký tự.

R, 99 byte

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

Hơi ít chơi golf:

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 byte

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

CJam, 25 byte

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

Hãy thử trực tuyến . Lưu ý rằng liên kết trực tuyến chỉ chạy đến 10.000. Tôi không chắc liệu nó có kết thúc trực tuyến hay không nếu bạn đủ kiên nhẫn. Nó đã không thử nghiệm nó với phiên bản ngoại tuyến của CJam, nhưng tôi hy vọng rằng nó sẽ chấm dứt.

Giải trình:

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

Đã được một thời gian kể từ khi tôi tham gia vì vậy tôi có lẽ đã quên một vài thủ thuật để loại bỏ số lượng lớn. Sẽ cải thiện khi tôi nghĩ về họ ... Lúc này:

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

Ung dung:

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

T1, 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 21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,3726,3829,39 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,9813612 124368.126384.129384.132648.132864.132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,388 1848, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,236176,261384,263184,273168,281736,283416,284136294,294 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416.318,18,18 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296488 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,62384,483 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,8136248181 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,8414897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978268898 C28 3186792 Số 6 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 byte

Đây là một bản chỉnh sửa tương đối nhỏ trong câu trả lời của Thomas Kwa , nhưng tôi đang gửi nó dưới dạng một câu trả lời mới bởi vì tôi nghe nói rằng anh ta đã đưa tiền thưởng vào việc đánh golf các câu trả lời TI-BASIC của mình.

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

Thay đổi chính của tôi là từ randIntNoRep(1,để randIntNoRep(0,ý nghĩa rằng có sẽ bây giờ là một zero trong mỗi danh sách được tạo ra chữ số.

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

Vì hiện tại có một số 0 trong mỗi bộ chữ số, điều này ảnh hưởng đến tổng số còn lại. Thông thường tổng của phần còn lại là 0, nhưng bây giờ, sự có mặt của một số 0 thừa gây ra một thất bại trong bài kiểm tra tính phân chia của chúng tôi.
Để chống lại điều này, tôi đổi 2Xnot(thành Xnot(. Cả 2 ban đầu ở đó để làm cho bài kiểm tra thất bại ở 0, nhưng bây giờ nó vượt qua ở mức 0. Tuy nhiên, các số có số 0 trong các chữ số của chúng, hiện tại có một min(ΔList(∟Dsố 0 (vì có 2 hoặc nhiều số không trong danh sách của chúng) nên thay đổi này không khiến bất kỳ số nào vượt qua bài kiểm tra.

Lợi ích của phương pháp này là, vì hiện tại có "hai chữ số" được tạo từ số 1-9, ΔList(hàm không tạo ra lỗi, cho phép chúng ta thoát khỏi một điều kiện đặc biệt cho các số có một chữ số.

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

-9 byte nhờ sự giúp đỡ và khuyến khích của @Enigma và @ Mr.Xcoder . Cảm ơn vì đã để tôi tự mình tìm ra nó, mặc dù bạn đã có một giải pháp 12 byte khi tôi vẫn ở tuổi 30. Đã học được rất nhiều về 05AB1E từ thử thách này!
-3 byte nhờ @Grimy

7°LʒÐÑÃÙQ

Hãy thử trực tuyến (chỉ xuất các số dưới 10 ³ thay vì 10 ⁷ để tránh thời gian chờ sau 60 giây).

Giải trình:

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)

Phiên bản 12 byter trước đó (một trong những câu trả lời 05AB1E đầu tiên của tôi):
LƯU Ý: Chỉ hoạt động trong phiên bản kế thừa của 05AB1E.

7°LʒÐSÖPsDÙQ*

Hãy thử trực tuyến (chỉ xuất các số dưới 10 ³ thay vì 10 ⁷ để tránh thời gian chờ sau 60 giây).

Giải trình:

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 byte

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

Điều này chỉ đơn giản là lấy tất cả các số từ 1 đến số Lynch-Bell lớn nhất và lọc chúng xuống chỉ còn các số Lynch-Bell.

Ung dung:

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 byte

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

Bạn có thể bỏ qua trình printthông dịch trong 96. Được sử dụng 6**9vì nó có 8 chữ số trong khi số thứ hai lớn nhất chỉ có 7 chữ số, một cái gì đó 9**9có thể sẽ mất nhiều thời gian, 6 ** 9 chỉ mất khoảng 10 giây.

Perl, 97 byte

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

Mất một lúc để chạy, nhưng tạo ra đầu ra cần thiết, thay đổi thành 1e3một ví dụ nhanh hơn!

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)

Và trong một định dạng dễ đọc hơn:

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$

Các kiểm tra như sau:

1. Đầu tiên kiểm tra nếu có bất kỳ bản sao. Bằng cách sắp xếp mảng, nếu chênh lệch giữa bất kỳ chữ số liên tiếp nào bằng 0, thì sẽ có trùng lặp

   diff(sort(a))
   

2. Kiểm tra nếu có bất kỳ số không. ASCII cho 0 là 48, vì vậy chúng tôi kiểm tra rằng tất cả các chữ số không bằng số đó.

   a~=48
   

3. Kiểm tra nếu nó chia hết cho tất cả các chữ số của nó. Chúng tôi kiểm tra phần còn lại khi chia cho mỗi chữ số (được chuyển đổi từ ASCII sang số thập phân, do đó -48) bằng không.

   ~mod(n,a-48)
   

Cuối cùng, chúng tôi đảm bảo rằng all()các kiểm tra là đúng và nếu vậy chúng tôi sẽ thêm nó vào chuỗi đầu ra được phân tách bằng dấu phẩy.

MATLAB không có STDOUT, vì vậy thay vào đó tôi in chuỗi kết quả ở cuối bằng cách sử dụng disp()

Mã này là SLOW! Tôi vẫn đang chạy nó để đảm bảo rằng nó tìm thấy chính xác tất cả các số thứ Hai, nhưng có vẻ tốt cho đến nay.

Cập nhật:

Mã chạy xong. Nó in như sau:

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

Mà nếu bạn chạy mã này với đầu vào:

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

Con cái 548.

Ruby, 79

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

Giải pháp thú vị hơn nhưng dài hơn một chút với biểu thức chính quy:

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

Trong mỗi trường hợp, chúng tôi đang sử dụng khả năng của Ruby để lặp lại các chuỗi như thể chúng là số nguyên thập phân: ?1.upto(?9*7)tương đương với 1.upto(9999999).map(&:to_s).each. Chúng tôi nối chuỗi với từng chữ số khác không bằng toán tử modulo và đánh giá kết quả, để kiểm tra tính phân chia.

Giải pháp Bonus Ruby 1.8 (yêu cầu -lcờ cho đầu ra thích hợp):

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

1.8 cho phép khối lặp là một biến toàn cục. Chỉ định để $_làm cho nó trở thành người nhận ngầm định cho các hoạt động chuỗi. Chúng ta cũng có thể nội suy các mảng thành biểu thức chính quy dễ dàng hơn: trong 1.8, /[#{[1,2]}]/ước tính /[12]/.

Pip , 25 byte

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

Xuất ra mỗi số trên dòng riêng của nó. Điều này đã chạy được khoảng 10 phút và đã lên đến 984312 cho đến nay, nhưng tôi khá chắc chắn rằng nó chính xác. (Chỉnh sửa: Vài giờ sau ... mã hoàn thành, tạo ra tất cả 548 trong số chúng.)

Đây là một biểu hiện mã giả 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)

Các #=nhà điều hành so sánh hai iterables theo chiều dài. Nếu số lượng ký tự Uni Que bằng avới số lượng ký tự trong ađó, thì không có số lần lặp lại.

Kiểm tra chia hết cho mỗi chữ số là từ một trong các chương trình ví dụ Pip của tôi. Tôi đã viết nó sau khi thấy thử thách trước đó , nhưng không đăng nó ở đó vì ngôn ngữ mới hơn câu hỏi. Nếu không, ở mức 8 byte, nó sẽ là câu trả lời chiến thắng cho câu hỏi đó. Đây là một lời giải thích từng bước:

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

Trẻ em, đừng thử điều này ở nhà; JS sẽ không hài lòng với triển vọng lặp qua từng chữ số của mỗi số nguyên từ một đến mười triệu với biểu thức chính quy.

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

Regex đầu tiên (đạo cụ cho @Jarmex) trả về truenếu số chứa các chữ số hoặc số 0 trùng lặp. Nếu điều này bật ra false, chương trình chuyển sang phần thứ hai, thay thế từng chữ số jbằng i%j. Kết quả là tất cả các số 0 nếu nó chia hết cho tất cả các chữ số của nó, trong trường hợp nó chuyển sang console.log(i).

Gợi ý chào mừng!

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)

Kiểm tra regrec cho 0 hoặc các chữ số lặp lại. Sau đó, mảng chữ số được kiểm tra tìm kiếm một modulo khác không cho bất kỳ chữ số nào.

đây là lời giải thích của tối đa 7 chữ số.

Ruby, 130 byte

... không tính khoảng trắng

Mới lập trình, chỉ muốn tham gia

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 byte

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

Đẹp hơ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 với mỗi ứng cử viên i, chúng tôi lặp lại các chữ số của nó atheo thứ tự nhỏ về cuối, theo dõi các chữ số nhìn thấy trong các bit của m. Nếu vòng lặp hoàn thành, thì tất cả các chữ số là các yếu tố ivà chúng tôi không thấy các số không hoặc các chữ số lặp lại, vì vậy hãy in nó, nếu không chúng tôi thoát sớm để tiếp tục vòng lặp bên ngoài.

CJam, 34 byte

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

Lua, 129 byte

Tôi đã tránh cách tiếp cận chuỗi để xử lý chữ số thuần túy, có vẻ nhanh hơn một chút và có lẽ cũng tiết kiệm cho tôi một số byte. (Tôi sẽ kiểm tra lý thuyết đó, nhưng việc xử lý chuỗi Lua khá dài dòng so với một số ngôn ngữ khác.)

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 byte

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}

Tôi có thể giảm xuống 97 nếu tôi sử dụng ENDthay vìBEGIN , nhưng sau đó bạn sẽ phải nhấn Ctrl-D để bắt đầu đầu ra thực tế, báo hiệu rằng sẽ không có đầu vào.

Tôi có thể giảm xuống còn 94 nếu tôi không viết gì thay vì BEGINhoặc END, nhưng sau đó bạn sẽ phải nhấn phím quay lại một lần để khởi động nó, có thể được tính là đầu vào.

Nó chỉ đơn giản là đi qua các chữ số của mỗi số và kiểm tra nếu các tiêu chí được đáp ứng.

i ~ 0: số chứa một `0`? -> thùng rác
i% (d = a [j]): số không chia hết cho chữ số hiện tại? -> thùng rác
id * 10 ^ (lj) ~ d: Tôi đã xóa chữ số hiện tại khỏi số đó
                  : vẫn chứa nó? -> thùng rác

Mất 140 giây để chấm dứt trên Core 2 Duo của tôi.

Thạch , 11 byte

9œ!ṖẎgḌ$ƑƇḌ

Điều này sử dụng œ!nguyên tử hai tuần tuổi . Thực sự đủ nhanh để chạy trên TIO.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.