Non sono abbastanza per te?


29

Sfondo:

L'attuale sfida dei numeri perfetti è piuttosto imperfetta e complicata, poiché ti chiede di produrre in un formato complesso che coinvolga i fattori del numero. Questo è un ripubblicare puramente un della sfida.

Sfida

Dato un numero intero positivo attraverso qualsiasi formato di input standard , distinguere se è perfetto o meno.

Un numero perfetto è un numero che è uguale alla somma di tutti i suoi divisori propri (i suoi divisori positivi meno di se stesso). Ad esempio, è un numero perfetto, poiché i suoi divisori sono , che si sommano a , mentre non è un numero perfetto poiché i suoi divisori ( ) si sommano a , non .61,2,36121,2,3,4,61612

Casi test:

Imperfect:
1,12,13,18,20,1000,33550335

Perfect:
6,28,496,8128,33550336,8589869056

Regole

  • Il tuo programma non deve completare i casi di test più grandi, se ci sono vincoli di memoria o di tempo, ma dovrebbe essere teoricamente in grado di ottenere più memoria / tempo.
  • L'output può essere due valori distinti e coerenti attraverso qualsiasi formato di output consentito . Se non è immediatamente ovvio ciò che rappresenta Perfect / Imperfect, assicurati di specificare nella tua risposta.

Aspetta, quindi la verità è per i valori che non sono perfetti, e la falsità è per i valori che sono?
Esolanging Fruit

2
@ Tvde1 I divisori appropriati devono essere inferiori al numero, altrimenti nessun numero diverso da quello 1sarebbe perfetto, poiché ogni numero è divisibile per 1se stesso. La somma dei veri divisori di 1è0
Jo King

3
@Grimy Solo se puoi dimostrarlo . In bocca al lupo! (anche se mi chiedo come ciò salverebbe i byte)
Jo King

1
Quindi no, peccato. Ridurrebbe le dimensioni di una risposta regex ECMA di un fattore di circa 3.
Grimmy

3
"L'output può essere due valori distinti e coerenti" - qui non possiamo usare "verità contro falsità" (ad es. Per Python che usa zero contro non zero; un elenco con contenuto vs un elenco vuoto; e loro combinazioni)?
Jonathan Allan,

Risposte:



9

Neim , 3 byte

𝐕𝐬𝔼

Provalo online!

(In realtà non so come eseguire tutti i casi di test contemporaneamente, da quando ho iniziato a studiare Neim circa quindici minuti fa, ma li ho controllati singolarmente.)

Stampa 0 per imperfetto, 1 per perfetto.

𝐕      Pop an int from the stack and push its proper divisors,
       implicitly reading the int from a line of input as the otherwise absent top of the stack.
 𝐬     Pop a list from the stack and push the sum of the values it contains.
  𝔼    Pop two ints from the stack and push 1 if they are equal, 0 if they are not;
       implicitly reading the same line of input that was already read as the second int, I guess?
       Implicitly print the contents of the stack, or something like that.

2
" Immagino? "; " o qualcosa del genere. ". Quando non sei nemmeno sicuro di quello che hai scritto, ahah. ;) Ma sì, è davvero così che funziona. Non conosco Neim, ma usare implicitamente quell'input e produrre implicitamente la fine implicitamente alla fine, è simile in 05AB1E.
Kevin Cruijssen,

Come è 𝔼1 byte? Neim usa solo 128 di questi personaggi non standard?
Kajacx,

3
@kajacx Neim ha una sua tabella codici . Pertanto, ciascuno dei 256 caratteri presenti nella tabella codici può essere codificato utilizzando 1 byte.
Mr. Xcoder,

8

R , 33 29 byte

!2*(n=scan())-(x=1:n)%*%!n%%x

Provalo online!

Restituisce TRUEper numeri perfetti e FALSEper quelli imperfetti.


Cosa ti danno i 2! S di fila?
CT Hall

@CTutto ho letto male le specifiche; hanno originariamente mappato 0(perfetto) su FALSEe diverso da zero TRUEma ne ho rimosso uno per invertire la mappatura. E 'un trucco utile per il golf cast numerica logical, spesso in collaborazione con whicho [.
Giuseppe,


7

Japt -! , 4 byte

¥â¬x
-----------------
            Implicit Input U
¥           Equal to
   x        Sum of
 â          Factors of U
  ¬         Without itself

Per qualche motivo non ¦funziona su tio, quindi ho bisogno di usare la -!bandiera e ¥invece

Provalo online!


Non è un problema TIO; Unon viene inserito automaticamente prima !.
Shaggy

6

Python 3 , 46 byte

lambda x:sum(i for i in range(1,x)if x%i<1)==x

Provalo online!

Forza bruta, somma i fattori e verifica l'uguaglianza.


2
L'uso della condizione di comprensione come maschera per la variabile di iterazione salverebbe un byte.
Jonathan Frech,

Dal momento che è possibile restituire la verità per un numero imperfetto, lambda x:sum(i for i in range(1,x)if x%i<1)^xdovrebbe funzionare anche.
nedla2004,

5

Python , 45 byte

lambda n:sum(d*(n%d<1)for d in range(1,n))==n

Trueper perfetto; Falseper gli altri (cambia questo con ==-> !=)

Provalo online!

 44 42  41 byte (-2 grazie a ovs) se potessimo emettere usando "verità contro falsa":

f=lambda n,i=1:i/n or-~f(n,i+1)-(n%i<1)*i

(falsey ( 0)) per perfetto; verità (un numero intero diverso da zero) altrimenti


Se il secondo formato di output è valido, è possibile farlo in 42 byte .
lunedì

@ovs ah, ben fatto.
Jonathan Allan,

@ovs ..e un altro salvato da quello - grazie!
Jonathan Allan,

5

Ottava , 25 byte

@(n)~mod(n,t=1:n)*t'==2*n

Provalo online!

Spiegazione

@(n)~mod(n,t=1:n)*t'==2*n

@(n)                        % Define anonymous function with input n
             1:n            % Row vector [1,2,...,n]
           t=               % Store in variable t
     mod(n,     )           % n modulo [1,2,...,n], element-wise. Gives 0 for divisors
    ~                       % Logical negate. Gives 1 for divisors
                  t'        % t transposed. Gives column vector [1;2;...;n]
                 *          % Matrix multiply
                      2*n   % Input times 2
                    ==      % Equal? This is the output value

4

JavaScript, 38 byte

n=>eval("for(i=s=n;i--;)n%i||!(s-=i)")

Provalo online!

(Ultimo timeout testcase su TIO.)


@Arnauld Ho appena dimenticato di rimuovere il f=dopo la conversione da una funzione ricorsiva.
TSH

Solo per curiosità, perché non andare con una versione ricorsiva? (Sarebbe 34 byte.)
Arnauld

@Arnauld perché la versione ricorsiva avrebbe semplicemente fallito per testcase più grandi a causa di overflow dello stack. Forse ho bisogno di alcuni ambienti predefiniti in modalità rigorosa per farlo funzionare.
TSH

2
Abbastanza giusto, ma il tuo programma non deve completare i casi di test più grandi (che credo sia comunque la regola predefinita).
Arnauld,

4

C # (compilatore interattivo Visual C #) , 46 byte

n=>Enumerable.Range(1,n).Sum(x=>n%x<1?x:0)^n*2

Restituisce 0 se perfetto, altrimenti restituisce un numero positivo. Non so se l'output di diversi tipi di numeri interi sia consentito al posto di due distinti valori di verità e falsità, e non potrei trovare alcuna discussione su meta al riguardo. Se questo non è valido, lo rimuoverò.

Provalo online!

C # (compilatore interattivo Visual C #) , 49 47 byte

n=>Enumerable.Range(1,n).Sum(x=>n%x<1?x:0)==n*2

Provalo online!



3

TI-BASIC (TI-84), 30 23 byte

:2Ans=sum(seq(Ans/Xnot(remainder(Ans,X)),X,1,Ans,1

Orribilmente inefficiente, ma funziona.
Ridurre il numero di dipendenti ha accelerato molto il programma.
L'ingresso è in Ans.
L'output è attivo Anse viene stampato automaticamente al termine del programma.

Spiegazione:
(TI-BASIC non ha commenti, quindi supponiamo che ;faccia un commento)

:2Ans=sum(seq(Ans/Xnot(remainder(Ans,X)),X,1,Ans    ;Full program

 2Ans                                               ;double the input
          seq(                                      ;generate a list
                                         X,          ;using the variable X,
                                           1,        ;starting at 1,
                                             Ans     ;and ending at the input
                                                     ;with an implied increment of 1
              Ans/X                                 ;from the input divided by X
                   not(                ),           ;multiplied by the negated result of
                       remainder(Ans,X)              ;the input modulo X
                                                     ;(result: 0 or 1)
      sum(                                          ;sum up the elements in the list
     =                                              ;equal?

Esempio:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Nota: il conteggio dei byte di un programma viene valutato utilizzando il valore in [MEM] > [2] > [7] (36 byte) quindi sottraendo la lunghezza del nome del programma CDGF2, (5 byte) e altri 8 byte utilizzati per memorizzazione del programma:

36 - 5 - 8 = 23 byte


3

Java (JDK) , 54 byte

n->{int s=0,d=0;for(;++d<n;)s+=n%d<1?d:0;return s==n;}

Provalo online!

Sebbene per un numero rigoroso in base alla corrispondenza numerica, quanto segue restituirà gli stessi valori, ma è solo 40 byte.

n->n==6|n==28|n==496|n==8128|n==33550336

Provalo online!


Le regole diconoYour program doesn't have to complete the larger test cases, if there's memory or time constraints, but it should be theoretically able to if it were given more memory/time.
Jo King

@JoKing Significa che non riesco affatto a usare un Java int, ma piuttosto un BigInteger? Perché Java ha BigIntegers, ma non avrà mai un valore intsuperiore a 31 bit come firmato, che non può contenere nessun altro valore rispetto a quelli rappresentati qui ...
Olivier Grégoire

no, ma se il programma dovesse continuare a funzionare se il inttipo era illimitato
Jo King

1
@JoKing Ok, ho cambiato di nuovo le due soluzioni per avere prima il calcolo.
Olivier Grégoire,

3

x86 Assembly, 45 43 byte.

6A 00 31 C9 31 D2 41 39  C1 7D 0B 50 F7 F9 58 85
D2 75 F1 51 EB EE 31 D2  59 01 CA 85 C9 75 F9 39
D0 75 05 31 C0 40 EB 02  31 C0 C3

Spiegazione (sintassi Intel):

PUSH $0          ; Terminator for later
XOR ECX, ECX        ; Clear ECX
.factor:
    XOR EDX, EDX    ; Clear EDX
    INC ECX
    CMP ECX, EAX    ; divisor >= input number?
    JGE .factordone ; if so, exit loop.
    PUSH EAX        ; backup EAX
    IDIV ECX        ; divide EDX:EAX by ECX, store result in EAX and remainder in EDX
    POP EAX         ; restore EAX
    TEST EDX, EDX   ; remainder == 0?
    JNZ .factor     ; if not, jump back to loop start
    PUSH ECX        ; push factor
    JMP .factor     ; jump back to loop start
.factordone:
XOR EDX, EDX        ; clear EDX
.sum:
    POP ECX         ; pop divisor
    ADD EDX, ECX    ; sum into EDX
    TEST ECX, ECX   ; divisor == 0?
    JNZ .sum        ; if not, loop.
CMP EAX, EDX        ; input number == sum?
JNE .noteq          ; if not, skip to .noteq
    XOR EAX, EAX    ; clear EAX
    INC EAX         ; increment EAX (sets to 1)
JMP .return         ; skip to .return
.noteq:
    XOR EAX, EAX    ; clear EAX
.return:
RETN

L'input deve essere fornito in EAX.
La funzione è impostata EAXsu 1per perfetto e su 0per imperfetto.

EDIT : Numero di byte ridotto di due sostituendo MOV EAX, $1con XOR EAX, EAXeINC EAX


1
Uso un macro assembly quindi non lo so per certo ma il commento "; divisore> input number" per me sarebbe "; divisore> = input number"
RosLuP

L'assemblaggio ha delle operazioni facili che si potrebbero ridurre la lunghezza delle istruzioni, tutto in una riga, usare il rientro e commentare ogni 10 20 istruzioni asm ....
RosLuP

@RosLuP Ho corretto il commento nel codice (grazie), ma non so cosa intendi con il tuo secondo commento.
Fayti1703,

3

Labirinto , 80 byte

?::`}:("(!@
perfect:
{:{:;%"}
+puts; "
}zero: "
}else{(:
"negI"  _~
""""""{{{"!@

I caratteri latini perfect puts zero else neg Isono in realtà solo commenti *.
cioè se l'ingresso è perfetto 0viene stampato a, altrimenti lo -1è.

Provalo online!


* quindi anche questo o questo lavoro ...

?::`}:("(!@               ?::`}:("(!@
       :                  BEWARE :
{:{:;%"}                  {:{:;%"}
+    ; "                  +LAIR; "
}    : "                  } OF : "
}    {(:                  }MINO{(:
"    "  _~                "TAUR"  _~
""""""{{{"!@              """"""{{{"!@

Come?

Prende come input un numero intero positivo ne posiziona una variabile di accumulatore -nsullo stack ausiliario, quindi esegue un test di divisibilità per ciascun numero intero da n-1e verso compreso 1, aggiungendo quelli che si dividono nnell'accumulatore. Una volta che questo è completo se la variabile dell'accumulatore è diversa da zero -1viene emesso un a, altrimenti un 0è.

L' ?::`}:(viene eseguito solo una volta, all'inizio dell'esecuzione:

?::`}:(                                                      Main,Aux
?       - take an integer from STDIN and place it onto Main  [[n],[]]
 :      - duplicate top of Main                            [[n,n],[]]
  :     - duplicate top of Main                          [[n,n,n],[]]
   `    - negate top of Main                            [[n,n,-n],[]]
    }   - place top of Main onto Aux                       [[n,n],[-n]]
     :  - duplicate top of Main                          [[n,n,n],[-n]]
      ( - decrement top of Main                        [[n,n,n-1],[-n]]

L'istruzione successiva ", è una no-op, ma abbiamo tre istruzioni vicine quindi ci ramifichiamo in base al valore nella parte superiore di Main, zero ci porta in avanti, mentre lo zero ci porta a destra.

Se l'input è stato 1andiamo avanti perché la parte superiore di Main è zero:

(!@                                                          Main,Aux
(   - decrement top of Main                             [[1,1,-1],[-1]]
 !  - print top of Main, a -1
  @ - exit the labyrinth

Ma se l'input era maggiore di 1giriamo a destra perché la parte superiore di Main è diversa da zero:

:}                                                           Main,Aux
:  - duplicate top of Main                         [[n,n,n-1,n-1],[-n]]
 } - place top of Main onto Aux                        [[n,n,n-1],[-n,n-1]]

A questo punto abbiamo un ramo di tre vicini, ma sappiamo che n-1è diverso da zero, quindi giriamo a destra ...

"%                                                           Main,Aux
"  - no-op                                             [[n,n,n-1],[-n,n-1]]
 % - place modulo result onto Main                   [[n,n%(n-1)],[-n,n-1]]
   - ...i.e we've got our first divisibility indicator n%(n-1), an
   -    accumulator, a=-n, and our potential divisor p=n-1:
   -                                                 [[n,n%(n-1)],[a,p]]

Ora siamo in un'altra filiale di tre vicini a %.

Se il risultato è %stato diverso da zero, andiamo a sinistra per diminuire il nostro potenziale divisore p=p-1e lasciamo l'accumulatore a, così com'è:

;:{(:""}"                                                    Main,Aux
;          - drop top of Main                                [[n],[a,p]]
 :         - duplicate top of Main                         [[n,n],[a,p]]
  {        - place top of Aux onto Main                  [[n,n,p],[a]]
           - three-neighbour branch but n-1 is non-zero so we turn left
   (       - decrement top of Main                     [[n,n,p-1],[a]]
    :      - duplicate top of Main                 [[n,n,p-1,p-1],[a]]
     ""    - no-ops                                [[n,n,p-1,p-1],[a]]
       }   - place top of Main onto Aux                [[n,n,p-1],[a,p-1]]
        "  - no-op                                     [[n,n,p-1],[a,p-1]]
         % - place modulo result onto Main           [[n,n%(p-1)],[a,p-1]]
           - ...and we branch again according to the divisibility
           -    of n by our new potential divisor, p-1

... ma se il risultato di %era zero (per il primo passaggio solo quando n=2) passiamo direttamente a ENTRAMBE aggiungiamo il divisore al nostro accumulatore a=a+pe diminuiamo il nostro potenziale divisore p=p-1:

;:{:{+}}""""""""{(:""}                                       Main,Aux
;                      - drop top of Main                    [[n],[a,p]]
 :                     - duplicate top of Main             [[n,n],[a,p]]
  {                    - place top of Aux onto Main      [[n,n,p],[a]]
   :                   - duplicate top of Main         [[n,n,p,p],[a]]
    {                  - place top of Aux onto Main  [[n,n,p,p,a],[]]
     +                 - perform addition            [[n,n,p,a+p],[]]
      }                - place top of Main onto Aux      [[n,n,p],[a+p]]
       }               - place top of Main onto Aux        [[n,n],[a+p,p]]
        """""""        - no-ops                            [[n,n],[a+p,p]]
                       - a branch, but n is non-zero so we turn left
               "       - no-op                             [[n,n],[a+p,p]]
                {      - place top of Aux onto Main      [[n,n,p],[a+p]]
                       - we branch, but p is non-zero so we turn right
                 (     - decrement top of Main         [[n,n,p-1],[a+p]]
                  :    - duplicate top of Main     [[n,n,p-1,p-1],[a+p]]
                   ""  - no-ops                    [[n,n,p-1,p-1],[a+p]]
                     } - place top of Main onto Aux    [[n,n,p-1],[a+p,p-1]]

A questo punto se p-1è ancora diverso da zero giriamo a sinistra:

"%                                                           Main,Aux
"  - no-op                                             [[n,n,p-1],[a+p,p-1]]
 % - modulo                                          [[n,n%(p-1)],[a+p,p-1]]
   - ...and we branch again according to the divisibility
   -    of n by our new potential divisor, p-1

... ma se p-1colpisci zero andiamo dritti fino alla :seconda riga del labirinto (hai già visto tutte le istruzioni prima, quindi sto lasciando fuori le loro descrizioni e sto solo dando il loro effetto):

:":}"":({):""}"%;:{:{+}}"""""""{{{                           Main,Aux
:                                  -                   [[n,n,0,0],[a,0]]
 "                                 -                   [[n,n,0,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
  :                                -                 [[n,n,0,0,0],[a,0]]
   }                               -                   [[n,n,0,0],[a,0,0]]
                                   - top of Main is zero so we go straight
    ""                             -                   [[n,n,0,0],[a,0,0]]
      :                            -                 [[n,n,0,0,0],[a,0,0]]
       (                           -                [[n,n,0,0,-1],[a,0,0]]
        {                          -              [[n,n,0,0,-1,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
         (                         -             [[n,n,0,0,-1,-1],[a,0]]
          :                        -          [[n,n,0,0,-1,-1,-1],[a,0]]
           ""                      -          [[n,n,0,0,-1,-1,-1],[a,0]]
             }                     -             [[n,n,0,0,-1,-1],[a,0,-1]]
                                   - top of Main is non-zero so we turn left
              "                    -             [[n,n,0,0,-1,-1],[a,0,-1]]
               %                   - (-1)%(-1)=0     [[n,n,0,0,0],[a,0,-1]]
                ;                  -                   [[n,n,0,0],[a,0,-1]]
                 :                 -                 [[n,n,0,0,0],[a,0,-1]]
                  {                -              [[n,n,0,0,0,-1],[a,0]]
                   :               -           [[n,n,0,0,0,-1,-1],[a,0]]
                    {              -         [[n,n,0,0,0,-1,-1,0],[a]]
                     +             -           [[n,n,0,0,0,-1,-1],[a]]
                      }            -              [[n,n,0,0,0,-1],[a,-1]]
                       }           -                 [[n,n,0,0,0],[a,-1,-1]]
                        """""""    -                 [[n,n,0,0,0],[a,-1,-1]]
                                   - top of Main is zero so we go straight
                               {   -              [[n,n,0,0,0,-1],[a,-1]]
                                {  -           [[n,n,0,0,0,-1,-1],[a]]
                                 { -         [[n,n,0,0,0,-1,-1,a],[]]

Ora ci {sono tre istruzioni vicine, quindi ...

... se aè zero, che sarà perfetto n, allora andiamo dritti:

"!@                                                          Main,Aux
"   -                                        [[n,n,0,0,0,-1,-1,a],[]]
    - top of Main is a, which is zero, so we go straight
 !  - print top of Main, which is a, which is a 0
  @ - exit the labyrinth

... se aè diverso da zero, che sarà per non perfetto n, allora giriamo a sinistra:

_~"!@                                                        Main,Aux
_     - place a zero onto Main             [[n,n,0,0,0,-1,-1,a,0],[]]
 ~    - bitwise NOT top of Main (=-1-x)   [[n,n,0,0,0,-1,-1,a,-1],[]]
  "   -                                   [[n,n,0,0,0,-1,-1,a,-1],[]]
      - top of Main is NEGATIVE so we turn left
   !  - print top of Main, which is -1
    @ - exit the labyrinth


2

Javascript, 62

n=>n==[...Array(n).keys()].filter(a=>n%a<1).reduce((a,b)=>a+b)

Spiegazione (anche se è piuttosto semplice)

n=> //return function that takes n
  n== //and returns if n is equal to
    [...Array(n).keys()] //an array [0..(n-1)]...
      .filter(a=>n%a<1) //where all of the elements that are not divisors of n are taken out...
      .reduce((a,b)=>a+b) //summed up

Grazie a Jo King per il miglioramento!




2

C (gcc) , 41 byte

f(n,i,s){for(i=s=n;--i;s-=n%i?0:i);n=!s;}

Provalo online!

1: 0
12: 0
13: 0
18: 0
20: 0
1000: 0
33550335: 0
6: 1
28: 1
496: 1
8128: 1
33550336: 1
-65536: 0 <---- Unable to represent final test case with four bytes, fails

Fammi sapere se quell'errore per l'ultimo caso è un problema.



2
"L'output può essere due valori distinti e coerenti attraverso qualsiasi formato di output consentito." Non stai restituendo due valori distinti.
Olivier Grégoire il

2
@ OlivierGrégoire Fortunatamente questo può essere facilmente risolto sostituendo lo spazio con un punto esclamativo!
Neil

1
@Neil Meglio ancora, può essere risolto con n=!s;invece di return!s;salvare 5 byte.

@OlivierGrégoire ahh, ho dimenticato quel punto. Inoltre, aggiornato con il codice migliorato. Ho provato qualcosa di simile, ma l'idiota che sono che ho fatto è s=sstato probabilmente ottimizzato.
Marcos,


2

Forth (gforth) , 45 byte

: f 0 over 1 ?do over i mod 0= i * - loop = ;

Provalo online!

Spiegazione

Passa da un numero all'altro da 1 a n-1, sommando tutti i valori che dividono n perfettamente. Restituisce vero se la somma è uguale a n

Spiegazione del codice

: f                \ start word definition
  0 over 1         \ create a value to hold the sum and setup the bounds of the loop
  ?do              \ start a counted loop from 1 to n. (?do skips if start = end)
    over           \ copy n to the top of the stack
    i mod 0=       \ check if i divides n perfectly
    i * -          \ if so, use the fact that -1 = true in forth to add i to the sum
  loop             \ end the counted loop
  =                \ check if the sum and n are equal
;                  \ end the word definition

2

Pyth , 9 13 byte

qsf!%QTSt

Provalo online!

Grazie ai commentatori per l'aiuto del golf

Trova tutti i fattori dell'input, li somma e li confronta con l'input originale.


Alcuni campi da golf per te - q0possono essere sostituiti con !e SQproduce l'intervallo [1-Q], quindi l'intervallo [1-Q)può essere generato utilizzando StQ. Dato che le Qs sono ora alla fine del programma, possono essere entrambe omesse. Versione compilata, 9 byte -qsf!%QTSt
Pubblicato il

1

Lotto, 81 byte

@set s=-%1
@for /l %%i in (1,1,%1)do @set/as+=%%i*!(%1%%%%i)
@if %s%==%1 echo 1

Prende ncome parametro da riga di comando e genera 1se è un numero perfetto. Metodo della forza bruta, avvia la somma in -nmodo che possa includersi nnel ciclo.


1

Carbone , 13 byte

Nθ⁼θΣΦθ∧ι¬﹪θι

Provalo online! Il collegamento è alla versione dettagliata del codice. Uscite -per numeri perfetti. Usa la forza bruta. Spiegazione:

Nθ              Numeric input
     Φθ         Filter on implicit range
        ι       Current value (is non-zero)
       ∧        Logical And
           θ    Input value
          ﹪     Modulo
            ι   Current value
         ¬      Is zero
    Σ           Sum of matching values
  ⁼             Equals
   θ            Input value


1

Pyth, 8 byte

qs{*MPyP

Provalo online qui .

qs{*MPyPQQ   Implicit: Q=eval(input())
             Trailing QQ inferred
       PQ    Prime factors of Q
      y      Powerset
     P       Remove last element - this will always be the full prime factorisation
   *M        Take product of each
  {          Deduplicate
 s           Sum
q        Q   Is the above equal to Q? Implicit print

1

Retina 0.8.2 , 44 byte

.+
$*
M!&`(.+)$(?<=^\1+)
+`^1(1*¶+)1
$1
^¶+$

Provalo online! Utilizza la forza bruta, quindi il collegamento include solo i casi di test più veloci. Spiegazione:

.+
$*

Converti in unario.

M!&`(.+)$(?<=^\1+)

Abbina tutti i fattori dell'input. Questo utilizza la modalità di sovrapposizione, che in Retina 0.8.2 richiede che tutte le partite inizino in posizioni diverse, quindi le partite vengono effettivamente restituite in ordine decrescente, a partire dall'input originale.

+`^1(1*¶+)1
$1

Sottrai i fattori corretti dall'input.

^¶+$

Verifica se il risultato è zero.


1

Java 8, 66 byte


Qualcuno deve usare l'API dello stream ad un certo punto, anche se c'è un modo più breve per farlo

n->java.util.stream.IntStream.range(1,n).filter(i->n%i<1).sum()==n

Provalo online!


1

cQuents , 8 byte

?#N=U\zN

Provalo online!

Spiegazione

?           Mode query: return whether or not input is in sequence
 #          Conditional: iterate N, add N to sequence if condition is true
  N=         Condition: N == 
    U    )                   sum(                  )
     \z )                        proper_divisors( )
       N                                         N
        ))    implicit
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.