\begingroup

给定一个正整数数组，计算每个数字的自身幂之和。例如，给定 4,6,7，代码需要返回 870455。

这是代码高尔夫，因此最短的代码获胜。

\endgroup

3

  • 4
    \begingroup
    我们也必须处理负数吗？
    \endgroup


    – 

  • 1
    \begingroup
    除了指定数字是否为非负数之外，还应该指定它们是否仅为整数。
    \endgroup


    – 

  • 6
    \begingroup
    欢迎来到 Code Golf Stack Exchange！我投了反对票，因为我觉得你的挑战太基础了，而且与本网站上的其他挑战太相似了，但请不要因此而放弃尝试另一个挑战！对于未来的任务，我们有一个，你可以在沙盒中发布你的想法并在获得任何解决方案之前收到反馈。
    \endgroup


    – 



29 个解决方案
29

\begingroup

， 29  26 字节

-3 字节，感谢 Albert.Lang。

lambda l:sum(map(pow,l,l))

解释

lambda l:                    # Anonymous lambda
         sum(            )   # Sum of...
             map(pow,   )    # Exponentiation of...
                     l,l     # element ** element for each element

\endgroup

2

  • 2
    \begingroup
    使用 map 和 pow 表示 -3：lambda l:sum(map(pow,l,l))
    \endgroup


    – 

  • \begingroup
    @Albert.Lang：我一直认为map只能有 2 个参数……
    \endgroup


    – 

\begingroup

，4 个半字节（2 个字节）

+.$^


+.$^     # full program
+x$^$$   # with implicit variables shown
+        # sum of
 .       # map over
  $      # each element of input
   ^     # x to the power of y:
    $    #   x is each element
    $    #   y is each element

\endgroup

\begingroup

，19字节

$=>[∑map&'x->x^x]

解释

$=>[]      ; a function where input is assigned to &
∑          ; sum of...
map&'x->   ; map over input and assign current elt to x
x^x        ; x to the x power

\endgroup

\begingroup

，2

mO

解释：

m   # Take the power of each value in the (implicit) input-list with each value in
    # the (implicit) input-list at the same position
 O  # Sum those
    # (after which this sum is output implicitly as result)

\endgroup

\begingroup

s，1个

e

解释：

e   # Vectorized power with itself using the (implicit) input-list twice
 s  # Sum the list
    # (after which the result is output implicitly)

\endgroup

\begingroup

，17字节

sum.map((^)<*>id)

对于 而言是(^)<*>id无点的\x->x^x。列表推导式解决方案的长度相同。

f l=sum[x^x|x<-l]

\endgroup

\begingroup

-rz 4.2.2，167 137字节

s!.*!sed -r 'h;G;:r;s/.\\n./\\n/;x;s/\\n.*//;t;:b;s/.*/\&\\n\&/m;:;t;x;s/^#//;x;tb;G;h;s/\\n(.)/\\1/g;T;s/\\n../\&/;tr'<<<'&'!e
s/\n..//g

的脚本片段来调​​用 sed 的第二个实例来计算幂，然后在最后将所有内容连接在一起。

\endgroup

\begingroup

Uiua，4个字节

/+ⁿ.


/+    # Sum of
  ⁿ   # each to the power of
   .  # itself

\endgroup

\begingroup

，4字节

+.*⍨

\endgroup

\begingroup

Google 表格，27 字节

=sort(sum(if(A:A,A:A^A:A)))

用作sort数组启用器，并if()清除空白。在 Google 表格中，空白的数值为零，因此空白列的自指数总和等于该列的行数。

截屏

\endgroup

\begingroup

，3字节

*`S

解释：

*`S 
*   Raise to        
 `    its own [4,6,7] => [256, 46656, 823543]
  S Sum       [256, 46656, 823543] => 870455

\endgroup

\begingroup

，8 个字节

Tr[#^#]&

未命名函数以列表{4, 6, 7}作为输入。指数运算符^自动分布在相同长度的数组上，Tr一维列表的总和。

\endgroup

\begingroup

，12字节

\(x)sum(x^x)

\endgroup

\begingroup

，7 5字节

ＩΣＸθθ

链接为代码的详细版本。

   θ    Input array
  Ｘ     Vectorised raised to power
    θ   Input array
 Σ      Take the sum
Ｉ       Cast to string
        Implicitly print

编辑：节省了 2 个字节，因为我忘记了这Power是四个（ATO 上是五个）运算符之一，如果两个参数都是列表，则会自动矢量化。

7 个字节作为字符串输入：

ＩΣＥＡＸιι

链接是代码的详细版本。说明：Power自动将字符串转换为整数，因此我不需要写Ｉι两次。

\endgroup

\begingroup

，115 字节

[S S S N
_Push_sum=0][N
S S N
_Create_Label_OUTER_LOOP][S N
S _Duplicate_sum][S N
S _Duplicate_sum][T N
T   T   _Read_STDIN_as_Integer][T   T   T   _Retrieve_input][S N
S _Duplicate_input][N
T   S T N
_If_0_Jump_to_Label_PRINT][S N
S _Duplicate_input][S N
S _Duplicate_input][N
S S S N
_Create_Label_INNER_LOOP][S S S T   N
_Push_1][T  S S T   _Subtract_top_two][S N
S _Duplicate][N
T   S S S N
_If_0_Jump_to_Label_RETURN][S N
T   _Swap_top_two][S T  S S T   S N
_Copy_0-based_2nd_input_to_top][T   S S N
_Multiply_top_two][S N
T   _Swap_top_two][N
S N
S N
_Jump_to_INNER_LOOP][N
S S S S N
_Create_Label_RETURN][S N
N
_Discard_top_0][S N
T   _Swap_top_two][S N
N
_Discard_top_input][T   S S S _Add_top_two][N
S N
N
_Jump_to_OUTER_LOOP][N
S S T   N
_Create_Label_PRINT][S N
N
_Discard_top_0][T   N
S T _Print_as_Integer]

字母S（空格）、T（制表符）和N（换行符）仅作为突出显示添加。
[..._some_action]仅作为解释添加。

由于 Whitespace 一次只能读取一个字符/整数的输入，因此输入必须包含尾随字符0，这样我们才能知道何时读取完输入。

（仅使用原始空格、制表符和换行符）。

伪代码解释：

Integer sum = 0
Start OUTER_LOOP:
  Integer input = Read STDIN as integer
  If (input == 0):
    Stop OUTER_LOOP, and jump to PRINT
  Integer product = input
  Integer count = input
  Start INNER_LOOP:
    count = count - 1
    If (count == 0):
      Stop INNER_LOOP, and jump to RETURN
    product = product * input
    Go to next iteration of INNER_LOOP
  RETURN:
    sum = sum + product
    Go to next iteration of OUTER_LOOP
PRINT:
  Print sum as integer to STDOUT
  (implicitly stop the program with an error: No exit defined)

\endgroup

\begingroup

，29 字节

for i;{
let t+=i**i
}
echo $t

用作函数或 bash 脚本。将数组作为任意数量的参数，输出到 stdout。

解释：

for i;{ # in bash, if the 'in array' part is not provided to 'for elem in array', it implicitly loops over all arguments
let t+=i**i # bash variables are initialized to 0, the rest is simple enough
}
echo $t

\endgroup

\begingroup

，3个字节

s^V


s^V­⁡​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁢‏⁠‎⁡⁠⁣‏‏​⁡⁠⁡‌­
s    # ‎⁡sum of
 ^V  # ‎⁢vectorized power with itself using the (implicit) input-list twice
💎

的帮助下创建。

\endgroup

\begingroup

，7 个字节

{^↙?}ᵐ+

很少使用↙。还有一个不太优雅的版本，也是 7 个字节：gjz^₎ᵐ+

解释

{   }ᵐ     Map for each integer:
 ^           Raise to the power...
  ↙?         ...of itself
      +    Sum

\endgroup

\begingroup

APL+WIN，7 个字节

提示输入数字向量。

+/i*i←⎕

\endgroup

\begingroup

Excel，24 字节

A:A以A1数组形式输入（即={4;6;7}）

=SUM((A1#^A1#)*(0<>A1#))

\endgroup

1

  • \begingroup
    嗯…我认为在过去使用A1#类型引用的 Excel 答案中，生成输入的公式的长度已包含在字节数中？
    \endgroup


    – 

\begingroup

，26 字节

x=>x.map(t=>n+=t**t,n=0)|n

\endgroup

\begingroup

，41字节

func[b][x: 0 foreach n b[x: n ** n + x]x]

\endgroup

\begingroup

，6字节

+/@:^~


+/@:    NB. Sum the results of
    ^~  NB. raise each to the power of itself

\endgroup

\begingroup

，14字节

[ dup v^ sum ]

\endgroup

\begingroup

Java，49 字节

l->l.stream().mapToDouble(x->Math.pow(x,x)).sum()

\endgroup

1

  • 1
    \begingroup
    当挑战要求输入数字或列表时，默认允许输入双精度和流。因此，如果您将 aDoubleStream作为输入，则它可以只有 32 个字节：l->l.map(x->Math.pow(x,x)).sum()–。
    \endgroup


    – 

\begingroup

，24字节

(For X(+ ^ Twin)0 Let X)

\endgroup

\begingroup

，33 字节

-join($args|%{'+1'
"*$_"*$_})|iex

将表达式构建为字符串，例如

+1*4*4*4*4+1*6*6*6*6*6*6+1*7*7*7*7*7*7*7

然后评估它

\endgroup

\begingroup

，85 + 3 字节（-lm）

main(c,v,j,t,i)char**v;{i=t=0;while(i<c)j=atoi(i++[v]),t+=pow(j,j);printf("%d",t-1);}

这是我在不使用 Lambdas 的情况下可以对其进行的最大优化，如果不手动重写 Assembly，代码可能会变得更长。

我想使用不同于的东西printf()，但由于itoa()某种原因不可用，我无法将其替换，puts()因为它不支持字符串格式。

\endgroup

2

  • \begingroup
    ；仅供参考，您可以用函数而不是完整的程序来回答问题，这样您就可以省略 I/O，对于这个问题这样做可以让我们将所有内容打包在中。
    \endgroup


    – 


  • \begingroup
    谢谢！我没意识到这一点。
    \endgroup


    – 

\begingroup

，2 个字节

ṖƩ


Ṗ              implicit input; raise each element to itself
 Ʃ             sum the array; implicit print

\endgroup