Задача состоит в том, чтобы вычислить сумму цифр факториала числа.

пример

Input: 10
Output: 27

10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800, а сумма цифр в числе 10! 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27

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

Тестовые случаи:

10    27
19    45
469   4140
985   10053

NB. Некоторые языки не могут поддерживать большие числа выше 32-битных целых чисел; для этих языков вы не должны рассчитывать большие факториалы.

Ссылка OEIS здесь благодаря Мартину Эндеру

Это код-гольф , поэтому выигрывает самый короткий код в символах!

05AB1E , 3 байта

!SO

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

!   Factorial.
 S  Push characters separately.
  O Sum.

Желе , 3 байта

!DS

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

Делает то, что вы ожидаете:

!    Factorial.
 D   Decimal digits.
  S  Sum.

Mathematica, 21 байт

Tr@IntegerDigits[#!]&

C ++ 11, 58 байт

Как безымянная лямбда изменяет свой ввод:

[](int&n){int i=n;while(--n)i*=n;do n+=i%10;while(i/=10);}

Один из редких случаев , когда мой C ++ код короче , чем код C .

Если вы хотите поддержать большие случаи, переключитесь на C ++ 14 и используйте:

[](auto&n){auto i=n;while(--n)i*=n;do n+=i%10;while(i/=10);}

и поставьте вызывающий аргумент с ullсуффиксом.

Использование:

auto f=
[](int&n){int i=n;while(--n)i*=n;do n+=i%10;while(i/=10);}
;

main() {
  int n=10;
  f(n);
  printf("%d\n",n);
}

Рубин, 63 61 53 38 байт

Новый подход благодаря manatwork:

->n{eval"#{(1..n).reduce:*}".chars*?+}

Старый:

->n{(1..n).reduce(:*).to_s.chars.map(&:hex).reduce:+}

• -3 байта благодаря Мартину Эндеру
• -5 байт благодаря ГБ

Pyth, 7 6 байтов

Спасибо @Kade за то, что спасли мне байт

sj.!QT

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

Это мой первый раз, когда я использую Pyth, поэтому я уверен, что мой ответ может быть довольно удачным.

Объяснение:

s Sum
  j the digits of
    .! the factorial of
      Q the input
    T in base 10

Haskell, 41 40 байт

f x=sum$read.pure<$>(show$product[1..x])

Пример использования: f 985-> 10053.

Составьте список из 1в x, вычислите произведение элементов списка, превратите его в строковое представление, превратите каждый символ в число и сложите их.

Изменить: @Angs сохранил байт. Благодарность!

Python, 54 байта

f=lambda n,r=1:n and f(n-1,r*n)or sum(map(int,str(r)))

repl.it

R, 58 53 байта

Редактировать: один байт благодаря @Jonathan Carroll и пару благодаря @Micky T

sum(as.double(el(strsplit(c(prod(1:scan()),""),""))))

К сожалению, с 32-разрядными целыми числами это работает только для n < 22. Принимает ввод из stdin и выводит в stdout.

Если вам нужна более высокая точность, нужно использовать некоторую внешнюю библиотеку, такую ​​как Rmpfr:

sum(as.numeric(el(strsplit(paste(factorial(Rmpfr::mpfr(scan()))),""))))

зернышко , 8 байт

$+$*++,a

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

объяснение

      ,a    # range
    ++      # increment
  $*        # fold multiplication
$+          # fold sum

CJam , 8 байт

rim!Ab:+

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

объяснение

r   e# Read input.
i   e# Convert to integer.
m!  e# Take factorial.
Ab  e# Get decimal digits.
:+  e# Sum.

Брахилог , 5 байт

$!@e+

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

объяснение

В основном описанный алгоритм:

$!       Take the factorial of the Input
  @e     Take the elements of this factorial (i.e. its digits)
    +    Output is the sum of those elements

Java 7, 148 байт

int s=1,ret=0;while(i>1){s=s*i; i--;}String y=String.valueOf(s);for(int j=0;j<y.length();j++){ret+=Integer.parseInt(y.substring(j,j+1));}return ret;

Рубин, 63 60 53 51 байт

->n{a=0;f=(1..n).reduce:*;f.times{a+=f%10;f/=10};a}

Спасибо Мартину за помощь в игре в гольф.

Напористый , 4 байта

fsS#

Дайте ввод в командной строке: $ pushy facsum.pshy 5. Вот разбивка:

f      % Factorial of input
 s     % Split into digits
  S    % Push sum of stack
   #   % Output

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

@(n)sum(num2str(prod(1:n))-48)

Вычисляет факториал, беря произведение из списка [1 2 ... n]. Преобразует его в строку и вычитает 48из всех элементов (код ASCII для 0). Наконец это подводит итог :)

bash (seq, bc, fold, jq), 34 33 байта

Конечно, не самый элегантный, но для вызова

seq -s\* $1|bc|fold -1|jq -s add

C 58 байт

Это не идеально. Работает только потому, что в начале должно быть -1. Идея состоит в том, чтобы использовать две рекурсивные функции в одной функции. Это было не так просто, как я сначала подумал.

a=-1;k(i){a=a<0?i-1:a;return a?k(i*a--):i?i%10+k(i/10):0;}

Использование и понятный формат:

a = -1;
k(i){
   a = a<0 ? i-1 : a;
   return a ? k(i*a--) : i? i%10+k(i/10) :0;
}

main() {
   printf("%d\n",k(10));
}

Изменить: я нашел метод, который позволяет использовать эту функцию несколько раз, но тогда длина составляет 62 байта.

a,b;k(i){a=b?a:i+(--b);return a?k(i*a--):i?i%10+k(i/10):++b;}

Perl 6 , 21 байт

{[+] [*](2..$_).comb}

Expanded:

{  # bare block lambda with implicit parameter ｢$_｣

  [+]           # reduce the following with ｢&infix:<+>｣

    [*](        # reduce with ｢&infix:<*>｣
      2 .. $_   # a Range that include the numbers from 2 to the input (inclusive)
    ).comb      # split the product into digits
}

Cubix, 33 32 байта

u*.$s.!(.01I^<W%NW!;<,;;q+p@Opus

Чистая форма:

      u * .
      $ s .
      ! ( .
0 1 I ^ < W % N W ! ; <
, ; ; q + p @ O p u s .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

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

Заметки

• Работает со входами до 170 включительно, более высокие входы приводят к бесконечному циклу, потому что их факториал дает Infinity число (технически говоря, это не записываемое, не перечисляемое и не конфигурируемое свойство объекта окна).
• Точность теряется для входных данных 19 и выше, потому что числа выше 2 ⁵³ (= 9 007 199 254 740 992) не могут быть точно сохранены в JavaScript.

объяснение

Эта программа состоит из двух циклов. Первый вычисляет факториал ввода, другой разбивает результат на его цифры и складывает их вместе. Затем сумма печатается, и программа заканчивается.

Начало

Сначала нам нужно подготовить стек. Для этой части мы используем первые три инструкции. IP начинается на четвертой строке, указывая на восток. Стек пуст.

      . . .
      . . .
      . . .
0 1 I . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Мы будем хранить сумму в самом низу стека, поэтому нам нужно начинать с 0суммы, храня ее в нижней части стека. Затем нам нужно нажать a 1, потому что ввод будет сначала умножен на число перед ним. Если бы это было ноль, факториал также всегда давал бы ноль. Наконец, мы читаем входные данные как целое число.

Теперь, стек [0, 1, input]и IP находится на четвертой строке, четвертом столбце, указывающем на восток.

Факториальная петля

Это простой цикл, который умножает два верхних элемента стека (результат предыдущего цикла и входные данные - n, а затем уменьшает входные данные. Он прерывается, когда ввод достигает 0. Из-за $инструкции IP пропускает u- Поворот. Цикл является следующей частью куба. IP начинается в четвертой строке, четвертом столбце.

      u * .
      $ s .
      ! ( .
. . . ^ < . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Из-за этого ^персонажа IP сразу начинает двигаться на север. Затем uповорачивает IP и перемещает его вправо. Внизу есть еще одна стрелка: <указывает IP обратно в ^. Стек начинается как [previousresult, input-n], где nчисло итераций. В цикле выполняются следующие символы:

*s(
*   # Multiply the top two items
    #   Stack: [previousresult, input-n, newresult]
 s  # Swap the top two items
    #   Stack: [previousresult, newresult, input-n]
  ( # Decrement the top item
    #   Stack: [previousresult, newresult, input-n-1]

Затем в верхней части стека (уменьшил вход) сверяется 0по !инструкции, и если это 0, тоu персонаж будет пропущен.

Суммируйте цифры

IP оборачивается вокруг куба, заканчиваясь на последнем символе в четвертой строке, первоначально указывая на запад. Следующий цикл состоит в основном из всех оставшихся символов:

      . . .
      . . .
      . . .
. . . . . W % N W ! ; <
, ; ; q + p @ O p u s .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Цикл сначала удаляет верхний элемент из стека (который либо либо, 10либо 0), а затем проверяет, что осталось от результата факториала. Если это было уменьшено до 0, печатается дно стека (сумма), и программа останавливается. В противном случае выполняются следующие инструкции (стек начинается как [oldsum, ..., factorial]):

N%p+q;;,s;
N          # Push 10
           #   Stack: [oldsum, ..., factorial, 10]
 %         # Push factorial % 10
           #   Stack: [oldsum, ..., factorial, 10, factorial % 10]
  p        # Take the sum to the top
           #   Stack: [..., factorial, 10, factorial % 10, oldsum]
   +       # Add top items together
           #   Stack: [..., factorial, 10, factorial % 10, oldsum, newsum]
    q      # Send that to the bottom
           #   Stack: [newsum, ..., factorial, 10, factorial % 10, oldsum]
     ;;    # Delete top two items
           #   Stack: [newsum, ..., factorial, 10]
       ,   # Integer divide top two items
           #   Stack: [newsum, ..., factorial, 10, factorial/10]
        s; # Delete the second item
           #   Stack: [newsum, ..., factorial, factorial/10]

И цикл начинается снова, пока не будет factorial/10равен 0.

C, 47 байтов

f(n,a){return n?f(n-1,a*n):a?a%10+f(0,a/10):0;}

использование:

f(n,a){return n?f(n-1,a*n):a?a%10+f(0,a/10):0;}
main() {
  printf("answer: %d\n",f(10,1));
}

Python, 57 байт

import math
lambda n:sum(map(int,str(math.factorial(n))))

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

Пакет, 112 байт

@set/af=1,t=0
@for /l %%i in (1,1,%1)do @set/af*=%%i
:g
@set/at+=f%%10,f/=10
@if %f% gtr 0 goto g
@echo %t%

Удобно set/aработает с текущим значением переменной, поэтому она работает нормально внутри цикла. Работает только до 12 из-за ограничений целочисленного типа пакета, поэтому в теории я мог бы сохранить байт, предположив f<1e9:

@set/af=1,t=0
@for /l %%i in (1,1,%1)do @set/af*=%%i
@for /l %%i in (1,1,9)do @set/at+=f%%10,f/=10
@echo %t%

Но в этом и заключается безумие ... Я мог бы также жестко закодировать список в этом случае (97 байт):

@call:l %1 1 1 2 6 6 3 9 9 9 27 27 36 27
@exit/b
:l
@for /l %%i in (1,1,%1)do @shift
@echo %2

JavaScript (ES6), 50 байт

f=(n,m=1,t=0)=>n?f(n-1,n*m):m?f(n,m/10|0,t+m%10):t

Работает только n=22из-за ограничений точности с плавающей точкой.

Befunge 93 , 56 54 байта

Сохраненные 2 байта позволяют использовать вместо кавычек get. Это позволило мне сдвинуть верхние 2 строки на 1, уменьшив ненужные пробелы.

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

&#:<_v#:-1
: \*$<:_^#
g::v>91+%+00
_v#<^p00</+19
@>$$.

Объяснение:

&#:<                Gets an integer input (n), and reverses flow direction
&#:< _v#:-1         Pushes n through 0 onto the stack (descending order)

:  \*$<:_^#         Throws the 0 away and multiplies all the remaining numbers together

(reorganized to better show program flow):
vp00< /+19 _v#<    Stores the factorial at cell (0, 0). Pushes 3 of whatever's in
> 91+%+ 00g ::^    cell (0, 0). Pops a, and stores a / 10 at (0, 0),
                   and adds a % 10 to the sum.

@>$$.              Simply discards 2 unneeded 0s and prints the sum.

Javascript ES6 - 61 54 байта

n=>eval(`for(j of''+(a=_=>!_||_*a(~-_))(n,t=0))t-=-j`)

РЕДАКТИРОВАТЬ: Спасибо Hedi и ETHproductions за сбрить 7 байтов. Я должен помнить этот трюк.

AHK , 60 байт

a=1
Loop,%1%
a*=A_Index
Loop,Parse,a
b+=A_LoopField
Send,%b%

AutoHotkey не имеет встроенной факториальной функции, а функции цикла имеют длинные имена для своих встроенных переменных. Первый цикл - это факториал, а второй - сложение цифр.

J, 12 11 байт

Сохранено 1 байт благодаря Коул!

1#.10#.inv!

Это просто применяет sum ( 1#.) к цифрам (используя обратное invпреобразование базы)#. с основанием 10) факториала ( !) аргумента.

Контрольные примеры

Примечание: последние два контрольных примера - это bigints, отмеченные трейлингом x.

   f=:10#.inv!
   (,. f"0) 10 19 469x 985x
 10    27
 19    45
469  4140
985 10053

Brachylog (v2), 3 байта

ḟẹ+

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

Тот же «алгоритм», что и в ответе v1 от @Fatalize, только с лучшей кодировкой.

C 63 60 байт

-3 байта для do...whileцикла.

i;f(n){i=n;while(--n)i*=n;do n+=i%10;while(i/=10);return n;}

Ungolfed и использование:

i;
f(n){
 i=n;
 while(--n)
  i*=n;
 do
  n+=i%10;
 while(i/=10);
 return n;
}

main() {
 printf("%d\n",f(10));
}