Montagszahlen generieren

35

Montagszahlen , wie von Gamow in dieser Frage über Rätsel definiert, sind positive ganze Zahlen N mit den folgenden drei Eigenschaften:

  • Die Dezimaldarstellung von N enthält nicht die Ziffer 0
  • Die Dezimaldarstellung von N enthält keine doppelte Ziffer
  • N ist durch jede Ziffer D teilbar , die in ihrer Dezimaldarstellung vorkommt

Beachten Sie, dass diese im OEIS alternativ als Lynch-Bell-Nummern bezeichnet werden .

Beispiele:

  • 15ist ein Montag - Nummer, wie sie durch beide teilbar ist 1und 5und erfüllt die beiden anderen Bedingungen
  • 16ist nicht, weil es nicht teilbar ist durch 6.
  • Die Zahl 22ist nicht, da sie die Bedingungen 1 und 3 erfüllt, die Bedingung 2 jedoch nicht erfüllt.

Hier ist die Liste der ersten 25 Montagszahlen, mit denen Sie beginnen können (es gibt insgesamt 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

Die Herausforderung hierbei besteht darin , den kürzesten Code zu schreiben, der die vollständige Sequenz der Montagszahlen von 1 bis 9867312 generiert (wobei sich bei dieser Frage als der größtmögliche erwiesen hat).

Ihr Code sollte keine Eingabe und die Ausgabe sollte STDOUT oder ein gleichwertiges Zeichen sein, wobei Sie das Trennzeichen auswählen. Es gelten alle üblichen Code-Golf-Regeln und Standard -Regelungslücken sind verboten.

Bestenliste

AdmBorkBork
quelle
5
Related
FryAmTheEggman
1
Wird auch als Lynch-Bell-Nummer bezeichnet .
Geobits,
@Geobits Danke - Ich konnte es aus irgendeinem Grund nicht auf OEIS finden.
AdmBorkBork
8
Du
hättest
2
@ mbomb007 Hätte ich - habe Gamows Frage aber erst heute morgen gesehen!
AdmBorkBork

Antworten:

1

Gelee , 8 Bytes

ȷ7Dg⁼QƲƇ

Läuft vor Ort in weniger als acht Minuten.

Probieren Sie es online! (Geändert, um Zahlen mit sechs oder weniger Ziffern zu finden.)

Wie es funktioniert

ȷ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
quelle
16

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

Druckt eine Liste.

Grundsätzlich kombiniere ich zwei meiner Antworten auf frühere Herausforderungen:

Dank xsot für 1 Byte gespart durch die Kombination der Bedingungen besser.

xnor
quelle
Sie können ein Byte speichern: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 Bytes

46 Byte Code + 1 Byte Befehlszeilenparameter.

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

Verwendung:

perl -l entry.pl

Erläuterung

/(.).*\1|0/ Gibt 1 zurück, wenn die zu testende Nummer ein doppeltes Zeichen oder eine 0 enthält

s/./$_%$&/rgeErsetzt jede Ziffer durch den Wert der zu testenden Zahl% der Ziffer. Zum Beispiel 15 -> 00, 16 -> 04 (da 16% 6 = 4). Dies bedeutet, dass jede Eingabe, die durch alle Ziffern teilbar ist, aus allen Nullen besteht, andernfalls enthält sie eine Ziffer> 0. Um dies als Zahl zu behandeln, geben wir * 1 zurück, was bedeutet, dass eine zu testende Zahl für diesen Block 0 zurückgibt, wenn sie durch alle ihre Ziffern teilbar ist, andernfalls> 0.

Wenn Sie diese beiden Anweisungen und den Ausdruck durch 'oder' trennen und eine der beiden ersten Bedingungen> 0 zurückgibt, stimmt die Bedingung überein, und die nachfolgenden Teile des Ausdrucks werden nicht ausgewertet. Wenn und nur wenn beide vorherigen Bedingungen 0 sind, wird der Druck ausgeführt. Das -lFlag stellt sicher, dass nach jedem Druck eine neue Zeile eingefügt wird.

Jarmex
quelle
Sehr schön. Sie können ein paar Bytes sparen, indem Sie es zu Perl 5.10 machen und sayanstelle von print+ -l:-)
xebtl 30.09.15
Danke für den Vorschlag! Ich dachte say , zuerst eine explizite Erklärung erforderlich ?
Jarmex,
@Jarmex Vielleicht habe ich die Tradition angefangen, hier zu nehmen use feature 'say'oder use 5.012umsonst - ich erwähne immer, wann ich es tue, und niemand hat es jemals angefochten. Ich habe ein paar andere gesehen, die das gleiche
getan haben
2
@hobbs Diese Antwort auf Meta sagt "Der Konsens bisher auf SO und hier war" die -M5.010, wenn erforderlich, ist kostenlos ".
Xebtl
2
Mit mapund saybis zu 43: Probieren Sie es online aus!
Xcali
10

Pyth, 22 21

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

Vielen Dank an Jakube für das Abschlagen von 1 Byte unnötiger Formatierung.

Stark inspiriert von dieser CW-Antwort auf die verwandte Frage.

Ich habe eine Paste des Ergebnisses hier , von dem Zeitpunkt an, an dem es als Zeilenvorschub getrennt gedruckt wurde, jetzt als Python-Liste.

Ich würde empfehlen , es nicht online zu versuchen, es sei denn, Sie verwenden eine Zahl kleiner als 7 ... Ich habe es in diesem Link auf 2 gesetzt.

Filter von 1bis 10^7-1die alle notwendigen Werte abdecken. Diese Version kann einen Speicherfehler verursachen, wenn die Liste nicht erstellt werden kann S^T7, ähnlich wie list(range(1,10**7))in Python 3 (funktioniert jedoch bei mir einwandfrei). Wenn ja, könnten Sie versuchen:

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

Womit die ersten 548 Montagszahlen gefunden werden. Dies zeigt auch eine andere Möglichkeit, die 0s in der Nummer zu überprüfen , anstatt sie durch .3einen Try-Catch-Block zu ersetzen . Dank für diese Version geht ganz an Jakube. (Beachten Sie, dass dies für den Online-Dolmetscher immer noch viel zu langsam ist.)

FryAmTheEggman
quelle
1
Hier ist eine andere Lösung: .f&.{`Z.x!s%LZjZT0548Es ist ziemlich viel schneller (4x - 5x) als Ihr While-Loop-Ansatz und hat auch nur eine Länge von 21 Bytes.
Jakube
1
@ Jakube Backticks sind ein Schmerz in Kommentaren, nicht wahr? : P Vielen Dank!
FryAmTheEggman
Umm .. Ihre Lösung scheint nicht zu funktionieren .. In Ihrem TIO-Link im Bereich bis 100, zeigt es 55, 66, 77, 88, 99, alle Zahlen mit doppelten Ziffern ..
Kevin Cruijssen
1
@KevinCruijssen Leider wurde Pyth so oft aktualisiert, seit ich diesen Beitrag verfasst habe. Ich kann nicht feststellen, was sich geändert hat. Sie können in der Paste sehen, dass dies eindeutig vorher funktioniert hat. Ich denke, es könnte .{geändert worden sein, da das Ersetzen durch {Izu funktionieren scheint.
FryAmTheEggman
@FryAmTheEggman Ah, ich hatte die Paste nicht gesehen. Es ist in der Tat fast drei Jahre her, also kein Wunder, dass sich die Dinge geändert haben könnten. +1 in diesem Fall, weil die Paste beweist, dass es funktioniert hat. :)
Kevin Cruijssen
9

GS2 , 20 bis 19 Bytes

gs2 verwendet eine Vielzahl von Bytes, nicht nur druckbare ASCII-Zeichen. Ich werde meine Lösung in hex präsentieren.

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

Hier ist eine Erklärung. gs2 ist eine stapelbasierte Sprache, daher gibt es keine Variablen. (abgesehen von 4 Registern, von denen ich hier eins benutze)

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
rekursiv
quelle
8

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

Es gibt 548 Montagszahlen.

Zach Gates
quelle
1
Könnten Sie 1e8anstelle von sogar verwenden 9**9?
Dom Hastings
Entfernen Sie den Raum in '0' not. Auch i%int(k)==0kann wohl sein i%int(k)<1?
mbomb007
Vielen Dank. Ich wollte das nicht wieder hinzufügen. @ Mbomb007
Zach Gates
Sie können verwenden j=`i`.
mbomb007
Für einen weiteren -6 Einsatzif len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j)
Lirtosiast
7

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

7 Bytes gespart dank Moris Zucca!

Alex A.
quelle
Ich liebe APL. Deshalb.
Conor O'Brien
Ich denke, Sie können mit Function Trains Golf spielen und dabei 5 Bytes sparen: {0 = + / (⊢ | ∘⍵, 0∘∊, ⍴∘⊢ ⍴∘⊢ ≠) x ← ⍎¨⍎: ⍵⋄⍬} ¨⍳ 1e7
Moris Zucca
@ MorisZucca Super, danke für den Vorschlag!
Alex A.
Ich habe gerade gesehen, dass in dieser Form x ← nicht mehr benötigt wird, also 2 weitere Bytes gespeichert! :-)
Moris Zucca
@MorisZucca Du bist eine APL Golfmaschine! Danke noch einmal!
Alex A.
6

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

∟Dist die Liste der Ziffern, die mit math und dem randIntNoRep(Befehl generiert wird (zufällige Permutation aller ganzen Zahlen zwischen 1und 1+int(log(Xeinschließlich). Ich benutze eine etwas komplizierte Anweisungskette, um zu prüfen, ob alle Bedingungen erfüllt sind:

   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(

Um Zahlen mit wiederholten Ziffern oder mit Nullen zu versagen, ersetze ich Nullen durch 2X, da diese Xniemals durch teilbar sind 2X.

Für den Sonderfall 1 ~ 9 (weil ΔList(bei einer Liste mit einem Element Fehler aufgetreten sind ) verwende ich die IfAnweisung in der vierten Zeile, um die Prüfung in der fünften Zeile zu überspringen und automatisch alle X≤9 anzuzeigen.

Die Ausgabenummern werden durch Zeilenumbrüche getrennt.

Lirtosiast
quelle
5

Mathematica 105

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]
  • IntegerDigitsaufbricht n, in eine Liste ihrer Ziffern i.
  • FreeQ[i,0] prüft, ob die Liste keine Nullen enthält.
  • Length[i]==Length[Union[i]] prüft, ob es keine wiederholten Ziffern gibt.
  • And@@(Divisible[n,#]&/@i)prüft, ob jede Ziffer ein Teiler von ist n.

{1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 24, 36, 48, 124, 126, 128, 132, 135, 162, 168, 175, 184, 216, 248 , 264, 312, 315, 324, 384, 396, 412, 432, 612, 624, 648, 672, 728, 735, 784, 816, 824, 864, 936, 1236, 1248, 1296, 1326, 1362, 1368 1395, 1632, 1692, 1764, 1824, 1926, 1935, 1962, 2136, 2184, 2196, 2316, 2364, 2436, 2916, 3126, 3162, 3168, 3195, 3216, 3264, 3276, 3492, 3612, 3624 , 3648, 3816, 3864, 3915, 3924, 4128, 4172, 4236, 4368, 4392, 4632, 4872, 4896, 4932, 4968, 6132, 6192, 6312, 6324, 6384, 6432, 6912, 6984, 8136, 8496 , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12768, 12864, 13248, 13824, 13896, 13968, 14328, 14728, 14832, 16248, 16824, 17248 18264, 18432, 18624, 18936, 19368, 21384, 21648, 21784, 21864, 23184, 24168, 24816, 26184, 27384, 28416, 29736, 31248, 31824, 31896, 31968, 32184, 34128, 36792,37128, 37296, 37926, 38472, 39168, 39816, 41328, 41832, 42168, 42816, 43128, 43176, 46128, 46872, 48216, 48312, 61248, 61824, 62184, 64128, 68712, 72184, 73164, 724 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 98136, 123648, 1238 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 162384, 163248, 1638 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 216384, 218736, 219 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, 329824 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 36716248, 376824, 381264, 3816244, 38 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428716, 431928, 432168, 432786, 431928 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 61338 613872, 614328, 614832, 618432, 621384, 623184, 623784,627984, 631248, 631824, 632184, 634128, 634872, 641328, 641832, 643128, 648312, 671328, 671832, 681432, 684312, 689472, 732648, 732816, 74264646, 746928, 762384, 71664647832 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834216, 834912, 836472, 841392, 841632, 842136, 843192, 843216314, 842136, 843 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, 921384, 923184, 927864, 931248, 931824, 932184, 934128, 941328, 941832, 9431282, 9714323 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 211789976, 2189376, 2317896, 288913 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867192, 3869712, 3927168, 6328176, 6139728, 63798, 6328 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392, 7836192 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9217816, 9278136, 9283116, 9731213816 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613613, 7813, 7392168 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 92173796 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613613, 7813, 7392168 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 92173796 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 988796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 98

Length[%]

548

DavidC
quelle
Ich 9^91e8
gehe davon aus,
Ich bin überrascht, dass Mathematica dafür kein eingebautes Programm hat ;-). Netter Trick mit dem man Unionnach Duplikaten sucht.
AdmBorkBork
@FryAmTheEggman, Sie haben Recht mit Mathematica, wenn Sie 9 ^ 9 zulassen. Aber würde das nicht mehr als 548 Montagszahlen zurückgeben?
DavidC
Wie in der Frage gesagt, gibt es keine mögliche Montagszahl, die größer ist als die als Obergrenze angegebene.
FryAmTheEggman
5

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]

Anwendungsbeispiel (die ersten 20 Zahlen):

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]

So funktioniert es: iteriere über alle Zahlen von 1 bis 9 ^ 9 und überprüfe die Bedingungen. Die aktuelle Nummer xwird in ihre Zeichenfolgendarstellung ( show x) umgewandelt, um sie als Liste von Zeichen zu bearbeiten.

nimi
quelle
5

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

Etwas weniger Golf gespielt:

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
quelle
5

Perl, 90 75 70 Bytes

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7
Steve
quelle
1
Ahhh, ich habe den \ 1-Trick zur Überprüfung von Betrügereien verpasst, nett. Können Sie mit einem Anweisungsmodifikator und einem ternären Ausdruck mehr sparen?
Dom Hastings
@ DomHastings danke, jetzt mehr Golf mit Ihrem Vorschlag
Steve
Schön, ich glaube , Sie auch ein paar mehr sparen können, wie Sie das nicht brauchen ^und die $um die 0in Ihrem grep, können Sie die ersetzen können , &&bevor s/./mit einem einzigen &und ich glaube , das letzte |0nicht mehr benötigte (obwohl nur getestet up-to 1e3. ..). Gut und wahrhaftig meine Punktzahl verprügelt! :)
Dom Hastings
1
@DomHastings danke, bis zu 70 mit deinen Golftipps.
Steve
Golfed es ein bisschen mehr, indem Sie das Grep loswerden (unnötig - die Musterübereinstimmung kümmert sich darum, ohne Grep) und den Rest in eine Karte neu ordnen: Probieren Sie es online!
Xcali
4

CJam, 25 Bytes

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

Probieren Sie es online aus . Beachten Sie, dass der Online-Link nur zu 10.000 ausgeführt wird. Ich bin mir nicht sicher, ob es online enden würde, wenn Sie geduldig genug sind. Es wurde nicht mit der Offline-Version von CJam getestet, aber ich gehe davon aus, dass es beendet wird.

Erläuterung:

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
quelle
4

C #, 230 227

Es ist schon eine Weile her, dass ich golfen habe, also habe ich wahrscheinlich ein paar Tricks vergessen, um den Bytecount zu senken. Wird sich verbessern, wenn ich an sie denke ...

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,1296326,136236,236 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,16324816 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,2187364 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,28464,3126,291384,293184,2978126 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,31928,342168,3428169126128,348192,3482169128 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,41863232 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,48163282 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832618432,621384,623184,623784,632184,631248,631824,632184,634 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,8194 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,8912,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312976248,978264,91432,984312,1289736,17268 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,28196,283196,279 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,61397289129128,638728 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,78392167861392,7863912,7891632786139 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

RobIII
quelle
kann (int) 1e7 1 << 24 sein?
Lirtosiast
@ThomasKwa Ja, das kann sein. Tatsächlich. Vielen Dank!
RobIII
4

TI-BASIC, 55 53 Bytes

Dies ist eine relativ geringfügige Änderung von Thomas Kwas Antwort , aber ich sende sie als neue Antwort ein, weil ich gehört habe, dass er das Golfen seiner TI-BASIC-Antworten mit einer Prämie belegt hat .

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

Meine Hauptänderung ist von zu randIntNoRep(1,zu randIntNoRep(0,bedeuten, dass es jetzt eine Null in jeder erzeugten Liste der Stellen gibt.

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

Da jetzt in jedem Ziffernsatz eine Null steht, wirkt sich dies auf die Summe der Reste aus. Normalerweise ist die Summe der Reste 0, aber jetzt führt das Vorhandensein einer zusätzlichen Null zu einem Fehlschlag unseres Teilbarkeitstests.
Um dem entgegenzuwirken, wechselte ich 2Xnot(zu Xnot(. Die 2 war ursprünglich da, um den Test bei 0 fehlschlagen zu lassen, aber jetzt geht es bei Null. Zahlen, deren Ziffern eine Null enthalten, haben jetzt min(ΔList(∟Dsowieso eine Null (da ihre Listen 2 oder mehr Nullen enthalten), sodass diese Änderung nicht dazu führt, dass zusätzliche Zahlen den Test bestehen.

Der Vorteil dieser Methode besteht darin, dass die Funktion, da jetzt "zwei Ziffern" aus der Zahl 1-9 erzeugt werden, ΔList(keinen Fehler erzeugt, wodurch wir eine spezielle Bedingung für einstellige Zahlen beseitigen können.

PhiNotPi
quelle
4

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

-9 byte dank der hilfe und ermutigung von @Enigma und @ Mr.Xcoder . Vielen Dank, dass ich es größtenteils selbst herausfinden durfte, obwohl ich bereits mit 30 Jahren eine 12-Byte-Lösung im Sinn hatte. Ich habe viel über 05AB1E aus dieser Herausforderung gelernt!
-3 Bytes dank @Grimy

7°LʒÐÑÃÙQ

Probieren Sie es online aus (gibt nur Zahlen unter 10 3 statt 10 7 aus , um eine Zeitüberschreitung nach 60 Sekunden zu vermeiden).

Erläuterung:

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)

Vorherige 12-Byte-Version (eine meiner allerersten 05AB1E-Antworten):
HINWEIS: Funktioniert nur in der älteren Version von 05AB1E.

7°LʒÐSÖPsDÙQ*

Probieren Sie es online aus (gibt nur Zahlen unter 10 3 statt 10 7 aus , um eine Zeitüberschreitung nach 60 Sekunden zu vermeiden).

Erläuterung:

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
quelle
Ihre Antwort wird gedruckt 297, die nicht in der Reihenfolge der Lynch-Bell-Nummern liegt.
Herr Xcoder
@ Mr.Xcoder Seufz .. Hatte anfangs etwas länger Zeit, um zu überprüfen, ob eine Zahl durch alle ihre Ziffern teilbar ist, stellte sich aber eine solche Herausforderung vor. Es scheint, dass diese Antwort auch ungültig ist. Und hier sprechen Sie und Enigma über 12-15-Byte-Antworten, während meine 30-Byte-Antwort nicht einmal funktioniert, lol. Gibt es irgendwo ein Tutorial? ; p
Kevin Cruijssen
1
9 Bytes:7°LʒÐÑÃÙQ
Grimmy
@Grimy Eine meiner allerersten 05AB1E-Antworten. :) Netter Ansatz!
Kevin Cruijssen
3

Julia, 88 Bytes

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

Dies nimmt einfach alle Zahlen von 1 bis zur größten Lynch-Bell-Zahl und filtert sie nur bis zu den Lynch-Bell-Zahlen.

Ungolfed:

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

print(join(lynch, " "))
Alex A.
quelle
3

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

Sie können das printim Interpreter weglassen , um 96 zu erhalten. Verwendet, 6**9da es 8 Stellen ist, während die größte Montagszahl nur 7 Stellen ist, so etwas 9**9würde wahrscheinlich lange dauern, 6 ** 9 dauert nur ungefähr 10 Sekunden.

Rohcana
quelle
Wie bereits in einigen Fragen erwähnt, ist 1e7 kürzer als beide
Holloway,
@Trengot 1e7ist ein Float, Range nimmt ganze Zahlen.
Rohcana
Sehr richtig. Hätte nicht gedacht , davon
Holloway
3

Perl, 97 Bytes

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

Dauert eine Weile laufen, aber erzeugt die erforderliche Leistung, Veränderung 1e3für ein schnelleres Beispiel!

Dom Hastings
quelle
Ich bin im Moment nicht in der Lage, dies zu versuchen, aber können Sie stattdessen y///c==grep{2>eval"$n=~y/$_//"}/./getwas in der Art von verwenden !/(.).*\1/?
msh210
@ msh210 Mit ziemlicher Sicherheit! Ich denke, das wäre jetzt meine Standardeinstellung, aber wenn ich das ändere , wird es nur näher an die Antworten von Steve oder Jarmex rücken , die weit überlegen sind! Vielen Dank, dass Sie sich das angeschaut haben!
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)

Und in einem besser lesbaren Format:

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)

11×107

Die Prüfungen sind wie folgt:

  1. Überprüfen Sie zunächst, ob Duplikate vorhanden sind. Wenn durch Sortieren des Arrays die Differenz zwischen aufeinanderfolgenden Ziffern Null ist, gibt es Duplikate

    diff(sort(a))
    
  2. Überprüfen Sie, ob es Nullen gibt. Der ASCII-Wert für 0 ist 48, daher prüfen wir, ob nicht alle Ziffern gleich sind.

    a~=48
    
  3. Prüfen Sie, ob es durch alle Ziffern teilbar ist. Wir überprüfen, ob der Rest beim Teilen durch jede Ziffer (konvertiert von ASCII zu Dezimalzahl, daher -48) Null ist.

    ~mod(n,a-48)
    

Schließlich stellen wir sicher, dass all()die Prüfungen wahr sind, und hängen sie an eine durch Kommas getrennte Ausgabezeichenfolge an.

MATLAB hat kein STDOUT, also drucke ich stattdessen die Ergebniszeichenfolge am Ende mit disp()


Dieser Code ist LANGSAM! Ich führe es immer noch aus, um sicherzustellen, dass es alle Montagszahlen korrekt findet, aber es sieht bis jetzt gut aus.

Aktualisieren:

Der Code wurde ausgeführt. Es wird Folgendes gedruckt:

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

Was, wenn Sie diesen Code mit dem als Eingabe ausführen:

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

Yeilds 548.

Tom Carpenter
quelle
3

Rubin, 79

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

Interessantere, aber etwas längere Lösung mit Regex:

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

In jedem Fall verwenden wir Rubys Fähigkeit, Strings zu durchlaufen, als wären es Dezimalzahlen: ?1.upto(?9*7)entspricht 1.upto(9999999).map(&:to_s).each. Wir verbinden die Zeichenkette mit jeder Ziffer ungleich Null unter Verwendung des Modulo-Operators und werten das Ergebnis aus, um die Teilbarkeit zu überprüfen.

Bonus Ruby 1.8 Lösung ( -lFlag für korrekte Ausgabe erforderlich ):

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

1.8 erlaubte dem Blockiterator, eine globale Variable zu sein. Durch das Zuweisen von $_wird es zum impliziten Empfänger für Zeichenfolgenoperationen. Wir können Arrays auch leichter in den regulären Ausdruck interpolieren: in 1.8 /[#{[1,2]}]/ergibt sich /[12]/.

Histokrat
quelle
Jetzt, da Ruby 2.4 eine digitsFunktion für Ganzzahlen hat , können Sie Bytes aus dem eval-Hack speichern, da Sie nicht mehr mit Strings arbeiten! 63 Bytes.
Value Ink
3

Pip , 25 Bytes

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

Gibt jede Nummer in einer eigenen Zeile aus. Dies hat ungefähr 10 Minuten gedauert und ist bis jetzt auf 984312 aufgestiegen, aber ich bin mir ziemlich sicher, dass es richtig ist. (Edit: Paar Stunden später ... Code fertig, alle 548 von ihnen generiert.)

Hier ist eine Python-ähnliche Pseudocode-Wiedergabe:

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

Der #=Operator vergleicht zwei Iterablen nach ihrer Länge. Wenn die Anzahl der Uni Que Zeichen in adie gleiche wie die Anzahl der Zeichen in ist a, gibt es keine Wiederholungen.

Die durch jede Ziffer teilbare Prüfung stammt aus einem meiner Pip-Beispielprogramme. Ich habe es geschrieben, nachdem ich die frühere Herausforderung gesehen hatte , aber es dort nicht gepostet, weil die Sprache neuer war als die Frage. Andernfalls wäre es bei 8 Bytes die beste Antwort auf diese Frage. Hier ist eine schrittweise Erklärung:

      ^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
quelle
Das ist eine ziemlich ordentliche Sprache! Schön, etwas anderes als Stack-basiertes Golfen zu sehen.
AdmBorkBork
1
@TimmyD Wenn Sie nicht-Stack-basiertes Golfen sehen möchten, gibt es in der Regel einiges an Pyth.
Reto Koradi
@RetoKoradi Aber wenn Sie nicht stapelbasiertes Golfen mit Infix-Operatoren sehen möchten , ist Pip genau das Richtige für Sie. ; ^)
DLosc
Couple hours laterEs ist gut, dass die Leistung nicht berücksichtigt wird.
Holloway
3

Javascript (ES6), 106 90 83 Bytes

Kinder, versuchen Sie das nicht zu Hause. JS wird sich nicht über die Aussicht freuen, mit einem regulären Ausdruck jede Ziffer einer ganzen Zahl von eins bis zehn Millionen zu durchlaufen.

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

Der erste reguläre Ausdruck (Requisiten an @Jarmex) gibt zurück, truewenn die Nummer doppelte Ziffern oder Nullen enthält. Wenn sich herausstellt false, geht das Programm zur zweiten weiter, die jede Ziffer jdurch ersetzt i%j. Das Ergebnis sind alle Nullen, wenn es durch alle Ziffern teilbar ist. In diesem Fall geht es weiter zu console.log(i).

Vorschläge willkommen!

ETHproductions
quelle
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)

Der Regexp-Test für 0 oder wiederholte Ziffern. Dann wird das Ziffernarray überprüft, um nach einem Modulo ungleich Null für eine beliebige Ziffer zu suchen.

hier ist die erklärung der 7 stelligen max.

edc65
quelle
3

Ruby, 130 Bytes

... ohne Leerzeichen

Neu in der Programmierung, wollte nur teilnehmen

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
quelle
2
Willkommen bei PPCG! Lesen Sie einige zusätzliche Tipps für Ruby , um die Codelänge zu verringern.
AdmBorkBork
3

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

Schöner:

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

Für jeden Kandidaten iiterieren wir seine Ziffern ain Little-Endian-Reihenfolge und verfolgen die angezeigten Ziffern in den Bits von m. Wenn die Schleife abgeschlossen ist, sind alle Ziffern Faktoren von iund wir haben keine Nullen oder wiederholten Ziffern gesehen. Drucken Sie sie also aus. Andernfalls verlassen wir die Schleife vorzeitig, um die äußere Schleife fortzusetzen.

Toby Speight
quelle
Gut zu dem gotoBefehl, der verwendet wird.
Shaun Bebbers
2

CJam, 34 Bytes

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

Lua, 129 Bytes

Ich habe den String-Ansatz für reines Knacken von Ziffern vermieden, was etwas schneller zu sein scheint und mir wahrscheinlich auch ein paar Bytes erspart hat. (Ich werde diese Theorie testen lassen, aber der Umgang mit Lua-Strings ist im Vergleich zu einigen anderen Sprachen ziemlich ausführlich.)

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
Criptychon steht bei Monica
quelle
2

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}

Ich könnte das auf 97 reduzieren, wenn ich ENDstattdessen verwenden würdeBEGIN , aber dann müsste man Strg-D drücken, um die eigentliche Ausgabe zu starten, was signalisiert, dass es keine Eingabe geben wird.

Ich könnte es sogar auf 94 reduzieren, wenn ich nichts anstelle von BEGINoder schreiben würde END, aber dann müsste man die Eingabetaste einmal drücken, um es zu starten, was als Eingabe gezählt werden könnte.

Es geht einfach über die Ziffern jeder Zahl und prüft, ob die Kriterien erfüllt sind.

i ~ 0: Zahl enthält eine `0`? -> Müll
i% (d = a [j]): Zahl nicht durch aktuelle Ziffer teilbar? -> Müll
id * 10 ^ (lj) ~ d: Ich habe die aktuelle Ziffer von der Nummer noch entfernt
                  : enthält es noch? -> Müll

Bei meinem Core 2 Duo dauert die Beendigung 140 Sekunden.

Cabbie407
quelle
2

Jelly , 11 Bytes

9œ!ṖẎgḌ$ƑƇḌ

Dies verwendet das zwei Wochen alte œ!Atom. Eigentlich schnell genug, um mit TIO zu laufen.

Probieren Sie es online!

Wie es funktioniert

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
quelle