На этот раз я делал какую-то реальную работу, обновлял старый код и столкнулся с выражением, эквивалентным тому, что было бы записано как πx + e ^x. в старой доброй математике. Я думал, что можно было бы написать его короче, чем он был написан на языке, с которым я работаю (APL), и поэтому представить эту очень простую задачу:

Напишите функцию или программу, которая (любым способом) принимает ноль или более чисел и возвращает (любым способом) результат вышеприведенного выражения для x = каждое из заданных чисел по крайней мере с 3 значащими цифрами для каждого результата.

Если ваш язык не имеет π и / или e , используйте значения 3.142 и 2.718.

Оценка - это число байтов, поэтому предваряйте ответ # LanguageName, 00 bytes .

Стандартные петли не допускаются.

Edit: Теперь решение , которое я придумал, ○+*, было найдено . Оригинальный код был (○x)+*x.

Дьялог АПЛ, 3 персонажа

Как молчаливая фраза.

○+*

Monadic ○умножает свой аргумент на π, monadic *- экспоненциальная функция exp. ○+*это поезд такой, что (○+*)ωравен (○ω)+(*ω). Поскольку это APL, фраза работает для аргументов произвольной формы, т.е. грамм. Вы можете передать вектор произвольной длины.

Же раствор можно в 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() печатает результат.

редактирование: 1 байт сохранен благодаря Алексу А.

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

Входы должны вводиться по одному за раз. Нажмите OK, не вводя ничего, чтобы выйти.

Третий подчеркивает интересную особенность 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.

Пиф, 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 значащими цифрами

В любом случае, я оставлю свой ответ в этой форме, потому что 15-байтовое решение Matlab уже предоставлено @costrom

Юлия, 12 байт

x->π*x+e.^x

Это анонимная функция, которая принимает массив и возвращает массив с плавающей точкой. Чтобы назвать его, дайте ему имя, например f=x->....

У Джулии есть встроенные константы πи, 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 ○+*, но pi timesвызывается функция J 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. Результат, как вы могли ожидать.