Dado um valor x, encontre o menor valor numérico maior que y, capaz de ser multiplicado e dividido por x , mantendo todos os dígitos originais.
- Os novos números não perdem dígitos.
- Os novos números não ganham dígitos.
Por exemplo:
Entrada: x = 2, y = 250000
- Original: 285714
- Divisão: 142857
- Multiplicação: 571428
Isso é verdade porque 285714 é maior que y ; quando dividido por x resulta em 142857 e quando multiplicado por x resulta em 571428 . Nos dois testes, todos os dígitos originais de 285714 estão presentes e nenhum dígito extra foi adicionado.
As regras
- X deve ser 2 ou 3, pois qualquer coisa mais alta demora muito para ser calculada.
- É necessário que Y seja um número inteiro maior que zero .
- O código mais curto vence.
Casos de teste
Esses são os meus casos de teste mais comuns, pois são os mais rápidos para testar.
- x = 2, y = 250000 = 285714
- x = 2, y = 290000 = 2589714
- x = 2, y = 3000000 = 20978514
- x = 3, y = 31000000 = 31046895
- x = 3, y = 290000000 = 301046895
Esclarecimentos
- O tipo de divisão não importa. Se você pode obter 2,05, 0,25 e 5,20 de alguma forma, fique à vontade.
Boa sorte a todos vocês!
Respostas:
Casca , 14 bytes
Experimente online!
Explicação
fonte
-
que estava errado.Brachylog v2, 15 bytes
Experimente online!
Recebe entrada no formulário
[x,y]
.Explicação
Comentário
A fraqueza de Brachylog em reutilizar vários valores várias vezes aparece aqui; este programa é quase todo encanamento e muito pouco algoritmo.
Como tal, pode parecer mais conveniente simplesmente codificar o valor de y (há um comentário sobre esta questão, na hipótese de que 2 é o único valor possível). No entanto, existem de fato soluções para y = 3, o que significa que, infelizmente, o encanamento também tem que lidar com o valor de y . O menor que eu conheço é o seguinte:
(A técnica que eu usei para encontrar esse número não é totalmente geral, portanto, é possível que exista uma solução menor usando outra abordagem.)
É improvável que você verifique isso com este programa. O Brachylog's
p
é escrito de uma maneira muito geral que não possui otimizações para casos especiais (como o caso em que tanto a entrada quanto a saída já são conhecidas, o que significa que você pode fazer a verificação em O ( n log n ) por meio de classificação, em vez disso do que o O ( n !) para a abordagem de força bruta que eu suspeito que esteja usando). Como conseqüência, leva muito tempo para verificar se 105263157894736842 é uma permutação de 315789473684210526 (eu o deixo em execução há vários minutos sem progresso óbvio).(EDIT: verifiquei a fonte Brachylog pelo motivo. Acontece que, se você usar
p
em dois inteiros conhecidos, o algoritmo usado gera todas as permutações possíveis do número inteiro em questão até encontrar um que seja igual ao número inteiro de saída, como o algoritmo é "input → indigits, permute indigits → outdigits, outdigits → output". Um algoritmo mais eficiente seria configurar primeiro a relação outdigits / output , para que o retorno dentro da permutação levasse em consideração quais dígitos estavam disponíveis.)fonte
p
não rodapermutation/2
com duas listas conhecidas, mesmo quando dados dois inteiros conhecidos como argumentos; gera todas as permutações do primeiro inteiro (utilizandopermutation/2
com uma lista conhecida) e, em seguida, compara-os contra o segundo número inteiro.Perl 6 , 56
54bytesExperimente online!
Alternativa interessante, computando n * x k para k = -1,0,1:
fonte
Limpo , 92 bytes
Experimente online!
Bem simples. Explicação daqui a pouco.
fonte
q, 65 bytes
Divida o número na base 10, classifique cada ascendente e verifique se é igual. Caso contrário, aumente y e vá novamente
fonte
JavaScript (ES6),
767369 bytesSalva 3 bytes usando
eval()
, conforme sugerido por @ShieruAsakotoToma entrada como
(x)(y)
.Experimente online!
Uma versão recursiva teria 62 bytes , mas não é adequada aqui devido ao alto número de iterações necessárias.
Como?
A função auxiliar pega um número inteiro como entrada, converte-o em uma matriz de caracteres de dígitos e classifica essa matriz.g
Exemplo:
Para comparar os dígitos de e os de com os de , testamos se a concatenação de com é igual à concatenação de consigo mesmo.y×x y/x y g(y×x) g(y/x) g(y)
Ao adicionar duas matrizes, cada uma delas é implicitamente coagida a uma cadeia de caracteres separada por vírgula. O último dígito da primeira matriz será diretamente concatenado com o primeiro dígito da segunda matriz sem vírgula entre elas, o que torna esse formato inequívoco.
Exemplo:
Mas:
Comentado
fonte
x=>F=y=>(g=x=>r=[...x+''].sort()+'')(y*x)!=g(y)|r!=g(y/x)?F(y+1):y
Pode causar estouro de pilha se y estiver longe da solução.eval
:x=>y=>eval("for(;(g=x=>r=[...x+''].sort()+'')(y*x)!=g(y)|r!=g(y/x);y++);y")
eval()
ideia. Minha primeira tentativa foi de fato recursiva, mas desisti por causa do alto número de iterações necessárias.Haskell,
7674 bytesDois bytes cortados graças ao comentário de Lynn
fonte
f
pode serf x y=[n|n<-[y+1..],all(==s n)[s$n*x,s$n/x]]!!0
, mas, em seguida, definir a sua resposta como um operador poupa dois bytes:x!y=…
e, em seguida, sua resposta é(!)
:)Japonês, 24 bytes
Solução bastante ingênua com algumas cervejas; Tenho certeza de que há uma maneira melhor.
Tente
fonte
315789473684210526
é a primeira soluçãox=3
, Javascript ou Japt não podem computá-lo corretamente, pois não se encaixa em dupla precisão.Python 2 , 69 bytes
Experimente online!
fonte
f=lambda x,y,S=sorted:y*(S(`y`)==S(`y*x`)==S(`y/x`))or f(x,y+1)
deve funcionar, mas atinge o limite de recursão rapidamente, e não sei o que as regras do PPCG têm a dizer sobre isso.Geléia ,
1413 bytes-1 graças a Erik the Outgolfer (`` usa make_digits, portanto
D
não era necessário)+2 corrigindo um bug (obrigado novamente a Erik the Outgolfer por apontar o problema inicial)
Um programa completo imprimindo o resultado (como um link diádico é gerada uma lista de comprimento 1).
Experimente online!
Como?
Observe que, quando a divisão não é exata, a instrução decimal implícita (equivalente a
D
) aplicada antes da classificação produz uma parte fracionária,por exemplo:
1800÷3D
->[6,0,0]
while
1801÷3D
->[6.0,0.0,0.33333333333337123]
fonte
D
.>=
eu perdi totalmente isso! NãoṢ
tinha idéia de make_digits definido nele - obrigado. Terá que consertar e atualizar mais tarde ...Mathematica,
8274 bytes-8 bytes graças ao tsh
Função que aceita argumentos como
[x,y]
. Efetivamente procurar uma força bruta que verifica se a lista ordenada de dígitos paray
,y/x
exy
são os mesmos.Experimente online!
fonte
x=3
, mas não tenho certeza se é verdadex=2
.v = a[1]*10^p[1] + a[2]*10^p[2] + ... + a[n]*10^p[n]
,u = a[1] * 10^q[1] + ... + a[n] * 10^q[n]
. E jáu-v = a[1]*(10^p[1]-10^q[1]) + ... + a[n]*(10^p[n]-10^q[n])
que10^x-10^y=0 (mod 9)
sempre vale.u-v=0 (mod 9)
sempre segura. Se houver uma resposta erradaw
, uma vez quew*x-w=0 (mod 9)
, ew-floor(w/x)=0 (mod 9)
: temosfloor(w/x)=0 (mod 9)
. sefloor(w/x)*x <> w
,w-floor(w/x)*x>=9
mas este conflito com o fato de quew-floor(w/x)*x<x
, enquanto x poderia ser 2 ou 3.w=0 (mod 9)
segue-sew*x-w=0 (mod 9)
porquex-1
não é divisível por 3. #IntegerQ
teste, ele produz alguns erros quando tenta comIntegerDigits
frações, mas o Mathematica ainda os ultrapassa e produz a resposta correta. Não tenho certeza se os erros incluídos durante o cálculo serão permitidos, mesmo que a resposta final esteja correta.APL (NARS), 490 caracteres, 980 bytes
teste
Eu pensei que o problema era um número conveniente ra que pode variar, de modo que se tenha os 3 números r, r * x, r * x * x no modo r começa a um valor em que r * x está próximo de y (onde xey são entradas do problema usando as mesmas letras da postagem principal). Utilizei a observação de que se o primeiro dígito de r é d, em que r deve aparecer também os dígitos d * x e d * x * x, para tornar r (ou melhor r * x) uma solução.
fonte
05AB1E , 16 bytes
Experimente online. (OBSERVAÇÃO: Solução muito ineficiente, use entradas próximas ao resultado. Funciona também para entradas maiores localmente, mas no TIO o tempo limite será excedido após 60 s.)
Explicação:
fonte