Універсальний Spooky Meme Translator


43

Вступ

Виявляється, прибульці люблять меми так само, як і ми. У кожної чужорідної раси, з якою ми стикалися до цього часу, є своя версія 2spooky4me(див . Наступне питання ) та еквівалентна, хоча з деякою варіацією. Мешканці планети CUTE1f не можуть впоратися з великою кількістю спокусів, тому їх кращим спокусом є 1spooky2me, в той час як меморі скелерів7 люблять їх деякі спокуси, тому вони, як правило, використовують 9spooky11me.

Виклик

Переклад мемів - важка робота, тому вам поставили завдання написати універсальний перекладач мемів, щоб допомогти цим хлопцям правильно отримати доступ до меменету. Ваша програма прийме мем і перетворення, яке застосовується до цифрних послідовностей у цьому мемі, щоб зробити його відповідним для мешканців іншої планети.

Вхідні дані

Ваша програма отримає два рядкові входи:

  1. Вхідний мем (наприклад 2spooky4me). Матчі [a-zA-Z0-9]+.
  2. Перетворення застосувати до нього (наприклад +1, перейти від 2spooky4meдо 3spooky5me). Матчі [+\-*/^]\d+(ви повинні прийняти +, -, *, /, і в ^якості операторів, незалежно від рідного уявлення на вашій мові).

Вихідні дані

Ваша програма повинна повернути рядковий вихід (надрукований на стандартний вихід або еквівалент) із заданим перетворенням, застосованим до цифрових послідовностей у вхідному мемі. У дивному повороті подій також виявляється, що всі зустрічаються до цього часу раси віддають перевагу цілісним мемам над дробовими, тому ці перетворення повинні виконувати цілу арифметику (наприклад, це 1spooky1me /2має призвести до 0spooky0me).

Приклади

Застосовуються стандартні арифметичні операції:

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

Послідовності цифр є цілісними; ціле укорочення має відбуватися у таких випадках:

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

Ваш вхід може не мати жодних цифр:

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

Ви повинні підтримувати експоненцію, навіть якщо це не рідна операція на вибраній вами мові:

Input:  2spooky4me ^3
Output: 8spooky64me

Немає обмеження по довжині рядка кількості цифрних послідовностей у рядку:

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

Додаток

Якщо ваша мова підтримує довільну точність цілих чисел як функцію мови, ви повинні використовувати їх. Якщо цього немає, вам не потрібно підтримувати цілі числа довільної точності. Наприклад, ви повинні використовувати IntegerHaskell замість того, Intщо він доступний як частина мови; у користуванні Javaвам не потрібно використовувати, BigIntegerоскільки це бібліотечна функція, а не мовна функція.

Input:  2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
Output: 1000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky2me

Це , тому стандартні лазівки заборонені, а найкоротша відповідь у байтах виграє!

Таблиця лідерів

Фрагмент стека внизу цієї публікації генерує таблицю лідерів з відповідей а) як список найкоротших варіантів для кожної мови та б) як загальну таблицю лідерів.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

## Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Якщо ви хочете включити у свій заголовок декілька чисел (наприклад, тому що ваш результат становить суму двох файлів або ви хочете окремо вказати штрафні санкції для перекладача), переконайтесь, що фактичний результат - це останнє число у заголовку:

## Perl, 43 + 2 (-p flag) = 45 bytes

Ви також можете зробити ім'я мови посиланням, яке з’явиться у фрагменті:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


3
Ваш останній тестовий випадок неправильний. У вас є одна занадто велика кількість нулів на виході, щоб вона була / 5.
Нік Хартлі

5
Перш за все, це досить добре складене перше повідомлення, тому вітаю :) Зверніть увагу: у нас є пісочниця, де ви можете опублікувати свій виклик для зворотного зв’язку, перш ніж він з’явиться в прямому ефірі.
FryAmTheEggman

3
Ласкаво просимо до PPCG (хоча ти, мабуть, був тут уже 2 роки). Гарний перший виклик. Чи передбачено доповнення про довільні точні цілі числа, які, наприклад, Java повинна використовувати BigIntegerдля своїх обчислень?
AdmBorkBork

18
Кожна чужа раса, з якою ми стикалися досі ... Це абсолютно правда! :-)
Луїс Мендо

2
Це ваше завдання, і зрештою, вирішувати саме вам, але це не дуже справедливо по відношенню до мов, які, як правило, використовують інший синтаксис.
Денніс

Відповіді:


10

Джольф, 15 14 байт

ρi«\d+»dC!6+HI

Спробуйте тут!

Пояснення

ρi«\d+»dC!6+HI
ρ «\d+»         replace all digits
 i              in the input
       d        (functional replace)
         !6     eval (using jolf's custom infix eval)
           +H   the number as a string plus
             I  the second input
        C       floor the result (integer truncate)

Приємно зазначити, що я оновив Джольфа після цього виклику, додавши кілька вбудованих RegExp. Це може бути 12 11 байт:

ρiLRdC!6+HI

24

Ruby, 50 44 43 байт

Відповідь FGITW. Треба швидко йти!

Завдяки @Neil за збереження 6 байт.

О так, перекреслений 44 все ще 44

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}

О, людина, це майже точно відповідь я тикати геть на: a=gets;$><<gets.gsub(/\d+/){eval$&+a}. Хоча міна пропустила річ ^! = ** і, мабуть, трохи довша.
Нік Хартлі

3
+1 за те, щоб ваше ціле рішення було на 4 байти коротше, ніж потрібно для PowerShell просто для обробки ^. : D
AdmBorkBork

15

Perl, 36 34 байт

s/\d+/"0|$&$^I"=~s#\^#**#r/gee

Вихідний код довжиною 30 байт, і йому потрібні комутатори -pi( +4 байти ). Перший вхід приймається від STDIN, другий - як аргумент -i.

Дякуємо @DenisIbaev за те, що виграли 2 байти!

Перевірте це на Ideone .


Так, я подумав, що хтось може перемогти мою відповідь Рубі, це був би Денніс та / або опинився б у Перлі, і ти в кінцевому підсумку виконав обидва очікування одночасно
Value Ink

1
-piце 4 байти?
CalculatorFeline

@CatsAreFluffy Поточний консенсус полягає у підрахунку відстані редагування від виклику без прапорців. Це включає пробіл для відокремлення -piвід решти команди.
Денніс

"0|$&"коротше, ніж "0|".$&.
Денис Ібаєв

@DenisIbaev Оскільки введення є буквено-цифровим, "0|$&$^I"працює також. Дякую!
Денніс

9

PowerShell v2 +, 139 137 байт

param($a,$b)-join($a-split"(\d+)"|%{if($_-match"\d+"){if($b[0]-ne'^'){[math]::Floor((iex $_$b))}else{"$_*"*$b.Trim('^')+1|iex}}else{$_}})

Ооо ... 47 байт просто для врахування, ^оскільки це не власний оператор у PowerShell. Збережено 2 байти завдяки @TessellationHeckler.

Приймає вхідний сигнал , як $a=<word>, $b=<operation>, як .\universal-spooky-meme.ps1 2spooky4me ^3. Ми робимо -split $aцифри, вкладаючи це в парени, тому ми тримаємо роздільники і передаємо отриманий масив через цикл |%{...}. Якщо поточний твір є числом, ми в першому if. Нам потрібно перевірити , є чи перший символ $bIS ^. Якщо це не так, ми просто з'єднаємо наш поточний шматок і $bвідправляємо його iex(подібний до eval), а потім залишаємо це на конвеєрі. В іншому випадку нам потрібно створити рядок експоненції з "$_*"*$b.Trim('^')+1і передати це iex, і залишити його на конвеєрі. Для наведеного 2spooky4me ^3прикладу це буде 2*2*2*1і 4*4*4*1, відповідно.

В іншому випадку ми просто залишаємо рядок таким, який є на конвеєрі.

Усі ці результати зібрані з конвеєра з інкапсулюючими паренами, перш ніж їх -joinзнову зібрати в одну струну. Це повторно зліва на конвеєрі, і вихід неявний під час завершення програми.

Приклади

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me ^5
32spooky1024me

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me /3
0spooky1me

Я писав власну, перш ніж дивитись відповіді, потім я ще й твої ідеї вищипував - дякую. Я думаю , що ви могли б замінити Floor(("$_$b"|iex))з , Floor((iex $_$b))щоб заощадити пару, або , може бути iex $_+$b.
TessellatingHeckler

@TessellatingHeckler Дякую за два байти!
AdmBorkBork

8

JavaScript (ES7), 58 57 байт

(s,t)=>s.replace(/\d+/g,n=>0|eval(n+t.replace('^','**')))

Редагувати: Збережено 1 байт, коли я згадав, що replaceтакож працює в буквальних рядках.


Класно, я працюю над рішенням ES6
Балінт

Ви можете каррі, щоб зберегти байт?
gcampbell

1
@gcampbell Так, але я занадто ледачий.
Ніл

6

Піта, 29

Jws.i:zK"\d+"3m.vs.iJ]+d;:zK1

Це працює, витягуючи кожне число з мему, а потім переплітаючи ( .i), після чого пробіл і загортаючи у список з іншим аргументом. Так що, якщо наш номер 7і ми мали ^20ми отримаємо список груп : ["^", "7 ", "20"]. Вирівнювання та використання Pyth eval( .v) у цьому завжди дає операцію, яку ми хочемо. Нарешті ці значення переплітаються з вихідним рядком, розділеним на випадки чисел.

Це може бути байт коротше, якби обидва входи були оточені цитатами, або два байти коротше, якщо можна було б цитувати лише один з них.

Спробуйте тут або запустіть тестовий набір


6

Python 2, 156 89 88 87 байт

Натхненний іншими відповідями, які використовують функцію заміщення їхніх мов за допомогою обробника функції, щоб обробляти числові частини довгих iрядків nput з oпереглядачем. Не пощастило для Python, його ^потрібно замінити **, що коштує колосальних 18 байт. .group(0)Сигнал лише для доступу до об'єкту матчу «s строкове подання не робить речі краще ...

Завдяки QPaysTaxes за те, що вони виявили помилковий простір та RootTwo за непотрібний аргумент .group!

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)

Я думаю, ви зможете позбутися місця післяi,o:
Нік Хартлі

Можна зберегти ще два байти: (1) за допомогою p.group(). (за замовчуванням до 0); та (2) вставити r=re.sub;заміну першого re.subдзвінка на, rа потім використовувати r('^','**',o)замістьo.replace(...)
RootTwo

@RootTwo: Для мене, r('^','**',o)тоді потрібно уникнути , ^щоб \^для того , щоб відповідати символу, а не почало o, чистий не економити ні одного байта :-( - але спасибі за вказуючи непотрібних 0!
ojdo

5

Javascript (ES6) 99 байт

Ще один приклад, чому ми ненавидимо чекати, коли ES7 отримає сумісність

(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)|0:_).join``

Приклад:

f=(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?Math.ceil(eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)):_).join``

alert(f(prompt("Enter string!"), prompt("Enter operation!")));


Ваші відповідні регекси, здається, трохи відключені. У прикладі запуску ви залишаєте великі літери, які викреслюють їх із результату ("2spooky4ME", "+1" => "3spooky5"), а в першому прикладі ви співпадаєте \d+|\D+, що еквівалентно .+. [a-zA-Z0-9]+це ви регулярний вираз, чи ні? Або [a-zA-Z]+|[0-9]+якщо розщеплення має значення?
Ітаї Фербер

Напевно, було б простіше викликати Math.powбезпосередньо, оскільки вам все одно доведеться робити спеціальний випадок. Також ви використовуєте ціле ділення?
Ніл

@Neil Я забув це, хвилина
Bálint

@Neil чи є кращий спосіб для стелі?
Балінт

1
@ItaiFerber \d+|\D+Не зовсім те саме, що .+. Вони не однакові, тому що розширення kleene відбувається раніше or. Це було б так само, якби це виглядало (\d|\D)+, але, як це є, воно не відповідало б усім сказаним 2aв одній групі, це були б дві окремі групи.
FryAmTheEggman


4

Котлін, 416 413 байт

Відсутність eval()у Котліні дійсно збільшила кількість байтів ...

fun main(a:Array<String>){var r=Regex("\\d+");var i=a[0];var n=a[1].takeLast(a[1].length-1).toInt();when(a[1][0]){'+'->print(r.replace(i,{m->""+(m.value.toInt()+n)}));'*'->print(r.replace(i,{m->""+(m.value.toInt()*n)}));'/'->print(r.replace(i,{m->""+(m.value.toInt()/n)}));'-'->print(r.replace(i,{m->""+(m.value.toInt()-n)}));'^'->print(r.replace(i,{m->""+(Math.pow(m.value.toDouble(),n.toDouble())).toInt()}));}}

Спробуйте в Інтернеті!

Безумовно

fun main(a: Array<String>) {
    var r = Regex("""\d+""")
    var i = a[0]
    var n = a[1].takeLast(a[1].length - 1).toInt()
    when (a[1][0]) {
        '+' -> print(r.replace(i, { m -> "" + (m.value.toInt() + n) }))
        '*' -> print(r.replace(i, { m -> "" + (m.value.toInt() * n) }))
        '/' -> print(r.replace(i, { m -> "" + (m.value.toInt() / n) }))
        '-' -> print(r.replace(i, { m -> "" + (m.value.toInt() - n) }))
        '^' -> print(r.replace(i, { m -> "" + (Math.pow(m.value.toDouble(), n.toDouble())).toInt() }))
    }
}

4

PowerShell (v4), 124 120 байт

# New 120 byte version:
$s,$a=$args;[regex]::Replace($s,'\d+',{($(if($a-ne($a=$a.Trim('^'))){
"$args*"*$a+1}else{"$args$a"})|iex)-replace'\..*'})

# Previous 124 byte version
$s,$a=$args;[regex]::Replace($s,'\d+',{if($a[0]-eq'^'){
[math]::pow("$args",$a.Trim('^'))}else{iex "$args$a-replace'\..*'"}})

(нові рядки є лише тут, щоб уникнути горизонтальної прокрутки, вони працюють, коли зберігаються як один рядок).

Запросили коментарі та неперероблену версію:

$meme, $instruction = $args

# Scriptblock which processes the numbers
# to be replaced. $args is the input number.
$replacement = {

    # Generates a string of the calculation, by:
    # Removing leading ^ character, if present.
    # ^3 -> 3,      +3 -> +3
    # See if it was present, and switch code paths.
    # (Can be one combined step in the golf)
    # Switch code paths for "raise to the power of",
    # or basic arithmetic.
    $trimmedInstruction = $instruction.Trim('^')
    $tmp = if ( $instruction -ne $trimmedInstruction ) {

        # String multiplication, changes
        # function input "45" and instruction "3" into
        # "45*45*45*+1". The "3" implicitly casts to [int]
        # the +1 is there to make the trailing * not crash.
        "$args*" * $instruction + 1

    } else {
        # Cobble the basic math together as a string
        # "45" and "+10" becomes
        # "45+10"
        "$args$instruction"
    }

    # eval() the generated string (e.g. "45+10" or "45*45*45*+1")
    $tmp = Invoke-Expression $tmp      # iex

    # Use a regex golf to replace trailing .23423
    # decimals in case of division with remainder.
    # Acts as [math]::floor(), harmless on other numbers.
    $tmp -replace'\..*'
}

# A regular expression replacement which picks out all 
# the numbers (\d+) and runs them through the
# replacement function. Returns a string which 
# ends up on stdout
[regex]::Replace($meme, '\d+', $replacement)
  • .Net бібліотека регулярних регексів може замінити блокнот скриптів, який виконується на вмісті відповідності, а PowerShell перекидає рядки типів до чисел і iexподібно eval()до інших мов. Це просто "2spooky" "+3"->eval("2+3")
  • За винятком ... він не може обробити ^оператора або будь-яку іншу зручну експоненцію, наприклад **, він може використовувати лише [math]::Pow()виклик бібліотеки, тому існує великий блок для обробки цієї гілки.
    • Оновлена ​​версія викрадає ідею у @TimmyD і замість цього робить множення рядків - "2*" * nщо стає, "2*2*2*2*"а потім додає +1в кінці, щоб помножити на одне, а не скаржитися на трейлінг *.
  • Крім ... .Net робить Округлення Banker, який округляється до найближчого парного числа за замовчуванням, і 3/2 = 2 , а не 3/2 = 1. Це завдання викликів для усічення, і це означає , що [math]::Truncate(). Натомість я зберігаю символи, використовуючи -replaceдля обрізання десяткової крапки і нічого після нього.

Тестові приклади:

PS D:\> .\meme.ps1 2spooky4me +1
3spooky5me

PS D:\> .\meme.ps1 2spooky4me -1
1spooky3me

PS D:\> .\meme.ps1 2spooky4me *15
30spooky60me

PS D:\> .\meme.ps1 10spooky900me /5
2spooky180me

PS D:\> .\meme.ps1 idontunderstandememes3 /2
idontunderstandememes1

PS D:\> .\meme.ps1 "idontunderstandememes3" "/2"
idontunderstandememes1

PS D:\> .\meme.ps1 "notreallyafunnymeme" "*100"
notreallyafunnymeme

PS D:\> .\meme.ps1 "2spooky4me" "^3"
8spooky64me

PS D:\> .\meme.ps1 "some1meme2sequences3can4be5really6long7" "/2"
some0meme1sequences1can2be2really3long3

PS D:\> .\meme.ps1 2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
1E+78‌​0spooky2me

NB. В останньому тесті цифри [BigInteger]автоматично переходять у тип , але вони відображаються в наукових позначеннях. На щастя, кожна відома раса, здатна спілкуватися між зірками, має достатньо наукових розробок, щоб можна було без проблем обробляти наукові позначення.


1
Ви можете побачити в інших відповідях, як вони надають досить нечитабельну версію для гольфу, а потім окрему версію без вогків для вивчення поведінки коду. Ви повинні зробити це зі своїм (а саме видалити нові рядки у версії для гольфу).
jpmc26

Дякую за кредит, але не мій трюк - я витягнув його з теми PowerShell Tips.
AdmBorkBork

Мабуть, я досить дбаю, щоб залишити коментар, а хтось ще піклується, щоб підтримати мій коментар. ;)
jpmc26

Ні, я сказав, що ви повинні мати повністю гольф-версію та повністю безгольову версію. Гольф потребує прокрутки. Негольований не буде і буде читабельніший за той, що у вас є.
jpmc26

1
@ jpmc26 Гаразд, я редагував у неперевершеній коментованій версії.
TessellatingHeckler

3

Bash + GNU coreutils, 144 байт

d=
u=$1,
for((i=0;i<${#u};i++)){ l=${u:i:1}
[[ "$l" =~ [0-9] ]]&&d=$d$l||{ [ -z $d ]||echo -n `bc<<<$d$2`&&{ [ $l != , ]&&echo -n $l; };d=; }
}

Тут розглядається зміна між цифрами та нецифровими цифрами, тому до вхідного рядка додається випадковий недійсний символ введення (кома). Потім ця кома ігнорується у висновку. Конвенція ОП точно випливає з синтаксису, bcякий тут використовується для виконання математики.


До речі, через обговорення в PowerShell-рішенні від @TessellationHeckler: У моєму рішенні ви можете перевести програму в один рядок, замінивши перерви рядка на крапки з комою, що не змінює її довжину.
rexkogitans

3

Луа, 145 93 байт

r=io.read;m=r()o=r()m=m:gsub("%d",function(n)return loadstring("return..."..o)(n)end)print(m)

Чому б просто не розмістити функцію?
Балінт

2

R, 163 байти

Як хтось, хто вивчає регулярні вирази та підстановку рядків на R, це виявилося досить важким викликом. Тим більше, що зіставлення цифр легко, але я не міг знайти спосіб використовувати кілька підстановок gsub. Крім того, я не знаю, чи eval(parse(paste0(...є найбільш ефективним способом перемикання між операціями. Можливо, switchтут краще підійде функція.

function(s,o){p=strsplit;y=p(gsub("\\d+","?",s),"?")[[1]];x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]));y[y=="?"]=floor(eval(parse(,,paste0("x",o))));cat(y,sep="")}

Пояснення

f=function(s,o){
    p=strsplit                                    # alias for stringsplit    
    y=p(gsub("\\d+","?",s),"?")[[1]]              # substitute numbers with "?" and split into vector on "?"
    x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]))  # split at alphabetical char, return vector with numbers to be operated on
    y[y=="?"]=floor(eval(parse(,,paste0("x",o)))) # replace inserted "?" with vector of numbers operated on
    cat(y,sep="")                                 # print concatenated vector
}

Я думаю, ви можете зекономити тонну байтів, якщо ви будете використовувати gsub із закриттям на сірниках, на що ви натякали у своєму коментарі. Я не знаю, як це зробити в R, хоча. Я теж боровся з цим, поки не дізнався, як це зробити в Гроові; в значній мірі змінилася гра.
Magic Octopus Urn

2

Javascript (ES6), 85 байт

x=(s)=>{var a=s.split(" ");return[...a[0]].map(x=>(!isNaN(x))?eval(x+a[1]):x).join``}

console.log(x("2spookie5me +1"));

Безголівки:

x = (s) => {
  var a = s.split(" ");
  return [...a[0]].map(x => (!isNaN(x)) ? eval(x + a[1]) : x).join ``
}
console.log(x("2spookie5me +1"));

Хтось знає, чи можу я розділити пробіли за допомогою оператора Spread? З цього с.спліт (""); до ["" ... s]; Принаймні така ідея.
Бладімір Руїз

Вам не потрібно ()навколо аргументу лямбда, вам не потрібно var, і ви повинні використовувати парени і оператор коми замість дужок іreturn
Cyoce

Також, ^це особливий випадок JavaScript, це бітовий XOR замістьMath.pow
Sunny Pun

2

Groovy, 64 60 байт

{a,b->a.replaceAll(/\d+/,{Eval.me(it+b.replace("^","**"))})}

Замінює всі екземпляри цифр закриттям, що оцінює операцію над цифровими частинами переданого слова. Якщо передана функція експонента, вона замінює її належними позначеннями. Groovy неявно обробляє перетворення BigInteger / BigDecimal при використанні, Eval.me()оскільки проаналізовані рядки потенційно можуть бути поза 2^32-1діапазоном.

Пояснив

{a,b->...} - Закриття двома аргументами.

a.replaceAll(/\d+/,{...}) - Шукайте всі розрядні послідовності в рядку та замініть закриттям.

{Eval.me(it+b.replace("^","**"))} - Більш конкретно, закриття кожного матчу, що додає до нього операцію, а потім оцінюється як groovy-код.

.replace("^","**")- Замініть перший екземпляр ^оператора groovy exponent **у наданій операції. Якщо ви хочете, щоб це працювало з повними рядками рівнянь, в яких використовуються експоненти, replaceAll()замість цього використовуйте штраф у байт +3.

Весела сторона - це правильний тестовий сценарій:
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)


1

RProgN , 39 байт

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R

Пояснив

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R
►                                       # Spaceless segment.
 x=                                     # Assign the top value of the stack '[+*/-]\d+' 
   '$d+'§                         }R     # Replace everything in the pattern %d+ (all numbers) based on an anonymous function 
         x'%D+'''R                      # Replace all Non-digits in the modifer with nothing, leaving just the second argument for the operator.
                  x'%d+'''R             # Snip all digits, separating our operator from our digits such that digit operator exists in the stack.
                           g'y'=        # Grab the function that is represented by the top of the stack (the operator in this case)
                                y       # Run it
                                 _      # Floor the result. 

Технічно недійсна відповідь, оскільки ця мова для неї не існувала. Однак він не був спеціально розроблений для нього, ані якогось конкретного доповнення. Тож я його запускаю. Суди мене.

Спробуйте в Інтернеті!


0

Perl 6, 111 байт

{/(\w+)\s(<[+\-*/^]>)(\d+)/&&my \b=+$2;my \o=(*+b,*-b,* *b,*div b,* **b)[index "+-*/^",$1];$0.subst(/\d+/,o):g}

На жаль EVAL, вимкнено за замовчуванням. Крім того, ви повинні використовувати divдля цілого поділу.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.