Thách thức là tính tổng chữ số của giai thừa của một số.

Thí dụ

Input: 10
Output: 27

10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800 và tổng các chữ số trong số 10! là 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27

Bạn có thể mong đợi đầu vào là một số nguyên trên 0. Đầu ra có thể là bất kỳ loại nào, nhưng câu trả lời phải nằm trong cơ sở tiêu chuẩn của ngôn ngữ mã hóa.

Các trường hợp thử nghiệm:

10    27
19    45
469   4140
985   10053

NB Một số ngôn ngữ không thể hỗ trợ số lượng lớn trên số nguyên 32 bit; đối với những ngôn ngữ đó, bạn sẽ không thể tính được các yếu tố lớn.

Liên kết OEIS ở đây nhờ Martin Ender

Đây là mã golf , vì vậy mã ngắn nhất trong các nhân vật sẽ thắng!

05AB1E , 3 byte

!SO

Hãy thử trực tuyến!

!   Factorial.
 S  Push characters separately.
  O Sum.

Thạch , 3 byte

!DS

Hãy thử trực tuyến!

Có phải những gì bạn mong đợi:

!    Factorial.
 D   Decimal digits.
  S  Sum.

Toán học, 21 byte

Tr@IntegerDigits[#!]&

C ++ 11, 58 byte

Như lambda chưa đặt tên sửa đổi đầu vào của nó:

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

Một trong những trường hợp hiếm hoi khi C ++ mã của tôi là ngắn hơn so với mã C .

Nếu bạn muốn hỗ trợ các trường hợp lớn hơn, hãy chuyển sang C ++ 14 và sử dụng:

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

và cung cấp đối số gọi với ullhậu tố.

Sử dụng:

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

Ruby, 63 61 53 38 byte

Cách tiếp cận mới nhờ thao tác:

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

Cũ:

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

• -3 byte nhờ Martin Ender
• -5 byte nhờ GB

Bình thường, 7 6 byte

Cảm ơn @Kade đã tiết kiệm cho tôi một byte

sj.!QT

Hãy thử trực tuyến!

Đây là lần đầu tiên tôi sử dụng Pyth, vì vậy tôi chắc chắn rằng câu trả lời của tôi có thể bị đánh golf khá nhiều.

Giải trình:

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

Haskell, 41 40 byte

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

Ví dụ sử dụng: f 985-> 10053.

Lập một danh sách từ 1đểx , tính toán sản phẩm của các thành phần danh sách, biến nó thành biểu diễn chuỗi của nó, biến mỗi ký tự thành một số và tính tổng chúng.

Chỉnh sửa: @Angs đã lưu một byte. Cảm ơn!

Python, 54 byte

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

thay thế

R, 58 53 byte

Chỉnh sửa: Đã lưu một byte nhờ @Jonathan Carroll và một cặp nhờ @Micky T

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

Thật không may, với số nguyên 32 bit, điều này chỉ hoạt động n < 22. Đưa đầu vào từ stdin và đầu ra thành thiết bị xuất chuẩn.

Nếu muốn độ chính xác cao hơn, người ta sẽ phải sử dụng một số thư viện bên ngoài như Rmpfr:

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

Pip , 8 byte

$+$*++,a

Hãy thử trực tuyến!

Giải trình

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

CJam , 8 byte

rim!Ab:+

Hãy thử trực tuyến!

Giải trình

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

Brachylog , 5 byte

$!@e+

Hãy thử trực tuyến!

Giải trình

Về cơ bản thuật toán được mô tả:

$!       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 byte

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;

Ruby, 63 60 53 51 byte

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

Cảm ơn Martin đã giúp đỡ chơi golf.

Pushy , 4 byte

fsS#

Đưa ra đầu vào trên dòng lệnh : $ pushy facsum.pshy 5. Đây là sự cố:

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

Octave, 30 byte

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

Tính giai thừa bằng cách lấy sản phẩm của danh sách [1 2 ... n]. Chuyển đổi nó thành một chuỗi và trừ 48từ tất cả các phần tử (mã ASCII cho 0). Cuối cùng nó tổng hợp lại :)

bash (seq, bc, Fold, jq), 34 33 byte

Chắc chắn không phải là thanh lịch nhất nhưng cho thử thách

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

C, 58 byte

Điều này là không hoàn hảo. Chỉ hoạt động những cái vì phải bắt đầu -1. Ý tưởng là sử dụng hai hàm đệ quy trong một hàm. Nó không dễ như tôi nghĩ.

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

Định dạng sử dụng và dễ hiểu:

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

Chỉnh sửa: Tôi tìm thấy metode cho phép sử dụng chức năng này nhiều lần nhưng sau đó độ dài là 62 byte.

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

Perl 6 , 21 byte

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

Mở rộng:

{  # 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
}

Khối, 33 32 byte

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

Hình thức mạng:

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

Hãy thử trực tuyến!

Ghi chú

• Hoạt động với đầu vào lên đến 170, đầu vào cao hơn dẫn đến một vòng lặp vô hạn, bởi vì giai thừa của chúng mang lại Infinity số (nói về mặt kỹ thuật, đây là thuộc tính không thể ghi, không thể đếm được và không thể cấu hình của đối tượng cửa sổ).
• Độ chính xác bị mất cho đầu vào 19 trở lên, vì các số cao hơn 2 ⁵³ (= 9 007 199 254 740 992) không thể được lưu trữ chính xác trong JavaScript.

Giải trình

Chương trình này bao gồm hai vòng. Đầu tiên tính giai thừa của đầu vào, cái còn lại chia kết quả thành các chữ số của nó và cộng các số đó lại với nhau. Sau đó, tổng được in, và chương trình kết thúc.

Khởi đầu

Đầu tiên, chúng ta cần chuẩn bị ngăn xếp. Đối với phần đó, chúng tôi sử dụng ba hướng dẫn đầu tiên. IP bắt đầu trên dòng thứ tư, chỉ về phía đông. Ngăn xếp trống rỗng.

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

Chúng tôi sẽ giữ tổng số ở dưới cùng của ngăn xếp, vì vậy chúng tôi cần bắt đầu với 0 tổng bằng cách lưu trữ số đó ở dưới cùng của ngăn xếp. Sau đó, chúng ta cần phải đẩy một1 , vì đầu vào ban đầu sẽ được nhân với số trước nó. Nếu đây là 0, giai thừa sẽ luôn mang lại số không. Cuối cùng, chúng tôi đọc đầu vào như một số nguyên.

Bây giờ, ngăn xếp là [0, 1, input] và IP ở dòng thứ tư, cột thứ tư, chỉ về phía đông.

Vòng lặp nhân tố

Đây là một vòng lặp đơn giản nhân hai phần tử trên cùng của ngăn xếp (kết quả của vòng lặp trước và đầu vào - n, sau đó giảm đầu vào. Nó bị ngắt khi đầu vào đạt 0. Lệnh $khiến IP bỏ qua u- lần lượt. Vòng lặp là phần sau của khối. IP bắt đầu trên dòng thứ tư, cột thứ tư.

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

Vì ^đặc tính, IP bắt đầu di chuyển về phía bắc ngay lập tức. Sau đó, uxoay IP xung quanh và di chuyển nó sang bên phải. Ở phía dưới, có một mũi tên khác: <trỏ IP trở lại vào ^. Ngăn xếp bắt đầu như [previousresult, input-n], nơi nlà số lần lặp lại. Các ký tự sau được thực thi trong vòng lặp:

*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]

Sau đó, đỉnh của ngăn xếp (đầu vào giảm) được kiểm tra 0theo !hướng dẫn và nếu có 0,u ký tự sẽ bị bỏ qua.

Tổng các chữ số

IP bao quanh khối lập phương, kết thúc ở ký tự cuối cùng trên dòng thứ tư, ban đầu chỉ về phía tây. Vòng lặp sau bao gồm khá nhiều tất cả các ký tự còn lại:

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

Vòng lặp trước tiên xóa mục trên cùng khỏi ngăn xếp (là một trong hai 10hoặc 0), sau đó kiểm tra những gì còn lại của kết quả của giai thừa. Nếu điều đó đã được giảm xuống 0, phần dưới cùng của ngăn xếp (tổng) được in và chương trình dừng lại. Mặt khác, các hướng dẫn sau đây được thực thi (ngăn xếp bắt đầu như [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]

Và vòng lặp bắt đầu lại, cho đến khi factorial/10bằng 0.

C, 47 byte

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

sử dụng:

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 byte

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

Dùng thử trực tuyến

Mẻ, 112 byte

@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%

Thuận tiện set/ahoạt động trên giá trị hiện tại của một biến, vì vậy nó hoạt động bình thường trong một vòng lặp. Chỉ hoạt động tối đa 12 do các giới hạn của loại số nguyên của Batch, vì vậy theo lý thuyết tôi có thể lưu một byte bằng cách giả sử 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%

Nhưng cách đó nằm ở sự điên rồ ... Tôi cũng có thể mã hóa danh sách trong trường hợp đó (97 byte):

@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 byte

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

Chỉ hoạt động tối đa n=22do giới hạn độ chính xác dấu phẩy động.

Befunge 93 , 56 54 byte

Đã lưu 2 byte để sử dụng get thay vì dấu ngoặc kép. Điều này cho phép tôi thay đổi 2 dòng trên cùng 1, giảm khoảng trắng không cần thiết.

Hãy thử trực tuyến!

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

Giải trình:

&#:<                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 byte

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

EDIT: Cảm ơn bạn Hedi và ETHproductions đã cạo 7 byte. Tôi sẽ phải nhớ rằng t - = - j trick.

AHK , 60 byte

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

AutoHotkey không có chức năng giai thừa tích hợp và các hàm vòng lặp có tên dài cho các biến tích hợp của chúng. Vòng lặp đầu tiên là giai thừa và vòng thứ hai là cộng các chữ số lại với nhau.

J, 12 11 byte

Đã lưu 1 byte nhờ cole!

1#.10#.inv!

Điều này chỉ đơn giản áp dụng tổng ( 1#.) cho các chữ số (sử dụng nghịch đảoinv chuyển đổi cơ sở #.với cơ sở 10) của giai thừa ( !) của đối số.

Các trường hợp thử nghiệm

Lưu ý: hai trường hợp kiểm tra cuối cùng là các gợi ý, được đánh dấu bằng một dấu x.

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

Brachylog (v2), 3 byte

ḟẹ+

Hãy thử trực tuyến!

"Thuật toán" tương tự như câu trả lời v1 của @Firthize, chỉ với mã hóa tốt hơn.

C, 63 60 byte

-3 byte cho do...whilevòng lặp.

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

Ungolfed và cách sử dụng:

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

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