Raz wykonałem prawdziwą pracę, zaktualizowałem stary kod i wpadłem na wyrażenie, które jest równoważne temu, co byłoby napisane jako πx + e ^x w dobrej staromodnej matematyce. Pomyślałem, że będzie możliwe napisanie go krócej niż w języku, w którym pracuję (APL), i dlatego przedstawię to bardzo proste wyzwanie:

Napisz funkcję lub program, który (w jakikolwiek sposób) akceptuje zero lub więcej liczb i zwraca (w jakikolwiek sposób) wynik powyższego wyrażenia dla x = każdej z podanych liczb z co najmniej 3 cyframi znaczącymi dla każdego wyniku.

Jeśli twój język nie ma π i / lub e , użyj wartości 3.142 i 2.718.

Punktacja to liczba bajtów, więc poprzedzaj swoją odpowiedź # LanguageName, 00 bytes.

Standardowe otwory na pętle nie są dozwolone.

Edit: Teraz rozwiązanie wymyśliłem, ○+*, stwierdzono . Oryginalny kod był (○x)+*x.

Dyalog APL, 3 znaki

Jako milczące zdanie.

○+*

Monadic ○mnoży swój argument przez π, monadic *jest funkcją wykładniczą exp. ○+*jest takim pociągiem(○+*)ω jest równy (○ω)+(*ω). Ponieważ jest to APL, wyrażenie to działa na argumenty o dowolnym kształcie, np. sol. możesz podać wektor o dowolnej długości.

To samo rozwiązanie jest możliwe w J jak o.+^z o.bytem ○i ^bytem *.

Emotinomicon, 48 bajtów / 13 znaków

Robię to nie dlatego, że jest krótki, ale dlatego, że jest fajny. Wypróbuj tutaj. Musisz skopiować i wkleić go do pola tekstowego.

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

Wyjaśnienie:

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

Oto program w jego natywnym środowisku, telefon komórkowy:

R, 25 24 bajtów

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

Czy to jest to? Uzyskuje dane wejściowe od użytkownika, przypisuje je x, oblicza wykładnicze pomnożenie go pii ostatecznie cat()drukuje wynik.

edycja: 1 bajt zapisany dzięki Alexowi A.

JavaScript (ES6), 39 34 bajtów

Zaoszczędzono 5 bajtów dzięki @ edc65

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

Pobiera dane wejściowe jako tablicę liczb i dane wyjściowe w tym samym formacie.

Dzięki redukcji istnieją teraz trzy równoważne 45-bajtowe programy, wszystkie zgodne z 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))

Wejścia należy wprowadzać pojedynczo. Naciśnij OK bez wprowadzania niczego, aby wyjść.

Trzeci podkreśla ciekawą funkcję JS: withoświadczenie. Chociaż czasem jest niebezpieczny w użyciu (wyłączony w trybie ścisłym), można go nadal używać do zapisywania nazwy obiektu i okresu za każdym razem, gdy trzeba uzyskać do niego dostęp. Na przykład możesz to zrobić:

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

pushi lengthsą następnie używane jako właściwości x, które będą skutkiem xistnienia [0,1,2,3,4].

Działa to na każdym obiekcie, nawet nie-zmiennym, więc na przykład możesz to zrobić:

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

charAti lengthsą wywoływane jako właściwości ciągu. "0x"+x-0konwertuje xwartość szesnastkową na liczbę, więc są to alertliczby od 0 do 15.

Mathematica, 11 10 bajtów

N@Pi#+E^#&

Z 1 bajtem zapisanym dzięki LegionMammal978.

Pyth, 11 13

VQ+*N.n0^.n1N

Teraz trwa x jako listę, np[1.25, 2.38, 25]

Poprzednie (11 bajtów): +*Q.n0^.n1Q

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

Poważnie, 10 bajtów

,`;e(╦*+`M

Hex Dump:

2c603b6528cb2a2b604d

Wypróbuj online

Pobiera dane wejściowe jako listę (patrz link na przykład).

Wyjaśnienie:

,                               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 bajtów

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

TI-BASIC, 5 bajtów

πAns+e^(Ans

TI-BASIC nie używa bajtów ASCII, więc każdy z nich jest przechowywana jako jeden bajt w kalkulatorze: π, Ans, +, e^(, i Ans. Zakłada, że ​​poprzednie wyrażenie jest wejściem (jak {1,2,3}).

Python 2, 38 bajtów ( 52 49 bajtów z matematyki)

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

Jeśli muszę użyć modułu matematycznego:

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

Dane wejściowe powinny być listą liczb

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

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

MATL , 9 bajtów

Ta odpowiedź korzysta z bieżącej wersji języka ( 3.1.0 ), która jest wcześniejsza niż wyzwanie.

itYP*wZe+

Dane wejściowe to wektor zawierający wszystkie liczby (lista ujęta w nawiasy kwadratowe i oddzielone spacjami, przecinki średników), takie jak [5.3 -7 3+2j] . Złożone wartości są dozwolone. Wyjście ma 15 cyfr znaczących.

Przykład

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

Wyjaśnienie

Proste operacje:

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

MATLAB: 70 bajtów

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

Test:

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

Objaśnienie: Było kilka problemów z formatowaniem liczb.

Po pierwsze, pytanie wymaga 3 sig-fig. Matlab nie ma wbudowanej funkcji do zaokrąglania za pomocą sig-fig (tylko o miejsca dziesiętne), więc wymagane było następujące obejście:

floor(log10(pi*x+exp(x)))) oblicza największą cyfrę znaczącą.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))pobiera dane wejściowe xi zaokrągla do 3 cyfr znaczących.

Kolejnym wymaganiem była obsługa wielu danych wejściowych. Powyższy kod może działać tylko z jednym numerem. Aby temu zaradzić, używamy arrayfundo oceny funkcji dla każdego elementu wektora.

Ostatni problem, Matlab wyświetla wynik działania arrayfun z własnym zaokrągleniem, które prowadzi do wyników takich, 1.0e+04 * 0.0006które naruszają wymaganie 3 sig-fig. Tak więc num2strzostał użyty do przekształcenia tablicychar format.

Matlab jest dobry do analizy numerycznej, ale szczerze mówiąc, jest do bani, jeśli chodzi o precyzyjne formatowanie liczb

UPD: cóż, to wstyd, że się pomyliłem

z co najmniej 3 cyframi znaczącymi

z

z 3 cyframi znaczącymi

W każdym razie zostawię moją odpowiedź w tym formularzu, ponieważ 15 bajtowe rozwiązanie Matlab jest już podane przez @costrom

Julia, 12 bajtów

x->π*x+e.^x

Jest to anonimowa funkcja, która przyjmuje tablicę i zwraca tablicę liczb zmiennoprzecinkowych. Aby to nazwać, nadaj mu nazwę, np f=x->....

Julia ma wbudowane stałe πi odpowiednio e- zgadłeś - π i e. .^Operator wektorowy potęgowanie.

Japt, 12 bajtów

N®*M.P+M.EpZ

Pobiera dane wejściowe jako liczby oddzielone spacjami. Wypróbuj online!

Jak to działa

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 bajty

o.+^

To samo co APL ○+*, ale pi timeswywoływana jest funkcja J o., która jest dłuższa o jeden bajt.

Haskell, 22 19 bajtów

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

Wypróbuj online!

Edycja: -3 bajty dzięki @ H.PWiz

Par , 8 bajtów

✶[″℗↔π*+

Akceptuje dane wejściowe jako (1 2 3)

Wyjaśnienie

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

Rakieta , 27 bajtów

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

po umieszczeniu w pozycji funkcji wyrażenia:

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

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

CJam, 13 bajtów

q~{_P*\me+}%p

Pobiera dane wejściowe jako tablicę oddzieloną spacjami (np [1 2 3].). Wypróbuj online.

Wyjaśnienie

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 bajty

Niekonkurencyjny, ponieważ opóźnia to wyzwanie, ale hej, nie wygrywając żadnych nagród za zwięzłość. : P Wypróbuj tutaj!

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

Wiersz 0

Oto widok stosu w linii 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

ønastępnie przechodzi do następnej N-tej linii. Gdy0 wprowadzeniu przechodzi bezpośrednio do linii 2. W przeciwnym razie przechodzimy do linii 1.

Linia 1

1-)E*(:0eø

To mnoży E irazy, co oznacza e^i. IZmniejszamy licznik (początkowo ), mnożymy STOS (naszą emoc bieżącą ) przez E, wracamy do licznika i robimy to ( i'jest to bieżący licznik):

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

øwtedy robi jedną z dwóch rzeczy. Jeśli licznik nie jest równy 0, to przechodzimy do „następnej” linii zerowej, tj. Do początku bieżącej linii. Jeśli wynosi zero, to 0edaje 1 i przechodzi do następnego wiersza.

Linia 2

$+n~

$upuszcza licznik (NA PODŁOGĘ!). +dodaje dwa najlepsze wyniki, nwypisuje tę liczbę i ~wychodzi z programu.

Przypadek 1: wejście wynosi 0. TOS wynosi 1 („e ^ 0”), a STOS wynosi 0 (pi * 0). Dodanie ich daje poprawny wynik.

Przypadek 2: dane wejściowe nie są równe 0. Wynik jest taki, jak można się spodziewać.