Mô tả thử thách

Đối với mỗi số nguyên dương ntồn tại một số có dạng 111...10...000chia hết cho nsố đó là số thập phân bắt đầu bằng tất cả 1và kết thúc bằng tất cả 0. Điều này rất dễ chứng minh: nếu chúng ta lấy một tập hợp n+1các số khác nhau dưới dạng 111...111(tất cả 1), thì ít nhất hai trong số chúng sẽ cho cùng một phần còn lại sau khi chia theo n(theo nguyên tắc pigeonhole). Sự khác biệt của hai số này sẽ chia hết cho nvà sẽ có dạng mong muốn. Mục đích của bạn là viết một chương trình tìm thấy số này.

Mô tả đầu vào

Một số nguyên dương.

Mô tả đầu ra

Một số pở dạng 111...10...000, như vậy p ≡ 0 (mod n). Nếu bạn tìm thấy nhiều hơn một - hiển thị bất kỳ cái nào trong số chúng (không cần phải là cái nhỏ nhất).

Ghi chú

Chương trình của bạn phải đưa ra câu trả lời trong một khoảng thời gian hợp lý. Điều đó có nghĩa là vũ phu không được phép:

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

Đây cũng không phải là:

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

Lặp lại thông qua các số dưới dạng 11..10..00được cho phép.

Chương trình của bạn không cần xử lý đầu vào lớn tùy ý - giới hạn trên là bất cứ điều gì giới hạn trên của ngôn ngữ của bạn.

Đầu ra mẫu

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

Toán học, 29 byte

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

Mã của Martin Büttner .

Trên đầu vào n, điều này xuất ra số với các số 9*ϕ(n)tiếp theo là nsố 0, trong đó ϕlà hàm tổng của Euler . Với một hàm phi, điều này có thể được biểu thị bằng Python như

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

Nó sẽ đủ để sử dụng giai thừa n!thay vì ϕ(n), nhưng in ra rằng nhiều người không có thời gian chạy hợp lý.

Yêu cầu: 9*ϕ(n) những người theo sau là nsố không là bội số của n.

Chứng minh: Trước hết, chúng ta hãy chứng minh điều này đối với trường hợp mà nkhông phải là một bội số của 2, 3hoặc 5. Chúng tôi sẽ hiển thị số có bao gồm các số ϕ(n)là bội số của `n.

Số lượng làm kbằng những người bằng (10^k-1)/9. Vì nkhông phải là bội số của 3, nên đây là bội số của nmiễn 10^k-1là một hệ số nhoặc tương đương nếu 10^k = 1 (mod n). Lưu ý rằng công thức này làm rõ rằng nếu khoạt động cho số lượng cái, thì bất kỳ bội số nào cũng vậy k.

Vì vậy, chúng tôi đang tìm kiếm klà một bội số của các trật tự của ktrong nhân giống nhóm modulo n . Theo Định lý của Lagrange , bất kỳ thứ tự nào như vậy đều là ước số của kích thước của nhóm. Kể từ khi các phần tử của nhóm là số từ 1để ncó tố cùng nhau với n, kích thước của nó là chức năng hàm Ơ-le Euler ϕ(n) . Vì vậy, chúng tôi đã chỉ ra rằng 10^ϕ(n) = 1 (mod n), và vì vậy số lượng được tạo ra ϕ(n)là bội số của `n.

Bây giờ, hãy xử lý các yếu tố tiềm năng của 3trong n. Chúng tôi biết đó 10^ϕ(n)-1là bội số của n, nhưng (10^ϕ(n)-1)/9có thể không. Nhưng, (10^(9*ϕ(n))-1)/9là bội số của 9vì nó bao gồm các số 9*ϕ(n), vì vậy tổng các chữ số của nó là bội số của 9. Và chúng tôi đã lưu ý rằng nhân số mũ kvới một hằng số sẽ duy trì tính chia hết.

Bây giờ, nếu ncó các yếu tố của 2và 5, chúng ta cần thêm các số 0 vào cuối đầu ra. Nó không chỉ là đủ để sử dụng nsố không (trong thực tế log_2(n)sẽ làm được). Vì vậy, nếu đầu vào của chúng tôi nđược phân chia thành n = 2^a * 5^b * m, thì đủ để có 9*ϕ(m)một đầu vào là bội số của n, nhân với bội số 10^ncủa 2^a * 5^b. Và, vì nlà bội số của mnó, nó đủ để sử dụng 9*ϕ(n)những cái đó. Vì vậy, nó hoạt động để có 9*ϕ(n)những cái theo sau là nsố không.

Python 2, 44 byte

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

Khi jcó công suất bằng 10, chẳng hạn như 1000, j/9phép chia sàn cho một số được tạo bởi 1 giống như 111. Vì vậy, j/9*jcho 1 số theo sau là số 0 bằng nhau như 111000.

Hàm kiểm tra đệ quy các số của dạng này, thử các lũy thừa 10 và cao hơn cho đến khi chúng ta tìm thấy một số đó là bội số của số mong muốn.

Bình thường, 11 byte

.W%HQsjZ`TT

Bộ kiểm tra

Về cơ bản, nó chỉ đặt 1 ở phía trước và 0 ở phía sau lặp đi lặp lại cho đến khi số đó chia hết cho đầu vào.

Giải trình:

.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

Sử dụng phương pháp của xnor. nimi đã lưu một byte!

CJam, 28 25 19 byte

Đã lưu 6 byte với quan sát của xnor mà chúng ta chỉ cần nhìn vào số của biểu mẫu .1n0n

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

Kiểm tra nó ở đây.

Giải trình

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.

Toán học, 140 55 byte

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

Nhiều byte bị xóa nhờ thủ thuật 1 ^ n0 ^ n của xnor.

Giá trị tối thiểu, 140 156 byte Điều này mang lại giải pháp nhỏ nhất có thể.

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

Nó tính toán có bao nhiêu số không được yêu cầu sau đó kiểm tra tất cả các 1số có thể có cho đến khi nó hoạt động. Nó có thể xuất ra một số không có 0 nhưng điều đó có thể được sửa bằng cách thêm một <>"0"quyền trước trận chung kết &.

Haskell, 37 byte

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

Điều này sử dụng thực tế là nó hoạt động để có 9*phi(n)những cái, trong đó phihàm tổng số Euler. Ở đây, nó được triển khai bằng cách sử dụng gcdvà lọc, tạo ra một chữ số cho mỗi giá trị itương đối chính với nó nằm trong phạm vi 1và 9*n. Nó cũng đủ để sử dụng nhiều số không.

JavaScript (ES6), 65 byte

Chỉnh sửa 2 byte đã lưu thx @Neil

Nó hoạt động trong giới hạn của kiểu số javascript, với 17 chữ số có nghĩa. (Vì vậy, khá hạn chế)

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

Ít chơi gôn

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

Perl 5, 26 byte

bao gồm một byte cho -n( -M5.01miễn phí)

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

Sage, 33 byte

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

Điều này sử dụng phương pháp của xnor để tạo đầu ra.

Dùng thử trực tuyến

bc, 58 byte

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

Kết quả mẫu

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

Điều này định nghĩa một hàm fmong đợi đối số của nó trong biến n. Để sử dụng nó như một chương trình, ?sn lfx pđể đọc từ stdin, hãy gọi hàm và in kết quả ra thiết bị xuất chuẩn. Biến mvà đầu ngăn xếp phải được đặt lại thành 10 (bằng cách lặp lại Odsm) trước khi fcó thể được sử dụng lại.

Các kết quả:

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