Dividendo pari a zero

28

Descrizione della sfida

Per ogni numero intero positivo nesiste un numero che ha la forma di 111...10...000quello divisibile per nun numero decimale che inizia con tutto 1e finisce con tutto 0. Questo è molto facile da dimostrare: se prendiamo un insieme di n+1numeri diversi nella forma di 111...111(tutti 1), almeno due di essi forniranno lo stesso resto dopo la divisione per n(secondo il principio del buco del piccione). La differenza di questi due numeri sarà divisibile per ne avrà la forma desiderata. Il tuo obiettivo è scrivere un programma che trovi questo numero.

Descrizione dell'input

Un numero intero positivo.

Descrizione dell'output

Un numero psotto forma di 111...10...000, tale che p ≡ 0 (mod n). Se ne trovi più di uno, visualizzane uno (non è necessario che sia il più piccolo).

Gli appunti

Il tuo programma deve dare la risposta in un ragionevole lasso di tempo. Ciò significa che la forza bruta non è consentita:

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

Né questo è:

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

11..10..00È consentito scorrere i numeri sotto forma di .

Il tuo programma non ha bisogno di gestire un input arbitrariamente grande - il limite superiore è qualunque sia il limite superiore della tua lingua.

Output di esempio

2: 10
3: 1110
12: 11100
49: 1111111111111111111111111111111111111111110
102: 1111111111111111111111111111111111111111111111110
code-golf  math  arithmetic  number-theory 
— shooqie
fonte
Possiamo avere un limite superiore ragionevole al possibile output? (Qualcosa di circa meno di 2,4 miliardi (circa il valore massimo di un intero con
— segno
@ MartinBüttner Penso che il primo risultato soddisfacente dovrebbe essere sufficiente (ragionevole
— limite di
L'ultimo 0 non è necessario nel 49 test case.
— Calcolatrice
@CatsAreFluffy Penso che tutti i numeri debbano contenere almeno 1e almeno uno 0, altrimenti 0è una soluzione per qualsiasi input. (Sarebbe bello chiarire questo però.)
— Martin Ender,
Basta richiedere uno 1dovrebbe funzionare.
— Calcolatrice

Risposte:

22

Mathematica, 29 byte

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

Codice di Martin Büttner .

All'ingresso n, questo genera il numero con 9*ϕ(n)quelli seguiti da nzero, dove si ϕtrova la funzione totulante di Eulero . Con una funzione phi, questo potrebbe essere espresso in Python come

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

Basterebbe usare il fattoriale n!invece di ϕ(n), ma stampare che molti non hanno un tempo di esecuzione ragionevole.

Reclamo: 9*ϕ(n) quelli seguiti da nzero è un multiplo di n.

Dimostrazione: In primo luogo, cerchiamo di dimostrare questo per il caso che nnon è un multiplo di 2, 3o 5. Mostreremo che il numero con costituito da ϕ(n)uno è un multiplo di `n.

Il numero composto da kuno è uguale (10^k-1)/9. Dato che nnon è un multiplo di 3, questo è un multiplo di nfintanto che 10^k-1è un fattore di n, o equivalentemente se 10^k = 1 (mod n). Si noti che questa formulazione rende evidente che se kfunziona per il numero di quelli, lo stesso vale per qualsiasi multiplo di k.

Quindi, stiamo cercando kdi essere un multiplo dell'ordine di knel gruppo moltiplicativo modulo n . Secondo il teorema di Lagrange , tale ordine è un divisore delle dimensioni del gruppo. Poiché gli elementi del gruppo sono i numeri da 1a nche sono relativamente primi a n, la sua dimensione è la funzione totulante di Eulero ϕ(n) . Quindi, lo abbiamo dimostrato 10^ϕ(n) = 1 (mod n), e quindi il numero composto da ϕ(n)quelli è un multiplo di `n.

Ora, gestiamo i potenziali fattori di 3in n. Sappiamo che 10^ϕ(n)-1è un multiplo di n, ma (10^ϕ(n)-1)/9potrebbe non esserlo. Ma (10^(9*ϕ(n))-1)/9è un multiplo di 9perché è costituito da 9*ϕ(n)uno, quindi la somma delle sue cifre è un multiplo di 9. E abbiamo notato che moltiplicare l'esponente kper una costante preserva la divisibilità.

Ora, se nha fattori di 2"s 5", dobbiamo aggiungere zero alla fine dell'output. È molto più che sufficiente usare nzero (in effetti log_2(n)lo farebbe). Quindi, se il nostro input nè diviso come n = 2^a * 5^b * m, è sufficiente averne 9*ϕ(m)uno multiplo n, moltiplicato 10^nper essere multiplo 2^a * 5^b. E, poiché nè un multiplo di m, è sufficiente usarne 9*ϕ(n)uno. Quindi, funziona per avere 9*ϕ(n)quelli seguiti da nzero.

— XNOR
fonte
12
Solo per essere sicuro che nessuno pensi che questo sia stato pubblicato senza la mia autorizzazione: xnor ha inventato il metodo e la prova da solo, e gli ho appena fornito un'implementazione di Mathematica, perché ha una EulerPhifunzione integrata. Non c'è nulla di strabiliante nell'attuazione effettiva, quindi considererei questo interamente come un suo lavoro.
— Martin Ender,
9

Python 2, 44 byte

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

Quando jè una potenza di 10 come 1000, la divisione piano j/9dà un numero composto da 1 come 111. Quindi, j/9*jdà 1 seguito da un numero uguale di 0 come 111000.

La funzione verifica ricorsivamente i numeri di questo modulo, provando potenze sempre più alte di 10 fino a quando non ne troviamo uno che è un multiplo del numero desiderato.

— XNOR
fonte
1
Oh, buon punto, dobbiamo solo controllare 1 ^ n0 ^ n ...
— Martin Ender,
@ MartinBüttner Se è più semplice, è anche sufficiente fissare il numero di 0 come valore di input. Non so se conta altrettanto efficace per stampare così tanti zeri.
— xnor
Perché il controllo 1 ^ n0 ^ n funziona?
— Lynn,
5
@Lynn L'aggiunta di più zero non può far male, e ci sono infiniti numeri possibili di uno, un numero ne avrà abbastanza di entrambi e zero.
— xnor
5

Pyth, 11 byte

.W%HQsjZ`TT

Suite di test

Fondamentalmente, mette solo 1 in primo piano e 0 in più e più volte finché il numero non è divisibile per l'input.

Spiegazione:

.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.
— isaacg
fonte
4

Haskell, 51 byte

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

Usando l'approccio di xnor. nimi ha salvato un byte!

— Lynn
fonte
3

CJam, 28 25 19 byte

Ho salvato 6 byte con l'osservazione di xnor che dobbiamo solo guardare i numeri del modulo .1n0n

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

Provalo qui.

Spiegazione

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.
— Martin Ender
fonte
2

Mathematica, 140 55 byte

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

Molti byte rimossi grazie al trucco 1 ^ n0 ^ n di xnor.

Valore minimo, 140 156 byte Questo fornisce la soluzione più piccola possibile.

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

Calcola quanti zeri sono necessari, quindi controlla tutti i 1conteggi possibili fino a quando non funziona. Può produrre un numero senza 0 ma che può essere risolto aggiungendo un <>"0"diritto prima della finale &.

— CalculatorFeline
fonte
2

Haskell, 37 byte

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

Questo usa il fatto che funziona per averne 9*phi(n)uno, dov'è phila funzione totulante di Eulero. Qui, è implementato usando gcde filtrando, producendo una cifra per ogni valore iche è relativamente primo ad esso che è nell'intervallo 1e 9*n. Basta anche usare questi molti zeri.

— XNOR
fonte
2

JavaScript (ES6), 65 byte

Modifica 2 byte salvati grazie a @Neil

Funziona nei limiti del tipo numerico javascript, con 17 cifre significative. (Così abbastanza limitato)

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

Meno golf

function (a) {
    for (n = ''; !(m = n += '1')[17]; )
        for (; !(m += '0')[17]; )
            if (!(m % a))
                 return +m;
}
— edc65
fonte
1
Perché no for(m=n;?
— Neil,
@Neil perché ho bisogno di almeno uno zero. Forse posso trovare un modo più breve ... (grazie per la modifica)
— edc65,
Oh, non era chiaro nella domanda, ma ora vedo che tutti gli output di esempio hanno almeno uno zero. In tal caso è comunque possibile salvare un byte utilizzando for(m=n;!m[16];)if(!((m+=0)%a)).
— Neil,
1
@Neil o anche 2 byte. Thx
— edc65
1

Perl 5, 26 byte

include un byte per -n( -M5.01è gratuito)

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

bc, 58 byte

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

Risultati del campione

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
— Toby Speight
fonte
0

dc, 27 byte

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

Questo definisce una funzione fche prevede il suo argomento nella variabile n. Per usarlo come programma, ?sn lfx pper leggere da stdin, chiamare la funzione e stampare il risultato su stdout. La variabile me la parte superiore dello stack devono essere reimpostate su 10 (ripetendo Odsm) prima di fpoter essere riutilizzate.

risultati:

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
— Toby Speight
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.