Dado que tiene una secuencia infinita de números definidos de la siguiente manera:

1: 1 = 1
2: 1 + 2 = 3
3: 1 + 3 = 4
4: 1 + 2 + 4 = 7
5: 1 + 5 = 6
6: 1 + 2 + 3 + 6 = 12
7: 1 + 7 = 8
...

La secuencia es la suma de los divisores de n, incluidos 1 y n.

Dado un entero positivo xcomo entrada, calcule el número más bajo nque producirá un resultado mayor que x.

Casos de prueba

f(100) = 48, ∑ = 124
f(25000) = 7200, ∑ = 25389
f(5000000) = 1164240, ∑ = 5088960

Rendimiento esperado

Su programa debería devolver ambos n y la suma de sus divisores, así:

$ ./challenge 100
48,124

Reglas

Este es el código de golf, por lo que gana el código más corto en bytes, en cada idioma.

Brachylog , 9 bytes

∧;S?hf+S>

Este programa toma la entrada de la "variable de salida" .y las salidas a la "variable de entrada" ?. Pruébalo en línea!

Explicación

∧;S?hf+S>
∧;S        There is a pair [N,S]
   ?       which equals the output
    h      such that its first element's
     f     factors'
      +    sum
       S   equals S,
        >  and is greater than the input.

La variable implícita Nse enumera en orden creciente, por lo que se utiliza su valor legal más bajo para la salida.

Jalea , 18 12 11 10 bytes

1Æs>¥#ḢṄÆs

Pruébalo en línea!

-1 byte gracias al Sr. Xcoder !

Cómo funciona

1Æs>¥#ḢṄÆs - Main link. Argument: n (integer)
1   ¥#     - Find the first n integers where...
 Æs        -   the divisor sum
   >       -   is greater than the input
       Ṅ   - Print...
      Ḣ    -   the first element
        Æs - then print the divisor sum

Wolfram Language (Mathematica) , 53 bytes

{#,f@#}&@@Select[Range[x=#]+1,(f=Tr@*Divisors)@#>x&]&

Pruébalo en línea!

Intenta todos los valores entre 2 y x + 1, donde x es la entrada.

( SelectDevuelve una lista de todos los valores que funcionan, pero la función {#,f@#}&toma todos estos como entradas y luego ignora todas sus entradas, excepto la primera).

R , 71 bytes

function(x)for(n in 1:x){z=sum(which(n%%1:n==0));if(z>x)return(c(n,z))}

Pruébalo en línea!

Casco , 12 11 bytes

§eVḟ>⁰moΣḊN

-1 byte, gracias a @Zgarb!

Pruébalo en línea!

R , 73 bytes

n=scan();while(1){d=(x=1:T)[!T%%x];if(sum(d)>n)break;T=T+1};cat(T,sum(d))

Pruébalo en línea!

Superado por duckmayr .

Japt , 15 bytes

[@<(V=Xâ x}a V]

Intentalo

Explicación

Entrada implícita de entero U. []es nuestro contenedor de matriz. Para el primer elemento, @ }aes una función que se ejecuta continuamente hasta que devuelve un valor verdadero, pasándose un número entero incremental (comenzando en 0) cada vez, y generando el valor final de ese número entero. âobtiene los divisores del entero actual ( X), los xsuma y ese resultado se asigna a la variable V. <comprueba si Ues menor que V. El segundo elemento en la matriz es entonces justo V.

Clojure , 127 bytes

(defn f[n](reduce +(filter #(zero?(rem n %))(range 1(inc n)))))
(defn e[n](loop[i 1 n n](if(>(f i)n){i,(f i)}(recur(inc i)n))))

Pruébalo en línea!

¡Gracias a @steadybox por -4 bytes!

Rubí , 58 bytes

Programa completo porque no estoy seguro si las lambdas están permitidas. /encogimiento de hombros

gets
$.+=1until$_.to_i.<v=(1..$.).sum{|n|$.%n<1?n:0}
p$.,v

Pruébalo en línea!

Explicación

gets     # read line ($_ is used instead of v= because it cuts a space)
$.+=1    # $. is "lines read" variable which starts at 1 because we read 1 line
    until     # repeat as long as the next part is not true
$_.to_i  # input, as numeric
  .<v=   # is <, but invoked as function to lower operator prescedence
  (1..$.)        # Range of 1 to n
  .sum{|n|       # .sum maps values into new ones and adds them together
     $.%n<1?n:0  # Factor -> add to sum, non-factor -> 0
  }
p$.,v    # output n and sum

JavaScript (ES6), 61 58 bytes

f=(n,i=1,s=j=0)=>j++<i?f(n,i,i%j?s:s+j):s>n?[i,s]:f(n,++i)

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Editar: Guardado 3 bytes gracias a @Arnauld.

05AB1E , 11 bytes

>LʒÑO‹}нDÑO

Pruébalo en línea!

Deja el resultado en la pila, según lo permitido por meta consenso . Agregué )por el bien de la visualización, pero el programa también imprime implícitamente la parte superior de la pila.

APL (Dyalog) , 32 bytes

{⍺<o←+/o/⍨0=⍵|⍨o←⍳⍵:⍵,o⋄⍺∇⍵+1}∘0

Pruébalo en línea!

⍵o⍺⍵.

SOGL V0.12 , 14 bytes

1[:Λ∑:A.>?ao←I

Pruébalo aquí!

Explicación:

1               push 1
 [              while ToS != 0
  :Λ              get the divisors
    ∑             sum
     :A           save on variable A without popping
       .>?  ←     if greater than the input
          ao        output the variable A
            ←       and stop the program, implicitly outputting ToS - the counter
             I    increment the counter

C,  79  78 bytes

i,n,s;f(x){for(i=n=s=0;x>s;s+=n%++i?0:i)i-n||(++n,i=s=0);printf("%d %d",n,s);}

Pruébalo en línea!

MATL , 12 bytes

`@Z\sG>~}@6M

Pruébalo en línea!

Explicación

`      % Do...while
  @    %   Push iteration index (1-based)
  Z\   %   Array of divisors
  s    %   Sum of array
  G    %   Push input
  >~   %   Greater than; logical negate. This is the loop condition
}      % Finally (execute on loop exit)
  @    %   Push latest iteration index
  6M   %   Push latest sum of divisors again
       % End (implicit). Run new iteration if top of the stack is true
       % Display stack (implicit)

Gaia , 11 bytes

dΣ@>
↑#(:dΣ

Pruébalo en línea!

Deja el resultado en la pila, según lo permitido por meta consenso . Agregué €.por el bien de la visualización, pero el programa también imprime implícitamente la parte superior de la pila.

Haskell , 59 bytes

f x=[(i,s)|i<-[1..],s<-[sum[d|d<-[1..i],i`mod`d<1]],s>x]!!0

-1 byte, gracias a @nimi!

Pruébalo en línea!

Ohm v2 , 11 bytes

£^DVΣD³>‽;«

Pruébalo en línea!

Factor , 88

USE: math.primes.factors [ 0 0 [ drop 1 + dup divisors sum pick over > ] loop rot drop ]

Búsqueda de fuerza bruta. Es una cita (lambda), callcon xla pila, las hojas ny f(n)la pila.

Como una palabra:

: f(n)>x ( x -- n f(n) )
  0 0 [ drop 1 + dup divisors sum pick over > ] loop rot drop ;

Python 3, 163 bytes

def f(x):
    def d(x):return[i for i in range(1,x+1) if x%i==0]
    return min(i for i in range(x) if sum(d(i)) >x),sum(d(min(i for i in range(x) if sum(d(i)) >x)))

Python 3 , 100 bytes

d=lambda y:sum(i+1for i in range(y)if y%-~i<1)
f=lambda x:min((j,d(j))for j in range(x+1)if x<=d(j))

Pruébalo en línea!

Gracias a Jonathan Frech comentario de sobre el intento anterior de python 3, acabo de ampliar mi conocimiento de la sintaxis de python. Nunca hubiera pensado en el truco - ~ i para i + 1, que ahorra dos personajes.

Sin embargo, esa respuesta es 1) no mínima y 2) no funciona para x = 1 (debido a un error off-by-one que es fácil de hacer mientras se trata de brevedad; sugiero que todos los demás verifiquen sus respuestas para esta ventaja ¡caso!).

Explicación rápida: sum(i+1for i in range(y)if y%-~i<1)es equivalente sum(i for i in range(1,y+1)if y%i<1)pero guarda dos caracteres. Gracias de nuevo al Sr. Frech.

d=lambda y:sum(i+1for i in range(y)if y%-~i<1) por lo tanto, devuelve los divisores de y.

f=lambda x:min((j,d(j))for j in range(x+1)if x<=d(j))es donde realmente trabajé. Como comparar una tupla funciona en el orden del diccionario, podemos comparar j, d (j) tan fácilmente como podemos comparar j, y esto no nos permite encontrar el mínimo j, almacenarlo en una variable y / luego / calcular el tupla en una operación separada. Además, tenemos que tener <=, no <, in x<=d(j), porque d (1) es 1, por lo que si x es 1 no se obtiene nada. Por eso también necesitamos range(x+1)y no range(x).

Anteriormente había devuelto la tupla, pero luego tengo que subíndicela en f, por lo que se necesitan tres caracteres más.

Python 2 , 81 bytes

def f(n):
 a=b=0
 while b<n:
	a+=1;i=b=0
	while i<a:i+=1;b+=i*(a%i<1)
 return a,b

Pruébalo en línea!

Java (OpenJDK 8) , 91 bytes

i->{for(int j=0;j++<i;)for(int k=0,l=0;k++<j;)if((l+=j%k<1?k:0)>i)return k+","+l;return"";}

Pruébalo en línea! (tiempo de espera en el tercer caso de prueba)

Perl 5 , 60 + 1 ( -p) = 61 bytes

$"=$_;until($_>$"){$_=$/=0;$\--;$_+=$\%$/?0:$/until++$/>-$\}

Pruébalo en línea!

Formato de salida:

suma - n

Clojure, 102 bytes

#(loop[i 1](let[s(apply +(for[j(range 1(inc i)):when(=(mod i j)0)]j))](if(> s %)[i s](recur(inc i)))))

PHP, 69 bytes

for(;$argv[1]>=$t;)for($t=$j=++$i;--$j;)$t+=$i%$j?0:$j;echo$i,',',$t;

Perl 6 , 48 bytes

{first :kv,*>$_,map {sum grep $_%%*,1..$_},0..*}

Pruébalo en línea!