ครั้งหนึ่งฉันทำงานจริงอัปเดตโค้ดเก่าและชนเข้ากับนิพจน์ที่เทียบเท่ากับสิ่งที่จะเขียนเป็นπx + e ^xในวิชาคณิตศาสตร์ที่ล้าสมัยดี ฉันคิดว่ามันเป็นไปได้ที่จะเขียนมันสั้นกว่าที่เขียนในภาษาที่ฉันทำงานด้วย (APL) ดังนั้นจึงนำเสนอความท้าทายที่ง่ายมากนี้:

เขียนฟังก์ชั่นหรือโปรแกรมที่ (โดยวิธีการใด ๆ ) ยอมรับตัวเลขเป็นศูนย์หรือมากกว่านั้นและส่งกลับ (โดยวิธีการใด ๆ ) ผลลัพธ์ของนิพจน์ด้านบนสำหรับx = แต่ละหมายเลขที่กำหนดด้วยตัวเลขอย่างน้อย 3 หลักสำหรับแต่ละผลลัพธ์

หากภาษาของคุณไม่มีπและ / หรือeให้ใช้ค่า 3.142 และ 2.718

# LanguageName, 00 bytesเกณฑ์การให้คะแนนเป็นจำนวนไบต์ดังนั้นคำนำคำตอบของคุณด้วย

ไม่อนุญาตให้ใช้ลูปมาตรฐาน

แก้ไข: ตอนนี้วิธีการที่ฉันมาด้วย○+*, มีการค้นพบ (○x)+*xรหัสเดิมคือ

Dyalog APL, 3 ตัวอักษร

เป็นวลีที่เงียบขรึม

○+*

เอก○คูณโต้แย้งกับπ, เอกเป็นฟังก์ชั่นการชี้แจง* เป็นรถไฟดังกล่าวว่าจะมีค่าเท่ากับ เนื่องจากนี่คือ APL วลีนี้ใช้งานได้กับข้อโต้แย้งของรูปร่างที่กำหนดเอง e ก. คุณสามารถส่งเวกเตอร์ที่มีความยาวได้ตามใจชอบexp○+*(○+*)ω(○ω)+(*ω)

วิธีการแก้ปัญหาเดียวกันเป็นไปได้ใน J เป็นo.+^กับo.การเป็น○และ^ความเป็น*อยู่

อิโมติโนมิก 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()พิมพ์ผลลัพธ์

แก้ไข: บันทึก 1 ไบต์ขอบคุณAlex A.

JavaScript (ES6), 39 34 ไบต์

บันทึก 5 ไบต์ด้วย @ edc65

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จากค่าฐานสิบหกเป็นตัวเลขดังนั้นนี่alertคือตัวเลข 0 ถึง 15

Mathematica, 11 10 ไบต์

N@Pi#+E^#&

ด้วยการบันทึก 1 ไบต์ต้องขอบคุณ LegionMammal978

Pyth, 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 sig-figs 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 ตัว

อย่างไรก็ตามฉันจะทิ้งคำตอบไว้ในแบบฟอร์มนี้เพราะโซลูชั่น Matlab 15 ไบต์มอบให้โดย @costrom

จูเลีย 12 ไบต์

x->π*x+e.^x

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อที่ยอมรับอาร์เรย์และส่งกลับอาร์เรย์ของลอย หากต้องการเรียกใช้ให้ตั้งชื่อเช่นf=x->...เรียกว่าให้มันชื่อเช่น

Julia มีค่าคงที่ในตัวπและeสำหรับ - คุณคาดเดาได้ - πและ e ตามลำดับ .^ผู้ประกอบการจะ vectorized ยกกำลัง

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 ○+*แต่pi timesฟังก์ชันของ J ถูกเรียกใช้o.ซึ่งมีความยาวหนึ่งไบต์

Haskell, 22 19 ไบต์

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

ลองออนไลน์!

แก้ไข: -3 ไบต์ขอบคุณ @ H.PWiz

พาร์ 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

øจากนั้นไปที่บรรทัด Nth ถัดไป เมื่อ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 ผลลัพธ์จะเป็นไปตามที่คุณคาดหวัง