Deskripsi tantangan

Untuk setiap bilangan bulat positif nterdapat bilangan yang bentuknya 111...10...000dapat dibagi dengan nbilangan desimal yang dimulai dengan semua 1dan diakhiri dengan semua 0. Ini sangat mudah dibuktikan: jika kita mengambil satu set n+1angka yang berbeda dalam bentuk 111...111(semuanya 1), maka setidaknya dua dari mereka akan memberikan sisa yang sama setelah pembagian dengan n(sesuai prinsip pigeonhole). Perbedaan dari dua angka ini akan habis dibagi ndan akan memiliki bentuk yang diinginkan. Tujuan Anda adalah menulis program yang menemukan nomor ini.

Deskripsi input

Bilangan bulat positif.

Deskripsi keluaran

Sejumlah pdalam bentuk 111...10...000, sedemikian rupa p ≡ 0 (mod n). Jika Anda menemukan lebih dari satu - tampilkan salah satunya (tidak perlu yang terkecil).

Catatan

Program Anda harus memberikan jawaban dalam jumlah waktu yang wajar. Yang berarti pemaksaan kasar tidak diizinkan:

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

Tidak juga ini:

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

Iterasi melalui angka-angka dalam bentuk 11..10..00diperbolehkan.

Program Anda tidak perlu menangani input besar sembarang - batas atas adalah apa pun batas atas bahasa Anda.

Output sampel

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

Mathematica, 29 byte

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

Kode oleh Martin Büttner .

Input n, output ini jumlah dengan 9*ϕ(n)yang diikuti oleh nnol, di mana ϕadalah fungsi totient Euler . Dengan suatu fungsi phi, ini bisa diekspresikan dalam Python sebagai

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

Cukuplah menggunakan faktorial n!sebagai ganti ϕ(n), tetapi mencetak banyak yang tidak memiliki jangka waktu yang wajar.

Klaim: 9*ϕ(n) yang diikuti oleh nnol adalah kelipatan dari n.

Bukti: Pertama, mari kita buktikan ini untuk kasus yang nbukan kelipatan dari 2, 3atau 5. Kami akan menunjukkan nomor dengan yang terdiri dari ϕ(n)kelipatan `n.

Jumlah yang dibuat ksama dengan (10^k-1)/9. Karena nbukan kelipatan 3, ini merupakan kelipatan nselama 10^k-1merupakan faktor n, atau jika setara 10^k = 1 (mod n). Perhatikan bahwa formulasi ini membuat jelas bahwa jika kberfungsi untuk jumlah yang, maka demikian juga kelipatannya k.

Jadi, kami sedang mencari kuntuk menjadi kelipatan dari urutan dari kdalam perkalian kelompok modulo n . Menurut Teorema Lagrange , urutan seperti itu adalah pembagi ukuran grup. Karena unsur-unsur kelompok adalah jumlah dari 1ke nyang relatif prima untuk n, ukurannya adalah fungsi totient Euler ϕ(n) . Jadi, kami telah menunjukkan itu 10^ϕ(n) = 1 (mod n), dan jumlah yang dibuat ϕ(n)adalah kelipatan dari `n.

Sekarang, mari kita tangani faktor-faktor potensial dari 3dalam n. Kita tahu itu 10^ϕ(n)-1kelipatan n, tetapi (10^ϕ(n)-1)/9mungkin tidak. Tapi, (10^(9*ϕ(n))-1)/9adalah kelipatan 9karena terdiri dari 9*ϕ(n)yang, jadi jumlah digitnya kelipatan 9. Dan kami mencatat bahwa mengalikan eksponen kdengan konstanta menjaga keterbagian.

Sekarang, jika nmemiliki faktor 2's dan 5' s, kita perlu menambahkan nol ke akhir output. Itu jauh lebih dari cukup untuk menggunakan nnol (sebenarnya log_2(n)akan dilakukan). Jadi, jika input kita ndipecah menjadi n = 2^a * 5^b * m, itu sudah cukup untuk memiliki 9*ϕ(m)satu untuk menjadi kelipatan n, dikalikan dengan 10^nmenjadi kelipatan 2^a * 5^b. Dan, karena nmerupakan kelipatan m, itu sudah cukup untuk menggunakannya 9*ϕ(n). Jadi, berfungsi untuk memiliki 9*ϕ(n)yang diikuti oleh nnol.

Python 2, 44 byte

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

Ketika jkekuatan 10 seperti 1000, divisi-lantai j/9memberikan angka yang terbuat dari 1 seperti 111. Jadi, j/9*jmemberi 1 diikuti dengan jumlah yang sama dengan 0 seperti 111000.

Fungsi secara rekursif menguji angka dari formulir ini, mencoba kekuatan yang lebih tinggi dan lebih tinggi dari 10 hingga kami menemukan satu yang merupakan kelipatan dari angka yang diinginkan.

Pyth, 11 byte

.W%HQsjZ`TT

Suite uji

Pada dasarnya, itu hanya menempatkan 1 di depan dan 0 di belakang lagi dan lagi sampai jumlahnya habis oleh input.

Penjelasan:

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

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

Menggunakan pendekatan xnor. nimi menyimpan satu byte!

CJam, 28 25 19 byte

Disimpan 6 byte dengan pengamatan xnor bahwa kita hanya perlu melihat nomor formulir .1n0n

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

Uji di sini.

Penjelasan

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 byte

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

Banyak byte yang dihapus berkat trik 1 ^ n0 ^ n xnor.

Nilai minimal, 140 156 byte Ini memberikan solusi sekecil mungkin.

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

Ini menghitung berapa banyak nol yang diperlukan kemudian memeriksa semua 1jumlah yang mungkin sampai berfungsi. Ini bisa menampilkan angka tanpa 0 tetapi itu bisa diperbaiki dengan menambahkan <>"0"hak sebelum final &.

Haskell, 37 byte

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

Ini menggunakan fakta bahwa ia berfungsi untuk memilikinya 9*phi(n), di mana phifungsi totient Euler. Di sini, ini diterapkan menggunakan gcddan memfilter, menghasilkan satu digit untuk setiap nilai iyang relatif prima untuk itu yang berada dalam kisaran 1dan 9*n. Ini juga cukup untuk menggunakan banyak nol ini.

JavaScript (ES6), 65 byte

Edit 2 byte yang disimpan thx @Neil

Ia bekerja dalam batas tipe numerik javascript, dengan 17 digit signifikan. (Sangat terbatas)

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

Kurang golf

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

Perl 5, 26 byte

termasuk byte untuk -n( -M5.01gratis)

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

Sage, 33 byte

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

Ini menggunakan metode xnor untuk menghasilkan output.

Cobalah online

bc, 58 byte

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

Contoh hasil

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

dc, 27 byte

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

Ini mendefinisikan fungsi fyang mengharapkan argumennya dalam variabel n. Untuk menggunakannya sebagai program, ?sn lfx puntuk membaca dari stdin, panggil fungsi, dan cetak hasilnya ke stdout. Variabel mdan atas tumpukan harus diatur ulang ke 10 (dengan mengulangi Odsm) sebelum fdapat digunakan kembali.

Hasil:

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