Hasilkan Angka Senin

35

Angka Senin , seperti yang didefinisikan oleh Gamow dalam pertanyaan ini yang membahas tentang membingungkan, adalah bilangan bulat positif N dengan tiga properti berikut:

  • Representasi desimal N tidak mengandung angka 0
  • Representasi desimal N tidak mengandung digit apa pun dua kali
  • N dapat dibagi oleh setiap digit D yang terjadi dalam representasi desimalnya

Perhatikan bahwa ini dikenal sebagai alternatif, dalam OEIS, sebagai nomor Lynch-Bell .

Contoh:

  • 15adalah nomor Senin, karena itu dibagi oleh kedua 1dan 5dan memenuhi dua kondisi lain
  • 16bukan, karena itu tidak habis dibagi 6.
  • Jumlahnya 22tidak, karena meskipun memenuhi kondisi 1 dan 3, ia gagal kondisi 2.

Berikut daftar 25 angka Senin pertama yang Anda mulai (ada total 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

Tantangannya di sini adalah untuk menulis kode terpendek yang menghasilkan urutan penuh angka Senin, dari 1 hingga 9867312 (terbukti pada pertanyaan itu menjadi yang terbesar).

Kode Anda tidak boleh mengambil input, dan output harus STDOUT atau setara, dengan pembatas pilihan Anda. Semua aturan kode-golf biasa berlaku, dan Standard Loopholes dilarang.

Papan peringkat

Tampilkan cuplikan kode

code-golf  number  sequence 
— AdmBorkBork
sumber
5
— FryAmTheEggman
1
Juga dikenal sebagai nomor Lynch-Bell .
— Geobits
@Geobits Terima kasih - Saya tidak dapat menemukannya di OEIS karena alasan tertentu.
— AdmBorkBork
8
Anda seharusnya memposting tantangan ini kemarin ...
— mbomb007
2
@ mbomb007 saya akan - tidak melihat pertanyaan Gamow sampai pagi ini, meskipun!
— AdmBorkBork

Jawaban:

1

Jelly , 8 byte

ȷ7Dg⁼QƲƇ

Berjalan secara lokal dalam waktu kurang dari delapan menit.

Cobalah online! (dimodifikasi untuk menemukan angka dengan enam digit atau kurang)

Bagaimana itu bekerja

ȷ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.
— Dennis
sumber
16

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

Mencetak daftar.

Saya pada dasarnya menggabungkan dua jawaban saya untuk tantangan sebelumnya:

Berkat xsot selama 1 byte disimpan dengan menggabungkan kondisi yang lebih baik.

— Tidak
sumber
Anda dapat menyimpan 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`)]
— xsot
11

Perl, 61 47 byte

46 byte kode + 1 byte parameter baris perintah.

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

Pemakaian:

perl -l entry.pl

Penjelasan

/(.).*\1|0/ mengembalikan 1 jika angka yang diuji mengandung karakter duplikat atau 0

s/./$_%$&/rgemengganti setiap digit dengan nilai angka yang diuji% digit. Misalnya, 15 -> 00, 16 -> 04 (karena 16% 6 = 4). Ini berarti bahwa setiap input yang dapat dibagi oleh semua digitnya akan terdiri dari semua 0s, jika tidak maka akan mengandung digit> 0. Untuk menganggap ini sebagai angka, kita * 1, yang berarti setiap angka yang diuji akan mengembalikan 0 untuk blok ini jika dapat dibagi dengan semua digitnya, jika tidak> 0.

Dengan memisahkan kedua pernyataan ini dan cetakan dengan 'atau, jika salah satu dari dua kondisi pertama kembali> 0, kondisi tersebut cocok dan bagian selanjutnya dari ekspresi tidak akan dievaluasi. Jika dan hanya jika kedua kondisi sebelumnya adalah 0, hasil cetak akan dieksekusi. The -lbendera memastikan untuk menambahkan baris baru setelah setiap cetak.

— Jarmex
sumber
Sangat bagus. Anda dapat menyimpan beberapa byte dengan membuatnya Perl 5.10 dan menggunakan saybukannya print+ -l:-)
— xebtl
Terima kasih untuk sarannya! Saya pikir say diperlukan deklarasi eksplisit terlebih dahulu ?
— Jarmex
@Jarmex Saya mungkin telah memulai tradisi di sini tentang mengambil use feature 'say'atau use 5.012gratis - Saya selalu menyebutkan kapan saya melakukannya, dan tidak ada yang pernah menantangnya. Saya telah melihat beberapa orang lain melakukan hal yang sama :)
— hobbs
2
@hobbs Jawaban ini pada meta mengatakan "Konsensus sampai sekarang pada SO dan di sini adalah" -M5.010, bila diperlukan, gratis "".
— xebtl
2
Menggunakan mapdan saymenurunkannya menjadi 43: Cobalah online!
— Xcali
10

Pyth, 22 21

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

Terima kasih kepada Jakube untuk bermain golf dengan 1 byte format yang tidak perlu.

Sangat terinspirasi oleh jawaban CW ini untuk pertanyaan terkait.

Saya punya tempel hasilnya di sini , mulai dari saat dicetak baris baru, sekarang mencetak sebagai daftar pythonic.

Saya akan merekomendasikan untuk tidak mencobanya secara online kecuali jika Anda menggunakan angka yang lebih kecil dari 7 ... Saya telah menetapkannya menjadi 2 di tautan ini.

Filter dari 1ke 10^7-1yang mencakup semua nilai yang diperlukan. Versi ini dapat menyebabkan kesalahan memori jika tidak dapat membuat daftar S^T7, yang mirip dengan list(range(1,10**7))di python 3 (Namun, itu berfungsi dengan baik untuk saya). Jika demikian, Anda dapat mencoba:

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

Yang menemukan 548 angka Senin pertama. Ini juga menunjukkan cara lain untuk memeriksa 0s dalam jumlah, alih-alih menggantinya dengan .3ini menggunakan blok try-catch. Penghargaan untuk versi ini sepenuhnya jatuh ke Jakube. (Perhatikan bahwa ini masih sangat lambat untuk penerjemah online)

— FryAmTheEggman
sumber
1
Inilah solusi yang berbeda: .f&.{`Z.x!s%LZjZT0548Ini sedikit lebih cepat (4x - 5x) daripada pendekatan while-loop Anda dan panjangnya juga hanya 21 byte.
— Jakube
1
@Jakube Backticks menyebalkan dalam komentar, bukan? : P Terima kasih banyak!
— FryAmTheEggman
Umm .. solusi Anda sepertinya tidak berfungsi .. Di tautan TIO Anda dalam kisaran 100, itu menunjukkan 55, 66, 77, 88, 99, semua angka dengan digit yang digandakan ..
— Kevin Cruijssen
1
@KevinCruijssen Sayangnya, Pyth telah diperbarui berkali-kali sejak saya membuat posting ini, saya tidak dapat menemukan apa yang telah berubah. Anda dapat melihat di pasta bahwa ini jelas berhasil sebelumnya. Saya pikir itu mungkin .{telah diubah, karena menggantinya dengan {Itampaknya berfungsi.
— FryAmTheEggman
@FryAmTheEggman Ah, saya belum melihat pasta. Sudah hampir tiga tahun, jadi tidak heran banyak hal mungkin berubah. Memberi +1 pada kasus itu, karena pasta membuktikannya berhasil. :)
— Kevin Cruijssen
9

GS2 , 20 19 byte

GS2 menggunakan berbagai byte, bukan hanya chracters ascii yang dapat dicetak. Saya akan menyajikan solusi saya dalam hex.

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

Inilah beberapa penjelasan. gs2 adalah bahasa berbasis stack, jadi tidak ada variabel. (selain dari 4 register, salah satunya saya gunakan di sini)

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
— rekursif
sumber
8

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

Ada 548 Angka Senin.

— Zach Gates
sumber
1
Bisakah Anda menggunakan 1e8bahkan bukan 9**9?
— Dom Hastings
Hapus ruang di '0' not. Juga, i%int(k)==0mungkin bisa i%int(k)<1?
— mbomb007
Terima kasih. Saya tidak bermaksud menambahkan itu kembali. @ Mbomb007
— Zach Gates
Anda bisa menggunakannya j=`i`.
— mbomb007
Untuk penggunaan -6 lainnyaif len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j)
— lirtosiast
7

APL, 44 39 37 byte

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

Tidak Disatukan:

{
 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

Disimpan 7 byte berkat Moris Zucca!

— Alex A.
sumber
Saya suka APL. Ini sebabnya.
— Conor O'Brien
Saya pikir Anda bisa bermain golf menggunakan kereta fungsi, menghemat 5 byte: {0 = + / (⊢ | ∘⍵, 0∘∊, ⍴∘⊢ ≠ ⍴∘∪) x ← ⍎¨⍕⍵: ⍵⋄⍬} ¨⍳ 1e7
— Moris Zucca
@MorisZucca Luar Biasa, terima kasih atas sarannya!
— Alex A.
Saya hanya melihat bahwa dalam bentuk ini x ← tidak diperlukan lagi, jadi 2 byte lagi disimpan! :-)
— Moris Zucca
@MorisZucca Anda adalah mesin golf APL! Terima kasih lagi!
— Alex A.
6

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

∟Dadalah daftar digit, yang dihasilkan menggunakan matematika dan randIntNoRep(perintah (permutasi acak semua bilangan bulat di antara 1dan 1+int(log(Xinklusif). Saya menggunakan rantai pernyataan yang sedikit rumit untuk memeriksa apakah semua persyaratan terpenuhi:

   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(

Untuk gagal angka yang memiliki digit berulang atau nol digit, saya ganti dengan nol 2X, karena Xtidak pernah habis dibagi 2X.

Untuk kasus khusus 1 ~ 9 (karena ΔList(pada kesalahan daftar satu-elemen) Saya menggunakan Ifpernyataan di baris keempat untuk melewati pemeriksaan di baris kelima, secara otomatis menampilkan semua X≤9.

Nomor output dipisahkan oleh baris baru.

— lirtosiast
sumber
5

Mathematica 105

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]
  • IntegerDigits putus n menjadi daftar digit-nya,i ,.
  • FreeQ[i,0] memeriksa apakah tidak ada nol dalam daftar.
  • Length[i]==Length[Union[i]] memeriksa apakah tidak ada digit yang diulang.
  • And@@(Divisible[n,#]&/@i)memeriksa apakah setiap digit adalah pembagi n.

{1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 24, 36, 48, 124, 126, 128, 135, 135, 162, 168, 175, 184, 184, 216, 248, 248 , 264, 312, 315, 324, 384, 396, 412, 432, 612, 624, 648, 672, 728, 735, 784, 816, 816, 824, 864, 936, 1236, 1248, 1248, 1296, 1326, 1362, 1368 , 1395, 1632, 1692, 1764, 1824, 1926, 1935, 1962, 2136, 2184, 2196, 2316, 2464, 2916, 3116, 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, 6912, 8136, 8496 , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12768, 12864, 13248, 13824, 13896, 13968, 14328, 14728, 14824, 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, 48212, 61248, 61824, 62124, 64128, 64128, 68712, 7316 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84212, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 121348, 123648 124368, 126384, 129384, 132648, 132864, 132984, 134928, 134928, 136824, 138224, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 163848, 163248 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216364, 21488 231864, 231984, 234168, 234816, 236184, 238416, 239184, 241368, 243168, 243768, 243816, 247916, 247968, 248136,248976, 261384, 263184, 273168, 281736, 283416, 284136, 291318, 297818, 297864, 312648, 312864, 312984, 312.028, 316248, 316824, 318224, 319248, 319824, 3216, 328, 3216 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348.816, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 367248, 377248, 37824, 38816 391248, 391824, 392184, 394128, 412368, 413932, 416328, 416832, 41832, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 431928, 432688 438 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483272, 483672, 483912, 486312, 489312, 491328, 491328, 498128388 613872, 614328, 614832, 618432, 621384, 623184, 623784,627984, 631248, 631824, 632184, 634128, 634872, 641328, 641812, 643128, 648312, 671328, 671832, 681412, 68912, 68912, 68912, 732648, 732816, 742896, 742828, 768 788, 76868 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834216, 834912, 836472, 841332, 842136, 841219, 8412, 8412, 8412, 8412 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941828, 943128, 988, 988128, 988128, 988128, 988128, 98138 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 19237872, 1936872, 1982736, 2137968, 2138976, 2189376 278, 276 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867192, 3869712, 3927168, 3928176, 6319121282828 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829192, 7836192, 78368 788788) 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 879712, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816 978188328, 968188, 978, 978128, 978128, 978126, 9731296 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 739216812812878812 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 916378178188688688788 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 739216812812878812 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 916378178188688688788 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, 9781632, 9812138796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9781632, 981213

Length[%]

548

— DavidC
sumber
Saya berharap ada cara di Mathematica untuk mendapatkan jumlah besar di byte lebih sedikit, seperti 9^9atau 1e8atau sesuatu
— FryAmTheEggman
Saya terkejut Mathematica tidak memiliki bawaan untuk ini ;-). Trik yang bagus Unionuntuk memeriksa duplikat.
— AdmBorkBork
@FryAmTheEggman, Anda benar tentang Mathematica memungkinkan untuk 9 ^ 9. Tapi bukankah itu mengembalikan lebih dari 548 angka Senin?
— DavidC
Seperti yang dikatakan dalam pertanyaan, tidak ada angka Senin yang lebih besar dari yang diberikan sebagai batas atas.
— FryAmTheEggman
5

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]

Contoh penggunaan (20 nomor pertama):

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]

Cara kerjanya: beralihlah ke semua angka dari 1 hingga 9 ^ 9 dan periksa kondisinya. Angka saat xini diubah menjadi representasi string ( show x) untuk beroperasi sebagai daftar karakter.

— nimi
sumber
5

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

Sedikit kurang 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,"")
    }
— plannapus
sumber
5

Perl, 90 75 70 byte

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7
— steve
sumber
1
Ahhh, saya melewatkan trik \ 1 untuk memeriksa penipuan, bagus. Bisakah Anda menghemat lebih banyak dengan pengubah pernyataan sementara dan cetak ternary?
— Dom Hastings
@HomHastings terima kasih, sekarang lebih banyak bermain golf menggunakan saran Anda
— steve
Bagus, saya pikir Anda dapat menyimpan lebih banyak juga, karena Anda tidak perlu ^dan $sekitar di 0dalam Anda grep, Anda dapat mengganti &&sebelumnya s/./dengan satu &dan saya pikir yang terakhir |0tidak dibutuhkan (walaupun hanya diuji up-to 1e3. ..) Baik dan benar-benar menghancurkan skor saya! :)
— Dom Hastings
1
@HomHastings terima kasih, turun ke 70 dengan tips golf Anda.
— steve
Golf turun sedikit lebih banyak dengan menyingkirkan grep (tidak perlu - pertandingan pola merawatnya tanpa grep) dan menata ulang sisanya menjadi peta: Cobalah online!
— Xcali
4

CJam, 25 byte

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

Cobalah online . Perhatikan bahwa tautan online hanya beroperasi hingga 10.000. Saya tidak yakin apakah itu akan selesai online jika Anda cukup sabar. Itu belum mengujinya dengan versi offline CJam, tapi saya berharap itu akan berakhir.

Penjelasan:

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.
— Reto Koradi
sumber
4

C #, 230 227

Sudah lama sejak saya mengenang sehingga saya mungkin lupa beberapa trik untuk menurunkan bytecount. Akan membaik ketika saya memikirkan mereka ... Untuk saat ini:

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

Tidak Disatukan:

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.436.4368.4392.4632.482.498.498.449.649.6132.6192.619.632.4.638.464.364.612.691.884.613.6.8496.88736.9126.9135.9162.9216, 9315.9324.94.396.912.996.49864.1212.484.1212.864.112.848.113.824.113.886.113.968.14432.814.148.848.148.824.174.818.180.180.180 21384.21648.21784.21864,23184.224168.2488.226.884.227.384.229.336.31248.31824.31896.31968.300.336.882.337.88.379.239.378.339.438.339 41832.422168.42016.443128.443176.446128.46872.48216.48312.61248.61824.662184.664128.668712.772184.773164.73248.73416,73962.778.624.779128.779.612.81264.81432.81624.81936.82416.84216.84312.884.682.887.192.989.686.897.9.928.8.936.393.978.838.198.198.398.384 124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142288,146328,146832,148392,148632,1483216 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432.213864.21398418361818 231864,231984.234168.234816.236184.238416.239184,241368.2243682424161624246868,248136,248976,263184,273168,281736,283416.228.384.384.348 312984.314928.316248.316824.318264.318624.319248.319824.322168.31864.6321984.3321616323216163232161632321616323216163232183434342816343412121212 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,41632832818183232 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,483,483,483 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,61432818,143,621384,623184,623784,627984,631248,3441834 641328,641832,643128,648312,671328,671832,681432,684312,689472,732616,732816,742896,746928,762384,768432,783216,7894,64312868864813624,814392.814 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.989.978.298.978.378 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736.2137968.2138976.287.278.378.368.379 3186792.3187296.3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3867192,3867192,3869198,3928178688682828 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,763912878787878787878787868868868 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.99812376.99867312

— RobIII
sumber
bisakah (int) 1e7 menjadi 1 << 24?
— lirtosiast
@ThomasKwa Ya, bisa saja. Memang. Terima kasih!
— RobIII
4

TI-BASIC, 55 53 byte

Ini adalah suntingan yang relatif kecil jawaban Thomas Kwa , tetapi saya mengirimkannya sebagai jawaban baru karena saya pernah mendengar bahwa dia telah memberi hadiah pada golf atas jawaban TI-BASIC-nya.

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

Perubahan utama saya adalah dari randIntNoRep(1,ke randIntNoRep(0,makna yang ada sekarang akan nol di setiap daftar yang dihasilkan dari digit.

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

Karena sekarang ada nol di setiap rangkaian angka, ini memengaruhi jumlah sisanya. Biasanya jumlah sisanya adalah 0, tetapi sekarang, keberadaan nol tambahan menyebabkan satu kegagalan tes keterbagian kami.
Untuk mengatasi ini, saya berubah 2Xnot(menjadi Xnot(. 2 awalnya ada di sana untuk membuat tes gagal pada 0, tetapi sekarang melewati nol. Angka-angka yang mengandung nol dalam digitnya, bagaimanapun, sekarang memiliki amin(ΔList(∟D nol nol (karena ada 2 atau lebih nol dalam daftar mereka) sehingga perubahan ini tidak menyebabkan angka tambahan untuk lulus tes.

Manfaat dari metode ini adalah, karena sekarang ada "dua digit" yang dihasilkan dari angka 1-9, ΔList(fungsinya tidak menghasilkan kesalahan, yang memungkinkan kita untuk menyingkirkan kondisi khusus untuk angka satu digit.

— PhiNotPi
sumber
4

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

-9 byte berkat bantuan dan dorongan dari @Enigma dan @ Mr.Xcoder . Terima kasih telah mengizinkan saya untuk mencari tahu sendiri, meskipun Anda sudah memiliki solusi 12-byte dalam pikiran ketika saya masih di 30. Belajar banyak tentang 05AB1E dari tantangan ini!
-3 byte terima kasih kepada @Grimy

7°LʒÐÑÃÙQ

Cobalah online (hanya menampilkan angka-angka di bawah 10 3 bukan 10 7 untuk mencegah batas waktu setelah 60 detik).

Penjelasan:

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)

Versi byter 12 sebelumnya (salah satu jawaban 05AB1E pertama saya):
CATATAN: Hanya berfungsi dalam versi lawas 05AB1E.

7°LʒÐSÖPsDÙQ*

Cobalah online (hanya menampilkan angka-angka di bawah 10 3 bukan 10 7 untuk mencegah batas waktu setelah 60 detik).

Penjelasan:

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)
— Kevin Cruijssen
sumber
Jawaban Anda dicetak 297, yang tidak sesuai dengan urutan nomor Lynch-Bell.
— Tn. Xcoder
@ Mr.Xcoder Sigh .. Punya sesuatu yang lebih panjang pada awalnya untuk memeriksa apakah suatu angka dapat dibagi dengan semua digitnya, tetapi menemukan tantangan seperti itu ada. Sepertinya jawaban ini juga tidak valid .. Dan di sini Anda dan Enigma berbicara tentang jawaban 12-15 byte sementara jawaban 30-byte saya bahkan tidak berfungsi, hah .. Apakah ada tutorial di mana saja? ; p
— Kevin Cruijssen
1
9 byte:7°LʒÐÑÃÙQ
— Grimmy
@Grimy Salah satu jawaban 05AB1E pertama saya. :) Pendekatan yang bagus!
— Kevin Cruijssen
3

Julia, 88 byte

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

Ini hanya mengambil semua angka dari 1 hingga nomor Lynch-Bell terbesar dan memfilternya hanya ke nomor Lynch-Bell.

Tidak Disatukan:

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

print(join(lynch, " "))
— Alex A.
sumber
3

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

Anda dapat menghilangkan printdi dalam juru bahasa sampai ke 96. Digunakan 6**9karena itu adalah 8 digit sedangkan angka Senin terbesar hanya 7 digit, sesuatu seperti 9**9mungkin akan memakan waktu lama, 6 ** 9 hanya membutuhkan waktu sekitar 10 detik.

— Rohcana
sumber
Seperti yang ditunjukkan pada beberapa pertanyaan 1e7 lebih pendek dari keduanya
— Holloway
@ Trengot 1e7adalah float, range membutuhkan bilangan bulat.
— Rohcana
Sangat benar. Tidak memikirkan itu
— Holloway
3

Perl, 97 byte

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

Butuh beberapa saat untuk menjalankan, tetapi menghasilkan output yang diperlukan, ubah ke 1e3untuk contoh yang lebih cepat!

— Dom Hastings
sumber
Saya tidak dalam posisi untuk mencoba ini saat ini tetapi, alih-alih y///c==grep{2>eval"$n=~y/$_//"}/./g, dapatkah Anda menggunakan sesuatu seperti itu !/(.).*\1/?
— msh210
@ msh210 Hampir pasti! Saya pikir itu akan menjadi standar saya sekarang, tetapi mengubah ini hanya akan berakhir membuatnya lebih dekat dengan jawaban steve atau Jarmex , yang jauh lebih unggul! Terima kasih telah melihatnya!
— Dom Hastings
3

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)

Dan dalam format yang lebih mudah dibaca:

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)

Pada dasarnya ini dihitung melalui setiap angka di antara 1 dan 1×107dan memeriksa apakah itu nomor Senin. Setiap angka dikonversi ke string sehingga angka-angka dapat ditangani secara individual.

Cek adalah sebagai berikut:

  1. Pertama periksa apakah ada duplikat. Dengan mengurutkan array, jika perbedaan antara digit berurutan adalah nol, maka ada duplikat

    diff(sort(a))

  2. Periksa apakah ada nol. ASCII untuk 0 adalah 48, jadi kami memeriksa bahwa semua digit tidak sama dengan itu.

    a~=48

  3. Periksa apakah dapat dibagi dengan semua digitnya. Kami memeriksa bahwa sisanya ketika membagi dengan setiap digit (dikonversi dari ASCII ke desimal, karenanya -48) adalah nol.

    ~mod(n,a-48)

Akhirnya kami memastikan bahwa all()cek benar, dan jika demikian kami menambahkannya ke string output yang dipisahkan koma.

MATLAB tidak memiliki STDOUT, jadi saya mencetak string hasil pada akhirnya menggunakan disp()

Kode ini lambat! Saya masih menjalankannya untuk memastikan bahwa ia menemukan semua angka Senin dengan benar, tetapi sejauh ini terlihat bagus.

Memperbarui:

Kode selesai berjalan. Mencetak berikut ini:

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

Yang jika Anda menjalankan kode ini dengan itu sebagai input:

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

Yeilds 548.

— Tom Carpenter
sumber
3

Ruby, 79

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

Lebih menarik tetapi sedikit lebih lama dengan solusi regex:

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

Dalam setiap kasus, kami menggunakan kemampuan Ruby untuk beralih pada string seolah-olah mereka adalah bilangan bulat desimal: ?1.upto(?9*7)sama dengan 1.upto(9999999).map(&:to_s).each. Kami menggabungkan string ke setiap digit bukan nol menggunakan operator modulo, dan mengevaluasi hasilnya, untuk memeriksa keterpisahan.

Solusi Bonus Ruby 1.8 (membutuhkan -ltanda untuk hasil yang sesuai):

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

1.8 memungkinkan iterator blok menjadi variabel global. Menetapkan untuk $_menjadikannya penerima implisit untuk operasi string. Kita juga dapat menginterpolasi array ke dalam ekspresi reguler dengan lebih mudah: pada 1.8, /[#{[1,2]}]/dievaluasi menjadi /[12]/.

— histokrat
sumber
Sekarang Ruby 2.4 memiliki digitsfungsi pada integer , Anda dapat menyimpan byte dari hack eval karena Anda tidak lagi beroperasi pada string! 63 byte.
— Nilai Tinta
3

Pip , 25 byte

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

Output setiap nomor pada jalurnya sendiri. Ini telah berjalan sekitar 10 menit dan mencapai 984312 sejauh ini, tapi saya cukup yakin itu benar.(Edit: Beberapa jam kemudian ... kode selesai, menghasilkan semua 548 dari mereka.)

Inilah rendition pseudocode 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)

The #=Operator membandingkan dua iterables oleh panjang. Jika jumlah karakter Uni Que dalama sama dengan jumlah karakter dalama , tidak ada pengulangan.

Pemeriksaan dibagi-per-digit adalah dari salah satu program contoh Pip saya. Saya menulisnya setelah melihat tantangan sebelumnya , tetapi tidak mempostingnya di sana karena bahasanya lebih baru daripada pertanyaannya. Kalau tidak, pada 8 byte, itu akan menjadi jawaban yang menang untuk pertanyaan itu. Berikut penjelasan langkah demi langkah:

      ^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)
— DLosc
sumber
Ini adalah bahasa yang cukup rapi! Senang melihat sesuatu selain golf berbasis stack.
— AdmBorkBork
1
@ TimmyD Jika Anda ingin melihat golf berbasis non-stack, cenderung ada sedikit Pyth sekitar.
— Reto Koradi
@RetoKoradi Tetapi jika Anda ingin melihat golf berbasis non-stack dengan operator infix , Pip cocok untuk Anda. ; ^)
— DLosc
Couple hours laterUntung kinerja tidak diperhitungkan.
— Holloway
3

Javascript (ES6), 106 90 83 byte

Anak-anak, jangan coba ini di rumah; JS tidak akan senang dengan prospek perulangan melalui setiap digit setiap bilangan bulat dari satu hingga sepuluh juta dengan sebuah regex.

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

Regex pertama (props ke @ Jarmex) kembali truejika nomor tersebut berisi digit duplikat atau nol. Jika ini ternyata false, program ini pindah ke kedua, yang menggantikan setiap digit jdengan i%j. Hasilnya semua nol jika itu dapat dibagi dengan semua digit itu, dalam hal ini ia beralih keconsole.log(i) .

Saran diterima!

— Produksi ETH
sumber
3

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)
Luaskan cuplikan

Tes regexp untuk 0 atau angka berulang. Kemudian array digit diperiksa mencari modulo non-nol untuk setiap digit.

di sini adalah penjelasan dari 7 digit maks.

— edc65
sumber
3

Ruby, 130 byte

... tidak termasuk spasi

Baru dalam pemrograman, hanya ingin berpartisipasi

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
— skeezy_D
sumber
2
Selamat datang di PPCG! Lihat beberapa Tips tambahan untuk Ruby untuk membantu menurunkan panjang kode itu.
— AdmBorkBork
3

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

Lebih cantik:

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

Untuk setiap kandidat i, kami mengulangi digit-digitnya adalam urutan little-endian, melacak digit-digit yang terlihat dalam bit-bit m. Jika loop selesai, maka semua digit adalah faktor dari idan kami tidak melihat angka nol atau berulang, jadi cetaklah, jika tidak kita keluar lebih awal untuk melanjutkan loop luar.

— Toby Speight
sumber
Bagus untuk gotoperintah yang digunakan.
— Shaun Bebbers
2

CJam, 34 byte

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

Lua, 129 byte

Saya telah menghindari pendekatan string untuk digit-murni, yang tampaknya sedikit lebih cepat dan mungkin menyelamatkan saya beberapa byte juga. (Saya akan menguji teori itu, tetapi penanganan string Lua sangat verbose dibandingkan dengan beberapa bahasa lain.)

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
— criptych berdiri bersama Monica
sumber
2

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}

Saya bisa mengurangi bahwa untuk 97 jika saya akan menggunakan ENDbukannyaBEGIN , tetapi kemudian Anda harus menekan Ctrl-D untuk memulai output aktual, menandakan bahwa tidak akan ada input.

Saya bisa menguranginya menjadi 94 bahkan jika saya tidak akan menulis apa pun BEGINatau bukanEND , tetapi kemudian Anda harus menekan tombol kembali sekali untuk memulainya, yang dapat dihitung sebagai input.

Ini hanya melewati digit dari setiap angka dan menguji jika kriteria terpenuhi.

i ~ 0: angka mengandung `0`? -> sampah
i% (d = a [j]): angka tidak dapat dibagi dengan digit saat ini? -> sampah
id * 10 ^ (lj) ~ d: Saya menghapus digit saat ini dari nomor itu
                  : masih berisi itu? -> sampah

Butuh 140 detik untuk diakhiri pada Core 2 Duo saya.

— Cabbie407
sumber
2

Jelly , 11 byte

9œ!ṖẎgḌ$ƑƇḌ

Ini menggunakan œ!atom tua dua minggu . Sebenarnya cukup cepat untuk dijalankan di TIO.

Cobalah online!

Bagaimana itu bekerja

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.
— Dennis
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.