Recupera il primo dal potere principale

13

Definizione : un potere primo è un numero naturale che può essere espresso nella forma p n dove p è un numero primo e n è un numero naturale.

Compito : data una potenza primaria p n > 1, restituisce la p principale.

Test :

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

Punteggio : questo è code-golf . Vince la risposta più breve in byte.

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 
— Perdente Suora
fonte
1
Può nessere 1?
— user202729
@ user202729: nel quarto caso di test n = 1.
— Emigna,
15
Forse sarebbe stato più difficile ottenere la parte di potere invece della parte principale. Così com'è, questo è solo "Ottieni il fattore più basso che non è 1"
— Jo King,

Risposte:

7

Java 8, 46 39 37 byte

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

-7 byte indirettamente grazie a @Tsathoggua .
-2 byte grazie a JoKing

Provalo online.

Spiegazione:

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
Seguendo la risposta di Luis Mendo in python3 , sarebbe possibile scrivere n->{for(int i=1;++i<=n;)if(n%i<1)return i;}per ottenere 43 caratteri? (Non parlo Java.)
— Tsathoggua,
@Tsathoggua Dato che non ce l'hai proprio ora, poiché i metodi Java devono sempre avere un ritorno. n->{for(int i=1;++i<=n;)if(n%i<1)return i;return n;}funzionerebbe, ma purtroppo è più lungo. Java può comunque avere un singolo ritorno in infiniti loop, il che in effetti fa risparmiare byte, quindi grazie! n->{for(int i=1;;)if(n%++i<1)return i;}. Poiché alla fine idiventerà n(come nel caso del test 2687) e n%n==0, i<=nin questo caso non è richiesto.
— Kevin Cruijssen,
1
Come circa 37 byte . Non ho abbastanza familiarità con Java per vedere se è possibile giocare a golf
— Jo King,
@JoKing Non vedo più nulla per giocare a golf, quindi grazie per il -2.
— Kevin Cruijssen,
5

Python 3 , 36 35 byte

-1 byte grazie a mathmandan

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

Provalo online!

Funzione ricorsiva che trova il primo fattore maggiore di 1

— Jo King
fonte
1
Bello. Puoi (di solito) salvare un byte se lo sostituisci if/elsecon and/or. Come f=lambda n,x=2:n%x and f(n,x+1)or x.
— Mathmandan,
4

Spazio bianco , 80 61 60 byte

[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 byte grazie a @JoKing .

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

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

Esempio di esecuzione: 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

Il programma si interrompe con un errore: nessuna uscita trovata.

— Kevin Cruijssen
fonte
1
Hai bisogno i == ndell'assegno? n%nsarebbe 0 comunque
— Jo King il
@JoKing Ah, certo. Grazie, 19 byte salvati proprio lì. :)
— Kevin Cruijssen,
Potresti solo fare un ciclo in caso contrario n%ie chiamare la stampa in seguito?
— Jo King,
1
@JoKing Sono abbastanza sicuro di no. Lo spazio bianco in realtà non ha loop, ha solo salti alle etichette. Le uniche tre opzioni che ho sono: 1. passare a una determinata etichetta incondizionatamente; 2. passa a una determinata etichetta se la parte superiore della pila è 0; 3. passa a una determinata etichetta se la parte superiore della pila è negativa. Sfortunatamente non c'è un "salto per etichettare se positivo" per continuare il ciclo. Potrei farlo moltiplicando per -1 prima di verificare la presenza di negativi, ma dubito che sarà più breve.
— Kevin Cruijssen,
1
Ho provato a farlo con un modulo negativo ed è finito a <s> 62 </s> 60 byte (yay). Si scopre che non è possibile memorizzare in indirizzi heap negativi (anche se 0 ha salvato un paio di byte)
— Jo King,
4

Ottava , 16 byte

@(x)factor(x)(1)

Provalo online!

Spiegazione:

@(x)              % Anonymous function taking x as input
    factor(x)     % Prime factorization
             (1)  % Get the first element

O: 

@(x)max(factor(x))  % the makeup of makeup artists
— Stewie Griffin
fonte
1
+1 per il fattore massimo
— Brain Guider,
2

Forth (gforth) , 34 byte

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

Provalo online!

Spiegazione

  1. Iterare numeri interi a partire da 2
  2. Fermati e ritorna quando ne trovi uno che divide n senza resto

Spiegazione del codice

: 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

𝐔

Provalo online!

— Okx
fonte
U + 1D414 è un carattere, ma in UTF-8 e UTF-16 questo è rappresentato da 4 byte.
— Ruud Helderman,
1
@RuudHelderman Corretto, ma questo non è in UTF-8 né UTF-16.
— Okx,
1
@RuudHelderman Potresti voler vedere la codepage di Neim .
— JungHwan Min,
@JungHwanMin Grazie; sfogliando le precedenti osservazioni Neim di Okx, ho notato che la mia reazione leggermente ignorante non è stata la prima. Funzionalità intelligente, ma tutt'altro che ovvia; richiede una spiegazione (come fatto qui ). Citando le informazioni sui tag golf-code : "A meno che la domanda non sia specificata per essere segnata dai caratteri, viene segnata dai byte. Se non specifica una codifica dei caratteri da utilizzare per il punteggio, le risposte che utilizzano punti di codice Unicode da 0 a 255 dovrebbero indica la codifica utilizzata. "
— Ruud Helderman,
@RuudHelderman per meta consenso , se una risposta non specifica una codifica, viene impostata automaticamente la codifica predefinita della lingua. Se ciò non esiste, allora è UTF-8. In questo caso, Neim ha una codifica predefinita definita, quindi si presume che sia la codifica della risposta, senza che il rispondente debba spiegare come tale.
— JungHwan Min,
1

Mathematica, 17 byte

Divisors[#][[2]]&

Il secondo divisore più piccolo.

— per Monica
fonte
1

R , 32 26 byte

@Giuseppe con logica diversa e una soluzione più breve:

(x=2:(n=scan()))[!n%%x][1]

Provalo online!

Originale:

numbers::primeFactors(scan())[1]

Provalo online!

Questa è ovviamente una porta molto superiore della soluzione 05AB1E .

— ngm
fonte
0

PowerShell , 31 byte

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

Provalo online!

Costruisce un intervallo da 2a input $a, estrae quegli elementi where( ?) l'operazione modulo %risulta in uno zero !(...)(cioè quelli di cui sono divisori $a), e quindi prende il più piccolo di [0]esso. Rimane in cantiere, l'output è implicito.

— AdmBorkBork
fonte
0

Perl 6 , 22 byte

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

Provalo online!

Blocco di codice anonimo che filtra i fattori dell'intervallo 2 sull'input e restituisce il primo. Ho provato a utilizzare ^$per salvare 2 byte, ma non ha funzionato nel caso in cui l'input fosse primo.

— Jo King
fonte
0

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

-52 byte grazie a @Jo King

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

Provalo 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

Spiegazione:

Il iciclo cerca indietro dal primo numero e trova tutti i numeri che lo dividono in modo uniforme. Poiché stiamo andando indietro, il più piccolo viene archiviato nel vairableA .

VB ti dà una variabile gratuita che corrisponde al nome della tua funzione (nel mio caso, A). Alla fine dell'esecuzione della funzione, viene restituito il valore in quella variabile (salvo un'istruzione esplicita Return.

— Brian J
fonte
1
Non è necessario il controllo primo. Il fattore più piccolo di un numero (diverso da 1) è garantito per essere un numero primo, altrimenti ci sarebbe un fattore più piccolo
— Jo King
@JoKing D'oh! Certo, non posso credere che mi sia perso. Grazie!
— Brian J,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.