Um jogo de fatoração

13

Entrada

Um único inteiro .1≤x≤1015

Resultado

O número máximo de números inteiros positivos distintos que possuem o produto .x

Exemplos

Entrada: 1099511627776. Saída: 9. Uma lista ótima possível de fatores é: (1, 2, 4, 8, 16, 32, 64, 128, 4096).

Entrada: 127381. Saída 4. Uma lista ótima possível de fatores é: (1, 17, 59, 127).

Relacionado a esta pergunta antiga .

code-golf  math 
— Anush
fonte
9
Você poderia adicionar mais alguns casos de teste? (De um modo preferido de tamanho razoável.)
— Arnauld
8
Considerando seus comentários na maioria das respostas: se você estiver procurando por um código eficiente, isso definitivamente não deve ser marcado como code-golf. Você pode considerar um fastest-codeou fastest-algorithmum próximo desafio. Se você realmente queria que todas as respostas funcionassem em um tempo limitado dentro do intervalo especificado, isso deveria ter sido mencionado explicitamente. (E eu teria recomendado um intervalo menor para que ele não entre em conflito com code-golfinteiramente.)
— Arnauld
@ Arnauld Não, tenho o cuidado de torná-lo código de golfe e ninguém é julgado por isso. Seria legal se o código pudesse ser executado para os intervalos de entrada especificados.
— Anush
5
— Arnauld
1
Pois x=1, 2, ...recebo o f(x)=1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 2, 3, 3, 3, 2, 4, 2, 3, 3, 3, 2, 4, 2, 3, 3, 3, 3, 4, 2, 3que não encontro no OEIS. É claro o suficiente que os registros aparecerão para números fatoriais x. Por exemplo, o menor xtal que f(x)=13será 13!. Eu acho que fdepende apenas dos expoentes da fatoração principal. Então, para descobrir, f(13^4*19^7*29^2)podemos simplificar f(2^7*3^4*5^2).
— Jeppe Stig Nielsen

Respostas:

5

Wolfram Language (Mathematica) , 52 bytes

Max[Length/@Cases[Subsets@Divisors@#,{a__}/;1a==#]]&

Experimente online!

4 bytes salvos graças a @attinat

Aqui também está uma versão de 153 bytes que calcula 1099511627776e10^15 

Max[Length/@Table[s=RandomSample@Flatten[Table@@@FactorInteger[#]];Last@Select[Times@@@TakeList[s,#]&/@IntegerPartitions@Length@s,DuplicateFreeQ],5!]]+1&

Experimente online!

O resultado para 10^15é 12

{1, 2, 4, 5, 10, 16, 25, 40, 50, 100, 125, 250}

— J42161217
fonte
Falha com 1099511627776
— Anush
7
@ Anush Não trava. Só precisa de memória. Você não disse nada sobre limitações de memória. Este é o código do golfe
— J42161217 2/19/19
Sim, eu percebo. Seria bom se você pudesse realmente executar o código nos intervalos de entrada especificados na pergunta.
— Anush
6
@ Anush Este é código-golfe. Respostas não agradáveis. Especifique seus critérios. Uma resposta é válida ou não. Eu acho que o problema aqui é a pergunta ... Talvez você deve alterá-lo para "a maioria algoritmo suficiente"
— J42161217
3
@Anush eu fiz uma edição na minha resposta e acrescentou mais uma versão que é muito rápido e eficiente no caso de você querer verificá-la
— J42161217
3

05AB1E , 9 bytes

Muito ineficiente. Tempo limite no TIO para números com uma grande quantidade de divisores.

ÑæʒPQ}€gZ

Experimente online!

Explicação

Ñ          # push a list of divisors of the input
 æ         # push the powerset of that list
  ʒPQ}     # filter, keep only the lists whose product is the input
      €g   # get the length of each
        Z  # take the maximum
— Emigna
fonte
Seu código TIO parece
— gerar
@ Anush: É um número diferente do seu exemplo (uma vez que o tempo limite é devido a muitos fatores). Eu provavelmente deveria usar um exemplo mais distinto.
— Emigna
€gZé um pouco mais eficiente do que éθgpara o mesmo número de conta.
— Grimmy
@ Grimy: Verdadeiro. Não vai fazer muita diferença, pois é o filtro que é o grande vilão aqui, mas não faz mal a ser um pouco mais eficiente :)
— Emigna
2

Perl 6 , 38 bytes

{$!=$_;+grep {$!%%$_&&($!/=$_)},1..$_}

Experimente online!

Adota a abordagem gananciosa para selecionar divisores.

— Brincadeira
fonte
Não termina com 1099511627776
— Anush
6
@ Anush Bem, termina eventualmente . Geralmente, a resposta é válida se o algoritmo do programa funcionar com qualquer entrada, se lhe for dada a quantidade de memória e tempo que desejar. Uma vez que este é o código-golf , eu otimizado para o comprimento do código, não algorítmica complexidade
— Jo Rei
2

Javascript (ES6), 39 bytes

f=(n,i=0)=>n%++i?n>i&&f(n,i):1+f(n/i,i)

Provavelmente existem alguns bytes que podem ser salvos aqui e ali. Apenas usa o algoritmo ganancioso para os fatores.

— vrugtehagel
fonte
2

Geléia , 9 bytes

ŒPP=³ƊƇẈṀ

Experimente online!

-1 byte graças a alguém

-2 bytes graças a ErikTheOutgolfer

— HyperNeutrino
fonte
Enquanto preparava uma entrada para o superseeker OEIS, eu criei um programa Jelly provável golfable 11 bytes (que usa uma abordagem diferente), e estou pouco provável para postar uma resposta Jelly então eu vou fingir que eu golfed um byte da sua solução: ÆE×8‘½’:2S‘(-lo funciona com o poder da seção "fórmula" da OEIS para A003056). Isenção de responsabilidade: pode estar errado, mas funciona nos casos de teste.
— meu pronome é monicareinstate
Parece não terminar com 1099511627776
— Anush 2/19/19
@someone não funciona para 36 mas graças
— HyperNeutrino
@Anush sim, é realmente lento porque eu código golfed-lo, não otimizado para eficiência
— HyperNeutrino
1
Você pode remover ÆD, não é como se houvesse mais partições que serão criadas dessa maneira, só levaria muito mais tempo (o tempo limite para \ $ x \ ge21 \ $). x≥21 ).
— Erik the Outgolfer
2

Braquilog , 8 bytes

f;?⟨⊇×⟩l

Experimente online!

(A abordagem ingênua {~×≠l}ᶠ⌉, gera um número infinito de soluções com 1s extras antes de eliminá-las e ≠, portanto, não termina. Na verdade, não é um problema, pois é para a mesma contagem de bytes!)

Leva a entrada através da variável de entrada e a saída através da variável de saída. O cabeçalho no TIO contém uma cópia da maior parte do código para mostrar qual é a lista de fatores, mas isso funciona perfeitamente sem ela. Como ⊇primeiro fornece sublistas maiores, esse predicado faz essencialmente o mesmo que a maioria das outras respostas, mas sem gerar e filtrar explicitamente o conjunto completo de potências dos fatores, graças ao retorno.

            The output
       l    is the length of
    ⊇       a sublist (the largest satisfying these constraints)
f           of the factors of
            the input
 ; ⟨  ⟩     which
     ×      with its elements multiplied together
  ?         is the input.
— String não relacionada
fonte
1

Gaia , 10 9 bytes

Π=
dz↑⁇(l

Experimente online!

Segue o mesmo "algoritmo" visto em outro lugar - filtre o conjunto de potência do divisor por mais tempo com o produto igual ao número e retorne seu comprimento.

	| helper function
Π=	| is prod(list)==n (implicit)?
	|
	| main function; implicitly takes n
dz	| divisor powerset (in decreasing order of size)
  ↑⁇	| filter by helper function
    (l	| take the first element and take the length (implicitly output)
— Giuseppe
fonte
0

Amêijoa , 15 bytes

p}_`nq#:;qQ@s~Q

Link TIO em breve (quando dennis puxa)

Basicamente, uma porta da solução 05AB1E da @ Emigna.

Explicação

                - Implicit Q = first input
p               - Print...
 }              - The last element of...
  _             - Sorted...
   `nq          - Lengths of... (map q => q.len)
           @s   - Items in powerset of
             ~Q - Proper divisors of Q
      #         - Where... (filter)
        ;q      - Product of subset
       :        - Equals...
          Q     - Q
— Skidsdev
fonte
0

C # (compilador interativo do Visual C #) , 54 bytes

int f(int n,int i=0)=>n%++i<1?1+f(n/i,i):n>i?f(n,i):0;

Usa a mesma abordagem que as respostas de @ vrugtehagel e @ JoKing.

Experimente online!

— Modalidade de ignorância
fonte
Supondo que eu implementei sua lógica corretamente, uma solução de 53 bytes (que não consegui me livrar da palavra-chave "return"): Experimente on-line!
— meu pronome é monicareinstate
1
@ alguém Alguém Obrigado, mas de acordo com a meta, as funções precisam ser reutilizáveis . Além disso, não sei se é aceitável que declarações fora da função deixem um ponto-e-vírgula à direita, podendo fazer um meta post sobre isso.
— Modalidade de ignorância
0

Ruby , 34 bytes

Obviamente, atinge o tempo limite desse número massivo, mas eventualmente atingirá o tempo limite se houver tempo suficiente em outra máquina.

->n{(1..n).count{|e|n%e<1?n/=e:p}}

Experimente online!

— Value Ink
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.