Lần đầu tiên, tôi đang thực hiện một số công việc thực tế, cập nhật mã cũ và tình cờ gặp một biểu thức tương đương với những gì sẽ được viết là πx + e ^x trong toán học lỗi thời. Tôi nghĩ rằng có thể viết nó ngắn hơn so với nó được viết bằng ngôn ngữ tôi làm việc với (APL), và do đó đưa ra thử thách rất đơn giản này:

Viết hàm hoặc chương trình (bằng mọi cách) chấp nhận số 0 hoặc nhiều hơn và trả về (bằng mọi cách) kết quả của biểu thức trên cho x = mỗi số đã cho có ít nhất 3 chữ số có nghĩa cho mỗi kết quả.

Nếu ngôn ngữ của bạn không có π và / hoặc e , hãy sử dụng các giá trị 3.142 và 2.718.

Chấm điểm là số byte, vì vậy hãy mở đầu câu trả lời của bạn bằng # LanguageName, 00 bytes.

Lỗ vòng tiêu chuẩn không được phép.

Chỉnh sửa: Bây giờ giải pháp tôi đã đưa ra ○+*, đã được tìm thấy . Mã ban đầu là (○x)+*x.

APL Dyalog, 3 ký tự

Như một cụm từ ngầm.

○+*

Monadic ○nhân số đối số của nó với π, monadic *là hàm số mũ exp. ○+*là một chuyến tàu như vậy (○+*)ωlà bằng (○ω)+(*ω). Vì đây là APL, cụm từ hoạt động cho các đối số có hình dạng tùy ý, e. g. bạn có thể vượt qua một vectơ có độ dài tùy ý.

Giải pháp này cũng có thể trong J như o.+^với o.được ○và ^bị *.

Emotinomicon, 48 byte / 13 ký tự

Tôi làm điều đó, không phải vì nó ngắn, mà vì nó vui. Hãy thử nó ở đây.Bạn sẽ phải sao chép + dán nó vào hộp văn bản.

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

Giải trình:

😼  ⏪   🆙  😦  ✖   😎  😿  ➕   😼  🆙  😄  ⏩   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

Đây là chương trình trong môi trường tự nhiên của nó, điện thoại di động:

R, 25 24 byte

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

Có phải đây không? Nó nhận đầu vào từ người dùng, gán nó cho x, tính toán số mũ của nó nhân vớipi , và cuối cùng cat()in kết quả.

chỉnh sửa: 1 byte được lưu nhờ Alex A.

JavaScript (ES6), 39 34 byte

Đã lưu 5 byte nhờ @ edc65

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

Lấy đầu vào dưới dạng một mảng các số và đầu ra có cùng định dạng.

Nhờ giảm, hiện có ba chương trình 45 byte tương đương, tất cả đều tuân thủ 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))

Đầu vào nên được nhập từng cái một. Nhấn OK mà không cần nhập bất cứ điều gì để thoát.

Cái thứ ba làm nổi bật một tính năng thú vị trong JS: withcâu lệnh. Mặc dù đôi khi không an toàn để sử dụng (do đó bị vô hiệu hóa trong chế độ nghiêm ngặt), nó vẫn có thể được sử dụng để lưu việc gõ tên đối tượng và khoảng thời gian mỗi khi bạn cần truy cập. Ví dụ: bạn có thể làm điều này:

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

pushvà lengthsau đó được sử dụng như là thuộc tính của x, mà sẽ cho kết quả với xviệc[0,1,2,3,4] .

Điều này hoạt động trên bất kỳ đối tượng nào , thậm chí không phải là biến, vì vậy, ví dụ, bạn có thể làm điều này:

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

charAtvà lengthđược gọi là thuộc tính của chuỗi. "0x"+x-0chuyển đổi xtừ một giá trị hex thành một số, vì vậy đây alertlà các số từ 0 đến 15.

Toán học, 11 10 byte

N@Pi#+E^#&

Với 1 byte được lưu nhờ vào LegionMammal978.

Pyth, 11 13

VQ+*N.n0^.n1N

Now takes x as a list, e.g. [1.25, 2.38, 25]

Previous (11 bytes): +*Q.n0^.n1Q

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

Nghiêm túc, 10 byte

,`;e(╦*+`M

Bãi rác Hex:

2c603b6528cb2a2b604d

Dùng thử trực tuyến

Lấy đầu vào dưới dạng danh sách (xem liên kết chẳng hạn).

Giải trình:

,                               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 bytes

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

TI-BASIC, 5 bytes

πAns+e^(Ans

TI-BASIC doesn't use ASCII bytes, so each of these is stored as one byte in the calculator: π, Ans, +, e^(, and Ans. It assumes the previous expression is the input (like {1,2,3}).

Python 2, 38 bytes (52 49 bytes w. math)

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

If I have to use the math module:

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

Input should be a list of numbers

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

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

TOÁN, 9 bytes

Câu trả lời này sử dụng phiên bản hiện tại của ngôn ngữ ( 3.1.0 ), sớm hơn so với thử thách.

itYP*wZe+

Đầu vào là một vectơ chứa tất cả các số (danh sách được bao quanh bởi dấu ngoặc vuông và được phân cách bằng dấu cách, dấu phẩy của dấu chấm phẩy), chẳng hạn như [5.3 -7 3+2j]. Complex values are allowed. Output has 15 significant digits.

Thí dụ

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

Giải trình

Hoạt động đơn giản:

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

MATLAB: 70 byte

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

Kiểm tra:

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

Giải thích: Có một số vấn đề với định dạng số.

Firstly, the question requires 3 sig-figs. Matlab has no built-in function for rounding by sig-figs (only by decimal places), so the following workaround was required:

floor(log10(pi*x+exp(x)))) computes the largest significant digit.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x)) takes input x and rounds to 3 significant digits.

Một yêu cầu khác là xử lý nhiều đầu vào. Các mã trên chỉ có thể làm việc với một số duy nhất. Để giảm thiểu điều này, chúng tôi sử dụng arrayfunđể đánh giá hàm cho từng phần tử vectơ.

Vấn đề cuối cùng, Matlab hiển thị kết quả của mảng với tính năng làm tròn riêng dẫn đến kết quả đầu ra giống như 1.0e+04 * 0.0006vi phạm yêu cầu 3 sig-fig. Vì vậy, num2strđã được sử dụng để biến mảng thànhchar format.

Matlab là tốt cho phân tích số, nhưng, thẳng thắn, nó hút khi định dạng số tốt

CẬP NHẬT: tốt, đó là xấu hổ mà tôi bối rối

có ít nhất 3 chữ số có nghĩa

với

với 3 chữ số có nghĩa

Dù sao, tôi sẽ để lại câu trả lời của mình trong mẫu này vì giải pháp Matlab 15 byte đã được @costrom đưa ra

Julia, 12 bytes

x->π*x+e.^x

This is an anonymous function that accepts an array and returns an array of floats. To call it, give it a name, e.g. f=x->....

Julia has built-in constants π and e for—you guessed it—π and e, respectively. The .^ operator is vectorized exponentiation.

Japt, 12 bytes

N®*M.P+M.EpZ

Takes input as space-separated numbers. Try it online!

How it works

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 bytes

o.+^

Same as APL ○+*, but J's pi times function is called o., which is one byte longer.

Haskell, 22 19 bytes

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

Try it online!

Chỉnh sửa: -3 byte nhờ @ H.PWiz

Mệnh , 8 byte

✶[″℗↔π*+

Chấp nhận đầu vào là (1 2 3)

Giải trình

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

Vợt , 27 byte

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

khi đặt vào vị trí hàm của biểu thức:

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

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

CJam, 13 byte

q~{_P*\me+}%p

Lấy đầu vào dưới dạng một mảng được phân tách bằng dấu cách (ví dụ [1 2 3]). Hãy thử trực tuyến.

Giải trình

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 byte

Không tuân theo vì nó hoãn thử thách, nhưng hey, không giành được bất kỳ giải thưởng nào cho sự ngắn gọn. : P Hãy thử nó ở đây!

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

Dòng 0

Đây là hình ảnh của ngăn xếp trong dòng 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

øsau đó đi đến dòng thứ N tiếp theo. Khi nào0 là đầu vào, điều này đi thẳng đến dòng 2. Nếu không, chúng ta đi đến dòng 1.

Dòng 1

1-)E*(:0eø

Điều này nhân E ilần, đó là e^i. Chúng tôi giảm bộ đếm (ban đầu I), nhân STOS ( ecông suất hoạt động của chúng tôi ) với E, quay lại bộ đếm và làm điều này ( i'là bộ đếm hiện tại):

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

øsau đó làm một trong hai điều. Nếu bộ đếm không phải là 0, thì chúng ta sẽ đi đến dòng 0 "tiếp theo", tức là bắt đầu của dòng hiện tại. Nếu nó bằng 0, thì 0esinh ra 1 và đi đến dòng tiếp theo.

Dòng 2

$+n~

$làm rơi quầy (TRÊN SÀN!). +thêm hai kết quả hàng đầu, nxuất ra số đó và ~thoát khỏi chương trình.

Trường hợp 1: đầu vào là 0. ĐKDV là 1 ("e ^ 0") và STOS là 0 (pi * 0). Thêm chúng mang lại kết quả chính xác.

Trường hợp 2: đầu vào không bằng 0. Kết quả như bạn mong đợi.