_{Цей виклик натхненний математикою - це факт. Програмування - ні .}

Математичне позначення для факторіалу чи факту є знаком оклику !. Знак оклику також є загальним символом для notбагатьох мов програмування.

Виклик:

Візьміть рядок, що містить цифри та символи: + !як вхід та вихід наступного:

Все перед знаком оклику слід оцінювати як математичний вираз, так 2+2би і не було 4.

Все , після одного знаку оклику повинні бути додані в якості аксесуарів до того , що знаходиться перед ним, так: 2+2!5треба дати 45, тому що 2+2=4, і 5це аксесуар. 2+2!5+5повинні дати 410.

Оскільки !також означає not, що все, що не є аксесуаром після факту, не слід додавати. Отже, 2+2!!5слід давати 4, оскільки 5це не аксесуар. Тепер, not(not(true))==trueтак 2+2!!!5слід дати 45. 2+2!!5!5+5слід дати:, 410тому що 2+2=4, потім слідують факториал і !5!5+5. Перший 5- це не факт, але 5+5є після іншого знаком оклику, і, отже, факт знову.

Роз'яснення:

• Окличні знаки не будуть суміжними +з ані з одного боку.
• Не буде провідним +для чисел (це 5, ні +5).
• Ви можете необов'язково включати провідний нуль, якщо це результат виразу перед першим !. Обидва 4і 04приймаються вихідними для введення:0+0!4

Підсумок: оцінюйте кожну суму (трактуючи !як роздільники). Потім відкиньте всі числа, які з’являються після парного числа !(рахуючи з початку рядка). Потім видаліть усі !.

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

!
   <- Empty string

5
5

12!
12

!87
87

!!5
   <- Empty string

5+5!2+2
104

5+5!!2+2
10

1!2!3!4!5!6!7!8!9
12468

10+10!!2+2!!3+3!4+4
208

2!!3!5
25

2!!3!5!7
25

10!!!!!!!5
105

Це код-гольф, тому найкоротший код у байтах (кожною мовою) виграє! Пояснення настійно рекомендується!

Сітківка , 35 31 29 байт

Збережено 4 байти, взявши трохи натхнення від ETHproductions .

Дякуємо Лео за збереження ще 2-х байт.

\d+|\+
$*
1+
$.&
1`!

!\d*!?

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

JavaScript (ES6), 58 56 байт

Збережено два байти завдяки Мартіну Ендеру .

let f =
x=>x.replace(/[^!]+/g,eval).replace(/!(\d*)!?\d*/g,"$1")

<input value="2+2!5+5" oninput="try{O.value=f(value)}catch(e){}"><br>
<input id=O value="410" disabled>

Можна якось поліпшити ...

Желе , 16 байт

ṣ”!µḢW;m2$VṾ$L¡€

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

Пояснення

Основне зауваження тут полягає в тому, що ми можемо виконувати кроки "поза порядком"; замість того, щоб оцінювати суми, а потім ігнорувати ті, які нам не подобаються, ми можемо ігнорувати суми в недійсних позиціях, а потім оцінювати решту.

ṣ”!µḢW;m2$VṾ$L¡€
ṣ”!                Split input on '!'
   µ               Set as the new default for missing arguments
    Ḣ              Take the first element, removing it from the default
     W;  $         Cons with
       m2            every odd-numbered element of {the tail of the !-split input}
               €   For each remaining element
          VṾ$      Evaluate and de-evaluate it
             L¡      a number of times equal to its length

Оцінюючи суму , як "10+10"оцінить його номер, наприклад 20, то де-оцінити його в рядок, "20". Повторення цього процесу не дає додаткового ефекту (це ідентично). Таким чином, ми ефективно оцінюємо кожен елемент рядка, крім нульового рядка, який залишається неоціненим, оскільки має нульову довжину.

Желе , 18 байт

ṣ”!µḊm2;@ḢW$LÐfVṾ€

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

Як?

ṣ”!µḊm2;@ḢW$LÐfVṾ€ - Main link: string
ṣ”!                - split on '!' characters
   µ               - monadic chain separation (call that x)      e.g. ['1+1','0+0','0+0','0+0','','1+0','','','']
    Ḋ              - dequeue x (all but the leftmost entry of x) e.g.       ['0+0','0+0','0+0','','1+0','','','']
     m2            - modulo 2 index into that result             e.g.       ['0+0',      '0+0',   '1+0',   '']
           $       - last two links as a monad
         Ḣ         -     head x (the leftmost entry of x)        e.g.  '1+1'
          W        -     wrap                                    e.g. ['1+1']
       ;@          - concatenate with reversed arguments         e.g. ['1+1','0+0',      '0+0',   '1+0',   '']
             Ðf    - filter keep:
            L      -     length (keep that have non-zero length) e.g. ['1+1','0+0',      '0+0',   '1+0']
               V   - eval as jelly code (vectorises)             e.g. [  2,    0,          0,       1]
                      Yes, addition is just + and decimal numbers are just strings of digits in Jelly believe it or not!
                Ṿ€ - uneval €ach (creates a string from each one)e.g. [ '2',  '0',        '0'     ,'1']
                      without the € it would uneval the list and hence yield commas too)
                   - implicit print (prints the resulting list [of characters and possibly
                      lists of characters] as if it were all one string.)

CJam , 20 байт

r'!/{_{'+/1b}&}%(\2%

Спробуйте в Інтернеті! (Тестовий набір, відокремлений лініями подачі.)

Рубі , 58 56 + 1 = 59 57 байт

Використовує -pпрапор. -2 байти від Тутлемана .

i=0;$_=' '+$_;gsub(/!?([^!]*)/){eval$1if(2>i+=1)||i%2<1}

Спробуйте в Інтернеті! (Додано додатковий рядок коду, щоб він зайняв усі вхідні рядки та надрукував вихід у різних рядках.)

Пакетна, 192 184 байт

@echo off
set/ps=
call:c . "%s:!=" "%"
echo(%s%
exit/b
:c
set s=
if not %2=="" set/as=%2
:l
shift
shift
if "%1"=="" exit/b
if %1=="" goto l
set/at=%1
set s=%s%%t%
goto l

Доводиться обробляти порожні струни незручно.

Піп , 18 байт

Я думаю, що це найкоротше, що виходить ... хоча я це сказав і про три повторення.

{VaX++v%2+!v}Ma^'!

Вводиться як аргумент командного рядка. Спробуйте в Інтернеті!

Пояснення

                    a is 1st cmdline arg; global variable v is -1 (implicit)
              a^'!  Split a on !
{           }M      Map this function to the resulting list (note that inside function,
                    a is the function arg):
    ++v              Increment v (so that v tracks the 0-based index of the current
                     element)
       %2            We want to keep the elements where v%2 is 1...
         +!v         ... and also v=0, where v%2 is 0, but adding !v makes it 1
  aX                 String-multiply the argument by the above quantity (turning elements
                     we don't want into empty string)
 V                   Eval it (eval'ing empty string gives nil, but that's okay because
                     nil doesn't output anything)
                    Autoprint the resulting list, concatenated together (implicit)

R, 95 байт

function(x)for(e in strsplit(gsub('!([^!]*)![^!]*','\\1!',x),'!')[[1]])cat(eval(parse(text=e)))

Напевно, є дещо вдосконалення, але на даний момент це найкраще, що я можу придумати.