Un número superabundante es un número entero n que establece un nuevo límite superior para su relación con la función de suma de divisores σ. En otras palabras, n es superabundante si y solo si, para todos los enteros positivos x que son menores que n :

Para algunos de los valores:

n   σ(n)   σ(n)/n   superabundant
1   1      1.0000   yes
2   3      1.5000   yes
3   4      1.3333   no
4   7      1.7500   yes
5   6      1.2000   no
6   12     2.0000   yes
7   8      1.1429   no
8   15     1.8750   no
9   13     1.4444   no

Puede encontrar una lista más larga de estos (para casos de prueba) en OEIS A004394 .

Un caso de prueba negativa altamente recomendado (si su intérprete puede manejarlo) es 360360, ya que se vincula con el último número superabundante.

Reto

Su programa debe tomar un solo entero positivo y generar un valor verdadero o falso que represente si ese entero es superabundante.

Como se trata de código de golf , gana la respuesta más corta en bytes.

Jalea , 7 bytes

Æs÷$ÞṪ=

Pruébalo en línea!

Jalea , 8 bytes

Æs÷$ÐṀ⁼W

Pruébalo en línea!

¡Banco de pruebas!

Explicación

Æs ÷ $ ÐṀ⁼W ~ Programa completo (monádico).

    ÐṀ ~ Mantenga los elementos con el valor de enlace máximo (rangos automáticos).
Æs ~ Divisor sum.
  ÷ $ ~ Dividir por el elemento actual.
      ⁼W ~ Compruebe la igualdad con la entrada envuelta en un singleton.
         ~ (para enteros como 360360)

Haskell , 73 bytes

-1 byte gracias al Sr. Xcoder. -7 bytes gracias a Laikoni.

r=read.show
s n=sum[r i|i<-[1..n],n`mod`i<1]/r n
f n=all((s n>=).s)[1..n]

Pruébalo en línea!

El sistema de tipos de Haskell no es muy golfoso ...

Haskell , 64 63 61 bytes

-1 byte gracias al Sr. Xcoder .

-2 bytes gracias a Lynn .

a!x=a*sum[y|y<-[1..x],mod x y<1]
f n=and[x!n>n!x|x<-[1..n-1]]

Pruébalo en línea!

Octava , 41 bytes

@(n)([~,p]=max((x=1:n)*~mod(x,x')./x))==n

Pruébalo en línea!

Explicación

@(n)                                       % Define anonymous function of n
                x=1:n                      % Range from 1 to n. Call that x
                        mod(x,x')          % n×n matrix of all pair-wise moduli
                       ~                   % Logical negate. True means it's a divisor
               (     )*                    % Matrix-multiply x times the above matrix
                                           % (gives the dot product of vector x times
                                           % each column of the matrix)
                                 ./x       % Divide each column by each entry in x
     [~,p]=max(                     )      % Index of first occurrence of maximum
    (                                )==n  % Does it equal n?

J , 35 bytes

¡Gracias a Mr.Xcoder por encontrar el problema y a Cole por solucionarlo!

[:([:*/{:>}:)@(%~>:@#.~/.~&.q:)1+i.

Pruébalo en línea!

Julia 0.6 , 52 bytes

n->indmax(sum(x for x=1:m if m%x<1)//m for m=1:n)==n

Pruébalo en línea!

Esta solución utiliza números racionales para garantizar la corrección en caso de igualdad. (La prueba 360360 tomó casi 10 minutos).

Usando coma flotante, se pueden guardar 2 bytes con la división izquierda:

n->indmax(m\sum(x for x=1:m if m%x<1)for m=1:n)==n

Pyth , 14 bytes

^{_{( FryAmTheEggman guardó 1 byte)}}

qh.Mcs*M{yPZZS

Pruébalo aquí! o ver más casos de prueba.

Solo mi presentación obligatoria de Pyth, que probablemente sea golfable.

¿Cómo?

qh.Mcs * M {yPZZS ~ Programa completo. Q = entrada.

             S ~ Los enteros en el rango [1, Q].
  .M ~ Obtenga los elementos con el valor máximo de la función.
    cs * M {yPZZ ~ Función de tecla: utiliza una variable Z.
         yPZ ~ El conjunto de potencia de los factores primos de Z.
        {~ Deduplicado.
      * M ~ Producto de cada uno.
     s ~ Y resumido.
    c Z ~ Dividido por Z.
 h ~ Primer elemento.
q ~ Compruebe la igualdad con la entrada. Salidas Verdadero o Falso.

05AB1E , 10 bytes

LÑOā/ZQ¨_P

Pruébalo en línea! o como un conjunto de pruebas

Explicación

L            # push range [1 ... input]
 Ñ           # divisors of each
  O          # sum of each
   ā/        # divide each by its 1-based index
     Z       # get max
      Q      # compare to each
       ¨     # remove the last element
        _    # logical negation
         P   # product

Python 3 , 77 bytes

-1 byte gracias a Rod. -3 bytes gracias a Dennis.

lambda n:max(range(1,n+1),key=lambda k:sum((k%i<1)/i for i in range(1,k)))==n

Pruébalo en línea!

R usando numbers, 59 bytes

f=function(n)which.max(sapply(1:n,numbers::Sigma)/(1:n))==n

Mathematica, 53 50 bytes

a=Tr@Divisors@#/#&;AllTrue[a@#-Array[a,#-1],#>0&]&

Pura función. Toma un entero como entrada y devuelve Trueo Falsecomo salida.

Japt v2.0a0, 12 16 bytes

¡Parece que el cerebro privado de sueño no puede mejorar más en esto!

Devoluciones 1por veracidad o 0por falsey.

Æâ x÷U >Xâ x÷XÃ×

Intentalo

Sacrificado 4 bytes para manejar 360360.

Explicación

• Entrada implícita de entero U.
• Æ Ãcrea una matriz de números enteros de 0a U-1y pasa a través de cada uno de la siguiente función como X.
• âobtiene los divisores de U.
• ÷Udivide cada uno de esos por U.
• x suma los resultados.
• Xâobtiene los divisores de X.
• ÷Xdivide cada uno de esos por X.
• x suma los resultados.
• > comprueba si el primer resultado es mayor que el segundo.
• × reduce la matriz resultante de booleanos por multiplicación.

APL + WIN, 37 bytes

 ↑1=⍒⌽(+/¨((0=(⍳¨n)|¨n)×⍳¨n)~¨⊂0)÷n←⍳⎕

Solicita entrada de pantalla.

C (gcc), 99 bytes

s(n,j,k){for(j=k=0;j++<n;)k+=n%j?0:j;n=k;}f(n,i,r){for(i=r=0;++i<n;)r=1.*s(n)/n<1.*s(i)/i?:r;r=!r;}

Pruébalo en línea!

C, 108 bytes

float s(n,j,k){for(j=k=0;j++<n;)k+=n%j?0:j;return k;}f(n,i,r){for(i=r=0;++i<n;)s(n)/n<s(i)/i&&++r;return!r;}

Pruébalo en línea!

Swift , 120 118 bytes

let s={n in Float((1...n).reduce(0){n%$1>0 ?$0:$0+$1})}
{n in(1..<n).reduce(0){max($0,s($1)/Float($1))}<s(n)/Float(n)}

Toma algo de tiempo (alrededor de 6 segundos en TIO) compilar debido a las declaraciones de tipo implícitas en Swift.

Pruébalo en línea!

Jalea , 12 bytes

RÆs©Ṫ×R>®×$Ạ

Pruébalo en línea! o Encuentra todos los números superabundantes por debajo de 1000.

porque odio los puntos flotantes.

Funky , 79 bytes

d=n=>fors=i=0i<=n i++s+=i*!n%i
f=n=>{forc=1c<n c++if(d(n)/n)<=d(c)/c return0 1}

Explicado

Esto primero define la función dque es la σfunción, y esta es la versión de golf de

function d(n){
    var s = 0;
    for(var i=0; i<n; i++){
        if(n%i == 0){
            s += i;
        }
    }
    return s;
}

Podemos establecer i en 0, porque i*n%0siempre será igual 0*..., por lo tanto 0.

La siguiente mitad de esto define la función f, que es la función Superabandunce, y es solo la forma de golf de

function f(n){
    for(var c=1; c<n; c++){
        if( (d(n)/n) <= (d(c)/c) ){
            return 0;
        }
    }
    return 1;
}

Y esto solo comprueba, como sugiere la especificación de desafío, que todos los enteros de 1 a n-1 tienen un valor d(n)/nmenor que la entrada.

Pruébalo en línea!

APL (Dyalog) , 33 bytes

{⍵=⊃⌽+⌿∘.≤⍨((+/⍳(/⍨)0=⍳|⊢)÷⊢)¨⍳⍵}

Pruébalo en línea!

Casco , 9 bytes

εü<m§ṁ/Ḋṫ

Pruébalo en línea! Demasiado lento para el caso de prueba 360360.

Explicación

εü<m§ṁ/Ḋṫ  Implicit input, say n=6.
        ṫ  Decreasing range: [6,5,4,3,2,1]
   m       Map this function (example argument k=4):
       Ḋ    Divisors of k: [1,2,4]
    §ṁ      Map and sum
      /     division by k: 7/4
           Result: [2,6/5,7/4,4/3,3/2,1]
 ü         Remove duplicates by
  <        strict comparison. This greedily extracts a non-decreasing subsequence: [2]
ε          Is it a singleton list? Yes.

Perl 5, 84 bytes

say!grep$a[-1]<=$a[$_],0..(@a=map{$i=$_;my$j;map{$i%$_ or$j+=$_/$i}1..$i;$j}1..<>)-2

requiere -E(gratis)

una implementación directa de la especificación, golfizada

APL (NARS), 61 caracteres, 122 bytes

r←f w;m;k
r←m←0
r+←1⋄k←r÷⍨11πr⋄→3×⍳r≥w⋄→2×⍳∼m<k⋄m←k⋄→2
r←k>m

11π es la suma de funciones de factores

  (⍳9),¨ f¨1..9
1 1  2 1  3 0  4 1  5 0  6 1  7 0  8 0  9 0 
  f 360360
0