Calcola il numero più basso in cui la somma della sequenza di numeri supera un determinato valore

14

Dato che hai una sequenza infinita di numeri definita come segue:

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 sequenza è la somma dei divisori di n, inclusi 1 e n.

Dato un numero intero positivo xcome input, calcola il numero più basso nche produrrà un risultato maggiore di x.

Casi test

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

Uscita prevista

Il tuo programma dovrebbe restituire sia n la somma dei suoi divisori, in questo modo:

$ ./challenge 100
48,124

Regole

Questo è code-golf, quindi vince il codice più breve in byte, in ogni lingua.

code-golf  math 
— StudleyJr
fonte
4
Quella sequenza è solo la somma di ns divisori? Probabilmente vorrai affermarlo esplicitamente.
— Martin Ender,
3
Inoltre, a giudicare dal tuo "output atteso", vuoi entrambi n e f(n) , ma non lo dici da nessuna parte nelle specifiche.
— Martin Ender,
2
I bonus sono cattivi , specialmente quando sono vaghi. Ho deciso di rimuoverlo, al fine di proteggere questo dal downgrade.
— Mr. Xcoder,
2
Potresti ricontrollare f(1000) = 48? La somma divisore di 48is124
— caird coinheringaahing il
3
È bene aspettare almeno una settimana prima di accettare una risposta, altrimenti potresti scoraggiare nuove soluzioni.
— Zgarb,

Risposte:

8

Brachylog , 9 byte

∧;S?hf+S>

Questo programma prende l'input dalla "variabile di output" .e l'output alla "variabile di input" ?. Provalo online!

Spiegazione

∧;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 variabile implicita Nviene elencata in ordine crescente, quindi il suo valore legale più basso viene utilizzato per l'output.

— Zgarb
fonte
10

Gelatina , 18 12 11 10 byte

1Æs>¥#ḢṄÆs

Provalo online!

-1 byte grazie a Mr. Xcoder !

Come funziona

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
— caird coinheringaahing
fonte
Potresti spiegare perché 1è necessario e come ¥agisce?
— dylnan,
1
@dylnan Il 1dice #di iniziare a contare da 1 e ¥prende i due collegamenti precedenti ( Æse >) e li applica come una diade (cioè con due argomenti), con l'argomento sinistro come l'iterazione e l'argomento giusto come input.
— caird coinheringaahing il
Oh, ora ha senso. #in alcuni casi mi aveva confuso un po 'prima.
— Dylnan il
4

Wolfram Language (Mathematica) , 53 byte

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

Provalo online!

Cerca tutti i valori tra 2 e x + 1, dove x è l'input.

( SelectRestituisce un elenco di tutti i valori che funzionano, ma la funzione {#,f@#}&accetta tutti questi come input e quindi ignora tutti i suoi input tranne il primo.)

— Misha Lavrov
fonte
4

Buccia , 12 11 byte

§eVḟ>⁰moΣḊN

-1 byte, grazie a @Zgarb!

Provalo online!

— ბიმო
fonte
Intelligente! Strano però come ,non funziona (o l'inferenza impiega troppo tempo?).
— ბიმო
Ne deduce un tipo, ma genera un elenco infinito. Può essere causato dal sovraccarico di ḟ che accetta un numero intero come secondo argomento, ma è solo una supposizione.
— Zgarb,
4

Japt , 15 byte

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

Provalo

Spiegazione

Input implicito di numero intero U. []è il nostro wrapper di array. Per il primo elemento, @ }aè una funzione che viene eseguita continuamente fino a quando non restituisce un valore di verità, passando ogni volta un numero intero incrementale (a partire da 0) e producendo il valore finale di quel numero intero. âottiene i divisori dell'intero corrente ( X), xli somma e quel risultato viene assegnato alla variabile V. <controlla se Uè inferiore a V. Il secondo elemento dell'array è quindi giusto V.

— ispido
fonte
4

Clojure , 127 byte

(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))))

Provalo online!

grazie a @steadybox per -4 byte!

— Alonoaky
fonte
1
Benvenuti nel sito!
— caird coinheringaahing
Alcuni spazi bianchi possono essere rimossi per salvare pochi byte. Provalo online!
— Steadybox
In questo caso reducepuò essere sostituito da apply, anche la funzione epotrebbe essere espressa come una funzione anonima tramite la #(...)sintassi, non è necessario nominarla su Code Golf. #(=(rem n %)0)è più corto di #(zero?(rem n %)). E ricorda che ,è uno spazio bianco e può essere rimosso in questo caso poiché è seguito da (, quindi verrà analizzato correttamente.
— NikoNyrh,
@NikoNyrh piacere di conoscere un collega chierista, modificherò presto questo post
— Alonoaky,
3

Rubino , 58 byte

Programma completo perché non sono sicuro che i lambda siano ammessi. / scrollata di spalle

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

Provalo online!

Spiegazione

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
— Unihedron
fonte
3
Lambdas sono certamente ammessi.
— Giuseppe,
3

JavaScript (ES6), 61 58 byte

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>
Espandi frammento

Modifica: salvato 3 byte grazie a @Arnauld.

— Neil
fonte
Ottengo "Errore di script". quando si immette un valore superiore a 545
— StudleyJr
Prova a usare Safari; a quanto pare supporta l'ottimizzazione delle chiamate di coda. (O se riesci a trovarli, alcune versioni di Chrome lo abilitano tramite le "Funzioni JavaScript sperimentali".)
— Neil
2

SOGL V0.12 , 14 byte

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

Provalo qui!

Spiegazione:

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
— dzaima
fonte
2

MATL , 12 byte

`@Z\sG>~}@6M

Provalo online!

Spiegazione

`      % 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)
— Luis Mendo
fonte
2

Fattore , 88

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

Ricerca della forza bruta. È una citazione (lambda), callcon xnello stack, foglie nef(n) nello stack.

Come una parola:

: f(n)>x ( x -- n f(n) )
  0 0 [ drop 1 + dup divisors sum pick over > ] loop rot drop ;
— fede s.
fonte
2

Python 3, 163 byte

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)))
— novizio
fonte
3
Ciao e benvenuto in PPCG; bel primo post! Da un aspetto golfistico, è possibile salvare alcuni byte rimuovendo gli spazi bianchi, utilizzando le funzioni lambda, comprimendo tutto su una riga e non ripetendosi. Di solito ci colleghiamo anche a un ambiente di test online, come ad esempio TIO ( 105 byte , utilizzando le tecniche sopra descritte)
— Jonathan Frech,
@JonathanFrech: eccellente commento. Grazie per la pazienza con i noobies in generale e noobin particolare;)
— Eric Duminil,
2

Python 3 , 100 byte

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

Provalo online!

Grazie a Jonathan Frech commento sul precedente tentativo di Python 3, ho appena ampliato notevolmente la mia conoscenza della sintassi di Python. Non avrei mai pensato al trucco - ~ i per i + 1, che salva due personaggi.

Tuttavia, quella risposta è 1) non minima e 2) non funziona per x = 1 (a causa di un errore off-by-one che è facile da fare mentre si va per brevità; suggerisco a tutti gli altri di controllare le loro risposte per questo vantaggio Astuccio!).

Spiegazione rapida: sum(i+1for i in range(y)if y%-~i<1)equivale a sum(i for i in range(1,y+1)if y%i<1)ma salva due caratteri. Grazie ancora a Mr. Frech.

d=lambda y:sum(i+1for i in range(y)if y%-~i<1) pertanto restituisce i divisori di y.

f=lambda x:min((j,d(j))for j in range(x+1)if x<=d(j))è dove ho lavorato davvero. Dato che il confronto di una tupla funziona nell'ordine del dizionario, possiamo confrontare j, d (j) con la stessa facilità con cui possiamo confrontare j, e questo non ci permette di trovare il minimo j, memorizzarlo in una variabile e / quindi / calcolare il tupla in un'operazione separata. Inoltre, dobbiamo avere <=, non <, in x<=d(j), perché d (1) è 1, quindi se x è 1 non ottieni nulla. Questo è anche il motivo per cui abbiamo bisogno range(x+1)e nonrange(x).

In precedenza avevo restituito la tupla, ma poi devo sottoscriverla in f, quindi sono necessari altri tre caratteri.

— Michael Boger
fonte
1
Welcome to the site and nice first post. You can get to 98 bytes by removing the f= as anonymous functions are perfectly acceptable here!
— caird coinheringaahing
You can't call an anonymous function from another line of code, is the problem -- I have a separate print(f(100)) statement to test that the function works.
— Michael Boger
That's not a problem here. It's perfectly acceptable and works to not include the f= in your byte count, and is a good way to golf in Python. Check this for more golfing tips in Python!
— caird coinheringaahing
Hm. I can equal, but not better, my submission by appending q=range and replacing range with q in both existing instances. Sadly, this doesn't improve it and since lambda is a keyword I can't use it for that, I'd have to do exec() tricks wasting too many characters.
— Michael Boger
@MichaelBoger Well, you can call an anonymous function in Python; lambda expressions do not have to be assigned to a variable.
— Jonathan Frech
2

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

Try it online!

— Chas Brown
fonte
— Jonathan Frech
Replacing the tabs with two spaces makes this work in python 3 at 83 bytes, although to try it I had to put parentheses in the print statement. You can also replace the return statement with a print statement and not need an auxiliary function to print it; the bytes stay the same.
— Michael Boger
0

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)))))
— NikoNyrh
fonte
0

PHP, 69 bytes

for(;$argv[1]>=$t;)for($t=$j=++$i;--$j;)$t+=$i%$j?0:$j;echo$i,',',$t;
— chocochaos
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.