Determina la sovrabbondanza


21

Un numero sovrabbondante è un numero intero n che imposta un nuovo limite superiore per il suo rapporto con la funzione di somma divisore σ. In altre parole, n è sovrabbondante se e solo se, per tutti gli interi positivi x che sono inferiori a n :

σ(n)n>σ(X)X

Per alcuni dei valori:

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

Un elenco più lungo di questi (per casi di test) è disponibile in OEIS A004394 .

Un caso di test negativo altamente raccomandato (se l'interprete è in grado di gestirlo) è 360360, poiché si lega all'ultimo numero sovrabbondante.

Sfida

Il programma dovrebbe contenere un unico numero intero positivo e generare un valore di verità o falsità che indica se quel numero intero è sovrabbondante.

Dato che si tratta di , vince la risposta più breve in byte.

Risposte:


7

Gelatina , 7 byte

Æs÷$ÞṪ=

Provalo online!

Gelatina , 8 byte

Æs÷$ÐṀ⁼W

Provalo online!

Test Suite!

Spiegazione

Æs ÷ $ ÐṀ⁼W ~ Programma completo (monadico).

    ÐṀ ~ Mantieni gli elementi con il valore di collegamento massimo (auto-rangifica).
~s ~ Divisor sum.
  ÷ $ ~ Dividi per l'elemento corrente.
      ⁼W ~ Controlla l'uguaglianza con l'input racchiuso in un singleton.
         ~ (per numeri interi come 360360)

Penso che tu possa fare Æs÷$ÐṀ=per 7 byte. Non mi rendevo conto di quanto fosse ÐṀvariato, è utile saperlo.
dylnan,

@dylnan No, non posso. Sebbene non possa essere testato online, fallisce 360360. In realtà, questa era la mia versione iniziale
Mr. Xcoder il

Perché fallirebbe 360360?
dylnan,

@dylnan 360360è il primo numero che fallirebbe (credo), perché è il primo numero a legare un risultato che si è verificato prima. (e il nostro risultato sarebbe [0, 1])
Mr. Xcoder il

@ Mr.Xcoder Vedo, grazie
Dylnan,

5

Haskell , 73 byte

-1 byte grazie a Mr. Xcoder. -7 byte grazie 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]

Provalo online!

Il sistema di tipi di Haskell non è molto golfoso ...



4

Ottava , 41 byte

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

Provalo online!

Spiegazione

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

3

J , 35 byte

Grazie a Mr.Xcoder per aver trovato il problema e a Cole per averlo risolto!

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

Provalo online!


1
Questo fallisce per 360360(vedi la sfida per maggiori dettagli: un caso di test negativo altamente raccomandato è 360360, perché si lega con l'ultimo numero sovrabbondante. ).
Mr. Xcoder,

1
Risolto per +3 byte. Provalo online . Lavorando sul golf. Mi piace molto l'uso #.~(onestamente l'intera funzione di somma del divisore è davvero bella). Ciò che era sbagliato tra l'altro è che, sebbene il pensiero di fare {:=>./sia intelligente, non soddisfa la parte "maggiore di" della domanda.
Cole

1
Ecco quello che mi è venuta a sostituire la funzione sigma, che si trova alla stessa lunghezza attualmente: (1#.{:(]*0=|~)])\ . Qualcosa non va, forse hai qualche pensiero?
Cole

1
@cole I crediti per la somma della funzione divisori vanno a Roger Hui, in questo saggio . Ho anche iniziato a scrivere un'altra funzione sigma ma mi sono fermato dopo aver raggiunto i 9 byte e ho deciso che non sarebbe stato più breve di quello con la fattorizzazione in primo piano. Grazie per aver risolto il problema!
Galen Ivanov,

@cole L'altro verbo più breve per la somma dei divisori che ho escogitato è questo: (1#.]*0=|~)1+i.è un gancio e non si adatta facilmente al suo posto :)
Galen Ivanov,

3

Julia 0.6 , 52 byte

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

Provalo online!

Questa soluzione utilizza numeri razionali per garantire la correttezza in caso di uguaglianza. (Il test di 360360 ha richiesto quasi 10 minuti.)

Utilizzando il virgola mobile, è possibile salvare 2 byte con la divisione sinistra:

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

3

Pyth , 14 byte

( FryAmTheEggman ha salvato 1 byte)

qh.Mcs*M{yPZZS

Provalo qui! o vedi altri casi di test.

Solo la mia presentazione obbligatoria di Pyth che è molto probabilmente giocabile a golf.

Come?

qh.Mcs * M {yPZZS ~ Programma completo. Q = input.

             S ~ Gli interi nell'intervallo [1, Q].
  .M ~ Ottieni gli elementi con il valore massimo della funzione.
    cs * M {yPZZ ~ Funzione tasto: usa una variabile Z.
         yPZ ~ Il powerset dei fattori primi di Z.
        {~ Deduplicato.
      * M ~ Prodotto di ciascuno.
     s ~ E riassunto.
    c Z ~ Diviso per Z.
 h ~ Primo elemento.
q ~ Controlla l'uguaglianza con l'input. Emette True o False.

3

05AB1E , 10 byte

LÑOā/ZQ¨_P

Provalo online! o come una suite di test

Spiegazione

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

Penso che (anche se non ne sono sicuro) fallisce 360360(vedi la sfida per maggiori dettagli: un caso di test negativo altamente raccomandato è 360360, perché si lega con l'ultimo numero sovrabbondante. ).
Mr. Xcoder,

@ Mr.Xcoder: True. Risolto il problema, ma ora potrebbe esserci un modo migliore per farlo.
Emigna,


2

R utilizzando numbers, 59 byte

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

2

Mathematica, 53 50 byte

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

Funzione pura. Accetta un numero intero come input e restituisce Trueo Falsecome output.


Funzionerebbe qualcosa di simile Tr@Divisors@#?
user202729

1

Japt v2.0a0, 12 16 byte

Il cervello privato del sonno non sembra migliorarlo ulteriormente!

Restituisce 1per verità o 0per falsità.

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

Provalo

Sacrificato 4 byte da gestire 360360.


Spiegazione

  • Input implicito di numero intero U.
  • Æ Ãcrea una matrice di numeri interi da 0a U-1e passa attraverso ciascuno la seguente funzione X.
  • âottiene i divisori di U.
  • ÷Udivide ciascuno di quelli per U.
  • x somma i risultati.
  • ottiene i divisori di X.
  • ÷Xdivide ciascuno di quelli per X.
  • x somma i risultati.
  • > controlla se il primo risultato è maggiore del secondo.
  • × riduce l'array risultante di booleani mediante la multiplazione.

1
Se il tuo approccio attuale corrisponde alla tua spiegazione, fallisce per 360360o altri numeri simili: un caso di test negativo altamente raccomandato (se il tuo interprete può gestirlo) è 360360, perché si lega con l'ultimo numero sovrabbondante
Mr. Xcoder

@ Mr.XCoder: Noci, hai ragione! Probabilmente mi costerà qualche byte quando avrò un momento per ripararlo.
Shaggy,

@ Mr.Xcoder: risolto per ora, dovrà tornare più tardi per vedere se posso migliorarlo.
Shaggy,

0

APL + WIN, 37 byte

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

Richiede l'inserimento dello schermo.


0

C (gcc), 99 byte

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;}

Provalo online!

C, 108 byte

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;}

Provalo online!


Quindi, perché è snecessario restituire un galleggiante?
Nissa,

@StephenLeppik Per utilizzare la divisione float anziché la divisione intera durante il confronto s(n)/ncon s(i)/i.
Steadybox,

0

Rapido , 120 118 byte

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

Richiede del tempo (circa 6 secondi su TIO) per la compilazione a causa delle dichiarazioni di tipo implicito in Swift.

Provalo online!



0

Funky , 79 byte

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}

spiegato

Questo prima definisce la funzione dche è la σfunzione, e questa è la versione giocata a golf

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

Possiamo impostare i su 0, perché i*n%0sarà sempre uguale 0*..., quindi0 .

La metà successiva di questo definisce la funzione f, che è la funzione Superabandunce, ed è solo la forma di golf

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

E questo controlla, come suggeriscono le specifiche della sfida, che tutti i numeri interi da 1 a n-1 hanno a d(n)/n inferiore all'input.

Provalo online!



0

Buccia , 9 byte

εü<m§ṁ/Ḋṫ

Provalo online! Troppo lento per il test case 360360.

Spiegazione

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

Ho capito £ü¤<§ṁ/ḊN. Creazione dell'intero elenco di numeri sovrabbondanti
H.Pwiz

0

Perl 5, 84 byte

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

richiede -E (gratuito)

un'implementazione diretta della specifica, giocata a golf


0

APL (NARS), 61 caratteri, 122 byte

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π è la somma delle funzioni dei fattori

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