Determinar superabundância

21

Um número superabundante é um número inteiro n que define um novo limite superior para sua razão com a função de soma do divisor σ. Em outras palavras, n é superabundante se, e somente se, para todos os números inteiros positivos x menores que n :

σ(n)n>σ(x)x

Para alguns dos 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

Uma lista mais longa deles (para casos de teste) pode ser encontrada em OEIS A004394 .

Um caso de teste negativo altamente recomendado (se o seu intérprete puder lidar com isso) é o 360360, porque está vinculado ao último número superabundante.

Desafio

Seu programa deve receber um único número inteiro positivo e gerar um valor de verdade ou falsey que representa se esse número inteiro é superabundante.

Como esse é o , a resposta mais curta em bytes vence.

Nissa
fonte

Respostas:

7

Jelly , 7 bytes

Æs÷$ÞṪ=

Experimente online!

Gelatina , 8 bytes

Æs÷$ÐṀ⁼W

Experimente online!

Suíte de teste!

Explicação

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

    Keep ~ Mantenha os elementos com o valor máximo do link (auto-rangifica).
Soma do divisor.
  ~ $ ~ Divida pelo elemento atual.
      ~W ~ Verifique a igualdade com a entrada agrupada em um singleton.
         ~ (para números inteiros como 360360)
Mr. Xcoder
fonte
Eu acho que você pode fazer Æs÷$ÐṀ=por 7 bytes. Eu não percebi ÐṀrangified, isso é útil saber.
precisa
@dylnan Não, não posso. Embora não possa ser testado online, ele falha 360360. De fato, esta foi a minha versão inicial
Mr. Xcoder 19/12/19
Por que falharia 360360?
perfil completo de Dylnan
@dylnan 360360é o primeiro número pelo qual falharia (acho), porque é o primeiro número a vincular um resultado que ocorreu antes. (e nosso resultado seria [0, 1])
Mr. Xcoder
@ Mr.Xcoder vejo, graças
dylnan
5

Haskell , 73 bytes

-1 byte graças ao Sr. Xcoder. -7 bytes graças 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]

Experimente online!

O sistema de tipos de Haskell não é muito golfe ...

totalmente humano
fonte
4

Oitava , 41 bytes

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

Experimente online!

Explicação

@(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
fonte
3

J , 35 bytes

Agradecemos a Mr.Xcoder por encontrar o problema e a cole por corrigi-lo!

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

Experimente online!

Galen Ivanov
fonte
1
Isso falha 360360(veja o desafio para obter mais detalhes: um caso de teste negativo altamente recomendado é o 360360, porque está vinculado ao último número superabundante. ).
Sr. Xcoder
1
Corrigido para +3 bytes. Experimente online . Trabalhando no golfe. Eu gosto muito do uso #.~(honestamente, a função soma total do divisor é muito boa). O que havia de errado era que, embora o pensamento de fazer {:=>./seja inteligente, ele não satisfaz a parte "maior que" da questão.
Cole
1
Aqui está o que eu vim com para substituir a função sigma, que é ao mesmo comprimento atualmente: (1#.{:(]*0=|~)])\ . Algo está errado com isso, talvez você tenha alguma idéia?
Cole
1
@cole Os créditos para a função soma dos divisores vão para Roger Hui, neste ensaio . Também comecei a escrever outra função sigma, mas parei depois de atingir 9 bytes e decidi que não seria mais curto do que aquele com a fatoração principal. Obrigado por corrigir o problema!
Galen Ivanov
@cole O mais curto outro verbo para soma dos divisores eu vim com é esta: (1#.]*0=|~)1+i.É um gancho e não se encaixam tão facilmente no lugar embora :)
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

Experimente online!

Esta solução usa números racionais para garantir a correção em caso de igualdade. (O teste 360360 levou quase 10 minutos.)

Usando ponto flutuante, 2 bytes podem ser salvos com a divisão esquerda:

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

Pitão , 14 bytes

( FryAmTheEggman salvou 1 byte)

qh.Mcs*M{yPZZS

Experimente aqui! ou veja mais casos de teste.

Apenas minha submissão obrigatória ao Pyth, que provavelmente é jogável.

Quão?

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

             S ~ Os números inteiros no intervalo [1, Q].
  .M ~ Obtenha os elementos com o valor máximo da função.
    cs * M {yPZZ ~ Função da tecla: usa uma variável Z.
         yPZ ~ O conjunto de fatores primos de Z.
        {~ Desduplicado.
      * M ~ Produto de cada um.
     s ~ E resumido.
    c Z ~ Dividido por Z.
 h ~ Primeiro elemento.
q ~ Verifique a igualdade com a entrada. Saídas True ou False.
Mr. Xcoder
fonte
3

05AB1E , 10 bytes

LÑOā/ZQ¨_P

Experimente online! ou como um conjunto de testes

Explicação

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
fonte
Acho que (embora não tenha certeza) isso falha 360360(veja o desafio para obter mais detalhes: um caso de teste negativo altamente recomendado é o 360360, porque está vinculado ao último número superabundante. ).
Sr. Xcoder 19/12/19
@ Mr.Xcoder: Verdade. Corrigido, mas pode haver uma maneira melhor de fazer isso agora.
Emigna
3

Python 3 , 77 bytes

-1 byte graças a Rod. -3 bytes graças a Dennis.

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

Experimente online!

totalmente humano
fonte
2

R usando numbers, 59 bytes

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

Mathematica, 53 50 bytes

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

Função pura. Toma um número inteiro como entrada e retorna Trueou Falsecomo saída.

LegionMammal978
fonte
Algo como Tr@Divisors@#funciona?
user202729
1

Japt v2.0a0, 12 16 bytes

O cérebro privado de sono parece não melhorar ainda mais!

Retorna 1para verdade ou 0para falsey.

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

Tente

Sacrificado 4 bytes para manipular 360360.


Explicação

  • Entrada implícita de número inteiro U.
  • Æ Ãcria uma matriz de números inteiros de 0para U-1e passa cada um deles através da seguinte função como X.
  • ârecebe os divisores de U.
  • ÷Udivide cada um deles por U.
  • x soma os resultados.
  • recebe os divisores de X.
  • ÷Xdivide cada um deles por X.
  • x soma os resultados.
  • > verifica se o primeiro resultado é maior que o segundo.
  • × reduz a matriz resultante de booleanos por multiplicação.
Shaggy
fonte
1
Se a sua abordagem atual corresponder à sua explicação, ela falhará para 360360outros números inteiros: um caso de teste negativo altamente recomendado (se o seu intérprete puder lidar com isso) é 360360, porque está vinculado ao último número superabundante
Sr. Xcoder
@ Mr.XCoder: Nozes, você está certo! Isso provavelmente me custará alguns bytes quando eu tiver um momento para corrigi-lo.
Salsicha
@ Mr.Xcoder: Corrigido por enquanto, terá que voltar mais tarde para ver se posso melhorar.
Shaggy
0

APL + WIN, 37 bytes

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

Solicita a entrada da tela.

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

Experimente online!

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

Experimente online!

Steadybox
fonte
Então, por que sprecisa retornar um flutuador?
N17
@StephenLeppik Para usar a divisão flutuante em vez da divisão inteira ao comparar s(n)/ncom s(i)/i.
Steadybox
0

Rápido , 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)}

Demora algum tempo (cerca de 6 segundos no TIO) a ser compilado devido às declarações implícitas de tipo no Swift.

Experimente online!

Herman L
fonte
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

Isso primeiro define a função dque é a σfunção e esta é a versão em golf do

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

Podemos definir i como 0, porque i*n%0sempre será igual 0*..., portanto 0.

A próxima metade disso define a função f, que é a função Superabandunce, e é apenas a forma de golfe

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

E isso apenas verifica, como sugere a especificação do desafio, que todos os números inteiros de 1 a n-1 têm um valor d(n)/nmenor que a entrada.

Experimente online!

ATaco
fonte
0

Casca , 9 bytes

εü<m§ṁ/Ḋṫ

Experimente online! Muito lento para o caso de teste 360360.

Explicação

εü<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
fonte
Eu tenho £ü¤<§ṁ/ḊN. Criando a lista inteira 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

requer -E(grátis)

uma implementação direta da especificação,

msh210
fonte
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π é a soma da função dos fatores

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