Bir keresinde, gerçek bir iş yapıyordum, eski kodu güncelledim ve eski moda matematikte + ^x + e ^x olarak yazılana eşdeğer bir ifadeye çarptım . Çalıştığım dilde (APL) yazıldığından daha kısa yazmanın mümkün olacağını düşündüm ve bu nedenle bu çok basit meydan okumayı sunalım:

(Herhangi bir yolla) sıfır veya daha fazla sayıyı kabul eden ve x için verilen ifadenin sonucunu (herhangi bir şekilde), her bir sonuç için en az 3 anlamlı basamağı olan verilen sayıların her birine döndüren bir işlev veya program yazın .

Dil yoksa π ve / veya e değerleri 3,142 ve 2,718 kullanın.

Puanlama bayt sayısıdır, bu nedenle cevabınızı önceden yazınız # LanguageName, 00 bytes.

Standart halka deliklere izin verilmez.

Edit: Şimdi geldi ○+*,, bulundu çözüm bulundu . Orijinal kod oldu (○x)+*x.

Dyalog APL, 3 karakter

Gizli bir ifade olarak.

○+*

Monadic ○argümanını π ile çarpar, monadic *üstel işlevdir exp. eşit ○+*bir tren . Bu APL olduğundan, ifade keyfi şekil argümanları için çalışır, e. g. keyfi uzunluktaki bir vektörü iletebilirsiniz.(○+*)ω(○ω)+(*ω)

J'de varlık ve varlık o.+^ile aynı çözüm mümkündür .o.○^*

Emotinomicon, 48 bayt / 13 karakter

Yapıyorum, kısa olduğu için değil, eğlenceli olduğu için. Burada deneyin. Metin kutusuna kopyalayıp yapıştırmanız gerekir.

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

Açıklama:

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

İşte kendi ortamında cep telefonu programı:

R, 25 24 bayt

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

Bu mu? Kullanıcıdan girdi alır, atar x, üstel değerini çarparak hesaplar pive son cat()olarak sonucu yazdırır.

edit: Alex A. sayesinde 1 bayt kaydedildi

JavaScript (ES6), 39 34 bayt

@ Edc65 sayesinde 5 bayt kaydedildi

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

Girdiyi bir sayı dizisi olarak alır ve aynı biçimde çıktılar.

Azaltma sayesinde, şimdi tüm ES5 uyumlu üç eşdeğer 45 baytlık program var:

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

Girişler birer birer girilmelidir. Çıkmak için hiçbir şey girmeden Tamam'a basın.

Üçüncüsü JS'deki ilginç bir özelliği vurgular: withifade. Bazen kullanımı güvensiz olsa da (katı modda devre dışı bırakılır), yine de her erişmeniz gerektiğinde bir nesne adı ve dönemi yazmaktan tasarruf etmek için kullanılabilir. Örneğin, bunu yapabilirsiniz:

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

pushve lengthdaha sonra özellikleri olarak kullanılan xile sonuçlanır, xolma [0,1,2,3,4].

Bu , değişken olmayanlar da dahil olmak üzere herhangi bir nesne üzerinde çalışır, örneğin şunları yapabilirsiniz:

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

charAtve lengthdizenin özellikleri olarak adlandırılır. onaltılık bir değerden bir sayıya "0x"+x-0dönüştürülür x, bu da alert0 ile 15 arasındaki sayılardır.

Mathematica, 11 10 bayt

N@Pi#+E^#&

LegionMammal978 sayesinde 1 bayt kaydedildi.

Pyth, 11 13

VQ+*N.n0^.n1N

Şimdi alır x liste olarak , ör.[1.25, 2.38, 25]

Önceki (11 bayt): +*Q.n0^.n1Q

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

Ciddi, 10 bayt

,`;e(╦*+`M

Hex Dökümü:

2c603b6528cb2a2b604d

Çevrimiçi Deneyin

Girdileri liste olarak alır (örneğin bağlantıya bakınız).

Açıklama:

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

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

TI-BASIC, 5 bayt

πAns+e^(Ans

: Bunların her biri hesap makinesi içinde byte olarak saklanır, böylece TI-BASIC ASCII bayt kullanmaz π, Ans, +, e^(, ve Ans. Önceki ifadenin girdi (varsayım) olduğunu varsayar {1,2,3}.

Python 2,38 bayt ( matematikle 52 49 bayt)

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

Eğer matematik modülünü kullanmam gerekirse:

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

Girdi bir sayı listesi olmalıdır

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

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

MATL , 9 bayt

Bu yanıt, dilden önceki sürüm olan ( 3.1.0 ) sürümünü kullanır .

itYP*wZe+

Girdi, tüm sayıları içeren bir vektördür (liste köşeli parantez içine alınmış ve boşluklarla ayrılmış, noktalı virgül gibi) [5.3 -7 3+2j]. Karmaşık değerlere izin verilir. Çıktıda 15 önemli basamak vardır.

Misal

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

açıklama

Kolay işlemler:

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

MATLAB: 70 bayt

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

Ölçek:

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

Açıklama: Sayı biçimlendirmeyle ilgili birkaç sorun vardı.

İlk olarak, soru 3 sig-incir gerektirir. Matlab'ın sig-incir ile yuvarlama için yerleşik bir işlevi yoktur (yalnızca ondalık basamaklarla), bu nedenle aşağıdaki geçici çözüm gerekliydi:

floor(log10(pi*x+exp(x)))) en büyük anlamlı basamağı hesaplar.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))girişi alır xve 3 önemli basamağa yuvarlar.

Diğer bir gereklilik, birden çok girişi işlemekti. Yukarıdaki kod yalnızca tek bir numarayla çalışabilir. Bunu hafifletmek arrayfuniçin her vektör elemanının fonksiyonunu değerlendirmek için kullanırız .

Son sorun olan Matlab, arrayfun'un sonucunu 1.0e+04 * 0.0006, 3 sig-fig gereksinimini ihlal eden gibi çıktılara yol açan kendi yuvarlaması ile görüntüler . Yani, num2strdiziyi charformata dönüştürmek için kullanıldı .

Matlab sayısal analiz için iyidir, ancak açıkçası, ince sayı biçimlendirmesi söz konusu olduğunda berbat

UPD: Bu kafamı karıştırdığım için utanç verici

en az 3 anlamlı basamaklı

ile

3 anlamlı basamaklı

Her neyse, cevabımı bu formda bırakacağım çünkü 15 bayt Matlab çözümü zaten @costrom tarafından verildi

Julia, 12 bayt

x->π*x+e.^x

Bu, bir diziyi kabul eden ve bir kayan noktalı dizi döndüren anonim bir işlevdir. Bunu aramak için bir ad verin, örn f=x->....

Julia yerleşik sabitlere sahiptir πve esırasıyla - tahmin ettiniz π ve e için. .^Operatör üs vectorized edilir.

Japt, 12 bayt

N®*M.P+M.EpZ

Girdileri boşlukla ayrılmış sayılar olarak alır. Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

o.+^

APL ile aynı ○+*, ancak bir bayt daha uzun olan J'nin pi timesişlevi çağrılır o..

Haskell, 22 19 bayt

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

Çevrimiçi deneyin!

Düzenleme: @ H.PWiz sayesinde -3 bayt

Par , 8 bayt

✶[″℗↔π*+

Girişi şu şekilde kabul eder: (1 2 3)

açıklama

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

Raket , 27 bayt

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

bir ifadenin işlev konumuna getirildiğinde:

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

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

CJam, 13 bayt

q~{_P*\me+}%p

Girdileri boşluklarla ayrılmış bir dizi olarak alır (örneğin [1 2 3]). Çevrimiçi deneyin.

açıklama

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 bayt

Rekabeti zorlaştırdığı için meydan okumaya son verir, ama hey, kısalık için herhangi bir ödül kazanmaz. : P Burada deneyin!

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

Satır 0

İşte 0 satırındaki yığının bir görünümü:

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

øsonra bir sonraki N'inci satıra gider. 0Giriş yapıldığında , bu doğrudan 2. satıra gider. Aksi takdirde 1. satıra gideriz.

Satır 1

1-)E*(:0eø

Bu i, E katını çarpar e^i. Sayacı azaltır (başlangıçta I), STOS'u (çalışma egücümüz) E ile çarparız, sayaca geri döneriz ve bunu yaparız ( i'mevcut sayaçtır):

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

øsonra iki şeyden birini yapar. Sayaç 0 değilse, "sonraki" 0. satıra, yani geçerli satırın başlangıcına gideriz. Sıfırsa, 0e1 verir ve bir sonraki satıra gider.

Hat 2

$+n~

$sayacı düşürür (ZEMİN ÜZERİNDE!). +ilk iki sonucu ekler, nbu sayıyı ~çıkarır ve programdan çıkar.

Durum 1: giriş 0'dır. TOS 1'dir ("e ^ 0") ve STOS 0'dır (pi * 0). Bunları eklemek doğru sonucu verir.

Durum 2: giriş 0 değil. Sonuç beklediğiniz gibi.