Números fáceis de multiplicar
Sua tarefa é determinar se é fácil multiplicar dois números . Isso significa que a multiplicação longa da base 10 não possui nenhum valor (reagrupamento) entre os valores dos locais, observando as etapas de multiplicação e a etapa de adição. Isso acontece quando cada par de dígitos multiplicado fornece 9 ou menos e a soma de cada coluna é 9 ou menos.
Por exemplo, 331e 1021são fáceis de multiplicar:
E o mesmo é verdade (como sempre) se multiplicarmos na outra ordem:
Mas, 431e 1021não é fácil multiplicar, com carregamentos acontecendo entre as colunas indicadas:
Além disso, 12e 16não é fácil multiplicar porque uma transferência ocorre ao multiplicar 12 * 6para obter 72, mesmo que nenhuma transferência ocorra na etapa de adição.
Entrada: Dois números inteiros positivos ou suas representações de sequência. Você pode assumir que eles não excederão o tipo inteiro do seu idioma, nem o produto deles.
Saída: um valor consistente, se é fácil multiplicar, e outro valor consistente, se não.
Casos de teste: os 5 primeiros são fáceis de multiplicar, os 5 últimos não.
A entrada para cada número pode ser uma lista de dígitos?
@dylnan Não, embora uma lista de caracteres seja válida por padrão para a opção string.
Usa convolução (que eu contribuí com Jelly: D)
o wow convolução: DI acho que essa é a minha primeira convolução tempo vendo usado em um código-golf: D 1
@HyperNeutrino codegolf.stackexchange.com/search?q=matl
codegolf.stackexchange.com/questions/114495/topple-the-sandpile/…
@LuisMendo Não, é uma convolução diferente.
BTW Você pode substituir os últimos 3 bytes <⁵Ạpor output sem um booleano NÃO executado nele.
Recebe entrada como 2 strings na sintaxe de currying (a)(b). Retorna falsepara fácil ou truepara não fácil.
Alt. versão (falha), 64 55 52 bytes
Salva 3 bytes usando cadeias de caracteres, conforme sugerido por @Shaggy
Como apontado por @LeakyNun, esse método falharia em alguns números inteiros grandes e específicos
Recebe entrada como 2 strings na sintaxe de currying (a)(b). Retorna truepara fácil ou falsepara não fácil.
A idéia aqui é expor explicitamente os carregamentos inserindo zeros antes de cada dígito de cada fator.
331 x 1021 se torna 30301 x 1000201 , o que fornece 30307090501 em vez de 337951 . Ao adicionar um zero inicial ao resultado e agrupar todos os dígitos por 2, isso pode ser escrito como 03 03 07 09 05 01 . Todos os grupos têm menos de 10 , o que significa que não haveria nenhum resultado na multiplicação padrão.
431 x 1021 torna-se 40301 x 1000201 , que fornece 40309100501 e pode ser gravado como 04 03 09 10 05 01 . Desta vez, temos um 10 que revela um carry na multiplicação padrão.
Podemos ... Podemos ter uma explicação básica sobre o algoritmo?
@totallyhuman Adicionei uma explicação. (Oops ... e também fixa um bug.)
Parece que você deve conseguir salvar 3 bytes usando as entradas como seqüências de caracteres.
Levei uma eternidade para encontrar um contra-exemplo (teórico), que seu algoritmo falhará: tio.run/##y0rNyan8/9/l8LJk/f///… ( 108o meio bagunça seu algoritmo)
@LeakyNun Nice find. Sim, teoricamente pode transbordar.
Alice , 30 bytes
Saídas 1para fácil e 0difícil.
Os números são fáceis de multiplicar se e somente se a soma do dígito do produto for igual ao produto da soma do dígito.
Saídas 0para fácil, 1para difícil.
R , 135 110 109 86 bytes
Recebe entrada como strings.
É feio, mas funciona ™.
Agora, ele usa uma abordagem de convolução, como na resposta de Leaky Nun , de modo que recebe entradas como números inteiros e retorna TRUEpara números difíceis de multiplicar e FALSEfáceis de multiplicar.
Eu sempre tive alguns problemas para portar abordagens de convolução no passado, mas hoje finalmente li a documentação :
Observe que a definição usual de convolução de duas seqüências xe yé dada porconvolve(x, rev(y), type = "o")
O que é bobo. Portanto, a extração de dígitos é revertida ne se transforma em um porto da resposta de Leaky Nun.
Toma dois números inteiros como entrada e retorna False(fácil de multiplicar) ou True(não).
Experimente online! (muito lento para um dos casos de teste)
len(`n+m`)na verdade falharia por 40, 30 .
len(`n+m`)+1?
Isso falha para 400, 300 . len(`n`+`m`)deve fazer embora.
JavaScript (Node.js) , 43 41 37 36 bytes
Obrigado @ Dennis pela idéia de usar interpolação de string nesta resposta e economize 4 bytes!
Obrigado @ ØrjanJohansen por -1!
É claro que quando a base de destino é menor que a base original (como na minha resposta Jelly, a base é 2), ela <deve ser invertida.
Parabéns por ser o primeiro a descobrir o uso da conversão de base, pela qual dou a você a recompensa!
Wolfram Language (Mathematica) , 75 66 65 56 bytes
Recebendo 2 entradas de string
-9 para mudar para usar string como entrada
-1 para usar o operador infix
-9 Obrigado @MartinEnder pela Maxfunção
Python 2 , 158 135 123 113 113 bytes
-12 bytes graças a Freira Furada -10 bytes graças a ovs
Experimente online! ou Experimente todos os casos de teste
Não all(d[k]<10for k in d)funciona ou é apenas Python 3?
@shooqie sim, ele faz, mas agora é uma lista c:
Julia 0.6 , 30 bytes
A entrada é uma tupla de números, a saída é truepara números difíceis de multiplicar e falsefáceis.
. é um aplicativo de função elemento a elemento.
...expande a tupla (de listas de dígitos inteiros) para duas entradas separadas da convfunção.
Python 3 , 58 35 13 40 39 bytes
Parece que tive essa ideia duas horas tarde demais .
Obrigado a @ ØrjanJohansen por jogar fora um byte!
SNOBOL4 (CSNOBOL4) , 268 264 247 246 243 131 bytes
Portos a abordagem por Nitrodon . Acho que é a primeira vez que defino uma função no SNOBOL, Dpara soma de dígitos.
versão antiga, 243 bytes:
Entrada no STDIN separada por novas linhas, saída para STDOUT: uma única nova linha para fácil multiplicação e nenhuma saída para não fácil multiplicar.
Isso não vai ganhar nenhum prêmio, mas apresenta outra abordagem (bem, realmente essa é a abordagem ingênua). Eu não acho que poderia escrever isso no cubix, mas o SNOBOL é duro o suficiente para trabalhar como está.
Como recebe a entrada como uma sequência, isso funcionará para qualquer entrada com menos de 512 dígitos cada; Não tenho 100% de certeza de quão grande ARRAYpode ser o SNOBOL.
INPUT é armazenado em buffer nesta versão do SNOBOL para ter uma largura máxima de 1024 caracteres; todos os outros caracteres são perdidos. Parece que um ARRAY pode ser bastante grande; bem acima das 2048 células necessárias.
Carvão , 38 bytes
Experimente online! Link é a versão detalhada do código. Produz a -quando os números são fáceis de multiplicar. Explicação:
Inicialize zcom uma matriz de zeros grande o suficiente (soma dos comprimentos de entradas).
Faça um loop sobre os índices das entradas qe h.
Execute um passo da multiplicação longa.
Verifique se há carregamentos.
Pari / GP , 52 bytes
Os números são tomados como cadeias. Retorna Falsese os números forem fáceis de multiplicar e Truecaso contrário.
Eu acho que é diferente o suficiente da resposta de @ Laikoni . Como funciona:
Ótima solução! Eu estava procurando maneiras de se livrar da importação, mas elas acabaram ainda mais.
Haskell , 45 44 bytes
-1 byte mudando ==para <.
Pensei nisso antes de olhar para as outras respostas, depois descobri que a Alice usava a mesma idéia básica. Postando assim mesmo, já que é mais curto que as outras respostas de Haskell.
?pega dois números inteiros e retorna a Bool. Use como 331?1021. Falsesignifica que a multiplicação é fácil.
sé uma função que calcula a soma dos dígitos de um número inteiro. ( read.pureconverte um caractere de um dígito em um número inteiro.)
Se é fácil multiplicar um par de números, a soma do dígito do produto é igual ao produto da soma dos dígitos.
Por outro lado, qualquer transporte durante a multiplicação longa reduzirá a soma de dígitos do produto desse ideal.
Ruby , 69 bytes
Haskell , 123 bytes
Experimente online! Exemplo de uso: "331" % "1021"rendimentos True.
Perl 5 , 100 + 2 ( -F) = 102 bytes
produz falso para fácil, verdadeiro para não fácil.
Uma porta da minha resposta Javascript . Não é menor do que a resposta existente da Jelly, porque a Jelly possui uma poderosa convolução incorporada.
Tome entrada como uma lista de dois números. Retorna 1para fácil, 0para não fácil.
C (gcc) , 104 bytes
Basicamente, faça uma multiplicação "à mão" em r [] e defina o valor de retorno se alguma coluna for maior que 9, pois isso significaria uma ocorrência.
Surpreendentemente, isso foi mais curto do que minha primeira tentativa, que tomou as seqüências de caracteres como argumentos.