Determinar la superabundancia

21

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 :

σ(norte)norte>σ(X)X

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 , gana la respuesta más corta en bytes.

Nissa
fuente

Respuestas:

7

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)
Sr. Xcoder
fuente
Creo que puedes hacerlo Æs÷$ÐṀ=por 7 bytes. No me di cuenta ÐṀrangificado, es útil saberlo.
dylnan
@dylnan No, no puedo. Aunque no se puede probar en línea, falla 360360. De hecho, esta fue mi versión inicial
Sr. Xcoder,
¿Por qué fallaría 360360?
dylnan
@dylnan 360360es el primer número en el que fallaría (creo), porque es el primer número que vincula un resultado que ocurrió antes. (y nuestro resultado sería [0, 1])
Sr. Xcoder
@ Mr.Xcoder Ya veo, gracias
dylnan
5

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

totalmente humano
fuente
4

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?
Luis Mendo
fuente
3

J , 35 bytes

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

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

Pruébalo en línea!

Galen Ivanov
fuente
1
Esto falla 360360(vea el desafío para obtener más detalles: un caso de prueba negativa altamente recomendado es 360360, porque se vincula con el último número superabundante ).
Sr. Xcoder
1
Corregido por +3 bytes. Pruébalo en línea . Trabajando en golf. Me gusta mucho el uso #.~(sinceramente, toda la función de suma de divisores es realmente agradable). Lo que estaba mal por cierto es que, aunque la idea de hacer {:=>./es inteligente, no satisface la parte "mayor que" de la pregunta.
cole
1
Esto es lo que ocurrió con reemplazar la función sigma, que está en la misma longitud actualmente: (1#.{:(]*0=|~)])\ . Sin embargo, algo anda mal, ¿tal vez tienes algunos pensamientos?
cole
1
@cole Los créditos para la función de suma de divisores van a Roger Hui, en este ensayo . También comencé a escribir otra función sigma, pero me detuve después de alcanzar los 9 bytes y decidí que no sería más corta que la que tenía la factorización prima. ¡Gracias por solucionar el problema!
Galen Ivanov
@cole El otro verbo más corto para la suma de divisores que se me ocurrió es este: (1#.]*0=|~)1+i.es un gancho y no encaja tan fácilmente en su lugar :)
Galen Ivanov
3

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
Lucas
fuente
3

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.
Sr. Xcoder
fuente
3

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
Emigna
fuente
Creo que (aunque no estoy seguro) esto falla 360360(vea el desafío para obtener más detalles: un caso de prueba negativa muy recomendable es 360360, porque se vincula con el último número superabundante ).
Sr. Xcoder
@ Mr.Xcoder: Cierto. Lo solucionó, pero puede haber una mejor manera de hacerlo ahora.
Emigna
3

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!

totalmente humano
fuente
2

R usando numbers, 59 bytes

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

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.

LegionMammal978
fuente
¿Algo como Tr@Divisors@#funciona?
user202729
1

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.
  • 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.
Lanudo
fuente
1
Si su enfoque actual coincide con su explicación, falla 360360u otros enteros similares: un caso de prueba negativa altamente recomendado (si su intérprete puede manejarlo) es 360360, porque se vincula con el último número superabundante
Sr. Xcoder,
@ Mr.XCoder: ¡Nueces, tienes razón! Eso probablemente me costará algunos bytes cuando tenga un momento para arreglarlo.
Shaggy
@ Mr.Xcoder: solucionado por ahora, tendré que volver más tarde para ver si puedo mejorarlo.
Shaggy
0

APL + WIN, 37 bytes

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

Solicita entrada de pantalla.

Graham
fuente
0

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!

Steadybox
fuente
Entonces, ¿por qué snecesita devolver un flotador?
Nissa
@StephenLeppik Para usar la división flotante en lugar de la división entera al comparar s(n)/ncon s(i)/i.
Steadybox
0

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!

Herman L
fuente
0

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!

Un taco
fuente
0

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.
Zgarb
fuente
Llegué £ü¤<§ṁ/ḊN. Creación de la lista completa de números superabundantes
H.PWiz
0

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

msh210
fuente
0

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
RosLuP
fuente