Одного разу я робив якусь справжню роботу, оновлював старий код і натикався на вираз, еквівалентний тому, що було б записано як πx + e ^x у гарній старомодній математиці. Я подумав, що можна написати коротше, ніж це було написано мовою, з якою я працюю (APL), і тому представляю це дуже просте завдання:

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

Якщо у вашій мові немає π та / або e , використовуйте значення 3.142 та 2.718.

Оцінка балів - це кількість байтів, тому передмовте свою відповідь # LanguageName, 00 bytes .

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

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

Діалог APL, 3 символи

Як мовчазна фраза.

○+*

Монадик ○множить свій аргумент на π, монадична *- експоненціальна функція 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з шістнадцяткового значення в число, тому це alerts числа 0 до 15.

Математика, 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 відображає результат масиву з власним округленням, яке призводить до результатів, подібних 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

Пар , 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. Результат такий, як ви могли очікувати.