一次，我做了一些实际的工作，更新了旧代码，碰到了一个表达式，该表达式等于在老式数学中用πx+ e ^x编写的表达式。我认为编写它的时间可能比使用我使用的语言（APL）编写的时间短，因此提出了一个非常简单的挑战：

编写一个函数或程序（以任何方式）接受零个或多个数字，并返回（以任何方式）x = 每个给定数字的上述表达式的结果，每个结果至少具有3个有效数字。

如果您的语言没有π和/或e，请使用值3.142和2.718。

得分是字节数，因此请以开头# LanguageName, 00 bytes。

不允许使用标准孔。

编辑：现在，我想出了一个解决方案，○+*，已被发现。原始代码为(○x)+*x。

Dyalog APL，3个字符

作为一个默认的短语。

○+*

Monadic ○将其自变量乘以π，monadic *是指数函数exp。○+*是(○+*)ω等于的火车(○ω)+(*ω)。由于这是APL，因此该短语适用于任意形状的参数，例如e。G。您可以传递任意长度的向量。

在J中o.+^与o.存在○和^存在相同的解决方案是可能的*。

Emotinomicon，48个字节/ 13个字符

我这样做不是因为它很短，而是因为它很有趣。 在这里尝试。您必须将其复制并粘贴到文本框中。

😼⏪🆙😦✖😎😿➕😨😼🆙😄⏩

说明：

😼  ⏪   🆙  😦  ✖   😎  😿  ➕   😼  🆙  😄  ⏩   explanation
😼                                              take numeric input
    ⏪                                           open loop
        🆙                                      duplicate top of stack
            😦                                  push pi
                ✖                               multiply top two elements on stack
                    😎                          reverse stack
                        😿                      pop N, push e^N
                            ➕                   add top two elements on stack
                                😼              take numeric input
                                    🆙          duplicate top of stack
                                        😄      pop N, push N+1
                                            ⏩   close loop

这是在其本机环境中的程序，即手机：

R，25 24字节

cat(exp(x<-scan())+pi*x)    

是这个吗？它从用户处获取输入，将其分配给x，计算其指数乘以pi，最后cat()输出结果。

编辑：由于Alex A，节省了1个字节。

JavaScript（ES6），39 34字节

@ edc65节省了5个字节

a=>a.map(x=>x*Math.PI+Math.exp(x))

将输入作为数字数组，并以相同格式输出。

由于减少了，现在有了三个等效的45字节程序，所有程序都符合ES5：

for(;x=prompt();)alert(x*Math.PI+Math.exp(x))
for(M=Math;x=prompt();)alert(x*M.PI+M.exp(x))
with(Math)for(;x=prompt();)alert(x*PI+exp(x))

输入应该一次输入一次。按确定而不输入任何内容退出。

第三个突出显示了JS中一个有趣的功能：with语句。尽管有时使用起来不安全（因此在严格模式下已禁用），但仍可以使用它来保存键入每次对象名称和句点的时间。例如，您可以这样做：

x=[];with(x)for(i=0;i<5;i++)push(length);

push并且length随后被用作性能x，这将导致与x被[0,1,2,3,4]。

这适用于任何对象，甚至是非变量，因此，例如，您可以执行以下操作：

with("0123456789ABCDEF")for(i=0;i<length;i++)alert("0x"+charAt(i)-0);

charAt并length称为字符串的属性。"0x"+x-0转换x从十六进制值的数，所以这个alertS中的数字0到15。

Mathematica，11 个10字节

N@Pi#+E^#&

使用LegionMammal978，节省了1个字节。

佩斯，11 13

VQ+*N.n0^.n1N

现在以x列表为例，例如[1.25, 2.38, 25]

上一个（11个字节）： +*Q.n0^.n1Q

VQ            +       * N .n0            ^ .n1 N
For each      Add     List Item * Pi     e ^ List Item
input item

认真地，10个字节

,`;e(╦*+`M

十六进制转储：

2c603b6528cb2a2b604d

在线试用

将输入作为列表（例如，请参阅链接）。

说明：

,                               Get input list
 `      `M                      Map this function over it
  ;                             Copy the input value.
   e                            exponentiate
    (                           dig up the other copy
     ╦*                         multiply by pi
       +                        add

MATLAB，15个字节

@(x)pi*x+exp(x)

TI-BASIC，5个字节

πAns+e^(Ans

TI-BASIC不使用ASCII字节，所以每个这些被存储在计算器一个字节：π，Ans，+，e^(，和Ans。假定先前的表达式是输入（如{1,2,3}）。

Python 2，38个字节（数学上为52 49个字节）

lambda l:[3.142*x+2.718**x for x in l]

如果必须使用数学模块：

from math import*
lambda l:[pi*x+e**x for x in l]

输入内容应为数字列表

f([1,2,3,4,5])

> [5.8599999999999994, 13.671524, 29.505290232, 67.143510850576007, 164.04623849186558]

MATL，9字节

该答案使用当前版本的语言（3.1.0），它比挑战更早。

itYP*wZe+

输入是一个包含所有数字的向量（列表用方括号括起来，并用空格，分号逗号分隔），例如[5.3 -7 3+2j]。允许使用复数值。输出有15个有效数字。

例

>> matl itYP*wZe+
> [1 2 3]
5.859874482048839 13.67224140611024 29.51031488395705

说明

简单的操作：

i       % input  
t       % duplicate 
YP      % pi   
*       % multiplication
w       % swap elements in stack                           
Ze      % exponential                                      
+       % addition 

MATLAB：70个字节

@(x)num2str(arrayfun(@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))

测试：

ans(1:10)
5.86            13.7            29.5            67.2             164             422            1120            3010            8130           22100

说明：数字格式存在多个问题。

首先，这个问题需要3个签名。Matlab没有内置功能可按sig-figs（仅按小数位）四舍五入，因此需要以下解决方法：

floor(log10(pi*x+exp(x)))) 计算最大有效数字。

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x)) 接受输入 x并四舍五入到3个有效数字。

另一个要求是处理多个输入。上面的代码只能使用一个数字。为了减轻这种情况，我们使用arrayfun评估每个矢量元素的功能。

最后一个问题，Matlab用自己的舍入显示arrayfun的结果，该结果会导致输出1.0e+04 * 0.0006违反3 sig-fig要求。因此，num2str用于将数组转换为char格式。

Matlab可以很好地进行数值分析，但是坦率地说，在进行精细数字格式化时很烂

UPD：好吧，这让我感到困惑

至少3位有效数字

与

3位有效数字

无论如何，我将以这种形式留下我的答案，因为@costrom已经给出了15个字节的Matlab解决方案

朱莉娅，12个字节

x->π*x+e.^x

这是一个匿名函数，它接受一个数组并返回一个浮点数数组。要给它起个名字，例如f=x->...。

朱莉娅（Julia）具有内置常数，π并且（e对于您猜对了）分别具有π和e。该.^操作被矢量幂。

Japt，12个字节

N®*M.P+M.EpZ

将输入作为空格分隔的数字。在线尝试！

怎么运行的

N®   *M.P+M.EpZ
NmZ{Z*M.P+M.EpZ

        // Implicit: N = array of inputs, M = Math object
NmZ{    // Map each item Z in N to:
Z*M.P+  //  Z times PI, plus
M.EpZ   //  E to the power of Z.
        // Implicit: output last expression

J，4个字节

o.+^

与APL相同○+*，但J的pi times函数称为o.，其长度增加了一个字节。

Haskell，22个 19字节

map(\x->pi*x+exp x)

在线尝试！

编辑：-3字节感谢@ H.PWiz

Par，8字节

✶[″℗↔π*+

接受输入为 (1 2 3)

说明

               ## [implicit: read line]
✶              ## Parse input as array of numbers
[              ## Map
 ″             ## Duplicate
 ℗             ## e to the power
 ↔             ## Swap
 π*            ## Multiply by π
 +             ## Add

拍子，27字节

map(λ(x)(+(* pi x)(exp x)))

当放在表达式的函数位置时：

(map(λ(x)(+(* pi x)(exp x))) '(1 2 3 4))

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

CJam，13个字节

q~{_P*\me+}%p

将输入作为一个由空格分隔的数组（例如[1 2 3]）。在线尝试。

说明

q~    e# Read the input and evaluate it as an array
{     e# Do this for each number x in the array...
  _P* e# Multiply x by pi
  \me e# Take the exponential of x (same as e^x)
  +   e# Add the two results together
}%
p     e# Pretty print the final array with spaces

Reng v.3.3，53个字节

非竞争性的，因为它推迟了挑战，但是嘿，为简洁起见，没有赢得任何奖项。：P 在这里尝试！

2²5³*:"G"(%3+i#II*ZA*9+(%2+#E1II0e1+ø
1-)E*(:0eø
$+n~

0行

这是第0行中的堆栈视图：

Sequence read | Stack
2²            | 4
5³            | 4 125
*             | 500
:             | 500 500
"G"           | 500 500 71
(             | 500 71 500
%             | 500 0.142
3+            | 500 3.142
i             | 500 3.142 <i>
#I            | 500 3.142     ; I <- i
I             | 500 3.142 <i>
*             | 500 3.142*<i>
ZA            | 500 3.142*<i> 35 10
*             | 500 3.142*<i> 350
9+            | 500 3.142*<i> 359
(             | 3.142*<i> 359 500
%             | 3.142*<i> 0.718
2+            | 3.142*<i> 2.718
#E            | 3.142*<i>     ; E <- 2.718
1II0          | 3.142*<i> 1 <i> <i> 0
e             | 3.142*<i> 1 <i> <i>==0
1+            | 3.142*<i> 1 <i> (<i>==0)+1

ø然后转到下一个第N行。当0输入时，它直接进入第2行。否则，我们进入第1行。

1号线

1-)E*(:0eø

这是E的i倍数，即e^i。我们将计数器递减（最初是I），将STOS（我们的运行e功率）乘以E，返回到计数器，然后执行此操作（i'是当前计数器）：

Sequence read | Stack (partial)
              | i'
:             | i' i'
0             | i' i' 0
e             | i' i'==0

ø然后做两件事之一。如果计数器不为0，则转到“下一个”第0行，即当前行的开头。如果为零，则0e产生1，然后转到下一行。

2号线

$+n~

$下降计数器（在地板上！）。+将前两个结果相加，n输出该数字，然后~退出程序。

情况1：输入为0。TOS为1（“ e ^ 0”），STOS为0（pi * 0）。将它们相加会得到正确的结果。

情况2：输入不为0。结果与您预期的一样。