_{Bu meydan okuma esinlenilen Matematiktir. Programlama değildir .}

Bir faktöriyel veya bir gerçek için matematiksel gösterim bir ünlem işaretidir !. Ünlem işareti aynı zamanda notbirçok programlama dilinde ortak bir semboldür .

Meydan okuma:

Sayıları ve karakterleri içeren bir dize alın: + !giriş ve çıkış olarak:

Bir ünlem işaretinin önündeki her şey matematiksel bir ifade olarak değerlendirilmelidir, öyle 2+2de olur 4.

Tek bir ünlem işaretinden sonraki her şey, önündeki her şeye aksesuar olarak 2+2!5eklenmelidir , bu yüzden: vermeli 45, çünkü 2+2=4ve 5bir aksesuardır. 2+2!5+5vermeli 410.

Yana !da gelir not, bu şey değil aslında sonra bir aksesuar gerektiği değil eklenecektir. Yani, 2+2!!5vermek gerekir 4, çünkü 5bir aksesuar değil. Şimdi, not(not(true))==truebu yüzden 2+2!!!5vermelidir 45. 2+2!!5!5+5vermek gerekir:, 410çünkü 2+2=4, sonra bir faktöriyel ve !5!5+5. Birincisi 5bir gerçek değil 5+5, başka bir ünlem işaretinden sonra ve bu yüzden yine bir gerçek.

Açıklamalar:

• Ünlem işaretleri her +iki taraftaki a işaretinin yanında olmayacaktır .
• +Sayılar için öncülük olmayacak (öyle 5değil +5).
• Birincisinin önündeki ifadenin sonucuysa, isteğe bağlı olarak önde gelen bir sıfır ekleyebilirsiniz !. Hem 4ve 04giriş için çıkış kabul edilir:0+0!4

Yönetici özeti: her bir toplamı değerlendirin ( !ayırıcı olarak kabul edilir). Ardından, çift sayıdan !(dize başlangıcından itibaren sayma) sonra görünen tüm sayıları atın . Sonra hepsini kaldırın !.

Test senaryoları:

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

Bu kod golf yani bayt (her dilde) en kısa kod kazanır! Açıklamalar şiddetle teşvik edilir!

Retina , 35 31 29 bayt

ETHproductions'tan biraz ilham alarak 4 bayt tasarruf etti .

Leo'ya 2 bayt kazandığı için teşekkürler.

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

!\d*!?

Çevrimiçi deneyin!

JavaScript (ES6), 58 56 bayt

Martin Ender sayesinde iki bayt kurtardı .

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>

Bir şekilde geliştirilebilir ...

Jöle , 16 bayt

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

Çevrimiçi deneyin!

açıklama

Buradaki temel gözlem, "sıra dışı" adımları yürütebilmemiz; meblağları değerlendirip beğenmediklerimizi görmezden gelmek yerine, meblağları geçersiz konumlarda görmezden gelebilir, gerisini değerlendirebiliriz.

ṣ”!µḢ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

Gibi bir toplamı "10+10"değerlendirmek, bir sayıyı değerlendirir, örneğin 20, bir dizeye de değerlendirmesini kaldırır "20". Bu işlemi tekrarlamanın ek bir etkisi yoktur (bu idempotenttir). Bu nedenle, uzunluğu sıfır olduğu için değerlendirilmemiş kalan null dize hariç , dizenin her öğesini etkili bir şekilde değerlendiririz .

Jöle , 18 bayt

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

Çevrimiçi deneyin!

Nasıl?

ṣ”!µḊ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 bayt

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

Çevrimiçi deneyin! (Satır besleme ile ayrılmış test takımı.)

Yakut , 58 56 + 1 = 59 57 bayt

-pBayrağı kullanır . Tutleman'dan -2 bayt .

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

Çevrimiçi deneyin! (Tüm giriş satırlarını alacak ve çıktıyı farklı satırlara yazdırabilmek için fazladan bir kod satırı eklendi.)

Toplu, 192184 bayt

@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

Boş dizeleri işlemek elverişsizdir.

Pip , 18 bayt

Sanırım bu en kısa süredir ... Üç tekrardan önce de söylemiş olsam da.

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

Girdiyi komut satırı argümanı olarak alır. Çevrimiçi deneyin!

açıklama

                    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 bayt

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

Muhtemelen iyileştirme için bir yer var ama şu anda gelebileceğim en iyisi.