Eu não sou bom o suficiente para você?

29

Fundo:

O desafio atual do Perfect Numbers é um tanto falho e complicado, pois solicita que você produza em um formato complexo que envolva os fatores do número. Este é um repost puramente .

Desafio

Dado um número inteiro positivo através de qualquer formato de entrada padrão , faça uma distinção entre ser perfeito ou não.

Um número perfeito é um número que é igual à soma de todos os seus divisores adequados (seus divisores positivos menores que ele próprio). Por exemplo, é um número perfeito, pois seus divisores são , que somam , enquanto não é um número perfeito, pois seus divisores ( ) somam , não .61 1,2,36121 1,2,3,4,61612

Casos de teste:

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

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

Regras

  • Seu programa não precisa concluir os casos de teste maiores, se houver restrições de memória ou tempo, mas, teoricamente, deve ser possível se receber mais memória / tempo.
  • A saída pode ter dois valores distintos e consistentes em qualquer formato de saída permitido . Se não for imediatamente óbvio o que representa Perfeito / Imperfeito, certifique-se de especificar em sua resposta.
Brincadeira
fonte
Espere, então verdade é para valores que não são perfeitos, e falsey é para valores que são?
Esolanging Fruit
2
@ Tvde1 Os divisores adequados têm que ser menores que o número, caso contrário, nenhum número que 1não seja perfeito seria, pois cada número é divisível por 1si próprio. A soma dos divisores adequados de 1é0
Jo King
3
@ Grimy Somente se você puder provar isso . Boa sorte! (embora eu esteja querendo saber como isso salvaria bytes)
Jo King
11
Então não, que pena. Reduziria o tamanho de uma resposta de regex da ECMA em um fator de cerca de 3.
Grimmy
3
"Saída pode ser dois valores distintos e consistentes" - não podemos usar "truthy vs falsey" aqui (por exemplo, para Python usando zero vs não zero; uma lista com conteúdo vs uma lista vazia; e combinações dos mesmos)?
Jonathan Allan

Respostas:

16

Braquilog , 4 bytes

fk+?

Experimente online!

O predicado consegue entradas perfeitas e falha em entradas imperfeitas, impressão true.ou false.se for executado como um programa completo (exceto no último caso de teste que leva mais de um minuto no TIO).

        The input's
f       factors
 k      without the last element
  +     sum to
   ?    the input.
String não relacionada
fonte
11
Eu gosto de como o código diz fk: x
Ismael Miguel
9

Neim , 3 bytes

𝐕𝐬𝔼

Experimente online!

(Na verdade, eu não sei como executar todos os casos de teste de uma só vez, desde que comecei a aprender Neim cerca de quinze minutos atrás, mas os verifiquei individualmente.)

Imprime 0 para imperfeito, 1 para perfeito.

𝐕      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.
String não relacionada
fonte
2
" Eu acho? "; " ou algo assim. " Quando você nem tem certeza do que escreveu, haha. ;) Mas sim, é assim que funciona. Não conheço Neim, mas usar a entrada implicitamente assim e emitir implicitamente no final implicitamente é semelhante em 05AB1E.
Kevin Cruijssen 13/03
Como é 𝔼1 byte? Neim usa apenas 128 caracteres não padrão?
kajacx 13/03
3
@kajacx Neim tem sua própria página de código . Portanto, cada um dos 256 caracteres presentes na página de códigos pode ser codificado usando 1 byte.
Sr. Xcoder 13/03
8

R , 33 29 bytes

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

Experimente online!

Retorna TRUEpara números perfeitos e FALSEpara números imperfeitos.

Giuseppe
fonte
O que os 2! S seguidos lhe dão?
CT Hall
@CTHall Eu interpretei mal as especificações; eles originalmente mapearam 0(perfeito) para FALSEe diferente de zero, TRUEmas eu removi um deles para reverter o mapeamento. É um truque de golfe útil elenco de numericque logical, muitas vezes em conjunto com whichou [.
Giuseppe
7

Japonês -! , 4 bytes

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

Por alguma razão, ¦não funciona no tio, então eu preciso usar a -!bandeira e, em ¥vez disso,

Experimente online!

Luis felipe De jesus Munoz
fonte
Isso não é um problema do TIO; Unão é inserido automaticamente antes !.
Shaggy
6

Python 3 , 46 bytes

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

Experimente online!

Força bruta, soma os fatores e verifica a igualdade.

Neil A.
fonte
2
Usar a condição de compreensão como uma máscara para sua variável de iteração salvaria um byte.
Jonathan Frech 12/03
Como você pode retornar a verdade para um número imperfeito, também lambda x:sum(i for i in range(1,x)if x%i<1)^xdeve funcionar.
nedla2004 12/03
5

Python , 45 bytes

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

Truepara perfeito; Falsepara outras pessoas (alterne com ==-> !=)

Experimente online!

 44 42  41 bytes (-2 graças a ovs) se pudermos produzir usando "truthy vs falsey":

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

(falsey ( 0)) para perfeito; truthy (um número inteiro diferente de zero)

Jonathan Allan
fonte
Se o segundo formato de saída for válido, isso poderá ser feito em 42 bytes .
ovs 12/03
@ ah ah, muito bem feito.
Jonathan Allan
@ovs ..e outro salvo disso - obrigado!
Jonathan Allan
5

Oitava , 25 bytes

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

Experimente online!

Explicação

@(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
Luis Mendo
fonte
4

JavaScript, 38 bytes

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

Experimente online!

(Último tempo limite da caixa de teste no TIO.)

tsh
fonte
@ Arnauld Esqueceu-se de remover o f=após a conversão de uma função recursiva.
tsh 12/03
Por curiosidade, por que não usar uma versão recursiva? (Seria 34 bytes.)
Arnauld
@ Arnauld porque a versão recursiva simplesmente falhou em um caso de teste maior devido ao estouro da pilha. Talvez eu precise de alguns ambientes padrão para o modo estrito para fazê-lo funcionar.
tsh
2
É justo, mas o seu programa não precisa concluir os casos de teste maiores (que eu acho que é a regra padrão, de qualquer maneira).
Arnauld
4

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

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

Retorna 0 se perfeito, caso contrário, retorna um número positivo. Eu não sei se a saída de diferentes tipos de números inteiros é permitida no lugar de dois valores distintos de verdade e falsidade, e não consegui encontrar nenhuma discussão sobre meta sobre isso. Se isso for inválido, eu o removerei.

Experimente online!

C # (compilador interativo do Visual C #) , 49 47 bytes

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

Experimente online!

Modalidade de ignorância
fonte
3

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

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

Horrivelmente ineficiente, mas funciona.
Reduzir o número de bytes acelerou muito o programa.
A entrada é no Ans.
A saída está emAns impressa e automaticamente impressa quando o programa é concluído.

Explicação:
(O TI-BASIC não tem comentários, então assuma que ;faz um comentário)

: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?

Exemplo:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Nota: A contagem de bytes de um programa é avaliada usando o valor em [MEM] > [2] > [7] (36 bytes), subtraindo o comprimento do nome do programa CDGF2, (5 bytes) e 8 bytes extras usados ​​para armazenando o programa:

36-5-5 = 23 bytes

Tau
fonte
3

Java (JDK) , 54 bytes

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

Experimente online!

Embora para um número estrito por número correspondente, o seguinte retornará os mesmos valores, mas é de apenas 40 bytes.

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

Experimente online!

Olivier Grégoire
fonte
As regras dizemYour 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 Isso significa que eu não posso usar um Java int, mas sim um BigInteger? Porque o Java possui BigIntegers, mas nunca terá intmais do que 31 bits como assinado, o que não pode conter outro valor além daqueles representados aqui ...
Olivier Grégoire
não, mas se o programa ainda funcionar se o inttipo não for ilimitado
Jo King
11
@ JoKing Ok, troquei as duas soluções novamente para ter o cálculo primeiro.
Olivier Grégoire
3

Montagem x86, 45 43 bytes.

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

Explicação (Sintaxe da 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

A entrada deve ser fornecida em EAX.
Conjuntos de funções EAXpara 1para aperfeiçoar e0 para imperfeito.

EDIT : Reduzido Byte-Count por dois, substituindo MOV EAX, $1por XOR EAX, EAXeINC EAX

Fayti1703
fonte
11
Eu uso um assembly de macro para que eu não tenha certeza, mas o comentário "; divisor> número de entrada" para mim seria "; divisor> = número de entrada"
RosLuP
Assembléia tem operações fáceis se poderia reduzir o comprimento instruções coloca todos em uma linha, recuo uso e comentar cada 10 20 instruções asm ....
RosLuP
@RosLuP Corrigi o comentário no código (obrigado), mas não sei o que você quer dizer com seu segundo comentário.
Fayti1703 14/03
3

Labirinto , 80 bytes

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

Os caracteres latinos perfect puts zero else neg Isão na verdade apenas comentários *.
ou seja, se a entrada é perfeita, a 0é impressa, caso contrário, -1é.

Experimente online!


* Então este ou este trabalho também ...

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

Quão?

Pega como entrada um número inteiro positivo ne coloca uma variável acumuladora -nna pilha auxiliar e, em seguida, executa um teste de divisibilidade para cada número inteiro de n-1baixo para, e incluindo 1, adicionando qualquer um que seja dividido nno acumulador. Quando isso estiver concluído, se a variável do acumulador for diferente de zero, a -1é emitida, caso contrário, a 0é.

O ?::`}:(é executado apenas uma vez, no início da execução:

?::`}:(                                                      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]]

A próxima instrução,, "é no-op, mas temos três instruções vizinhas, portanto, ramificamos de acordo com o valor no topo de Main, zero nos leva adiante, enquanto diferente de zero nos leva à direita.

Se a entrada foi 1, seguimos em frente porque o topo de Main é zero:

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

Mas se a entrada for maior do 1que virar à direita, porque a parte superior de Main é diferente de 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]]

Neste ponto, temos um ramo de três vizinhos, mas sabemos que n-1é diferente de zero, por isso vimos à direita ...

"%                                                           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]]

Agora estamos em outra filial de três vizinhos em %.

Se o resultado de %for diferente de zero, vamos para a esquerda para diminuir nosso divisor em potencial p=p-1e deixar o acumulador a, como ele é:

;:{(:""}"                                                    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

... mas se o resultado de %foi zero (para a primeira passagem somente quando n=2), vamos direto para AMBOS, adicionamos o divisor ao nosso acumulador a=a+p, E diminui nosso divisor em potencial 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]]

Neste ponto, se p-1ainda for diferente de zero, vire à esquerda:

"%                                                           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

... mas se p-1acertar zero, vamos direto para a :segunda linha do labirinto (você já viu todas as instruções antes, então deixo suas descrições de fora e apenas produzo seus efeitos):

:":}"":({):""}"%;:{:{+}}"""""""{{{                           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],[]]

Agora isso {tem três instruções vizinhas, então ...

... se afor zero, o que será perfeito n, então vamos direto:

"!@                                                          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 afor diferente de zero, o que não será perfeito n, viramos à esquerda:

_~"!@                                                        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
Jonathan Allan
fonte
2

Javascript, 62

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

Explicação (embora seja bastante simples)

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

Obrigado a Jo King pela melhoria!

vityavv
fonte
2

05AB1E , 4 bytes

ѨOQ

Experimente online!

Explicação

  O    # the sum
Ñ      # of the divisors of the input
 ¨     # with the last one removed
   Q   # equals the input
Emigna
fonte
2

Powershell, 46 bytes 43 bytes

param($i)1..$i|%{$o+=$_*!($i%$_)};$o-eq2*$i

Experimente Online!

Edit: -3 bytes graças a @AdmBorkBork

J. Bergmann
fonte
43 bytes rolando o acumulador no loop e comparando 2*$ipara eliminar a subtração-um parens.
AdmBorkBork 12/03
2

C (gcc) , 41 bytes

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

Experimente 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

Deixe-me saber se essa falha no caso final é um problema.

Marcos
fonte
11
41 bytes
tsh
2
"A saída pode ser dois valores distintos e consistentes através de qualquer formato de saída permitido." Você não está retornando dois valores distintos.
Olivier Grégoire
2
@ OlivierGrégoire Felizmente, isso pode ser facilmente corrigido substituindo o espaço por um ponto de exclamação!
Neil
11
@ Neil Melhor ainda, ele pode ser corrigido com, em n=!s;vez de return!s;salvar 5 bytes.
@ OlivierGrégoire ahh, esqueci esse ponto. Além disso, atualizei o com o código aprimorado. Eu tentei algo parecido, mas o idiota que sou, s=sque mais do que provavelmente foi otimizado.
Marcos
2

Smalltalk, 34 bytes

((1to:n-1)select:[:i|n\\i=0])sum=n
Leandro Caniglia
fonte
2

Quarto (gforth) , 45 bytes

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

Experimente online!

Explicação

Repete todos os números de 1 a n-1, somando todos os valores que dividem n perfeitamente. Retorna true se sum for n

Código Explicação

: 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
reffu
fonte
2

Pitão , 9 13 bytes

qsf!%QTSt

Experimente online!

Obrigado aos comentaristas pela ajuda do golfe

Localiza todos os fatores da entrada, soma-os e compara-os à entrada original.

JPeroutek
fonte
Alguns tacos para você - q0podem ser substituídos !e SQproduzem o alcance [1-Q], para que o alcance [1-Q)possa ser gerado usando StQ. Como os Qs estão agora no final do programa, ambos podem ser omitidos. Versão instável, 9 bytes -qsf!%QTSt
Sok
1

Lote, 81 bytes

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

Toma ncomo parâmetro da linha de comando e gera 1se for um número perfeito. Método de força bruta, inicia a soma em -npara que ele possa se incluir nno loop.

Neil
fonte
1

Carvão vegetal , 13 bytes

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

Experimente online! Link é a versão detalhada do código. Saídas -para números perfeitos. Usa força bruta. Explicação:

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
Neil
fonte
1

Pitão, 8 bytes

qs{*MPyP

Experimente online aqui .

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
Sok
fonte
1

Retina 0.8.2 , 44 bytes

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

Experimente online! Usa força bruta, portanto, o link inclui apenas os casos de teste mais rápidos. Explicação:

.+
$*

Converta para unário.

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

Combine todos os fatores da entrada. Isso usa o modo de sobreposição, que no Retina 0.8.2 exige que todas as correspondências sejam iniciadas em posições diferentes; portanto, as correspondências são realmente retornadas em ordem decrescente, começando com a entrada original.

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

Subtraia os fatores adequados da entrada.

^¶+$

Teste se o resultado é zero.

Neil
fonte
1

Java 8, 66 bytes


Alguém precisa usar a API de fluxo em algum momento, mesmo se houver uma maneira mais curta de fazer isso

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

Experimente online!

Benjamin Urquhart
fonte
1

cQuents , 8 bytes

?#N=U\zN

Experimente online!

Explicação

?           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
Stephen
fonte