21

В избытке число является целым числом п , который устанавливает новую верхнюю границу для ее соотношение с функцией делителем суммы а. Другими словами, n является сверхизбыточным тогда и только тогда, когда для всех натуральных чисел x меньше n :

\frac{σ (n)}{n} > \frac{σ (x)}{x}

$\frac{\sigma(n)}n>\frac{\sigma(x)}x$

Для нескольких значений:

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

Более длинный список (для тестовых случаев) можно найти по адресу OEIS A004394 .

Один настоятельно рекомендуемый негативный тестовый случай (если ваш переводчик может его обработать) - 360360, потому что он связан с последним избыточным числом.

Вызов

Ваша программа должна принимать одно положительное целое число и выводить истинное или ложное значение, показывающее, является ли это целое число избыточным.

Поскольку это код-гольф , выигрывает самый короткий ответ в байтах.

— Нисса
источник

7

Желе , 7 байт

Æs÷$ÞṪ=

Попробуйте онлайн!

Желе , 8 байт

Æs÷$ÐṀ⁼W

Попробуйте онлайн!

Тестирование!

объяснение

Æs ÷ $ ÐṀ⁼W ~ Полная программа (монадическая).

    Сохранить элементы с максимальным значением ссылки (автоматически ранжируется).
Сумма делителей.
  ÷ $ ~ Разделить на текущий элемент.
      ⁼W ~ Проверить равенство с входом, завернутым в синглтон.
         ~ (для целых чисел типа 360360)

— Мистер Xcoder
источник

Я думаю, что вы можете сделать Æs÷$ÐṀ=для 7 байтов. Я не осознавал ÐṀ, что это полезно, это полезно знать.

— Дилнан

@ dylnan Нет, не могу. Хотя он не может быть проверен в Интернете, он не проходит 360360. Фактически это была моя первоначальная версия

— Mr. Xcoder

Почему бы это не удалось 360360?

— Дилнан

@dylnan 360360- это первое число, для которого он потерпит неудачу (я думаю), потому что это первое число, связывающее результат, который произошел ранее. (и наш результат будет [0, 1])

— г-н Xcoder

@ Mr.Xcoder Понятно, спасибо

— Дилнан

5

Haskell , 73 байта

-1 байт благодаря мистеру Xcoder. -7 байт благодаря Лайкони.

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]

Попробуйте онлайн!

Система типов Хаскелла не очень хорошая ...

— totallyhuman
источник

5

Haskell , 64 63 61 байт

-1 байт благодаря мистеру Xcoder .

-2 байта благодаря Линн .

a!x=a*sum[y|y<-[1..x],mod x y<1]
f n=and[x!n>n!x|x<-[1..n-1]]

Попробуйте онлайн!

— user28667
источник

4

Октава , 41 байт

@(n)([~,p]=max((x=1:n)*~mod(x,x')./x))==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?

— Луис Мендо
источник

3

J 35 байт

Спасибо Mr.Xcoder за обнаружение проблемы и помощь для ее устранения!

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

Попробуйте онлайн!

— Гален Иванов
источник

1

Это не удастся 360360(см. Проблему для более подробной информации: один настоятельно рекомендуемый отрицательный контрольный пример - 360360, потому что он связан с последним избыточным числом. ).

— г-н Xcoder

1

Исправлено на +3 байта. Попробуйте онлайн . Работаю в гольф. Мне нравится использование #.~много (честно, целая функция суммы делителя действительно хороша). Что было не так между прочим, так это то, что, хотя мысль о действии {:=>./умна, она не удовлетворяет «большей, чем» части вопроса.

— Коул

1

Вот что я придумал заменить функцию сигмы, которая в той же длины в настоящее время: (1#.{:(]*0=|~)])\ . Что-то не так с этим, хотя, может быть, у вас есть какие-то мысли?

— Коул

1

@cole Кредиты для функции суммы делителей идут в этом эссе Роджеру Хуэю . Я также начал писать еще одну сигма-функцию, но остановился после того, как достиг 9 байтов и решил, что она не будет короче, чем та, которая имеет простую факторизацию. Спасибо за исправление проблемы!

— Гален Иванов

@cole Самый короткий глагол для суммы делителей, который я придумал, такой: (1#.]*0=|~)1+i.это крюк, и он не так легко укладывается на место :)

— Гален Иванов

3

Юлия 0.6 , 52 байта

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

Попробуйте онлайн!

Это решение использует рациональные числа для обеспечения корректности в случае равенства. (Тестирование 360360 заняло почти 10 минут.)

Используя плавающую точку, можно сохранить 2 байта с разделением влево:

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

— LUKEŠ
источник

3

Pyth , 14 байт

^{_{( FryAmTheEggman сохранил 1 байт)}}

qh.Mcs*M{yPZZS

Попробуй это здесь! или увидеть больше тестов.

Просто мое обязательное представление Pyth, которое, скорее всего, пригодно для игры в гольф.

Как?

qh.Mcs * M {yPZZS ~ Полная программа. Q = вход.

             S ~ Целые числа в диапазоне [1, Q].
  .M ~ Получить элементы с максимальным значением функции.
    cs * M {yPZZ ~ Функция ключа: использует переменную Z.
         yPZ ~ Powerset основных факторов Z.
        {~ Дедуплицировано.
      * M ~ Продукт каждого.
     S ~ И подвела.
    c Z ~ Разделено на Z.
 h ~ Первый элемент.
q ~ Проверьте равенство с входом. Выводит либо True, либо False.

— Мистер Xcoder
источник

3

05AB1E , 10 байтов

LÑOā/ZQ¨_P

Попробуйте онлайн! или как тестовый набор

объяснение

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
источник

Я думаю (хотя я не уверен), что это не удается 360360(см. Проблему для более подробной информации: один настоятельно рекомендуемый негативный тестовый случай - 360360, потому что он связан с последним избыточным числом. ).

— г-н Xcoder

@ Mr.Xcoder: правда. Исправлено, но может быть лучший способ сделать это сейчас.

— Emigna

3

Python 3 , 77 байт

-1 байт благодаря Роду. -3 байта благодаря Денису.

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

Попробуйте онлайн!

— totallyhuman
источник

2

R используя `numbers`, 59 байт

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

— Джозеф Вуд
источник

2

Mathematica, 53 50 байт

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

Чистая функция. Принимает целое число в качестве входных данных и возвращает Trueили в Falseкачестве выходных данных.

— LegionMammal978
источник

Будет ли что-то подобное Tr@Divisors@#работает?

— user202729

1

Japt v2.0a0, 12 16 байт

Мозг, лишенный сна, не может улучшить это дальше!

Возвращается 1за правду или 0за фальси.

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

Попытайся

Пожертвовал 4 байта для обработки 360360.

объяснение

Неявный ввод целого числа U.
Æ Ãсоздает массив целых чисел от 0до U-1и передает каждый через следующую функцию как X.
âполучает делителей U.
÷Uделит каждого из них на U.
x подводит итоги
Xâполучает делителей X.
÷Xделит каждого из них на X.
x подводит итоги
> проверяет, больше ли первый результат, чем второй.
× уменьшает результирующий массив логических значений путем умножения.

— мохнатый
источник

1

Если ваш текущий подход соответствует вашему объяснению, он не подходит для 360360других целых чисел: один крайне рекомендуемый отрицательный тестовый случай (если ваш интерпретатор может его обработать) равен 360360, поскольку он связан с последним избыточным числом

— Mr. Xcoder

@ Mr.XCoder: Орехи, ты прав! Это, вероятно, будет стоить мне несколько байтов, когда у меня будет время, чтобы это исправить.

— лохматый

@ Mr.Xcoder: исправлено, придется вернуться позже, чтобы посмотреть, смогу ли я улучшить его.

— Лохматый

0

APL + WIN, 37 байт

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

Подсказки для ввода с экрана.

— Грэхем
источник

0

C (gcc), 99 байтов

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

Попробуйте онлайн!

C 108 байтов

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

Попробуйте онлайн!

— Steadybox
источник

Итак, почему sнужно вернуть поплавок?

— Nissa

@StephenLeppik Чтобы использовать деление с плавающей точкой вместо целочисленного деления при сравнении s(n)/nс s(i)/i.

— Steadybox

0

Swift , 120 118 байт

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

Занимает некоторое время (около 6 секунд на TIO) для компиляции из-за неявных объявлений типов в Swift.

Попробуйте онлайн!

— Герман Л
источник

0

Желе , 12 байт

RÆs©Ṫ×R>®×$Ạ

Попробуйте онлайн! или Найти все сверхизбыточные числа ниже 1000.

потому что я ненавижу плавающие точки.

— Дрянная Монахиня
источник

0

Фанки , 79 байт

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}

Разъяснения

Это сначала определяет функцию, dкоторая является σфункцией, и это версия гольфа

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

Мы можем установить I в 0, потому i*n%0что всегда будет равным 0*..., таким образом0 .

Следующая половина этого определяет функцию f, которая является функцией Superabandunce, и это просто игра в гольф

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

И это просто проверяет, как предполагает спецификация задачи, что все целые числа от 1 до n-1 имеют значение d(n)/nменьше, чем входное.

Попробуйте онлайн!

— Ataco
источник

0

APL (Dyalog) , 33 байта

{⍵=⊃⌽+⌿∘.≤⍨((+/⍳(/⍨)0=⍳|⊢)÷⊢)¨⍳⍵}

Попробуйте онлайн!

— Уриэль
источник

0

Шелуха , 9 байт

εü<m§ṁ/Ḋṫ

Попробуйте онлайн! Слишком медленно для теста 360360.

объяснение

εü<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
источник

Я получил £ü¤<§ṁ/ḊN. Создание всего списка излишних чисел

— H.PWiz

0

Perl 5, 84 байта

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

требует -E(бесплатно)

прямая реализация спецификации, игра в гольф

— msh210
источник

0

APL (NARS), 61 символ, 122 байта

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π - функция сумма факторов

  (⍳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
источник

Определить избыток

Вызов

Желе , 7 байт

Желе , 8 байт

объяснение

Haskell , 73 байта

Haskell , 64 63 61 байт

Октава , 41 байт

объяснение

J 35 байт

Юлия 0.6 , 52 байта

Pyth , 14 байт

Как?

05AB1E , 10 байтов

Python 3 , 77 байт

R используя numbers, 59 байт

Mathematica, 53 50 байт

Japt v2.0a0, 12 16 байт

объяснение

APL + WIN, 37 байт

C (gcc), 99 байтов

C 108 байтов

Swift , 120 118 байт

Желе , 12 байт

Фанки , 79 байт

Разъяснения

APL (Dyalog) , 33 байта

Шелуха , 9 байт

объяснение

Perl 5, 84 байта

APL (NARS), 61 символ, 122 байта

R используя `numbers`, 59 байт