C 468
#include <stdlib.h>
#include <stdio.h>
#define a(s)fputs(s,stdout);
#define b(c)putchar(c);
int r;int z(char*s,int m){for(int i=0;i++<=m;)a(s)b(47)b(r+48)b(61)char*t=s;
while(*++t==48);a(t)while(m--)a(s)b(*s)b(10)}char x[10][60];
int main(int c,char**v){r=atoi(v[1]);int n=atoi(v[2]),q=10*r-1,d=0,p;
while(d++<9){p=r*d;char*y=x[d];do{p*=10;*y++=p/q+48;p%=q;}while(p!=r*d);}
d=1;p=q=0;while(n--){r==5&p<6?z(x[7],7*q+p++):(z(x[d],(r==5&d==7)?7*q+6:q),
++d>9?q+=d=1,p=0:0);}}
(Algumas linhas novas não contadas na contagem de bytes foram adicionadas acima para eliminar as barras de rolagem. Sim, a nova linha final é contada.)
Espera argumentos na linha de comando e assume que a saída padrão aceita ASCII. O tempo de execução é O (número de bytes de saída) = O (n * n).
Não, eu não posso usar printf. Isso leva muito tempo e leva o programa além do limite de minutos na minha área de trabalho. Como é, alguns casos de teste levam cerca de 30 segundos.
O algoritmo trata a saída como seqüências de caracteres, não como números, uma vez que elas rapidamente se tornam enormes e existem padrões fortes na saída.
Um pouco não-destruído:
#include <stdlib.h>
#include <stdio.h>
/* r is as in the problem description */
int r;
void show_line(const char* num, int repeats) {
for (int i=0; i <= repeats; ++i)
fputs(num, stdout);
printf("/%c=", '0'+r);
/* Assume the repeated num is a solution. Just move the first
digit and skip any resulting leading zeros. */
const char* num_tail = num;
++num_tail;
while (*num_tail=='0')
++num_tail;
fputs(num_tail, stdout);
while (repeats--)
fputs(num, stdout);
printf("%c\n", *num);
}
/* sol[0] is unused. Otherwise, sol[d] is the repeating digits in the
decimal representation of (r*d)/(10*r-1). */
char sol[10][60];
int main(int argc, char** argv) {
r = atoi(argv[1]);
int n = atoi(argv[2]);
int q = 10*r-1;
int d = 0;
/* Populate the strings in sol[]. */
while (d++<9) {
int p = r*d;
char* sol_str = sol[d];
/* Do the long division p/q in decimal, stopping when the remainder
is the original dividend. The integer part is always zero. */
do {
p *= 10;
*sol_str++ = p/q + '0';
p %= q;
} while (p != r*d);
}
/* Output the answers. */
d = 1;
int repeats = 0;
int r5x7_repeats = 0;
while (n--) {
if (r==5 && r5x7_repeats<6) {
show_line(x[7], 7*repeats + r5x7_repeats);
} else {
if (r==5 && d==7)
show_line(x[d], 7*repeats + 6);
else
show_line(x[d], repeats);
if (++d > 9) {
d = 1;
++repeats;
r5x7_repeats = 0;
}
}
}
}
Prova
que o programa resolve o problema:
(Na prova, considere todos os operadores e funções como as funções matemáticas reais, não as operações do computador que as aproximam. ^Denota exponenciação, não xor a bit).
Para maior clareza, usarei uma função ToDecpara descrever o processo comum de escrever um número como uma sequência de dígitos decimais. Seu alcance é o conjunto de tuplas ordenadas {0...9}. Por exemplo,
ToDec(2014) = (2, 0, 1, 4).
Para um número inteiro positivo n, defina L(n)como o número de dígitos na representação decimal de n; ou,
L(n) = 1+floor(log10(n)).
Para um número inteiro positivo ke um número não negativo ncom L(n)<k, defina Rep_k(n)como o número real obtido adicionando zeros na frente dos dígitos decimais de n, se necessário, para obter o ktotal de dígitos e, em seguida, repetindo infinitamente esses kdígitos após o ponto decimal. Por exemplo
Rep_4(2014) = .201420142014...
Rep_5(2014) = .020140201402...
A multiplicação Rep_k(n) * 10^kfornece os dígitos nanteriores ao ponto decimal e os dígitos (preenchidos com zero) de ninfinitamente repetidos após o ponto decimal. então
Rep_k(n) * 10^k = n + Rep_k(n)
Rep_k(n) = n / (10^k - 1)
Dado um número inteiro positivo r, suponha que xseja uma solução para o problema e
ToDec(x) = ( x_1, x_2, ..., x_k )
onde x_1 != 0e k = L(x).
Para ser uma solução, xé um múltiplo de re
ToDec(x/r) : ( x_2, x_3, ..., x_k, x_1 ).
A aplicação da Rep_kfunção fornece uma boa equação:
10*Rep_k(x) = x_1 + Rep_k(x/r)
Usando sua forma fechada de cima,
10x / (10^k - 1) = x_1 + x / r / (10^k - 1)
x = x_1 * r * (10^k-1) / (10r - 1)
x_1deve estar no conjunto {1 ... 9}. rfoi especificado para estar no conjunto {2 ... 9}. Agora, a única questão é: para quais valores ka fórmula acima xfornece um número inteiro positivo? Vamos considerar cada valor possível rindividualmente.
Quando r= 2, 3, 6, 8 ou 9, 10r-1é 19, 29, 59, 79 ou 89, respectivamente. Em todos os casos, o denominador p = 10r-1é primo. No numerador, só 10^k-1pode haver um múltiplo de p, o que acontece quando
10^k = 1 (mod p)
O conjunto de soluções é fechado em adição e subtração que não resulta em um número negativo. Portanto, o conjunto compreende todos os múltiplos de algum fator comum, que também é a solução menos positiva para k.
Quando r = 4e 10r-1 = 39; ou quando r = 7e 10r-1 = 69, o denominador é 3 vezes um primo diferente p=(10r-1)/3. 10^k-1é sempre um múltiplo de 3 e, novamente, nenhum outro fator no numerador pode ser múltiplo de p, portanto, novamente o problema se reduz a
10^k = 1 (mod p)
e novamente as soluções são todos os múltiplos da solução menos positiva para k.
[Não finalizado...]
gprof, um caso de entrada para o meu programa gasta menos de meio segundo no meu código, mas leva cerca de 80 segundos no total, o que suponho que deva estar bloqueando a saída.