Herausforderungsbeschreibung

Für jede positive ganze Zahl ngibt es eine Zahl, deren Form 111...10...000durch neine Dezimalzahl teilbar ist , die mit allen beginnt und mit allen 1endet 0. Dies ist sehr einfach zu beweisen: Wenn wir eine Reihe n+1verschiedener Zahlen in Form von 111...111(allen 1) nehmen, geben mindestens zwei von ihnen den gleichen Rest nach der Division durch n(nach dem Taubenprinzip). Die Differenz dieser beiden Zahlen ist teilbar durch nund hat die gewünschte Form. Ihr Ziel ist es, ein Programm zu schreiben, das diese Nummer findet.

Eingabebeschreibung

Eine positive ganze Zahl.

Ausgabebeschreibung

Eine Zahl pin Form von 111...10...000, so dass p ≡ 0 (mod n). Wenn Sie mehr als eine finden - zeigen Sie eine davon an (muss nicht die kleinste sein).

Anmerkungen

Ihr Programm muss die Antwort innerhalb eines angemessenen Zeitraums geben. Was bedeutet, dass Brute-Forcing nicht erlaubt ist:

p = 0
while (p != 11..10.00 and p % n != 0)
    p++

Weder ist dies:

do
    p = random_int()
while (p != 11..10.00 and p % n != 0)

Das Durchlaufen der Zahlen in Form von 11..10..00ist erlaubt.

Ihr Programm muss keine willkürlich großen Eingaben verarbeiten - die Obergrenze ist die Obergrenze Ihrer Sprache.

Beispielausgaben

2: 10
3: 1110
12: 11100
49: 1111111111111111111111111111111111111111110
102: 1111111111111111111111111111111111111111111111110

Mathematica, 29 Bytes

⌊10^(9EulerPhi@#)/9⌋10^#&

Code von Martin Büttner .

Bei der Eingabe nwird die Zahl mit 9*ϕ(n)Einsen gefolgt von nNullen ausgegeben , wobei ϕes sich um die Euler-Totientenfunktion handelt . Mit einer Funktion phikönnte dies in Python ausgedrückt werden als

lambda n:'1'*9*phi(n)+'0'*n

Es würde ausreichen, n!stattdessen die Fakultät zu verwenden ϕ(n), aber das Drucken, das viele nicht hat, hat eine angemessene Laufzeit.

Behauptung: 9*ϕ(n) Einsen gefolgt von nNullen ist ein Vielfaches von n.

Beweis: Zunächst wollen wir beweisen dies für den Fall , dass nnicht ein Vielfaches von ist 2, 3oder 5. Wir werden zeigen, dass die Zahl, die aus ϕ(n)Einsen besteht, ein Vielfaches von `n ist.

Die Anzahl der kEinsen ist gleich (10^k-1)/9. Da nes sich nicht um ein Vielfaches von handelt 3, ist dies ein Vielfaches von n, solange 10^k-1es ein Faktor von noder gleichwertig mit if ist 10^k = 1 (mod n). Beachten Sie, dass diese Formulierung deutlich macht, dass, wenn sie kfür die Anzahl von Einsen funktioniert, dies auch für ein Vielfaches von funktioniert k.

Wir wollen kalso ein Vielfaches der Ordnung von kin der multiplikativen Gruppe modulo n sein . Nach dem Satz von Lagrange ist jede solche Ordnung ein Teiler der Größe der Gruppe. Da es sich bei den Elementen der Gruppe um die Zahl von 1bis handelt n, die relativ hochn ist, ist ihre Größe die Euler-Totientenfunktion ϕ(n) . Wir haben also gezeigt 10^ϕ(n) = 1 (mod n), dass die Anzahl der ϕ(n)Einsen ein Vielfaches von `n ist.

Lassen Sie uns nun mögliche Faktoren von 3in behandeln n. Wir wissen, dass dies 10^ϕ(n)-1ein Vielfaches von ist n, aber (10^ϕ(n)-1)/9möglicherweise nicht. Ist (10^(9*ϕ(n))-1)/9aber ein Vielfaches von, 9weil es aus 9*ϕ(n)Einsen besteht , also ist die Summe seiner Ziffern ein Vielfaches von 9. Und wir haben festgestellt, dass das Multiplizieren des Exponenten kmit einer Konstanten die Teilbarkeit bewahrt.

Wenn Sie nnun die Faktoren 2's und 5' s haben, müssen Sie am Ende der Ausgabe Nullen hinzufügen. Es ist weit mehr als ausreichend, nNullen zu verwenden ( log_2(n)würde tatsächlich reichen). Wenn also unsere Eingabe nso aufgeteilt wird n = 2^a * 5^b * m, genügt es, wenn 9*ϕ(m)diejenigen ein Vielfaches von sind n, multipliziert mit 10^neinem Vielfachen von 2^a * 5^b. Und da nes sich um ein Vielfaches von handelt m, ist es ausreichend, 9*ϕ(n)solche zu verwenden . Es funktioniert also, 9*ϕ(n)Einsen gefolgt von nNullen zu haben.

Python 2, 44 Bytes

f=lambda n,j=1:j/9*j*(j/9*j%n<1)or f(n,j*10)

Wenn jeine Potenz von 10 wie 1000 ist j/9, j/9*jgibt die Bodenteilung eine Zahl aus Einsen wie 111 an. Geben Sie also Einsen gefolgt von einer gleichen Zahl von Nullen wie 111000 an.

Die Funktion testet rekursiv Zahlen dieser Form und probiert immer höhere Potenzen von 10 aus, bis wir eine finden, die ein Vielfaches der gewünschten Zahl ist.

Pyth, 11 Bytes

.W%HQsjZ`TT

Testsuite

Grundsätzlich setzt es immer wieder eine 1 vor und eine 0 zurück, bis die Zahl durch die Eingabe teilbar ist.

Erläuterung:

.W%HQsjZ`TT
                Implicit: Q = eval(input()), T = 10
.W              while loop:
  %HQ           while the current value mod Q is not zero
      jZ`T      Join the string "10" with the current value as the separator.
     s          Convert that to an integer.
          T     Starting value 10.

Haskell, 51 Bytes

\k->[b|a<-[1..],b<-[div(10^a)9*10^a],b`mod`k<1]!!0

Mit xnors Ansatz. nimi hat ein byte gespeichert!

CJam, 28 25 19 Bytes

6 Bytes gespart mit der Beobachtung von xnor, dass wir nur die Nummern des Formulars betrachten müssen .1n0n

ri:X,:)Asfe*{iX%!}=

Teste es hier.

Erläuterung

ri:X    e# Read input, convert to integer, store in X.
,:)     e# Get range [1 ... X].
As      e# Push "10". 
fe*     e# For each N in the range, repeat the characters in "10" that many times,
        e# so we get ["10" "1100" "111000" ...].
{iX%!}= e# Select the first element from the list which is divided by X.

Mathematica, 140-55 Bytes

NestWhile["1"<>#<>"0"&,"1",FromDigits@#~Mod~x>0&/.x->#]

Dank des 1 ^ n0 ^ n-Tricks von xnor wurden viele Bytes entfernt.

Minimalwert, 140 156 Bytes Dies ergibt die kleinstmögliche Lösung.

NestWhile["1"<>#&,ToString[10^(Length@NestWhileList[If[EvenQ@#,If[10~Mod~#>0,#/2,#/10],#/5]&,#,Divisors@#~ContainsAny~{2, 5}&],FromDigits@#~Mod~m>0&/.m->#]&

Es berechnet, wie viele Nullen erforderlich sind, und überprüft dann alle möglichen 1Zählungen, bis es funktioniert. Es kann eine Zahl ohne 0 ausgegeben werden, dies kann jedoch durch Hinzufügen eines <>"0"Rechts vor dem Finale behoben werden &.

Haskell, 37 Bytes

f n=[d|d<-"10",i<-[1..n*9],gcd n i<2]

Dies nutzt die Tatsache dass es funktioniert, um 9*phi(n)diejenigen zu haben , wo phidie Euler-Totientenfunktion ist. Hier wird es unter Verwendung gcdund Filtern implementiert , wobei eine Ziffer für jeden Wert erzeugt wird i, der im Bereich 1und relativ hoch ist 9*n. Es reicht auch aus, so viele Nullen zu verwenden.

JavaScript (ES6), 65 Byte

Bearbeiten 2 Bytes, die dank @Neil gespeichert wurden

Es funktioniert innerhalb der Grenzen des numerischen Javascript-Typs mit 17 signifikanten Ziffern. (Also ziemlich begrenzt)

a=>{for(n='';!(m=n+=1)[17];)for(;!(m+=0)[17];)if(!(m%a))return+m}  

Weniger golfen

function (a) {
    for (n = ''; !(m = n += '1')[17]; )
        for (; !(m += '0')[17]; )
            if (!(m % a))
                 return +m;
}

Perl 5, 26 Bytes

Beinhaltet ein Byte für -n( -M5.01ist kostenlos)

($.="1$.0")%$_?redo:say$.

Salbei, 33 Bytes

lambda n:'1'*9*euler_phi(n)+'0'*n

Dies verwendet die Methode von xnor , um die Ausgabe zu erzeugen.

Probieren Sie es online aus

bc, 58 bytes

define f(n){for(x=1;m=10^x/9*10^x;++x)if(m%n==0)return m;}

Probenergebnisse

200: 111000
201: 111111111111111111111111111111111000000000000000000000000000000000
202: 11110000
203: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000
204: 111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000
205: 1111100000
206: 11111111111111111111111111111111110000000000000000000000000000000000
207: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
208: 111111000000
209: 111111111111111111000000000000000000
210: 111111000000
211: 111111111111111111111111111111000000000000000000000000000000
212: 11111111111110000000000000
213: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
214: 1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000
215: 111111111111111111111000000000000000000000
216: 111111111111111111111111111000000000000000000000000000
217: 111111111111111111111111111111000000000000000000000000000000
218: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
219: 111111111111111111111111000000000000000000000000

Gleichstrom, 27 Bytes

Odsm[O*lmdO*sm+O*dln%0<f]sf

Dies definiert eine Funktion f, die ihr Argument in der Variablen erwartet n. Um es als Programm ?sn lfx pzu verwenden, aus stdin zu lesen, die Funktion aufzurufen und das Ergebnis in stdout auszugeben. Variable mund Stapeloberseite müssen Odsmzuvor (durch Wiederholen ) auf 10 zurückgesetzt werdenf sie wieder verwendet werden können.

Ergebnisse:

200: 111000
201: 111111111111111111111111111111111000000000000000000000000000000000
202: 11110000
203: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000
204: 111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000
205: 1111100000
206: 11111111111111111111111111111111110000000000000000000000000000000000
207: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
208: 111111000000
209: 111111111111111111000000000000000000
210: 111111000000
211: 111111111111111111111111111111000000000000000000000000000000
212: 11111111111110000000000000
213: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
214: 1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000
215: 111111111111111111111000000000000000000000
216: 111111111111111111111111111000000000000000000000000000
217: 111111111111111111111111111111000000000000000000000000000000
218: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
219: 111111111111111111111111000000000000000000000000