Recupere o primo do poder primo

13

Definição : uma potência primária é um número natural que pode ser expresso na forma p n, em que p é uma primária e n é um número natural.

Tarefa : Dada uma potência primária p n > 1, retorne a prime p.

Casos de teste :

input output
9     3
16    2
343   7
2687  2687
59049 3

Pontuação : Este é o código-golfe . A resposta mais curta em bytes vence.

code-golf  arithmetic  primes  king-of-the-hill  python  board-game  code-golf  number  subsequence  code-golf  ascii-art  code-golf  array-manipulation  decision-problem  grid  fastest-algorithm  logic-gates  logic  code-golf  cards  code-golf  rational-numbers  code-golf  math  number  sequence  code-golf  array-manipulation  integer  code-golf  number  array-manipulation  code-golf  number  sequence  decision-problem  code-golf  ascii-art  number  code-challenge  sequence  arithmetic  sorting  code-golf  date  fastest-algorithm  code-golf  string  number  random  combinatorics  code-golf  combinatorics  code-golf  ascii-art  base-conversion  code-golf  array-manipulation  code-golf  string  code-golf  string  number  arithmetic  code-golf  kolmogorov-complexity  code-golf  string  array-manipulation  json  code-golf  puzzle-solver  code-golf  binary  graph-theory  code-golf  arithmetic  haskell  code-golf  string  cipher  code-golf  code-golf  string  parsing  alphabet  code-golf  string  code-golf  ascii-art  code-golf  string  number  code-golf  string  balanced-string 
— Freira Furada
fonte
1
Pode nser 1?
— user202729
@ user202729: No quarto caso de teste n = 1.
— Emigna
15
Talvez tivesse sido mais desafiador obter a parte do poder do que a parte principal. Do jeito que está, isso é apenas "Obtenha o fator mais baixo que não é 1"
— Jo King

Respostas:

7

Java 8, 46 39 37 bytes

n->{int r=1;for(;n%++r>0;);return r;}

-7 bytes indiretamente, graças a @Tsathoggua .
-2 bytes graças ao JoKing

Experimente online.

Explicação:

n->{               // Method with integer as both parameter and return-type
  int r=1;         //  Start the result-integer `r` at 1
  for(;n%++r>0;);  //  Increase `r` by 1 before every iteration with `++r`
                   //  and loop until `n` is divisible by `r`
  return r;}       //  After the loop, return `r` as result
— Kevin Cruijssen
fonte
Seguindo a resposta de Luis Mendo em python3 , seria possível escrever n->{for(int i=1;++i<=n;)if(n%i<1)return i;}para obter 43 caracteres? (Eu não falo Java.)
— Tsathoggua
@Tsathoggua Como você está agora, não, pois os métodos Java sempre devem ter um retorno. n->{for(int i=1;++i<=n;)if(n%i<1)return i;return n;}funcionaria, mas infelizmente é mais longo. No entanto, o Java pode ter um único retorno em loops infinitos, o que realmente salva bytes, então obrigado! n->{for(int i=1;;)if(n%++i<1)return i;}. Como ise tornará neventualmente (como no caso de teste 2687) e n%n==0, i<=nnão é necessário neste caso.
— Kevin Cruijssen
1
Que tal 37 bytes . Eu sou o suficiente para não familiarizado com Java para ver se algum mais pode ser golfed
— Jo rei
@ JoKing Não vejo nada para jogar mais, então obrigado pelo -2.
— 21718 Kevin Kurtzssen
5

Python 3 , 36 35 bytes

-1 byte graças a mathmandan

f=lambda n,x=2:n%x and f(n,x+1)or x

Experimente online!

Função recursiva que encontra o primeiro fator maior que 1

— Brincadeira
fonte
1
Agradável. Você pode (geralmente) salvar um byte se substituir if/elsepor and/or. Como f=lambda n,x=2:n%x and f(n,x+1)or x,.
— mathmandan
4

Espaço em branco , 80 61 60 bytes

[S S T  T   N
_Push_-1][S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_number][N
S S N
_Create_Label_LOOP][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][S S S N
_Push_0][T  T   T   _Retrieve][S N
T   _Swap][T    S T T   _Modulo][N
T   T   N
_If_0_Jump_to_Label_LOOP][S S T T   N
_Push_-1][T S S N
_Multiply][T    N
S T _Print_as_number]

-20 bytes graças a @JoKing .

Letras S(espaço), T(guia) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-código:

Integer n = STDIN as integer
Integer i = -1
Start LOOP:
  i = i - 1
  if(n modulo-i is negative)
    Go to next iteration of LOOP
  else
    i = i * -1
    Print i
    Exit with error: No exit defined

Exemplo de execução: input = 9

Command   Explanation                    Stack        Heap     STDIN    STDOUT    STDERR

SSTTN     Push -1                        [-1]
SSSN      Push 0                         [-1,0]
TNTT      Read STDIN as integer          [-1]         {0:9}    9
NSSN      Create Label_LOOP              [-1]         {0:9}
 SSSTN    Push 1                         [-1,1]       {0:9}
 TSST     Subtract top two (-1-1)        [-2]         {0:9}
 SNS      Duplicate top (-2)             [-2,-2]      {0:9}
 SSSN     Push 0                         [-2,-2,0]    {0:9}
 TTT      Retrieve                       [-2,-2,9]    {0:9}
 SNT      Swap top two                   [-2,9,-2]    {0:9}
 TSTT     Modulo top two (9%-2)          [-2,-1]      {0:9}
 NTSN     If neg.: Jump to Label_LOOP    [-2]         {0:9}

 SSTTN    Push -1                        [-2,-1]      {0:9}
 TSST     Subtract top two (-2-1)        [-3]         {0:9}
 SNS      Duplicate top (-2)             [-3,-3]      {0:9}
 SSSN     Push 0                         [-3,-3,0]    {0:9}
 TTT      Retrieve                       [-3,-3,9]    {0:9}
 SNT      Swap top two                   [-3,9,-3]    {0:9}
 TSTT     Modulo top two (9%-3)          [-3,0]       {0:9}
 NTSN     If neg.: Jump to Label_LOOP    [-3]         {0:9}
 SSTTN    Push -1                        [-3,-1]      {0:9}
 TSSN     Multiply top two (-3*-1)       [3]          {0:9}
 TNST     Print as integer               []           {0:9}             3
                                                                                  error

O programa para com um erro: Nenhuma saída encontrada.

— Kevin Cruijssen
fonte
1
Você precisa do i == ncheque? n%nseria 0 de qualquer maneira
— Jo King
@ JoKing Ah, é claro. Obrigado, 19 bytes salvos ali. :)
— Kevin Cruijssen
Você só poderia fazer um loop, se não, n%ie ligar para a impressão depois?
— Jo rei
1
@JoKing Tenho certeza que não. O espaço em branco não possui realmente loops, apenas salta para os rótulos. As únicas três opções que tenho é: 1. pular para um determinado rótulo incondicionalmente; 2. pule para um determinado rótulo se o topo da pilha for 0; 3. pule para um determinado rótulo se o topo da pilha for negativo. Infelizmente, não há um "salto para rotular se positivo" para continuar o loop. Eu poderia conseguir isso multiplicando por -1 antes de procurar por negativo, mas duvido que seja mais curto.
— Kevin Cruijssen
1
Tentei fazer isso com um módulo negativo e acabei em <s> 62 </s> 60 bytes (yay). Acontece que você não pode armazenar em endereços heap negativos (embora 0 salvo um par de bytes)
— Jo rei
2

Quarto (gforth) , 34 bytes

: f 1 begin 1+ 2dup mod 0= until ;

Experimente online!

Explicação

  1. Iterar números inteiros a partir de 2
  2. Pare e retorne quando encontrar um que divide n sem deixar resto

Código Explicação

: f               \ Define a new word
  1               \ place a 1 on the stack (to use as a counter/index)
  begin           \ start indefinite loop
    1+ 2dup       \ increment counter and duplicate counter and prime power
    mod           \ calculate power % index
  0= until        \ end the loop if modulus is 0 (no remainder)
;                 \ end word definition
— reffu
fonte
1

Neim , 1 byte

𝐔

Experimente online!

— Okx
fonte
U + 1D414 é um caractere, mas em UTF-8 e UTF-16 isso é representado por 4 bytes.
— Ruud Helderman
1
@RuudHelderman Correto, mas isso não está no UTF-8 nem no UTF-16.
— Okx
1
@RuudHelderman Você pode querer ver a página de códigos Neim .
— JungHwan Min
@JungHwanMin Thanks; navegando pelos envios anteriores de Okx ao Neim, notei que minha reação um pouco ignorante não foi a primeira. Funcionalidade inteligente, mas longe de ser óbvia; justifica a explicação (como feito aqui ). Citando informações da tag code-golf : "A menos que a pergunta seja especificada para ser pontuada por caracteres, ela será pontuada por bytes. Se não especificar uma codificação de caracteres a ser usada na pontuação, as respostas que usam pontos de código Unicode fora de 0 a 255 devem indique a codificação usada ".
— Ruud Helderman
@RuudHelderman por meta consenso , se uma resposta não especificar uma codificação, o padrão será a codificação padrão do idioma. Se isso não existir, é UTF-8. Nesse caso, o Neim tem uma codificação padrão definida, portanto, é assumida a codificação da resposta, sem que o respondente precise explicar como tal.
— JungHwan Min
1

Mathematica, 17 bytes

Divisors[#][[2]]&

O segundo menor divisor.

— u54112
fonte
0

PowerShell , 31 bytes

param($a)(2..$a|?{!($a%$_)})[0]

Experimente online!

Constrói um intervalo de 2entrada $a, puxa esses elementos where( ?), a operação do módulo %resulta em um zero !(...)(ou seja, aqueles que são divisores de $a) e, em seguida, leva o menor [0]deles. Isso é deixado no pipeline, a produção está implícita.

— AdmBorkBork
fonte
0

Perl 6 , 22 bytes

{grep($_%%*,2..$_)[0]}

Experimente online!

Bloco de código anônimo que filtra os fatores do intervalo de 2 na entrada e retorna o primeiro. Eu tentei usar ^$para salvar 2 bytes, mas isso não funcionou no caso em que a entrada era prime.

— Brincadeira
fonte
0

Visual Basic .NET (.NET Framework v4.5), 123 71 bytes

-52 bytes graças a @Jo King

Function A(n)
For i=n To 2 Step-1
A=If(n Mod i=0,i,A)
Next
End Function

Experimente online!

Ungolfed:

Function A(input As Long) As Long
    For i = input To 2 Step -1
        A = If (input Mod i = 0, i, A)
    Next
End Function

Explicação:

O iloop pesquisa para trás a partir do primeiro número e encontra todos os números que o dividem igualmente. Como estamos indo para trás, o menor é armazenado no valor variável A.

O VB fornece uma variável livre que corresponde ao nome da sua função (no meu caso A). No final da execução da função, o valor nessa variável é retornado (exceto uma Returninstrução explícita .

— Brian J
fonte
1
Você não precisa do cheque principal. O menor fator de um número (diferente de 1) é garantido para ser um primo, caso contrário não seria um fator menor
— Jo rei
@JoKing D'oh! Claro, não acredito que perdi isso. Obrigado!
— Brian J
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.