# Question
Title: Shortest method to implement the Pythagorean Theorem
Who doesn't love the Pythagorean theorem \\$a^2+b^2=c^2\\$? Write the shortest method you can in any language that takes in value `a` and `b` and prints out `The hypotenuse of this right triangle is c`. Keep `c` to only three decimal places.

# Answer
> 14 votes
## APL (54)

```
'The hypotenuse of this right triangle is',3⍕.5*⍨+/⎕*2

```

Test:

```
      'The hypotenuse of this right triangle is',3⍕.5*⍨+/⎕*2
⎕:
      9 10
The hypotenuse of this right triangle is 13.454

```

Explanation:

* `⎕*2`: raise the values in the input to the second power
* `+/`: take the sum
* `.5*⍨`: raise the result to the 0.5th power
* `3⍕`: round to 3 decimal places

# Answer
> 11 votes
# TI-BASIC, ~~76~~ ~~55~~ ~~53~~ 52 bytes

```
Input :Disp "THE HYPOTENUSE OF THIS RIGHT TRIANGLE IS
Fix 3:R▶Pr(X,Y

```

No, a closing parentheses is not required. Also, less bytes than that APL answer :)

# Answer
> 9 votes
# Python 2.7 - 76 Characters

```
print'The hypotenuse of this right triangle is %.3f'%abs(input()+1j*input())

```

**Explanation**

$$|a+bi| = \sqrt{a^2 + b^2} = c \\ \implies a^2 + b^2 = c^2$$

**PJ on hypotenuse**

> Teacher: "Can you tell me, what is hypotenuse?"
>
> LJ: "Hypotenuse, an easy question. If there's a high profile party last night, and you read it in the news paper, its called High Party News"

# Answer
> 8 votes
# Sclipting, 46 characters

```
글坼各갠方終加감半方갾밈乘增貶껠矽녆둥긆둹댆뭴뉖멵댶넠닶눠덆둩댲걲늖덨덂건댦땡닦덬뉒걩댲밀⓶

```

Expects the input as two numbers (can be fractional!) separated by a space.

This is shorter than APL, despite having to use a few inconvenient tricks.

## Explanation

```
글坼 | split at space
各 | for each...
  갠方 | to the power of two
終
加 | add
감半方 | to the power of one half
갾밈乘 | multiply by 1000
增貶 | increment, then decrement (kludge for rounding)
껠矽 | insert '.' at 4th-last character position
녆둥긆둹댆뭴뉖멵댶넠닶눠덆둩댲걲늖덨덂건댦땡닦덬뉒걩댲밀⓶ | "The hypotenuse..."

```

# Answer
> 4 votes
# dc 54

Tangents the score of the APL answer!

```
2^r2^+3kv[The hypotenuse of this right triangle is ]Pp

```

Test:

```
$ dc
3 4
2^r2^+3kv[The hypotenuse of this right triangle is ]Pp
The hypotenuse of this right triangle is 5.000

```

# Answer
> 3 votes
## C, 77 or 99

77 characters if input can just be the function arguments:

```
f(a,b){printf("The hypotenuse of this right triangle is %.3f\n",hypot(a,b));}

```

99 if input must be read from stdin:

```
a,b;f(){scanf("%d %d",&a,&b);printf("The hypotenuse of this right triangle is %.3f\n",hypot(a,b));}

```

A big thanks to @Yimin Rong!

# Answer
> 3 votes
# Ruby, ~~94~~ ~~90~~ 82 chars

```
p "The hypotenuse of this right triangle is %.3f"%(Math.sqrt(gets.to_i**2+gets.to_i**2))

```

Update (thanks for the comments):

```
p "The hypotenuse of this right triangle is %.3f"%(gets.to_i**2+gets.to_i**2)**0.5

```

# Answer
> 3 votes
**Powershell**

Just to see if i could...

```
echo "The hypotenuse of this right triangle is " ([math]::round([math]::sqrt(([math]::pow(([double](Read-Host -p "A")),2) + [math]::pow(([double](Read-Host -p "B")),2))),3))

```

# Answer
> 3 votes
# Whispers v2, <sup>~~133~~</sup>, 93 bytes

```
> Input
> Input
> "The hypotenuse of this right triangle is %.3f"
>> 1⊿2
>> 3%4
>> Output 5

```

Try it online!

~~The major part of this program is calculating the decimal point's index and truncating to 3 digits.~~ -40 bytes from Leo!

# Answer
> 2 votes
# C++ - 90

```
void h(int a,int b){printf("The hypotenuse of this right triangle is %.3f\n",hypot(a,b));}

```

# Answer
> 2 votes
## MATLAB ~~79~~ 74

```
@(a,b)sprintf('The hypotenuse of this right triangle is %.3f',norm([a b]))

```

# Answer
> 2 votes
# Python 2.7 - 80 chars

```
print'The hypotenuse of this right triangle is %.3f'%(input()**2+input()**2)**.5

```

# Answer
> 2 votes
# Perl 6 (~~68~~ 74 bytes)

```
{printf "The hypotenuse of this right triangle is %.3f
",sqrt [+] @_ X**2}

```

`{}` declares a lambda function. `[+]` is sum operator, `X**` is cross power operator (for example, `1, 2 X+ 10, 20` gives `11, 21, 12, 22`). In this case, cross power operator takes one argument, so the result has the same length as `@_`. `@_` contains all function arguments.

If it's disallowed to have function that may take wrong number of arguments (unsafe), it's possible to replace `[+] @_ X**2` with `$^a**2+$^b**2`, where `$^a` and `$^b` are placeholder arguments.

# Answer
> 2 votes
## EcmaScript 6, 82 79

```
f=(a,b)=>"The hypotenuse of this right triangle is "+Math.hypot(a,b).toFixed(3)

```

Usage:

```
f(3, 5)
> "The hypotenuse of this right triangle is 5"

```

**Update:** Switch to `Math.hypot()`

# Answer
> 2 votes
**Golfscript (~~69 67 66~~ 65)**

This would be much easier if floating point was actually supported without resorting to workarounds... :)

```
~'The hypotenuse of this right triangle is '@.*@.*+2-1??+.'.'?4+<

```

A link to test it.

# Answer
> 2 votes
**Javascript (97)**

```
x=prompt;a=x(),b=x();x('The hypotenuse of this right triangle is '+Math.sqrt(a*a+b*b).toFixed(3))

```

# Answer
> 2 votes
## C, 100 chars (beats the other C solution by 1!)

A ridiculously inefficient algorithm.

```
x;f(a,b){for(;x-a*a-b*b;x=rand());printf("The hypotenuse of this right triangle is %.3f",sqrt(x));}

```

# Answer
> 2 votes
## DELPHI / PASCAL

### With indent (157)

```
program p;
{$APPTYPE CONSOLE}
var a,b:integer;
begin
     readln(a,b);
     writeln('the hypotenuse of this right triangle is',sqrt(b*b+a*a):2:3);
end.

```

# Answer
> 2 votes
# Python 2 (79)

```
def p(a,b):print'The hypotenuse of this right triangle is %.3d'%((a*a+b*b)**.5)

```

# Answer
> 1 votes
# AWK — ~~84~~ 78 characters

```
awk '{printf"The hypotenuse of this right triangle is %.3f\n",($1^2+$2^2)^.5}'

```

Thanks to Wasi for suggesting ^ operator and removing ()!

e.g.

```
$ echo 3 4 | awk '{printf"The hypotenuse of this right triangle is %.3f\n",($1^2+$2^2)^.5}'
The hypotenuse of this right triangle is 5.000

```

# Answer
> 1 votes
**C#**

**Method Only (114)**

```
void H(double a, double b)
{
    Console.Write("The hypotenuse of this right triangle is {0:N3}", Math.Sqrt(a * a + b * b));
}

```

**Complete Program (171)**

```
using System;
class P
{
   static void H(double a, double b)
   {
     Console.Write("The hypotenuse of this right triangle is {0:N3}", Math.Sqrt(a * a + b * b));
   }
   static void Main()
   {
    H(3, 4);
   }
}

```

**Complete Program (without using method - 141)**

```
using System;class P{static void Main(){double a=3,b=4;Console.Write("The hypotenuse of this right triangle is {0:N3}",Math.Sqrt(a*a+b*b));}}

```

# Answer
> 1 votes
# PowerShell: 111

**Golfed Code**

```
1..2|%{sv $_ (read-host)};"The hypotenuse of this right triangle is $("{0:N3}"-f[math]::sqrt($1/1*$1+$2/1*$2))"

```

**Walkthrough**

`1..2|%{sv $_ (read-host)};` Gets two inputs interactively from the user, and stores them in $1 and $2. Might be able to cut some length by using arguments or pipeline inputs instead.

`"The hypotenuse of this right triangle is` Required text in the output, per the challenge specifications.

`$(`...`)"` Encapsulated code block will be processed as script before being included in the output.

`"{0:N3}"-f` Formats output from the next bit of code as a number with exactly three digits after the decimal point.

`[math]::sqrt(`...`)` Gets the square root of the encapsulated value.

`$1/1*$1+$2/1*$2` Serves as our "a^2+b^2". Multiplying a number by itself is the shortest way to square it in PowerShell, but the variables need to be divided by 1 first to force them to integers. Otherwise, they are treated as text and 3\*3+4\*4 would be 3334444 instead of 25.

# Answer
> 1 votes
# JavaScript 118 106 93

Unlike @micha's solution, mine takes in two variables via function and sends the alert of the result.

`function(a,b){m=Math;c=d=>d*d,e=1e3;alert("The hypotenuse of this right triangle is "+m.round(m.sqrt(c(a)+c(b))*e)/e)}`

`function(a,b){e=1e3;alert("The hypotenuse of this right triangle is "+Math.round(Math.sqrt(a*a+b*b)*e)/e)}`

Fat arrow functions to the rescue!

`h=(a,b,e=1e3)=>"The hypotenuse of this right triangle is "+Math.round(Math.sqrt(a*a+b*b)*e)/e`

# Answer
> 1 votes
## JavaScript: 83

```
i=prompt,'The hypotenuse of this right triangle is '+Math.hypot(i(),i()).toFixed(3)

```

Currently the shortest JS implementation using `stdin` :D
Works only on Firefox 27.0+ (EcmaScript 6)

## JavaScript: 78

If we can use just two variables (as lot of scripts do here):

```
a=2,b=3,'The hypotenuse of this right triangle is '+Math.hypot(a,b).toFixed(3)

```

# Answer
> 1 votes
# dc, 55

```
3k?d*?d*+v[The hypotenuse of this right triangle is ]Pp

```

# Answer
> 1 votes
## Java, 112

(Also prints out a No Such Method error, though I'm not sure if this is against the rules)

```
class A{static{int a=1,b=1;System.out.printf("The hypotenuse of this right triangle is %.3f",Math.hypot(a,b));}}

```

## Java, 149

(No error)

```
class A{static{int a=1,b=1;System.out.printf("The hypotenuse of this right triangle is %.3f",Math.hypot(a,b));}public static void main(String[] a){}}

```

# Answer
> 1 votes
### c64 basic v2, 60 66 bytes

```
0inputa,b:?"The hypotenuse of this right triangle is";sQ(a*a+b*b)

```

Screenshot:

How to try it.

# Answer
> 1 votes
# R, ~~61~~ 76 bytes

```
cat("The hypotenuse of this right triangle is",round(sqrt(sum(scan()^2)),3))

```

`cat` displays its content to STDOUT.

The `scan()` function takes user's input from keyboard. This input exists as a vector, on which the `^2` is applied (`^`function is vectorized), and the `sum()` sums the elements of the vector. `sqrt` outputs the square-root, which is rounded to 3 decimal places by `round(,3)`

Thanks to @caird coinheringaahing for noticing that the previous answer didn't round.

# Answer
> 1 votes
# ARBLE, ~~73~~ 60 bytes

```
"The hypotenuse of this right triangle is %.3f"%(a^2+b^2)^.5

```

Try it online!

# Answer
> 1 votes
# OML, 57 bytes

```
"The hypotenuse of this right triangle is "shnhn+A6`*N3eD

```

Try it online!

## Part 1

This simply outputs the string

```
"The hypotenuse of this right triangle is "s

```

## Part 2

```
hnhn+A6`*N3eD
hn              take input and square it
  hn            take another input and square it
    +           add them
     A6`        push 10^6
        *       multiply the sum with that number
         N      take integer square root
          3eD   output with three places of precision
                implicit output

```

# Answer
> 1 votes
# Jelly, 32 characters

```
,²S½ær3µ,“¡ÆC⁷⁺ɱSoṿȤç½?⁶Ẏtḍỵŀ»ṚK

```

Try it online!

There is probably a better string compression that allows me to get around needing to join with spaces but I was having trouble finding it.

**Explanation:**

```
,²S½ær3µ,“...»ṚK    Example inputs: 3, 4
,                   Pair the inputs. Result: [3, 4]
 ²                  Square them. Result: [9, 16]
  S                 Sum them. Result: 25
   ½                Get the square root of the sum. Result: 5
    ær3             Round to 3 decimal places. Result: 5
       µ            Take the result of that... Result: 5
         “...»       ...and  the compressed string Result: "The hypotenuse of this right triangle is"
        ,           And put them into a pair. Result: [5, "The hypotenuse of this right triangle is"]
              Ṛ     Reverse that. Result: ["The hypotenuse of this right triangle is", 5]
               k    Join it with spaces. Result: "The hypotenuse of this right triangle is 5.0"
                    Implicit output.

```

# Answer
> 1 votes
# JavaScript, 70 bytes

```
(a,b)=>'The hypotenuse of the triangle is '+((a*a+b*b)**.5).toFixed(3)

```

The latter function rounds the number to 3 decimal places.

# Answer
> 1 votes
# Vyxal, ~~32~~ 30 bytes

```
∆/`λƛ h⁼Ǐ¢Ṗλ₇ of λ× ¬ẋ Ȧ⇩ is Π

```

Try it Online!

# Answer
> 1 votes
# Fig, \\$36\log\_{256}(96)\approx\\$ 29.632 bytes

```
+qDFQ$XS)s2lSXreS8x%twBEZ:x@KUX"mqS*

```

Try it online!

# Answer
> 0 votes
## Javascript, 109

```
A=1,B=1,s=1e3,console.log("The hypotenuse of this right triangle is " + (Math.round(Math.sqrt(A*A+B*B)*s)/s))

```

Fiddledee

# Answer
> 0 votes
## Scala (95c)

```
import Math._;val x=sqrt(pow(a,2)+pow(b,2));f"The hypotenuse of this right triangle is $x%1.3g"

```

# Answer
> 0 votes
## Java : 223

```
   class l {
        public static void main(String[] args) {
          new l().H(2,4);
        }
        void H(float a, float b)
    {
        System.out.printf("The hypotenuse of this right triangle is %.3f",Math.hypot(a,b));
    }
    }

```

# Answer
> 0 votes
## newLISP, 103 characters

```
(let(a 3.1 b 4)(println"The hypotenuse of this right triangle is "(round(pow(add(pow a)(pow b)).5)-3)))

```

The unspecified input method helps a lot... :)

# Answer
> 0 votes
## Groovy : 78 Characters

```
a={x,y->printf"The hypotenuse of this right triangle is %.3f",Math.hypot(x,y)}

```

Assuming the task is just writing a method. If you need to take input parameters:

**99 Characters**

```
printf"The hypotenuse of this right triangle is %.3f",Math.hypot(args[0].toLong(),args[1].toLong())

```

I found two ways to it with the same length:

```
printf"The hypotenuse of this right triangle is %.3f",Math.sqrt(args.collect{it.toLong()**2}.sum())

```

# Answer
> 0 votes
# F#, 78

```
let f a b=sqrt(a*a+b*b)|>printf"The hypotenuse of this right triangle is %.3f"

```

# Answer
> 0 votes
**Java : 155**

```
class A{A(int x,int y){System.out.printf("The hypotenuse of this right triangle is %.3f",Math.hypot(x,y));}public static void main(String[]s){new A(1,4);}}

```

# Answer
> 0 votes
# Javascript 98 characters/bytes

This is implemented as a browser alert in a function.

```
function p(a,b){alert('The hypotenuse of this right triangle is: '+Math.sqrt(a*a+b*b).toFixed(3))};

```

# Answer
> 0 votes
# Fortran (90)

```
read(*,*)a,b;print'(a,f9.3)',"The hypotenuse of this right triangle is ",sqrt(a*a+b*b);end

```

Uses implicit typing so that `a,b` are single precision reals.

# Answer
> 0 votes
# Javascript, 110 bytes

```
function h(a,b){return a/1==a&&b/1==b?'The hypotenuse of this right triangle is '+(a*a+b*b||0).toFixed(3):!1;}

```

It's a monster!!!

But it can handle NaN and invalid numbers, like text, objects, 0/0 and other invalid numbers.

# Answer
> 0 votes
### Ruby 2.1+ (73 characters)

```
f=->a,b{puts"The hypotenuse of this right triangle is %.3f"%(a+b*1i).abs}

```

# Answer
> 0 votes
# Prolog

```
h(A,B):-X is A*A+B*B, C is sqrt(X),format('The hypotenuse of this right triangle is ~3f',C).

```

# Answer
> 0 votes
# Bash with `bc`, 91

No bash script yet?!

```
read a b
echo -n 'The hypotenuse of this right triangle is '
bc<<<"scale=3;sqrt($a^2+$b^2)"

```

There is no way this can win.

# Answer
> 0 votes
**Haskell, 77 characters**

```
(\x y->print$"The hypotenuse of this right triangle is "++(show$sqrt$x^2+y^2))

```

Useage:

```
(\x y->print$"The hypotenuse of this right triangle is "++(show$sqrt$x^2+y^2)) 3.0 4.0
The hypotenuse of this right triangle is 5.0

```

# Answer
> 0 votes
# Fortran 2008 (87 characters)

Based on the Fortran 90 solution, but now in Fortran 2008, HYPOT is an intrinsic function.

```
read(*,*)a,b;print'(a,f9.3)','The hypotenuse of this right triangle is ',hypot(a,b);end

```

# Answer
> 0 votes
# J, 56 bytes

```
'The hypotenuse of this right triangle is '&,@":@(+&.*:)

```

### explanation

J's "Under" verb `&.` is a nice fit here. It applies a transformation, executes a verb, and then applies the reverse transformation to the result. In this case, squaring is the transformation `*:`, its reverse is taking the square root, and the verb in question is addition. So we do addition "under" the square transformation. The rest is just formatting the number and cat'ing it onto the sentence.

Try it online!

# Answer
> 0 votes
# Perl 5, 69 bytes

```
printf"The hypotenuse of this right triangle is %.3f",sqrt<>**2+<>**2

```

Try it online!

# Answer
> 0 votes
# Tcl, 80 bytes

```
puts "The hypotenuse of this right triangle is [expr int(hypot($a,$b)*1e3)/1e3]"

```

Try it online!

# Answer
> 0 votes
# Jq 1.5, 80 bytes

```
"The hypotenuse of this right triangle is \(1e3*pow(map(.*.)|add;.5)|floor/1e3)"

```

Assumes input is `[a,b]`

Try it online at **tio.run** or **jqplay.org**

# Answer
> 0 votes
# Axiom, 92 bytes

```
g(a,b)=="The hypotenuse of this right triangle is "((round((a^2+b^2)^.5*1.e3)/1.e3)::String)

```

test

```
(4) -> g(12, 19)
   (4)  "The hypotenuse of this right triangle is 22.472"
                                                             Type: String

```

# Answer
> 0 votes
# 05AB1E, 53 characters

```
"The hypotenuse of this right triangle is "|nOt₄*ï₄/«

```

Try it online!

I could not figure out how to compress 05AB1E strings. :(

**Explanation:**

```
"..."|nOt₄*ï₄/«

     |             Push array of inputs.
      n            Square them.
       O           Get the sum.
        t          Get the square root.
         ₄*        Multiply by 1000
           ï       Convert to integer. This rounds it.
            ₄/     Divide by 1000
"..."         «    Append it to the string.
                   Implicit print.

```

# Answer
> 0 votes
# Petit Computer BASIC, 66 bytes

```
INPUT A,B?"The hypotenuse of this right triangle is ";SQR(A*A+B*B)

```

PTC only displays the first 3 decimal places when printing.

# Answer
> 0 votes
# APL (Dyalog), 51 bytes

```
'The hypotenuse of this right triangle is',3⍕|0j1⊥⎕

```

Try it online!

`0j1⊥⎕`: Convert the input into base `i`. e.g `a b -> b+ai`

`|`: Magnitude

`3⍕`: Round to 3 decimal places

# Answer
> 0 votes
# Stax, 24 bytes

```
╬Z.-êû$P¿[▐Ä√#╙δdr▼▀Ö☺┐ç

```

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

```
`1/yyH\fBXNR&X+{.SC`p   print "The hypotenuse of this right triangle is "
:J+                     square and add the inputs
|Q                      square root
3j                      round to 3 places
p                       print

```

Run this one

# Answer
> 0 votes
# JavaScript (Node.js), 76 bytes

```
a=>b=>'The hypotenuse of this right triangle is '+Math.hypot(a,b).toFixed(3)

```

Try it online!

# Explanation

```
a => b => // the two arguments (curry method)
    `The hypotenuse of this right triangle is // write the text required
    ${Math.hypot(a,b)}` // and use JS Math.hypot function to calculate the hypotenuse.

```

Alternately, if the you spare me the pain of writing this text.

```
f=Math.hypot // is also a valid answer

```

# Answer
> 0 votes
# Japt, 37 bytes

```
`T hypÇQ«e  È ght â0Ø8  `+Nx²¬x3

```

Try it

# Answer
> 0 votes
# Husk, 41 bytes

```
+¨ΣŸṗ¤μe₀fı≤ṙ↔ẏ«G¹∫¨J"."msλ‰⁰i*⁰)1000√¤+□

```

Try it online!

With rounding being involved, I sure didn't pick the right language for the task...

```
+                              The concatenation of
 ¨...¨                         the compressed prefix for the output
          ms                   with the stringified elements of
            λ‰⁰   )1000        the divmod by 1000 of
                       √       the square root of
                         +     the sum of
                        ¤ □    the squares of the two arguments
                *⁰             times 1000
               i               converted to an integer
      J"."                     with a period inserted between them.

```

Computing the actual length of the hypotenuse only takes four bytes, rounding to three decimal places takes seventeen bytes, and adding on `The hypotenuse of this right triangle is` to the output takes twenty bytes. 90.244% of this answer is just formatting!

# Answer
> 0 votes
# Pyth, 51 bytes

```
+." y¢ó³-.n?ãÜPŽýD'9¹i¾5ŠÁ«£¿9WhI‚".R@s^RJ2QJ3

```

Try it online!

---

The actual math only takes up 8 bytes.

Despite having built-in string compression capabilities, Pyth is pretty bad at compressing strings.

# Answer
> 0 votes
# Jelly, 28 bytes

```
ÆḊær3“¡ÆC⁷⁺ɱSoṿȤç½?⁶Ẏtḍỵŀ»,K

```

Try it online!

## How it works

```
ÆḊær3“¡ÆC⁷⁺ɱSoṿȤç½?⁶Ẏtḍỵŀ»,K - Main link. Takes a pair [a, b] as input
ÆḊ                           - Take the norm √(a²+b²)
  ær3                        - Round the 3 decimal places
     “¡ÆC⁷⁺ɱSoṿȤç½?⁶Ẏtḍỵŀ»   - "The hypotenuse of this right triangle is"
                          ,  - Pair the string with the norm
                           K - Insert a space between the two

```

# Answer
> 0 votes
# Rust, 72 bytes

```
|a,b|print!("The hypotenuse of this right triangle is {:.3}",a.hypot(b))

```

Try it online!

Woohoo, rust has built-ins for this. The `hypot` method calculates the hypotenuse between the numbers. Instead of the usual `"{}"` format substitution I used `"{:.3}"` which forces the number to display with three decimal places.

# Answer
> 0 votes
# Go, 108 bytes

```
import(."fmt";."math")
func f(a,b float64){Printf("The hypotenuse of the triangle is %.3f\n",Sqrt(a*a+b*b))}

```

Attempt This Online!

# Answer
> 0 votes
# Thunno `Kj`, \\$ 46 \log\_{256}(96) \approx \\$ 37.86 bytes

```
AO3Zu"The hypotenuse of this right triangle is

```

Attempt This Online!

Not having string compression really hurts in challenges like these.

#### Explanation

```
           # Implicit input
AO         # Push the hypotenuse of the inputs (yes, this is a built-in)
  3Zu      # Round to three decimal places
     "...  # Push the string
           # Flags join the stack by spaces
           # Implicit output

```

# Answer
> 0 votes
# Thunno 2 `j`, 35 bytes

```
ÆH3ȯ‘The hypotenuse of ċṠ Ṗṇ ġḳ is

```

Attempt This Online!

4 bytes (`ÆH3ȯ`) for the main bit, and 31 bytes for the compressed string.

#### Explanation

```
ÆH3ȯ‘...  # Implicit input
ÆH        # Compute hypotenuse
  3ȯ      # Round to 3 d.p.s
    ‘...  # Push compressed string
          # Join the stack
          # Implicit output

```

---
Tags: code-golf, math
---


title: Am I not good enough for you?

text:
# Question
Title: Am I not good enough for you?
### Background:

The current Perfect Numbers challenge is rather flawed and complicated, since it asks you to output in a complex format involving the factors of the number. This is a purely repost of the challenge.

## Challenge

Given a positive integer through any standard input format, distinguish between whether it is perfect or not.

A perfect number is a number that is equal to the sum of all its proper divisors (its positive divisors less than itself). For example, \\$6\\$ is a perfect number, since its divisors are \\$1,2,3\\$, which sum up to \\$6\\$, while \\$12\\$ is not a perfect number since its divisors ( \\$1,2,3,4,6\\$ ) sum up to \\$16\\$, not \\$12\\$.

### Test Cases:

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

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

```

### Rules

* Your 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.
* Output can be two distinct and consistent values through any allowed output format. If it isn't immediately obvious what represents Perfect/Imperfect, please make sure to specify in your answer.

# Answer
> 17 votes
# Brachylog, 4 bytes

```
fk+?

```

Try it online!

The predicate succeeds for perfect inputs and fails for imperfect inputs, printing `true.` or `false.` if run as a complete program (except on the last test case which takes more than a minute on TIO).

```
        The input's
f       factors
 k      without the last element
  +     sum to
   ?    the input.

```

# Answer
> 11 votes
# Neim, 3 bytes

```

```

Try it online!

(I don't actually know how to run all of the test cases at once, since I started learning Neim about fifteen minutes ago, but I did check them individually.)

Prints 0 for imperfect, 1 for perfect.

```
      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.

```

# Answer
> 9 votes
# , ~~33~~ 29 bytes

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

```

Try it online!

Returns `TRUE` for perfect numbers and `FALSE` for imperfect ones.

# Answer
> 8 votes
# Japt `-!`, 4 bytes

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

```

*For some reason `¦` doesnt work on tio so I need to use the `-!` flag and `¥` instead*

Try it online!

# Answer
> 7 votes
# Jelly, 3 bytes

```
Æṣ=

```

Try it online!

# Answer
> 6 votes
# Python 3, 46 bytes

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

```

Try it online!

Brute force, sums the factors and checks for equality.

# Answer
> 5 votes
# C# (Visual C# Interactive Compiler), 46 bytes

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

```

Returns 0 if perfect, otherwise returns a positive number. I don't know if outputting different types of integers are allowed in place of two distinct truthy and falsy values, and couldn't find any discussion on meta about it. If this is invalid, I will remove it.

Try it online!

# C# (Visual C# Interactive Compiler), ~~49~~ 47 bytes

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

```

Try it online!

# Answer
> 5 votes
# Octave, 25 bytes

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

```

Try it online!

### Explanation

```
@(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

```

# Answer
> 5 votes
# Python, 45 bytes

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

```

`True` for perfect; `False` for others (switch this with `==` -\> `!=`)

**Try it online!**

**~~44 42~~  41 bytes** (-2 thanks to ovs) if we may output using "truthy vs falsey":

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

```

(falsey (`0`)) for perfect; truthy (a non-zero integer) otherwise

# Answer
> 5 votes
# Labyrinth, 80 bytes

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

```

The Latin characters `perfect puts zero else neg I` are actually just comments\*.
i.e. if the input is perfect a `0` is printed, otherwise `-1` is.

**Try it online!**

---

* so this or this work too...

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

```

### How?

Takes as an input a positive integer `n` and places an accumulator variable of `-n` onto the auxiliary stack, then performs a divisibility test for each integer from `n-1` down to, and including, `1`, adding any which do divide `n` to the accumulator. Once this is complete if the accumulator variable is non-zero a `-1` is output, otherwise a `0` is.

The `?::`}:(` is only executed once, at the beginning of execution:

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

```

The next instruction, `"`, is a no-op, but we have three neighbouring instructions so we branch according to the value at the top of Main, zero takes us forward, while non-zero takes us right.

If the input was `1` we go forward because the top of Main is zero:

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

```

But if the input was greater than `1` we turn right because the top of Main is non-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]]

```

At this point we have a three-neighbour branch, but we know `n-1` is non-zero, so we turn right...

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

```

We are now at another three-neighbour branch at `%`.

If the result of `%` was non-zero we go left to decrement our potential divisor, `p=p-1`, and leave the accumulator, `a`, as it is:

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

```

...but if the result of `%` was zero (for the first pass only when `n=2`) we go straight on to BOTH add the divisor to our accumulator, `a=a+p`, AND decrement our potential divisor, `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]]

```

At this point if `p-1` is still non-zero we turn left:

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

```

...but if `p-1` hit zero we go straight up to the `:` on the second line of the labyrinth (you've seen all the instructions before, so I'm leaving their descriptions out and just giving their effect):

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

```

Now this `{` has three neighbouring instructions, so...

...if `a` is zero, which it will be for perfect `n`, then we go straight:

```
"!@                                                          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

```

...if `a` is non-zero, which it will be for non-perfect `n`, then we turn left:

```
_~"!@                                                        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

```

# Answer
> 4 votes
# JavaScript, 38 bytes

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

```

Try it online!

(Last testcase timeout on TIO.)

# Answer
> 4 votes
# Ruby, 33 bytes

```
->n{(1...n).sum{|i|n%i<1?i:0}==n}

```

Try it online!

# Answer
> 4 votes
# Java (JDK), 54 bytes

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

```

Try it online!

Though for a strict number by number matching, the following will return the same values, but is only 40 bytes.

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

```

Try it online!

# Answer
> 4 votes
# TI-BASIC (TI-84), ~~30~~ 23 bytes

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

```

~~Horribly inefficient, but it works.~~
Reducing the bytecount sped up the program by a lot.
Input is in `Ans`.
Output is in `Ans` and is automatically printed out when the program completes.

**Explanation:**
(TI-BASIC doesn't have comments, so just assume that `;` makes a comment)

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

```

**Example:**

```
6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

```

---

**Note:** The byte count of a program is evaluated using the value in **\[MEM\]**\>**\[2\]**\>**\[7\]** (36 bytes) then subtracting the length of the program's name, `CDGF2`, (5 bytes) and an extra 8 bytes used for storing the program:

36 - 5 - 8 = 23 bytes

# Answer
> 4 votes
# x86 Assembly, 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

```

**Explaination** (Intel Syntax):

```
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

```

Input should be provided in `EAX`.
Function sets `EAX` to `1` for perfect and to `0` for imperfect.

**EDIT**: Reduced Byte-Count by two by replacing `MOV EAX, $1` with `XOR EAX, EAX` and `INC EAX`

# Answer
> 4 votes
# Regex (Perl/PCRE+`(?^=)`RME), ~~44~~ 41 bytes

```
((\2x+?|^x\B)(?^=\2+$))++$(?^!(\2x+)\3+$)

```

Try it on replit.com

This was a port of my 48 byte .NET regex below, using lookinto instead of variable-length lookbehind. This makes it far faster, and able to scan all numbers from 0 to 9000 in about 7 seconds on my PC. It also enables somes golfs that aren't possible in the .NET version.

```
                   # No anchor needed, because \2 cannot be initially captured if
                   # matching is started anywhere besides the beginning.
# Sum as many divisors of N as we can (using the current position as the sum),
# without skipping any of them:
(
    (
        \2x+?      # \2 = the smallest number larger than the previous value of \2
                   # for which the following is true; add \2 to the running total
                   # sum of divisors.
    |
        ^x         # This must always be the first step. Add 1 to the sum of
                   # divisors, thus setting \2 = 1 so the next iteration can keep
                   # going.
        \B         # Exclude 1 as a divisor if N == 1. We don't have to do this for
                   # N > 1, because this loop will never be able to add N to the
                   # already summed divisors (as 1 will always be one of them).
    )
    (?^=\2+$)      # Assert that \2 is a divisor of N
)++                # Iterate the above at least once, with a possessive quantifier
                   # to lock in the match (i.e. prevent any iteration from being
                   # backtracked into).
$                  # Require that the sum equal N exactly. If this fails, the loop
                   # won't be able to find a match by backtracking, because
                   # everything inside the loop is done atomically.
# Assert that there are no more proper divisors of N that haven't already been summed:
(?^!               # Lookinto – Assert that the following cannot match:
    (\2x+)         # \3 = any number greater than \2
    \3+$           # Assert \3 is a proper divisor of N
)

```

## Regex (Perl/PCRE+`(?^=)`RME), 45 bytes

```
^(?=(x(?=(x*))(?^=(?(?=\2+$)(\3?+\2))))+$)\3$

```

Try it on replit.com

This is a port of the largest-to-smallest 47 byte .NET regex below, using lookinto instead of variable-length lookbehind.

## Regex (Perl/PCRE+`(?^=)`RME), 47 bytes

```
^(?=((?^0=(x*))(?^=(?(?=\2+$)(\3?+\2)))x)+$)\3$

```

Try it on replit.com

This is a port of the smallest-to-largest 47 byte .NET regex below, using lookinto instead of variable-length lookbehind. This one is less conducive to being ported, and I had to use `(?^0=)`, lookinto accessing the in-progress current match. I've not decided how to finalize the current behavior of this, so it's likely this version will not work with a future version of lookinto.

# Regex (.NET), 47 bytes

```
^(?=((?<=(?=(?(\3+$)((?>\2?)\3)))(^x*))x)+$)\2$

```

Try it online!

```
^(?=(x(?=(x*$)(?<=(?(^\2+)(\2(?>\3?))))))+$)\3$

```

Try it online!

This is based on my 44 byte abundant numbers regex, with is in turn based on Martin Ender's 45 byte abundant numbers regex. It was trivial to adapt to matching perfect numbers; just two small changes were needed, with a third change made for aesthetic purposes.

```
# For the purpose of these comments, the input number will be referred to as N.

^(?=                  # Attempt to add up all the divisors of N.
  (x                  # Cycle through all positive values of tail that are less than N,
                      # testing each one to see if it is a divisor of N. Start at N-1.
    (?=               # Do the below operations in a lookahead, so that upon popping back
                      # out of it our position will remaing the same as it is here.
      (x*$)           # \2 = tail, a potential divisor; go to end to that the following
                      # lookbehind can operate on N as a whole.
      (?<=            # Switch to right-to-left evaluation so that we can operate both
                      # on N and the potential divisor \2. This requires variable-length
                      # lookbehind, a .NET feature. Please read these comments in the
                      # order indicated, from [Step 1] to [Step 4].
        (?(^\2+)      # [Step 1] If \2 is a divisor of N, then...
          (           # [Step 2] Add it to \3, the running total sum of divisors:
                      #          \3 = \3 + \2
            \2        # [Step 4] Iff we run out of space here, i.e. iff the sum would
                      #          exceed N at this point, the match will fail, and the
                      #          summing of divisors will be halted. It can't backtrack,
                      #          because everything in the loop is done atomically.
            (?>\3?)   # [Step 3] Since \3 is a nested backref, it will fail to match on
                      #          the first iteration. The "?" accounts for this, making
                      #          it add zero to itself on the first iteration. This must
                      #          be done before adding \2, to ensure there is enough room
                      #          for the "?" not to cause the match to become zero-length
                      #          even if \3 has a value.
          )
        )
      )
    )
  )+                  # Using "+" instead of "*" here is an aesthetic choice, to make it
                      # clear we don't want to match zero. It doesn't actually make a
                      # difference (besides making the regex ever so slightly more
                      # efficient) because \3 would be unset anyway for N=0.
  $                   # We can only reach this point if all proper divisors of N, all the
                      # way down to \2 = 1, been successfully summed into \3.
)
\3$                   # Require the sum of divisors to be exactly equal to N.

```

# Regex (.NET), 48 bytes

```
((?=.*(\1x+$)(?<=^\2+))\2|^x\B)+$(?<!^\3+(x+\2))

```

Try it online!

This is based on my 43 byte abundant numbers regex. It was interesting and somewhat tricky to adapt into a fully golfed perfect numbers regex.

```
                   # No anchor needed, because \1 cannot be initially captured if
                   # matching is started anywhere besides the beginning.
# Sum as many divisors of N as we can (using the current position as the sum),
# without skipping any of them:
(
    (?=            # Atomic lookahead:
        .*(\1x+$)  # \2 = the smallest number larger than the previous value of \1
                   # (which is identical to the previous value of \2) for which the
                   # following is true. We can avoid using "x+?" because the ".*"
                   # before this implicitly forces values to be tested in increasing
                   # order from the smallest.
        (?<=^\2+)  # Assert that \2 is a divisor of N
    )
    \2             # Add \2 to the running total sum of divisors
|
    ^x             # This must always be the first step. Add 1 to the sum of divisors,
                   # thus setting \1 = 1 so the next iteration can keep going
    \B             # Exclude 1 as a divisor if N == 1. We don't have to do this for
                   # N > 1, because this loop will never be able to add N to the
                   # already summed divisors (as 1 will always be one of them).
)+$                # Require that the sum equal N exactly. If this fails, the loop
                   # won't be able to find a match by backtracking, because everything
                   # inside the loop is done atomically.
# Assert that there are no more proper divisors of N that haven't already been summed:
(?<!               # Assert that the following, evaluated right-to-left, cannot match:
    ^\3+           # [Step 2] is a proper divisor of N
    (x+\2)         # [Step 1] Any value of \3 > \2
)

```

# Regex (Perl / PCRE2 v10.35+), ~~64~~ ~~60~~ 57 bytes

This is a port of the 41 byte regex, emulating variable-length lookbehind using a recursive subroutine call.

```
(?=((\2x+?|^x\B)((?<=(?=^\2+$|(?3)).)))++$)(?!(\2x+)\4+$)

```

Try it online! \- Perl
Attempt This Online! \- PCRE2 v10.40+

```
                   # No anchor needed, because \2 cannot be initially captured if
                   # matching is started anywhere besides the beginning.
(?=
    # Sum as many divisors of N as we can (using the current position as the sum),
    # without skipping any of them:
    (
        (
            \2x+?      # \2 = the smallest number larger than the previous value of \2
                       # for which the following is true; add \2 to the running total
                       # sum of divisors.
        |
            ^x         # This must always be the first step. Add 1 to the sum of
                       # divisors, thus setting \2 = 1 so the next iteration can keep
                       # going.
            \B         # Exclude 1 as a divisor if N == 1. We don't have to do this for
                       # N > 1, because this loop will never be able to add N to the
                       # already summed divisors (as 1 will always be one of them).
        )
        ((?<=          # Define subroutine (?3); lookbehind
            (?=        # Circumvent the constant-width limitation of lookbehinds
                       # in PCRE by using a lookahead inside the lookbehind
                ^\2+$  # This is the payload of the emulated variable-length
                       # lookbehind: Assert that \2 is a divisor of N
            |
                (?3)   # Recursive call - this is the only alternative that can
                       # match until we reach the beginning of the string
            )
            .          # Go back one character at a time, trying the above
                       # lookahead for a match each time
        ))
    )++                # Iterate the above at least once, with a possessive quantifier
                       # to lock in the match (i.e. prevent any iteration from being
                       # backtracked into).
    $                  # Require that the sum equal N exactly. If this fails, the loop
                       # won't be able to find a match by backtracking, because
                       # everything inside the loop is done atomically.
)
# Assert that there are no more proper divisors of N that haven't already been summed:
(?!                # Assert that the following cannot match:
    (\2x+)         # \4 = any number greater than \2
    \4+$           # Assert \4 is a proper divisor of N
)

```

It isn't practical to directly port the 47 byte regex to PCRE, because it changes the value of a capture group inside the lookbehind, and upon the return of any subroutine in PCRE, all capture groups are reset to the values they had upon entering the subroutine. It is possible, however, and I did this for the corresponding Abundant numbers regex by changing the main loop from iteration into recursion.

# Regex (ECMAScript), 53 bytes – Even perfect numbers

If it is ever proved that there are no odd perfect numbers, the following would be a robust answer, but for now it is noncompeting, as it only matches even perfect numbers. It was written by Grimmy on 2019-03-15.

```
^(?=(x(x*?))(\1\1)+$)((x*)(?=\5$))+(?!(xx+)\6+$)\1\2$

```

Try it online!

This uses the fact that every even perfect number is of the form \\$2^{n-1} (2^n-1)\\$ where \\$2^n-1\\$ is prime. For \\$2^n-1\\$ to be prime, it is necessary that \\$n\\$ itself be prime, so the regex does not need to do a \\$log\_2\\$ test on \\$2^n\\$ to verify \\$n\\$ is prime. (I have used \\$n\\$ here instead of \\$p\\$ to make that clear.)

```
^                     # N = tail = input
(?=(x(x*?))(\1\1)+$)  # Assert that the largest odd divisor of N is >= 3 (due to
                      # having a "+" here instead of "*"; this is not necessary, but
                      # speeds up the regex's non-match when N is a a power of 2);
                      # \1 = N / {largest odd divisor of N}
                      #    == {largest power of 2 divisor of N}; \2 = \1 - 1
((x*)(?=\5$))+        # tail = N / {largest power of 2 divisor of N}
                      #      == {largest odd divisor of N}
(?!(xx+)\6+$)         # Assert tail is prime
\1\2$                 # Assert tail == \1*2 - 1; if this fails to match, it will
                      # backtrack into the "((x*)(?=\5$))+" loop (effectively
                      # multiplying by 2 repeatedly), but this will always fail
                      # to match because every subsequent match attempt will be
                      # an even number, and "\1\2$" can only be odd.

```

# Answer
> 3 votes
# Pyth, 9 ~~13~~ bytes

```
qsf!%QTSt

```

Try it online!

Thank you to the commentors for the golf help

Finds all the factors of the input, sums them, and compares that to the original input.

# Answer
> 3 votes
# C (gcc), 41 bytes

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

```

Try it 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

```

Let me know if that failure for the final case is an issue.

# Answer
> 3 votes
# Forth (gforth), 45 bytes

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

```

Try it online!

### Explanation

Loops over every number from 1 to n-1, summing all values that divide n perfectly. Returns true if sum equals n

### Code Explanation

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

```

# Answer
> 3 votes
# Husk, 5 bytes

```
=¹ΣhḊ

```

Yields `1` for a perfect argument and `0` otherwise.

**Try it online!**

### How?

```
=¹ΣhḊ - Function: integer, n   e.g. 24
    Ḋ - divisors                    [1,2,3,4,6,8,12,24]
   h  - initial items               [1,2,3,4,6,8,12]
  Σ   - sum                         36
 ¹    - first argument              24
=     - equal?                      0

```

# Answer
> 3 votes
# Actually, 5 bytes

```
;÷Σ½=

```

Full program taking input from STDIN which prints `1` for perfect numbers and `0` otherwise.

**Try it online!**

### How?

```
;÷Σ½= - full program, implicitly place input, n, onto the stack
;     - duplicate top of stack
 ÷    - divisors (including n)
  Σ   - sum
   ½  - halve
    = - equal?

```

# Answer
> 3 votes
# MathGolf, ~~5~~ 4 bytes

```
─╡Σ=

```

Try it online!

## Explanation

```
─       get divisors (includes the number itself)
 ╡      discard from right of list (removes the number itself)
  Σ     sum(list)
   =    pop(a, b), push(a==b)

```

Since MathGolf returns divisors rather than proper divisors, the solution is 1 byte longer than it would have been in that case.

# Answer
> 3 votes
# Kotlin, 38 bytes

```
{i->(1..i-1).filter{i%it==0}.sum()==i}

```

Expanded:

```
{ i -> (1..i - 1).filter { i % it == 0 }.sum() == i }

```

Explanation:

```
  {i->                      start lambda with parameter i
    (2..i-1)                create a range from 2 until i - 1 (potential divisors)
      .filter{i%it==0}      it's a divisor if remainder = 0; filter divisors
        .sum()              add all divisors
          ==i                compare to the original number
             }               end lambda

```

Try it online!

# Answer
> 3 votes
# Qbasic, ~~53~~ 47 bytes

Thank you @Deadcode, -6 bytes

```
INPUT n
FOR i=1TO n-1
s=s-i*(n\i=n/i)
NEXT
?n=s

```

Literally quite Basic... Prints `-1` for perfect numbers, `0` otherwise.

REPL

# Answer
> 3 votes
# MATL, 5 bytes

```
EGZ\s=

```

Try it out at MATL Online

**Explanation**

```
      % Implicitly grab the input as an integer
      %    STACK: { 6 }
E     % Multiply by two
      %    STACK: { 12 }
G     % Grab the input again
      %    STACK: { 12,  6 }
Z\    % Compute all divisors (including itself)
      %    STACK: { 12,  [1, 2, 3, 6] }
s     % Sum up these divisors
      %    STACK: { 12, 12 }
=     % Check that the two elements on the stack are equal
      %    STACK: { 1 }
      % Implicitly display the result

```

# Answer
> 3 votes
# VDM-SL, 101 bytes

```
f(i)==s([x|x in set {1,...,i-1}&i mod x=0])=i;s:seq of nat+>nat
s(x)==if x=[]then 0 else hd x+s(tl x)

```

Summing in VDM is not built in, so I need to define a function to do this across the sequences, this ends up taking up the majority of bytes

A full program to run might look like this:

```
functions
f:nat+>bool
f(i)==s([x|x in set {1,...,i-1}&i mod x=0])=i;s:seq of nat+>nat
s(x)==if x=[]then 0 else hd x+s(tl x)

```

# Answer
> 3 votes
# Gaia, 4 bytes

```
dΣ⁻=

```

Try it online!

1 for perfect, 0 for imperfect.

```
d	| implicit input, n, push divisors
 Σ	| take the sum
  ⁻	| subtract n
   =	| equal to n?
```

# Answer
> 3 votes
# Machine Language (x86 32-bit), ~~24~~ 23 bytes

This is a macro that takes an unsigned integer in EAX as input (N), and outputs the result in the Zero Flag (set=perfect, clear=imperfect). It also outputs a result in the Carry Flag (set=abundant, clear=non-abundant). As such, it's actually an answer for both this question and An abundance of integers!, requiring no modification.

It's based on 640KB's abundant numbers answer, with the two additional optimizations from l4m2's answer, where the divisors are subtracted from N instead of added to it (thus simultaneously setting the flags for the return value). An input of 1 is correctly handled, costing ~~3~~ 2 bytes.

```
89 C1 89 C3 9E EB 0E 31 D2 50 F7 F1 58 85 D2 75 04 29 CB 72 02 E2 F0

```

Try it online!

```
89 C1              mov  ecx, eax     ; copy input number into ECX
89 C3              mov  ebx, eax     ; copy input number into EBX
9E                 sahf              ; in case input number is 1, let ZF=0 and CF=0
EB 0E              jmp  cont_loop    ; exclude original number as a divisor
       fact_loop:
31 D2              xor  edx, edx     ; clear EDX (high word for dividend)
50                 push eax          ; save original dividend
F7 F1              div  ecx          ; divide EDX:EAX / ECX
58                 pop  eax          ; restore dividend
85 D2              test edx, edx     ; if remainder = 0, it divides evenly
75 04              jnz  cont_loop    ; if not, continue loop
29 CB              sub  ebx, ecx     ; Subtract divisor from EBX; this simultaneously
                                     ; changes the running total, and sets the flags for
                                     ; the return value.
72 02              jc   done         ; If CF=1, the sum of divisors subtracted from EBX has
                                     ; exceeded our input number, meaning it is abundant,
                                     ; and we need to exit the loop now to return this
                                     ; result in the flags.
       cont_loop:
E2 F0              loop fact_loop
       done:                         ; return value:
                                     ; (JZ)  = ZF=1 = perfect
                                     ; (JNZ) = ZF=0 = imperfect
                                     ; (JC)  = CF=1 = abundant
                                     ; (JNC) = CF=0 = non-abundant
                                     ; (JA)  = CF=0 and ZF=0 = deficient
                                     ; (JNA) = CF=1 or  ZF=1 = non-deficient

```

# Answer
> 3 votes
# Vyxal,  ~~3+1~~ 3 bytes

```
∆K=

```

Try it Online!

*-1 byte thanks to @Deadcode for telling me to not be an idiot and remember that I added a sum of proper divisors built-in. I actually forgot that I did*

This is: does the sum of the proper divisors of the input (`∆K`) equal the input itself (`=`).

# Answer
> 3 votes
# Machine Language (x86 32-bit), 21 bytes

```
is_perfect:
        mov  ecx, esi       ; copy input number into ECX
	inc  esi
        mov  ebx, esi       ; copy input number + 1 into EBX
fact_loop:
        xor  edx, edx       ; clear EDX (high word for dividend)
        mov  eax, esi
        div  ecx            ; divide (n+1) / ECX
        dec  edx            ; if remainder = 1, n/ECX is zero and ECX is not 1
	                    ; In case EAX = 2^32-1, this doesn't work as intended
	                    ; (get edx=0 for all ECXs)
                            ; According to test 2^(2^n)-1 up to 2^128-1 are all
	                    ; deficient so it happens to be correct
        jnz  cont_loop      ; if not, continue loop
        sub  ebx, eax       ; Subtract divisor from EBX; this simultaneously
                            ; changes the running total, and sets the flags for
                            ; the return value.
        jc   done           ; If CF=1, the sum of divisors subtracted from EBX has
                            ; exceeded our input number, meaning it is abundant,
                            ; and we need to exit the loop now to return this
                            ; result in the flags.
cont_loop:
        loop fact_loop
	dec  ebx            ; Subtract the 1 added into esi for ZF
done:                       ; return value:
                            ; (JZ)  = ZF=1 = perfect
                            ; (JNZ) = ZF=0 = imperfect
end_is_perfect:

```

Try it online!

# Machine Language (x86 32-bit), 22 bytes edited from here with also abundant? output

```
is_perfect:
        mov  ecx, esi       ; copy input number into ECX
        mov  ebx, esi       ; copy input number into EBX
fact_loop:
        xor  edx, edx       ; clear EDX (high word for dividend)
        lea  eax, [esi+1]
        div  ecx            ; divide (n+1) / ECX
        dec  edx            ; if remainder = 1, n/ECX is zero and ECX is not 1
	                    ; In case EAX = 2^32-1, this doesn't work as intended
	                    ; (get edx=0 for all ECXs)
                            ; According to test 2^(2^n)-1 up to 2^128-1 are all
	                    ; deficient so it happens to be correct
        jnz  cont_loop      ; if not, continue loop
        sub  ebx, eax       ; Subtract divisor from EBX; this simultaneously
                            ; changes the running total, and sets the flags for
                            ; the return value.
        jc   done           ; If CF=1, the sum of divisors subtracted from EBX has
                            ; exceeded our input number, meaning it is abundant,
                            ; and we need to exit the loop now to return this
                            ; result in the flags.
cont_loop:
        loop fact_loop
	test ebx, ebx       ; Not SUBed in last cycle
done:                       ; return value:
                            ; (JZ)  = ZF=1 = perfect
                            ; (JNZ) = ZF=0 = imperfect
                            ; (JC)  = CF=1 = abundant
                            ; (JNC) = CF=0 = non-abundant
                            ; (JA)  = CF=0 and ZF=0 = deficient
                            ; (JNA) = CF=1 or  ZF=1 = non-deficient
end_is_perfect:

```

Try it online!

Bad luck in last round `sub` is not runned and a `test` is needed

# Answer
> 3 votes
# Prolog (SWI), ~~70~~ ~~67~~ 63 bytes

*-3 bytes thanks to @Jo King*

*-4 bytes thanks to @Steffan*

```
$N:-bagof(M,(between(1,N,M),N mod M<1),L),sumlist(L,S),S=:=2*N.

```

Try it online!

# Answer
> 3 votes
# Fig, \\$3\log\_{256}(96)\approx\\$ 2.469 bytes

```
=Sk

```

Try it online!

```
=Sk
 S  # Does the sum
  k # Of the divisors
=   # Equal the input?

```

# Answer
> 3 votes
# Qi, 72 bytes (45 characters + 22 brackets)

`(λ(n)((☯(~> △(pass(~>(/ n _)integer?))+(= n)))(cdr(range n 0 -1))))`

# Answer
> 3 votes
# PowerShell, 84 bytes

```
param($n)1..[math]::sqrt($n)|%{$a+=$_,($n/$_)*!($n%$_)};$n-eq(($a|gu)-join"+"|iex)/2

```

Try it online!

# Answer
> 2 votes
# Javascript, 62

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

```

Explanation (although it's pretty simple)

```
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

```

Thanks to *Jo King* for the improvement!

# Answer
> 2 votes
# CJam, 17 bytes

```
ri_,(;{1$\%!},:+=

```

Try it online!

# Answer
> 2 votes
# 05AB1E, 4 bytes

```
Ñ¨OQ

```

Try it online!

**Explanation**

```
  O    # the sum
Ñ      # of the divisors of the input
 ¨     # with the last one removed
   Q   # equals the input

```

# Answer
> 2 votes
## Batch, 81 bytes

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

```

Takes `n` as a command-line parameter and outputs `1` if it is a perfect number. Brute force method, starts the sum at `-n` so that it can include `n` itself in the loop.

# Answer
> 2 votes
# Charcoal, 13 bytes

```
Ｎθ⁼θΣΦθ∧ι¬﹪θι

```

Try it online! Link is to verbose version of code. Outputs `-` for perfect numbers. Uses brute force. Explanation:

```
Ｎθ              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

```

# Answer
> 2 votes
# Wolfram Language (Mathematica), 14 bytes

```
PerfectNumberQ

```

Try it online!

# Answer
> 2 votes
# Pyth, 8 bytes

```
qs{*MPyP

```

Try it online here.

```
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

```

# Answer
> 2 votes
# Retina 0.8.2, ~~44~~ 40 bytes

crossed out 44 is still regular 44

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

^(1+)¶\1$

```

Try it online! Edit: Saved 4 bytes thanks to @Deadcode. Still somewhat slow, so link excludes largest test cases. Explanation:

```
.+
$*

```

Convert to unary.

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

```

Match all factors of the input. This uses overlapping mode, which in Retina 0.8.2 requires all of the matches to start at different positions, so the matches are actually returned in descending order, starting with the original input.

```
1>`¶

```

Delete all of the newlines except for the first. This sums together the proper factors, leaving the original input and sum of factors.

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

```

Test whether they are the same.

# Answer
> 2 votes
# Powershell, ~~46 bytes~~ 43 bytes

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

```

Try it Online!

**Edit:** -3 bytes thanks to @AdmBorkBork

# Answer
> 2 votes
# Java 8, 66 bytes

Someone has to use the stream API at some point, even if there's a shorter way to do it

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

```

Try it online!

# Answer
> 2 votes
# cQuents, 8 bytes

```
?#N=U\zN

```

Try it online!

## Explanation

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

```

# Answer
> 2 votes
# Smalltalk, 34 bytes

```
((1to:n-1)select:[:i|n\\i=0])sum=n

```

# Answer
> 2 votes
# Factor, 57 bytes

```
: f ( x -- ? ) dup [1,b) [ dupd divisor? ] filter sum = ;

```

Try it online!

There is a shorter solution on the Rosetta Code that uses the `divisors` builtin:

```
: f ( n -- ? )  [ divisors sum ] [ 2 * ] bi = ;

```

but I wanted to come up with my own solution.

# Answer
> 2 votes
# Racket, 54 bytes

```
(require math)(define(p n)(=(sum(divisors n))(* 2 n)))

```

Try it online!

# Answer
> 2 votes
# APL(NARS), chars 11, bytes 22

```
{⍵=2÷⍨11π⍵}

```

11π return the sum of all divisors, test:

```
  f←{⍵=2÷⍨11π⍵}
  f¨1 12 13 18 20 1000 33550335
0 0 0 0 0 0 0
  f¨6 28 496 8128 33550336 8589869056
1 1 1 1 1 1

```

# Answer
> 2 votes
# MMIX, 48 bytes (12 instrs)

(jxd¹ -T)

```
00000000: 27010001 f7010000 e3020000 1eff0001  '¢¡¢ẋ¢¡¡ẉ£¡¡œ”¡¢
00000010: feff0006 72ffff01 220202ff 27010101  “”¡©r””¢"££”'¢¢¢
00000020: 5b01fffb 32000002 73000001 f8010000  [¢”»2¡¡£s¡¡¢ẏ¢¡¡

```

Disassembly:

```
perf    SUBU $1,$0,1        // i = n - 1
        PUT  rD,0           // zero out hidiv register
        SETL $2,0           // s = 0
0H      DIVU $255,$0,$1     // loop: t:rR = rD:n /% i
        GET  $255,rR        // t = rR
        ZSZ  $255,$255,$1   // t = t? 0 : i
        ADDU $2,$2,$255     // s += i
        SUBU $1,$1,1        // i--
        PBNZ $1,0B          // iflikely(i) goto loop
        CMPU $0,$0,$2       // r = n <=> s
        ZSZ  $0,$0,1        // r = !r
        POP  1,0            // return r

```

The best part of this is that the only branch in the whole thing is to do a loop. Testing the division is handled by the `ZSZ` instruction (which is also used later to handle a negation).

I could save an instruction if I were allowed to return different results for abundant and deficient numbers.

1. jxd is a program I wrote, available on request; it is like xxd, but with support for only jelly and 05AB1E codepages (and no `-p` or `-r` support, it would be redundant).

# Answer
> 2 votes
# Arturo, ~~25~~ 24 bytes

```
$=>[=∑chop factors<=&]

```

Try it

# Answer
> 2 votes
# Thunno `D`, \\$ 5 \log\_{256}(96) \approx \\$ 4.12 bytes

```
fZHS=

```

Attempt This Online!

#### Explanation

```
fZHS=  # D flag duplicates input
f      # Factors, including 1 and input
 ZH    # Without last item (input)
   S   # Sum this list
    =  # Equal to the input?
       # Implicit output

```

# Answer
> 2 votes
# Pip, 16 bytes

```
a=$+Y{!\a%a}FI,a

```

Attempt This Online!

There's no factors builtin so we have to implement it ourselves

```
a=$+Y{!\a%a}FI,a    ; input on command line
              ,a    ; range(input)
     {     }FI      ; filtered by:
       \a%a         ;  the input mod this number
      !             ;  logical not
  $+Y               ; sum of the list
a=                  ; equals the input?

```

# Answer
> 2 votes
# Pyt, 5 bytes

```
ĐðƩ₂=

```

Try it online!

Returns `True` if perfect, `False` otherwise

```
Đ             implicit input; Đuplicate
 ð            get ðivisors
  Ʃ           Ʃum
   ₂          divide by two
    =         is it equal to the input; implicit print

```

# Answer
> 2 votes
# Stax, 6 bytes

```
ôxⁿ♪σ▀

```

Run and debug it

This is PackedStax, which unpacks to the following 7 bytes:

```
:dNs|+=

```

Run and debug it

# Explanation

```
:d      # divisors
  N     # minus the last item (which is equal to the input)
    |+  # summed
      = # is equal to
   s    # the input

```

Times out for larger test cases on the online interpreter.

# Answer
> 1 votes
# Bash, 56 bytes

Maybe a recursive function will be shorter? My Bash is certainly not strong.

```
s=0;for ((;v++<$1;)){ $[s+=($1%$v<1)*$v-1];};[ $s = $1 ]

```

A full program taking a command line argument which has a return code `0` if it was perfect and `1` otherwise.

**Try it online!**

# Answer
> 1 votes
# Haskell, 35 bytes

```
f x=x==sum[y|y<-[1..x-1],x`mod`y<1]

```

Try it online!

# Answer
> 1 votes
# Twig, 108 bytes

Yeah, I managed to get something longer than Java :/

This creates a macro that you import into your own template and call the method `a`

```
{%macro a(n,x=0)%}{%if n>1%}{%for i in 1..n-1%}{%set x=x+i*(n%i==0)%}{%endfor%}{{x==n}}{%endif%}{%endmacro%}

```

Returns 1 for perfect numbers, nothing for imperfect.

You can try it on https://twigfiddle.com/0or03v (testcases included)

# Answer
> 1 votes
# MACHINE LANGUAGE(X86, 32 bit), 38 bytes

```
00000788  53                push ebx
00000789  8B442408          mov eax,[esp+0x8]
0000078D  31DB              xor ebx,ebx
0000078F  31C9              xor ecx,ecx
00000791  43                inc ebx
00000792  39C3              cmp ebx,eax
00000794  730E              jnc 0x7a4
00000796  31D2              xor edx,edx
00000798  50                push eax
00000799  F7F3              div ebx
0000079B  58                pop eax
0000079C  09D2              or edx,edx
0000079E  75F1              jnz 0x791
000007A0  01D9              add ecx,ebx
000007A2  EBED              jmp short 0x791
000007A4  29C8              sub eax,ecx
000007A6  0F94C0            setz al
000007A9  0FB6C0            movzx eax,al
000007AC  5B                pop ebx
000007AD  C3                ret
000007AE

```

Function lenght: 7AEh-788h=26h=38d; below assembly file that generate obj for linking:

```
; nasmw -fobj  this.asm
; bcc32 -v  file.c this.obj
section _DATA use32 public class=DATA
global _sumd
section _TEXT use32 public class=CODE

_sumd:
      push    ebx
      mov     eax,  dword[esp+  8]
      xor     ebx,  ebx
      xor     ecx,  ecx
.1:   inc     ebx
      cmp     ebx,  eax
      jae     .2
      xor     edx,  edx
      push    eax
      div     ebx
      pop     eax
      or      edx,  edx
      jnz     .1
      add     ecx,  ebx
      jmp     short  .1
.2:   sub     eax,  ecx
      setz    al
      movzx   eax,  al
      pop     ebx
      ret

```

below the C file for link and test that function:

```
#include <stdio.h>
unsigned es[]={1,12,13,18,20,1000,33550335,6,28,496,8128,33550336,0};
int sumd(unsigned);

main(void)
{int  i;
 for(i=0;es[i];++i)
    printf("f(%u)=%u\n",es[i],sumd(es[i]));
 return 0;
}

```

below the macro assembly file source of the .asm one:

```
; nasmw -fobj  this.asm
; bcc32 -v  file.c this.obj
section _DATA use32 public class=DATA
global  _sumd
section _TEXT use32 public class=CODE

_sumd:
<b  |a=^8|b^=b|c^=c
.1:  ++b |b>=a#.2|r^=r|<a|div b|>a|r|=r|jnz .1|c+=b|#.1
.2:  a-=c|setz al|movzx eax, al
>b
ret

```

below the 113 bytes golfing code of above:

```
_sumd:<b|a=^8|b^=b|c^=c|.1:++b|b>=a#.2|r^=r|<a|div b|>a|r|=r|jnz .1|c+=b|#.1|.2:a-=c|setz al|movzx eax, al|>b|ret

```

the results:

```
f(1)=0
f(12)=0
f(13)=0
f(18)=0
f(20)=0
f(1000)=0
f(33550335)=0
f(6)=1
f(28)=1
f(496)=1
f(8128)=1
f(33550336)=1

```

I got the trick of use push eax|div | pop eax from https://codegolf.stackexchange.com/a/181515/58988

# Answer
> 1 votes
# C++ (clang), 55 bytes

```
[](long n){long i,s;for(i=s=n;--i;n%i?:s-=i);return!s;}

```

Try it online!

Can handle `8589869056` just fine thanks to the use of `long`, but this input is not included in the TIO as it takes more than 60 seconds to process. (On my i7-4930K @ 4.1 GHz it takes 65 seconds.)

This has a golf optimization that can't be done in C – `n%i?:s-=i`, using not only the GNU extension of allowing the true or false field of a ternary to be empty, but taking advantage of the fact that in C++, `?:` and `-=` have the same operator precedence with right-to-left associativity – whereas in C `?:` has a higher precedence than `-=`, so the only way to make it work would be as `n%i?:(s-=i)` and then it'd cost 1 byte over `s-=n%i?0:i` rather than saving 1 byte.

# Answer
> 1 votes
# Raku, 24 bytes

```
{$_==sum grep $_%%*,^$_}

```

Try it online!

# Answer
> 1 votes
# Desmos, 45 bytes

```

f(n)=\{\sum_{N=1}^nN\{\mod(n,N)=0,0\}=2n,0\}

```

\\$f(n)\\$ returns \\$1\\$ if \\$n\\$ is a perfect number, \\$0\\$ is \\$n\\$ is an imperfect number.

Try It On Desmos!

Try It On Desmos! - Prettified

# Answer
> 1 votes
# Alice, 17 bytes

```
/O\B!d v
@I/-?+&<

```

Try it online!

Outputs `0` if the number is perfect, `non 0` if imperfect

## Flattened

```
/I\B!d&+?-/O@
/I\             Reads the input
   B            Get all the divisors in ascending order
    !           Remove the input number and save it on the tape
     d&+        Sum all the remaining divisors of the stack
        ?       Get the input from the tape
         -      Subtract from the sum
          /O@   Output and exit

```

# Answer
> 1 votes
# APL (Dyalog/GNU), 18 bytes, ⎕IO=0

```
{⍵=+/(0=⍵|⍨⍳⍵)/⍳⍵}

```

Try it online! (The in-browser version of APL has too small a workspace to handle the larger test cases.)

Explanation:

* `{`...`}` creates an anonymous function (dfn), whose argument becomes the parameter . We'll examine the expression inside the braces from right to left.
    1. `⍳N` generates a vector of the first N numbers starting with the index origin. Since that is set to 0, it goes up to N-1. For this function to work we only need to go up to N/2, but  only accepts integers, and making the division result an integer would take more characters.
    2. `/` with two vector operands produces a new vector with each element of the right vector repeated a number of times equal to the corresponding element of the left vector. In this case we're going to build a vector of N 0s and 1s with 1s only at the positions corresponding to the proper divisors of N; the result will therefore be a vector containing only those divisors.
    3. The expression inside parentheses builds the selector; going right to left again, we start with another `⍳⍵`. (We could have built a DRYer version that didn't need to repeat that, but it would have taken more characters.)
    4. `|` is the divide-and-take-remainder operator (mod). By itself it takes its operands on the opposite order from e.g. C's `%`, but we are transposing it with  to flip that, which removes the need for another pair of parentheses. `⍵|⍨⍳⍵` divides each number from 0 to `⍵-1` into  and returns a vector of the remainders. (Fortunately for this use, `0|N` just returns N rather than throwing a division-by-zero error.)
    5. `0=` is what it looks like: a simple equality test with 0. Applied to a vector, it returns a vector with 1's wherever the original vector had a 0, and 0's everywhere else - exactly what we want for our selector.
    6. Having built our vector of the proper divisors, we then compute the sum of its elements with `+/` (reduction via addition).
    7. Finally, `⍵=` returns our desired result: 1 if the sum is equal to  itself, 0 otheriwse.

# Answer
> 1 votes
# Scala, ~~72~~ 71 bytes

saved 1 byte thanks to the comment.

Try it online!

```
def f(n:Int):Boolean={val F=for(i<-1 until n if n%i<1)yield i;F.sum==n}

```

# Answer
> 1 votes
# Thunno 2, 4 bytes

```
FṫS=

```

Attempt This Online!

#### Explanation

```
FṫS=  # Implicit input     ->  28
F     # Factors of input   ->  [1,2,4,7,14,28]
 ṫ    # Without the tail   ->  [1,2,4,7,14]
  S   # Sum the list       ->  28
   =  # Equals the input?  ->  1
      # Implicit output

```

---
Tags: code-golf, number, decision-problem, number-theory, factoring
---