Uma maneira de representar um número natural é multiplicando expoentes de números primos. Por exemplo, 6 podem ser representados por 2 ^ 1 * 3 ^ 1 e 50 podem ser representados por 2 ^ 1 * 5 ^ 2 (onde ^ indica exponência). O número de primos nessa representação pode ajudar a determinar se é mais curto usar esse método de representação, em comparação com outros métodos. Mas como não quero calculá-las manualmente, preciso de um programa para fazer isso por mim. No entanto, como terei que me lembrar do programa até chegar em casa, ele deve ser o mais curto possível.

Sua tarefa:

Escreva um programa ou função para determinar quantos primos distintos existem nessa representação de um número.

Entrada:

Um número inteiro n tal que 1 <n <10 ^ 12, obtido por qualquer método normal.

Resultado:

O número de primos distintos necessários para representar a entrada, conforme descrito na introdução.

Casos de teste:

24      -> 2 (2^3*3^1)
126     -> 3 (2^1*3^2*7^1)
1538493 -> 4 (3^1*11^1*23^1*2027^1)
123456  -> 3 (2^6*3^1*643^1)

Este é o OEIS A001221 .

Pontuação:

Isso é código-golfe , a menor pontuação em bytes ganha!

— Gryphon
fonte

3

Tantas perguntas importantes recentemente! Eu amo isso.

— Giuseppe

2

Relacionado

— Mr. Xcoder 8/17

3

A razão por trás do voto negativo pode ser sua trivialidade. Até onde pude ver, existem 3 situações em idiomas de golfe: 1. embutido 2. cadeia de dois embutidos 3. cadeia de 3 embutidos (eu pessoalmente tenho três respostas de 2 bytes); Eu não sei se isso é uma razão sólida para uma downvote, mas é uma possível causa

— Mr. Xcoder

1

Poderia ser, mas eu apreciaria se um dos três rebaixadores tivesse comentado me dizendo isso. Embora seja trivial em idiomas de golfe, existem algumas soluções interessantes em idiomas que não são de golfe, que eu queria ver quando publiquei esse desafio. Afinal, existem muitos desafios no site que são triviais para golflangs, mas produzem soluções interessantes que não são golflang.

— Gryphon

1

Seria benéfico incluir um prime nos casos de teste. Além disso, algumas linguagens / abordagens são difíceis de testar para grandes números. Alguns casos de teste menores seriam bons.

— Dennis

6

MATL , 4 3 bytes

-1 byte graças a Luis Mendo

YFz

Experimente online!

YF         Exponents of prime factors
  z        Number of nonzeros

Resposta original:

Yfun

Experimente online!

Uma Yfunresposta ver .

          (Implicit input)
Yf         Prime factorization
  u        Unique
   n       Numel
           (Implicit output)

— Giuseppe
fonte

1

Por que diversão? - ;-)

— Adám

1

Riscado 4 ainda é regular 4

— Gryphon

5

05AB1E , 2 bytes

^{outra resposta muito chata ...}

fg

Um programa completo que aceita uma entrada numérica e imprime o resultado

Experimente online!

Quão?

fg - implicitly take input
f  - get the prime factors with no duplicates
 g - get the length
   - implicit print

— Jonathan Allan
fonte

5

Mathematica, 7 bytes

PrimeNu

Sim, há um embutido.

Mathematica, 21 bytes

Length@*FactorInteger

O longo caminho.

— Misha Lavrov
fonte

Qual o motivo do asterisco? Não é Length@FactorIntegero mesmo?

— numbermaniac

1

Length@*FactorIntegerproduz uma função pura: a composição de Lengthe FactorInteger. Eu posso definir fun=Length@*FactorIntegere depois ligar fun[1001]. Por outro lado, Length@FactorIntegersignificaria Length[FactorInteger]e avaliaria 0.

— Misha Lavrov

5

Gaia , 2 bytes

^{Ainda outra resposta bastante chata ... --- J. Allan}

ḋl

Experimente online!

ḋ- Fatoração primária como pares [primos, expoentes] .
l - Comprimento.

— Mr. Xcoder
fonte

4

Python 2, 56 bytes

f=lambda n,p=2,k=1:n/p and[f(n,p+1),k+f(n/p,p,0)][n%p<1]

— orlp
fonte

Este é um porto da resposta de Dennis aqui por acaso?

— Jonathan Allan

1

@ JonathanAllan Sim, modificado para contar fatores primos únicos.

— orlp

4

Retina , 31 30 bytes

&`(?!(11+)\1+$)(11+)$(?<=^\2+)

A entrada está unária.

Obrigado a @MartinEnder pelo golfe de 1 byte!

Experimente online! (inclui conversor decimal para unário)

Como funciona

Como o programa consiste em uma única regex com o &modificador, o Retina simplesmente conta a quantidade de correspondências sobrepostas . Supõe-se que a entrada consiste em n repetições de 1 e nada mais.

O lookahead negativo

(?!(11+)\1+$)

partidas em locais entre 1 's que são não seguidos por duas ou mais 1 ' s ( 11+), seguido por uma ou mais repetições da mesma quantidade de 1 's ( \1+), seguindo-se a extremidade de entrada ( $).

Qualquer número composto ab com a, b> 1 pode ser escrito como b repetições de uma repetição de 1 ; portanto, o lookahead corresponde apenas a locais seguidos de p repetições de 1 , onde p = 1 ou p é primo.

O regex

(11+)$

torna-se p> 1 , exigindo que pelo menos dois 1 's ( 11+) e armazena a cauda de 1 está no segundo grupo de captura ( \2).

Finalmente, o olhar positivo por trás

(?<=^\2+)

verifica se a entrada inteira consiste em ocorrências de kp ( k ≥ 1 ) de 1 , verificando se p divide a entrada.

Assim, cada correspondência corresponde a um divisor principal exclusivo p .

— Dennis
fonte

4

Utilitários Bash + GNU, 33

1 byte salvo graças a @Dennis

factor|grep -Po ' \d+'|uniq|wc -l

Experimente online .

Explicação

factor|                            # Split input into prime factors
       grep -Po ' \d+'|            # group factors onto lines
                       uniq|       # remove duplicates
                            wc -l  # count the lines

— Trauma Digital
fonte

1

grep -Po ' \d+'salva um byte tr \ \\n|sed 1d.

— Dennis

Infelizmente, grep -Po '( \d+)\1*'falha na entrada 46 .

— Dennis

@ Dennis graças - Eu fixo-lo usando a sua sugestão original

— Trauma Digital

3

Geléia , 3 bytes

^{uma resposta bastante chata ...}

ÆFL

Um link monádico pegando um número e retornando um número

Experimente online!

Quão?

ÆFL - Link: number, n
ÆF  - prime factorisation as a list of prime, exponent pairs
  L - length

— Jonathan Allan
fonte

1

Como você perdeu Æv?

— meu pronome é monicareinstate

Foi fácil - nunca usei isso e não procurei na lista no wiki.

— Jonathan Allan

Como você digita caracteres de geléia sem lista de átomos e lista rápida?

— meu pronome é monicareinstate

1. Æé o código alt 0198. 2. Você pode configurar um teclado (não o tenho). 3. A página de código.

— Jonathan Allan

3

Ohm v2 , 2 bytes

ml

Experimente online!

Os dois built-ins estão próximos um do outro na documentação lol.

— totalmente humano
fonte

3

Gelatina , 2 bytes

^{Ainda outra resposta bastante chata ... --- J. Allan}

Æv

Experimente online!

Um embutido.

— Mr. Xcoder
fonte

3

Alice , 10 bytes

/o
\i@/Dcd

Experimente online!

Explicação

/o
\i@/...

Essa é apenas a estrutura padrão para programas aritméticos pesados lineares que precisam de E / S decimal. O programa atual é então apenas:

Dcd

O que faz:

D    Deduplicate prime factors. Does what it sounds like: for every p^k which
     is a divisor n, this divides n by p^(k-1).
c    Push the individual prime factors of n. Since we've deduplicated them
     first, the number of factors is equal to the value we're looking for.
d    Push the stack depth, i.e. the number of unique prime factors.

— Martin Ender
fonte

3

JavaScript 45 bytes

* Para o @SEJPM, solicite uma explicação: o que estou fazendo aqui é passar de 2 - n (que muda e, eventualmente, será o maior fator primordial) - agora, se a divisão do número atual ni quiser contar apenas uma vez (mesmo embora possa ser um fator de 2 * 2 * 2 * 3-2 é contado uma vez) - então o "j" aparece na imagem, quando j não é especificado na chamada da função - j receberá o valor de " undefined ", e quando n% i == 0, chamo a função com j = 1 na próxima chamada) - e adiciono apenas 1 quando j é igual a undefined, que é! j + Function (n / i, i, ( j = 1 ou apenas 1)). não mudo i nesse assunto, pois ainda pode ser divisível por i novamente (2 * 2 * 3), mas j será igual a 1 e não será considerado um fator. Espero que eu tenha explicado bem o suficiente.

P=(n,i=2,j)=>i>n?0:n%i?P(n,i+1):!j+P(n/i,i,1)

console.log(P(1538493)==4);
console.log(P(24)==2);
console.log(P(126)==3);
console.log(P(123456)==3);

Expandir snippet

Se o último primo for muito grande, ele terá uma pilha máxima de chamadas - se for um problema, eu posso criar um iterativo

— DanielIndie
fonte

Você se importaria de escrever uma explicação para esta resposta? Parece usar uma abordagem usual do restante das respostas.

— SEJPM

@SEJPM eu adicionei algumas explicações lá

— DanielIndie 8/17/17

1

Para sua informação, podemos assumir pilhas de chamadas infinitas / recursos infinitos para a maioria dos desafios do código-golfe (basicamente, a menos que a pergunta indique o contrário).

— Jonathan Allan

3

CJam , 7 5 bytes

Obrigado a Martin Ender por 2 bytes de desconto!

{mF,}

Bloco anônimo (função) que espera o número de entrada na pilha e o substitui pelo número de saída.

Experimente online! Ou verifique todos os casos de teste .

Explicação

{   }   e# Define block
 mF     e# List of (prime, exponent) pairs
   ,    e# Length

— Luis Mendo
fonte

3

Braquilog , 3 bytes

ḋdl

Experimente online!

Explicação

ḋ      Prime decomposition
 d     Remove duplicates
  l    Length

— Fatalizar
fonte

2

Pitão, 3 bytes

l{P

Suíte de teste

Comprimento ( l) do conjunto ( {) de fatores primos ( P) da entrada.

— isaacg
fonte

2

Casca , 3 bytes

Lup

Experimente online!

Explicação

  p  -- prime factors
 u   -- unique elements
L    -- length

— ბიმო
fonte

2

Na verdade , 2 bytes

^{Ainda outra resposta bastante chata ... --- J. Allan}

yl

Experimente online!

O primeiro caractere pode ser substituído por w.

— Mr. Xcoder
fonte

Isso é o suficiente, cara ...: P

— totallyhuman 8/17

@icrieverytim prometo esta é minha última golfe -language resposta (eu só tenho 4: P)

— Mr. Xcoder

2

Pyke , 3 bytes

P}l

Experimente aqui!

— Mr. Xcoder
fonte

2

Python 3 , 68 67 bytes

1 byte removido graças a @ Mr.Xcoder

lambda n:sum(n%k<all(k%j for j in range(2,k))for k in range(2,n+1))

Isso expira nos maiores casos de teste. Experimente online!

— Luis Mendo
fonte

67 bytes

— Sr. Xcoder 8/17

2

Números R +, 30 14 bytes

16 bytes removidos graças a @Giuseppe

numbers::omega

Além disso, aqui está o Experimente online !! link para @ Giuseppe.

— Joseph Wood
fonte

Você pode omitir o f=function(x)eo (x)quanto numbers::omegaé uma função já. No entanto, como numbersnão é padrão para R, você deve responder "números R +". Além disso, você deve incluir um link TIO . Ainda assim, +1, muito bom.

— Giuseppe

@ Giuseppe, você é muito legal. Obrigado pela ajuda. BTW, além de algumas de suas respostas perspicazes, consultei Dicas para jogar golfe no R , como você sugeriu. Existem algumas verdadeiras jóias lá. Qualquer pessoa, atualizarei minha resposta com suas recomendações. Além disso, sua MATLsolução é muito boa (+1 ontem).

— 9757 Joseph Wood

NP, sinta-se à vontade para me enviar um bate-papo ou comentar uma resposta minha, se você tiver perguntas.

— Giuseppe

@ Giuseppe, existe um meta consenso sobre a necessidade de declarar explicitamente "números R +"? Parece que se declararmos o pacote adicional, poderemos salvar os bytes de chamá-lo explicitamente numbers::. Caso contrário, para mim é o mesmo que usar um importem qualquer outro idioma.

— BLT

(rola para baixo e vê um exemplo em python disso ...) Acho que estou pensando em um meta consenso mais amplo, então. Isso meio que parece bobagem para mim.

— BLT

1

Convexo , 3 bytes

mF,

Experimente online!

— GamrCorps
fonte

1

Pari / GP , 5 bytes

Não sei por que é chamado nu no Mathematica, mas ômega no Pari / GP.

omega

Experimente online!

— alefalpha
fonte

1

Haskell , 58 bytes

-4 bytes graças a @Laikoni

f n=sum[1|x<-[2..n],gcd x n>1,all((>)2.gcd x)[2..x-1]]

Experimente online!

Explicação

Essencialmente, gera todos os números primos no máximo ne os filtra por serem um fator de n e, em seguida, leva a duração do resultado.

f n=                                                   -- main function
    sum[                                             ] -- output the length of the list
        1|x<-[2..n],                                   -- consider all potential primes <=n
                                                       -- and insert 1 into the list if predicates are satisfied
                    gcd x n>1,                         -- which are a factor of n
                              all(          )[2..x-1]  -- and for which all smaller numbers satisfy
                                  (>)2.                -- 2 being larger than
                                       gcd x           -- the gcd of x with the current smaller number

— SEJPM
fonte

Você pode usar em sum[1|x<- ... ]vez de length.

— Laikoni

1

Japt, 5 4 bytes

â èj

Tente

Obtenha os divisores ( â) e conte ( è) os primos ( j).

— Shaggy
fonte

1

ARBLE , 28 bytes

len(unique(primefactors(n)))

Experimente online!

Esta é uma solução muito literal

— ATaco
fonte

Eu estava olhando para isso e dizendo "Ei, espere um minuto, isso é um trecho!" E então eu vejo ... isso deveria ser uma linguagem não esotérica com E / S implícita ?!

— totallyhuman

@icrieverytim Parabéns, você descobriu um dos principais motivos pelos quais esse idioma existe.

— ATaco

0

Dyalog APL , 17 bytes

⎕CY'dfns'
≢∪3pco⎕

Experimente online!

— Uriel
fonte

0

Python 2 , 63 55 bytes

^{Uma resposta muito mais interessante ...}

-8 bytes graças a Jonathan Frech (use um argumento com um padrão para o pós-ajuste do resultado de primos de 0para 1- muito melhor que um lambda de empacotamento !!)

f=lambda n,o=1:sum(n%i+f(i,0)<1for i in range(2,n))or o

Uma função recursiva que pega um número inteiro positivo ne retorna um número inteiro positivo, a contagem.

Experimente online! Realmente ineficiente, nem se preocupe com os outros casos de teste.

— Jonathan Allan
fonte

55 bytes .

— Jonathan Frech

@ JonathanFrech Obrigado, isso é muito mais limpo.

— Jonathan Allan

0

J, 12 bytes

{:@$@(__&q:)

q:é a função de expoentes primários de J, fornecendo a ele o argumento que __produz uma matriz cuja primeira linha é todos os fatores primos diferentes de zero e cuja segunda linha é seus expoentes.

Tomamos a forma $dessa matriz - linhas por colunas - o número de colunas é a resposta que buscamos.

{: nos fornece o último item desses dois itens (num linhas, num colunas) e, portanto, a resposta.

Experimente online!

— Jonah
fonte

0

Java (OpenJDK 9) , 67 bytes

n->{int c=0,p=1;for(;p<n;)if(n%++p<1)for(c++;n%p<1;n/=p);return c;}

Experimente online!

— Olivier Grégoire
fonte

0

Javascript ES6, 56 caracteres

n=>eval(`for(q=2,r=0;q<=n;++q)n%q||(n/=q,r+=!!(n%q--))`)

Teste:

f=n=>eval(`for(q=2,r=0;q<=n;++q)n%q||(n/=q,r+=!!(n%q--))`)
console.log([24,126,1538493,123456].map(f)=="2,3,4,3")

Expandir snippet

— Qwertiy
fonte

Quantos números primos exclusivos?

Sua tarefa:

Entrada:

Resultado:

Casos de teste:

Pontuação:

MATL , 4 3 bytes

05AB1E , 2 bytes

Quão?

Mathematica, 7 bytes

Mathematica, 21 bytes

Gaia , 2 bytes

Python 2, 56 bytes

Retina , 31 30 bytes

Como funciona

Utilitários Bash + GNU, 33

Explicação

Geléia , 3 bytes

Quão?

Ohm v2 , 2 bytes

Gelatina , 2 bytes

Alice , 10 bytes

Explicação

JavaScript 45 bytes

CJam , 7 5 bytes

Explicação

Braquilog , 3 bytes

Explicação

Pitão, 3 bytes

Casca , 3 bytes

Explicação

Na verdade , 2 bytes

Pyke , 3 bytes

Python 3 , 68 67 bytes

Números R +, 30 14 bytes

Convexo , 3 bytes

Pari / GP , 5 bytes

Haskell , 58 bytes

Japt, 5 4 bytes

ARBLE , 28 bytes

Dyalog APL , 17 bytes

Python 2 , 63 55 bytes

J, 12 bytes

Java (OpenJDK 9) , 67 bytes

Javascript ES6, 56 caracteres