गणित में, एन द्वारा निरूपित एक गैर-ऋणात्मक पूर्णांक n का तथ्यात्मक, छोटा "तथ्य" ! , n से कम या बराबर सभी सकारात्मक पूर्णांकों का उत्पाद है । उदाहरण के लिए, 5! है 1 * 2 * 3 * 4 * 5 = 120

खाली उत्पाद के लिए कन्वेंशन के अनुसार, 0 का फैक्टरियल 1 है ।

ये वे नियमित तथ्य हैं जिनका हम उपयोग करते हैं। आइए कुछ विकल्प जोड़ें:

तथ्यात्मक (ऊपर परिभाषित)
दोहरा गुट: n !! = 1 + 2 + ... + n
त्रिगुणात्मक तथ्य: n !!! = 1 - (2 - (3 - ((- एन))) ...)
चौगुनी तथ्य: n !!!! = 1 / (2 / (3 ... / n)) ...) । नोट: यह फ्लोटिंग पॉइंट डिवीजन है, न कि पूर्णांक डिवीजन।

चुनौती

एक गैर-नकारात्मक पूर्णांक इनपुट n लें , सीधे 1 और 4 विस्मयादिबोधक चिह्न के बीच । इनपुट इस तरह दिखेगा (बिल्कुल): 0! , 5 !! , 132 !!! या 4 !!!! । इस चुनौती में, आप एक लचीले इनपुट प्रारूप को नहीं मान सकते हैं, क्षमा करें।

उत्पादन

आउटपुट किसी भी सुविधाजनक प्रारूप पर परिणाम होना चाहिए। चतुर्भुज गुट के परिणाम में दशमलव बिंदु के बाद कम से कम 2 अंक होने चाहिए, सिवाय 0 !!!! = 0 ।

परीक्षण के मामलों:

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
---
0!! = 0
1!! = 1
2!! = 3
3!! = 6
4!! = 10
5!! = 15
6!! = 21
7!! = 28
8!! = 36
9!! = 45
10!! = 55
---
0!!! = 0
1!!! = 1
2!!! = -1
3!!! = 2
4!!! = -2
5!!! = 3
6!!! = -3
7!!! = 4
8!!! = -4
9!!! = 5
10!!! = -5
---
0!!!! = 0
1!!!! = 1
2!!!! = 0.5
3!!!! = 1.5
4!!!! = 0.375
5!!!! = 1.875
6!!!! = 0.3125
7!!!! = 2.1875
8!!!! = 0.27344
9!!!! = 2.4609
10!!!! = 0.24609

प्रत्येक भाषा में सबसे छोटा समाधान जीतता है।

— स्टीवी ग्रिफिन
स्रोत

2

क्या चतुर्भुज गुट भी तर्कसंगत विभाजन हो सकता है?

— मार्टिन एंडर

6

"द डबल फैक्टोरियल" की परिभाषा एक फिट है ...

— एरिक आउटगॉल्फर

4

@ एरिक, यह एक वैकल्पिक दोहरा तथ्य है ;-)

— स्टीवी ग्रिफिन

1

@StewieGriffin BTW यह एक छोटा सा डरपोक है कि 0!-> 1।

— आउटगोल्फ़र ऑग

5

शीर्षक वैकल्पिक तथ्य

— डिजिटल ट्रामा

7

जावास्क्रिप्ट (ईएस 6), 88 बाइट्स

s=>eval(([a,b]=s.split(/\b/),g=k=>+a?k-a?k+'_*+-/'[b.length]+`(${g(k+1)})`:k:+!b[1])(1))

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

s=>eval(([a,b]=s.split(/\b/),g=k=>+a?k-a?k+'_*+-/'[b.length]+`(${g(k+1)})`:k:+!b[1])(1))

for(o = '!'; o <= '!!!!'; o += '!') {
  for(n = 0; n <= 10; n++) {
    console.log(n + o + ' = ' + f(n + o));
  }
}

Expand snippet

प्रारूपित और टिप्पणी की गई

s =>                                // given the input string s,
  eval(                             // evaluate as JS code:
    ( [a, b] = s.split(/\b/),       //   a = integer (as string) / b = '!' string
      g = k =>                      //   g = recursive function taking k as input
        +a ?                        //     if a is not zero:
          k - a ?                   //       if k is not equal to a:
            k + '_*+-/'[b.length] + //         append k and the operation symbol
            `(${g(k + 1)})`         //         append the result of a recursive call
          :                         //       else:
            k                       //         just append k and stop recursion
        :                           //     else:
          +!b[1]                    //       return 1 for multiplication / 0 otherwise
    )(1)                            //   initial call to g() with k = 1
  )                                 // end of eval()

— Arnauld
स्रोत

7

भूसी , 15 बाइट्स

§!ëΠΣF-F/#'!oṫi

इसे ऑनलाइन आज़माएं!

व्याख्या

कार्यों की एक सूची में अनुक्रमण: एक कार्यात्मक भाषा का उपयोग करने की खुशियाँ।

§!ëΠΣF-F/#'!oṫi  Implicit input, say x = "6!!!"
              i  Convert to integer (parses the leading sequence of digits): 6
            oṫ   Descending range to 1: y = [6,5,4,3,2,1]
  ë              Four-element list containing the functions
   Π             product,
    Σ            sum,
     F-          left fold with subtraction (gives 0 for empty list), and
       F/        left fold with division (gives 0 for empty list).
 !               1-based index into this list with
         #'!     count of !-characters in input: gives F-
§                Apply to y and print implicitly: -3

मैं, एक अवरोही रेंज और बाईं परतों का उपयोग के बाद से -और /भूसी में उलटे क्रम में अपने तर्क ले।

— Zgarb
स्रोत

Indexing into a list of functionsis woah ...

— एरिक आउटगॉल्फ

मैं हास्केल के बारे में सोच रहा था, और फिर मैं यह देखता हूं ... सचमुच यह काम के लिए सही उपकरण है। +1

— जोड़ता है

यह वही है जो हस्क के लिए बनाया गया था: डी

— लियो

6

सी # (.NET कोर) , 134 130 128 बाइट्स

s=>{double e=s.Split('!').Length,n=int.Parse(s.Trim('!')),i=n,r=n;for(;--i>0;)r=e>4?i/r:e>3?i-r:e>2?i+r:i*r;return n<1&e<3?1:r;}

इसे ऑनलाइन आज़माएं!

कोड गोल्फिंग का सबसे अच्छा हिस्सा वे चीजें हैं जो आप चुनौतियों को हल करने की कोशिश करते समय सीखते हैं। इसमें मैंने सीखा है कि C # में आप स्ट्रिंग्स से व्हाट्सएप के अलावा अन्य कैरेक्टर ट्रिम कर सकते हैं।

4 बाइट्स LiefdeWen के लिए धन्यवाद बचा लिया!
2 बाइट्स बचाए गए क्योंकि मुझे 1 को बदलने की आवश्यकता नहीं है s.Split('!').Length, बस में सीमाएं ठीक करें e>4?i/r:e>3?i-r:e>2?i+r:i*rऔर n<1&e<3?1:r।

— चार्ली
स्रोत

1

आप कर सकते हैं e nऔर iयह भी double4 बाइट को बचाने के लिए आर के लिए यह घोषित करने से बचने के लिए।

— LiefdeWen

1

@LiefdeWen या floatकिसी अन्य बाइट को बचाने के लिए।

— केविन क्रूज़सेन

4

पर्ल 5 , 62 बाइट्स

61 बाइट्स कोड + 1 के लिए -p।

$_=/^0!$/+eval join(qw{| *( +( -( /(}[s/!//g],1..$_).")"x--$_

मेरी ओर से एक मिस इंगित करने के लिए @ जीबी को धन्यवाद !

इसे ऑनलाइन आज़माएं! (यह -lपठनीयता के लिए उपयोग करता है)

— डोम हेस्टिंग्स
स्रोत

4

0!

— जीबी

@ जीबी अच्छी तरह से कोई मतलब नहीं है ... +5 के लिए फिक्स्ड!

— डोम हेस्टिंग्स 12

4

आर , 113 111 बाइट्स

function(s){z=strtoi((n=strsplit(s,'!')[[1]])[1])
n=length(n)
`if`(z,Reduce(c('*','+','-','/')[n],1:z,,T),n<2)}

कुछ परीक्षण मामलों की कोशिश करो!

ungolfed:

function(s){
  n <- strsplit(s,"!")[[1]]          # split on "!"
  z <- strtoi(n[1])                  # turn to integer
  n <- length(n)                     # count number of "!"
  FUN <- c(`*`,`+`,`-`,`/`)[[n]]     # select a function
  right <- TRUE                      # Reduce (fold) from the right
  if( z > 0)                         # if z > 0
    Reduce(FUN, 1:z,,right)          # return the value
  else    
    (n < 2)                          # 1 if n = 1, 0 if n > 1
}

— ग्यूसेप
स्रोत

el(strsplit(s,"!")) 1 बाइट बचाता है

— बाउंसीबॉल

4

पायथन 3, 124 130 121 119 बाइट्स

इस बिंदु पर, मेरा मानना है कि पुनरावृत्ति आगे बाइट की बचत की कुंजी है।

s=input()
l=s.count('!')
v=int(s[:-l])+1
print(eval((" *+-/"[l]+"(").join(map(str,range(1,v)))+")"*(v-2)or"0")+(l<2>v))

पर testcases प्रयास करें यह ऑनलाइन कोशिश करो!

-9 बाइट्स @ Mr.Xcoder को धन्यवाद !

-2 बाइट्स के लिए धन्यवाद @ फेलिप नार्डी बतिस्ता !

— Yytsi
स्रोत

6 के लिए विफल! । यह 720 होना चाहिए।

— श्री Xcoder

मैंने Tio टेस्ट सूट को अपडेट किया।

— श्री एक्सकोडर

-3 बाइट्स ।

— श्री एक्सकोडर

ओह, हाँ, यकीन नहीं है कि

— श्री Xcoder

2

— ईएस

3

अजगर , 34 30 बाइट्स

+uv++H@"/*+-"/Q\!G_tUK.vQKq"0!

इसे ऑनलाइन आज़माएं!

व्याख्या

+uv++H@"/*+-"/Q\!G_tUK.vQKq"0!"Q    Implicit: append "Q
                                    Implicit: read input to Q
                      .vQ           Evaluate Q as Pyth code. This evaluates the integer,
                                    any !'s are parsed as unary NOT for the next expression
                                    and discarded.
                     K              Save the result to K.
                    U               Get a list [0, 1, ..., K-1].
                   t                Drop the first item to get [1, 2, ..., K-1].
                  _                 Reverse to get [K-1, K-2, ..., 1].
 u                       K          Starting from G = K, for H in [K-1, K-2, ..., 1] do:
             /Q\!                     Count the !'s in Q.
      @"/*+-"                         Get the correct operator.
    +H                                Prepend the current H.
   +             G                    Append the previous value G.
  v                                   Evaluate as Python code.
                          q"0!"Q    See if Q == "0!".
+                                   If so, add 1.

— PurkkaKoodari
स्रोत

का उपयोग कर.U एक बाइट बचाता है।

— आउटगोल्फर ऑग

2

05AB1E , 27 बाइट्स

þL"/*+-"¹'!¢©è".»"ì.VD_нi®Θ

इसे ऑनलाइन आज़माएं!

— आउटगोल्फ को एरिक करें
स्रोत

क्या आप जानते हैं कि „.»काम क्यों नहीं करता है?

— रिले

@ रिले »अधूरा कंप्रेस्ड स्ट्रिंग का हिस्सा है, इसलिए यह त्रुटियों को दूर करता है और, आमतौर पर 05AB1E में, त्रुटि को नजरअंदाज कर दिया जाता है।

— आउटगॉल्फ

मैं "*+-/"èUइसके बाद Lफॉलो अप करने की कोशिश कर रहा था, .»Xलेकिन यह Xएक स्ट्रिंग के रूप में व्यवहार करता है , एक कमांड नहीं है और .»X.Vयहां तक कि वाइनकियर भी है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn Xeval नहीं करता है। X.Vदो आदेश हैं।

— आउटगोल्फ ऑग

@EriktheOutgolfer हाँ, लेकिन मैं यह उम्मीद कर रहा था कि यह गुना प्रसंस्करण से पहले विकसित होगा। उम्मीद करना , उम्मीद न करना :(। शपथ ले सकते थे कि "एक ही पात्र स्ट्रिंग का उपयोग डोगैडिक श्रृंखला में कमांड के रूप में" या कुछ और है।

— मैजिक ऑक्टोपस Urn

2

रूबी , 83 80 79 बाइट्स

->s{z=s.count ?!;s<?1?1+1<=>z:eval([*1..w=s.to_i]*(".0"+"_*+-/"[z]+?()+?)*~-w)}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

->s{
    # Get number of !
    z=s.count ?!

    # Special case: if the number is 0, then output 0 or 1 depending on z
    s<?1?1+1<=>z:

    # Otherwise build the full expression as a string and then evaluate it
    eval([*1..w=s.to_i]*(".0"+"_*+-/"[z]+?()+?)*~-w)
}

— जीबी
स्रोत

2

जावा 8, 141 136 134 बाइट्स

s->{float q=s.split("!",-1).length,n=new Float(s.split("!")[0]),i=n,r=n;for(;--i>0;r=q<3?i*r:q<4?i+r:q<5?i-r:i/r);return n<1&q<3?1:r;}

-5 बाइट्स (141 → 136) @CarlosAlejo के C # उत्तर के लिए धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                                // Method with String parameter and float return-type
  float q=s.split("!",-1).length,   //  Amount of exclamation marks + 1
        n=new Float(s.split("!")[0]),
                                    //  The number before the exclamation marks
        i=n,                        //  Index (starting at `n`)
        r=n;                        //  Return sum (starting at `n`)
  for(;--i>0;                       //  Loop from `i-1` down to 1
    r=                              //   Change the result (`r`) to:
      q<3?                          //    If `q` is 2:
       i*r                          //     Multiply
      :q<4?                         //    Else if `q` is 3:
       i+r                          //     Addition
      :q<5?                         //    Else if `q` is 4:
       i-r                          //     Subtraction
      :                             //    Else (if `q` is 5):
       i/r                          //     Division
  );                                //  End of loop
  return n<1&q<3?                   //  Edge case if the input is `0!`:
          1                         //   Then return 1
         :                          //  Else:
          r;                        //   Return the result
}                                   // End of method

— केविन क्रूज़सेन
स्रोत

1

मैंने एक समान उत्तर कहीं और देखा है ...: -DI भूल जाते हैं कि floatतुलना में कम है double।

— चार्ली

@CarlosAlejo हाँ, मैंने अपने प्रारंभिक 141 बाइट उत्तर के बाद आपका उत्तर देखा। float q=s.length()-(s=s.replace("!","")).length(),n=new Float(s)वर्तमान उत्तर में परिवर्तन ने मुझे 5 बाइट्स बचाए। :) एक " बाइट्स बचाए गए धन्यवाद को जोड़ना भूल गया " भाग मैंने अब देखा .. इस बारे में क्षमा करें।

— केविन क्रूज़सेन

ओह, कोई बात नहीं, मुझे खुशी है कि आपको मेरा जवाब पसंद आया। :-)

— चार्ली

2

जेली , २४ २३ २६ 25 बाइट्स

+ ३ गलत व्याख्या के बाद ठीक करने के लिए 2 बाइट्स पैचिंग :(

×
+
_
÷
ṣ”!µḢVRṚȯL©Ị$®ŀ@/

एक पूरा कार्यक्रम (कार्यक्रम स्थान द्वारा संदर्भित सहायक लिंक के साथ एक विचित्र लिंक)

इसे ऑनलाइन आज़माएं! या देखें परीक्षण सूट ।

कैसे?

× - Link 1, multiply: number, number

+ - Link 2, add: number, number

_ - Link 1, subtract: number, number

÷ - Link 1, divide: number, number

ṣ”!µḢVRṚȯL©Ị$®ŀ@/ - Main link: list of characters, a
ṣ”!               - split s at '!' characters
   µ              - monadic separation, call that b
    Ḣ             - head - pop and yield the digit list from b, modifying b
     V            - evaluate as Jelly code (get the number, say N)
      R           - range = [1,2,3,...,N]
       Ṛ          - reverse = [N,...,3,2,1]
            $     - last two links as a monad:
         L        -   length of modified b (number of '!' characters)
          ©       -   (copy to register)
           Ị      -   insignificant? (1 when just one '!', 0 when two or more)
        ȯ         - logical or (1 for "0!", 0 for "0!!...", the reversed-range otherwise)
                / - cumulative reduce by:
               @  -  with swapped arguments:
              ŀ   -    dyadic call of link at index:
             ®    -      recall value from register (number of '!' characters)

— जोनाथन एलन
स्रोत

के लिए विफल रहता है 0!।

— आउटगोल्फर ऑग

ओह, हाहा - मैंने ओपी के तहत आपकी टिप्पणी गलत पढ़ी थी - मुझे लगा कि वे 0 बना लेंगे! 0 के रूप में परिभाषित किया गया है जो गलत होगा।

— जोनाथन एलन

अब सब तय हो गया :)

— जोनाथन एलन

बहुत बुरा TIO अभी टूट गया है ताकि मैं परीक्षण कर सकूं अगर यह अभी भी अमान्य है। :(: पी भी बहुत बुरा है कि आप उपयोग नहीं कर सकते /। एक खाली सूची पर डी: संपादित करें: जाहिर है के लिए वैध 0!, 0!!, 0!!!और 0!!!!+1।

— एरिक Outgolfer

2

स्व-संशोधित x86_64 मशीन कोड, 123 बाइट्स

0f b6 0f 31 c0 eb 11 0f be c9 8d 04 80 8d 44 41 d0 0f b6 4f 01 48 ff c7 83 f9 21 75 ea b9 21 21 21 a1 33 0f 0f bc c9 81 c1 ff 07 00 00 c1 e9 03 0f b6 c9 89 ca 09 c2 74 35 55 48 89 e5 c7 45 fc 59 58 5c 5e 8a 4c 0d fc 88 0d 15 00 00 00 f3 0f 2a c8 83 f8 02 5d 7c 1f ff c8 0f 57 c0 f3 0f 2a c0 f3 0f 5e c1 83 f8 01 0f 28 c8 7f eb c3 f3 0f 10 05 03 01 00 00 c3 0f 28 c1 c3

व्याख्या की गई भाषाएं फैंसी के साथ कोड को गतिशील रूप से चलाने में सक्षम क्यों होंगी eval एस , लेकिन सादे मशीन कोड नहीं?

इसके साथ कोशिश करें:

#include <stdio.h>
#include <sys/mman.h>
#include <errno.h>

char ff[] = "\x0f\xb6\x0f\x31\xc0\xeb\x11\x0f\xbe\xc9\x8d\x04\x80\x8d\x44\x41\xd0\x0f\xb6\x4f\x01\x48\xff\xc7\x83\xf9\x21\x75\xea\xb9\x21\x21\x21\xa1\x33\x0f\x0f\xbc\xc9\x81\xc1\xff\x07\x00\x00\xc1\xe9\x03\x0f\xb6\xc9\x89\xca\x09\xc2\x74\x35\x55\x48\x89\xe5\xc7\x45\xfc\x59\x58\x5c\x5e\x8a\x4c\x0d\xfc\x88\x0d\x15\x00\x00\x00\xf3\x0f\x2a\xc8\x83\xf8\x02\x5d\x7c\x1f\xff\xc8\x0f\x57\xc0\xf3\x0f\x2a\xc0\xf3\x0f\x5e\xc1\x83\xf8\x01\x0f\x28\xc8\x7f\xeb\xc3\xf3\x0f\x10\x05\x03\x01\x00\x00\xc3\x0f\x28\xc1\xc3";
int main()
{
    char* page = (char*)((unsigned long)((char*)ff) & (~0xfffLL));
    if (mprotect(page, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
        perror("mprotect");
        return -1;
    }
    float (*f)(char*) = (float (*)(char*))ff;
    char* testcases[] = { "0!","1!","2!","3!","4!","5!","6!","7!","8!","9!","10!",
                          "0!!","1!!","2!!","3!!","4!!","5!!","6!!","7!!","8!!","9!!","10!!",
                          "0!!!","1!!!","2!!!","3!!!","4!!!","5!!!","6!!!","7!!!","8!!!","9!!!","10!!!",
                          "0!!!!","1!!!!","2!!!!","3!!!!","4!!!!","5!!!!","6!!!!","7!!!!","8!!!!","9!!!!","10!!!!",
                        };
    for (int i = 0; i < 44; i++) {
        printf("%s -> %f\n", testcases[i], f(testcases[i]));
    }
}

सभा:

_f:
100000d4f:  0f b6 0f    movzx   ecx, byte ptr [rdi]
100000d52:  31 c0   xor eax, eax
100000d54:  eb 11   jmp 17 <_f+18>
100000d56:  0f be c9    movsx   ecx, cl
100000d59:  8d 04 80    lea eax, [rax + 4*rax]
100000d5c:  8d 44 41 d0     lea eax, [rcx + 2*rax - 48]
100000d60:  0f b6 4f 01     movzx   ecx, byte ptr [rdi + 1]
100000d64:  48 ff c7    inc rdi
100000d67:  83 f9 21    cmp ecx, 33
100000d6a:  75 ea   jne -22 <_f+7>
100000d6c:  b9 21 21 21 a1  mov ecx, 2703302945
100000d71:  33 0f   xor ecx, dword ptr [rdi]
100000d73:  0f bc c9    bsf ecx, ecx
100000d76:  81 c1 ff 07 00 00   add ecx, 2047
100000d7c:  c1 e9 03    shr ecx, 3
100000d7f:  0f b6 c9    movzx   ecx, cl
100000d82:  89 ca   mov edx, ecx
100000d84:  09 c2   or  edx, eax
100000d86:  74 35   je  53 <_f+6E>
100000d88:  55  push    rbp
100000d89:  48 89 e5    mov rbp, rsp
100000d8c:  c7 45 fc 59 58 5c 5e    mov dword ptr [rbp - 4], 1583110233
100000d93:  8a 4c 0d fc     mov cl, byte ptr [rbp + rcx - 4]
100000d97:  88 0d 15 00 00 00   mov byte ptr [rip + 21], cl
100000d9d:  f3 0f 2a c8     cvtsi2ss    xmm1, eax
100000da1:  83 f8 02    cmp eax, 2
100000da4:  5d  pop rbp
100000da5:  7c 1f   jl  31 <_f+77>
100000da7:  ff c8   dec eax
100000da9:  0f 57 c0    xorps   xmm0, xmm0
100000dac:  f3 0f 2a c0     cvtsi2ss    xmm0, eax
100000db0:  f3 0f 5e c1     divss   xmm0, xmm1
100000db4:  83 f8 01    cmp eax, 1
100000db7:  0f 28 c8    movaps  xmm1, xmm0
100000dba:  7f eb   jg  -21 <_f+58>
100000dbc:  c3  ret
100000dbd:  f3 0f 10 05 03 01 00 00     movss   xmm0, dword ptr [rip + 259]
100000dc5:  c3  ret
100000dc6:  0f 28 c1    movaps  xmm0, xmm1
100000dc9:  c3  ret

स्पष्टीकरण बाद में जोड़ा जाएगा। मूल विचार को संशोधित करने के लिए है divss xmm0, xmm1पर शिक्षा 0x100000db0और एक साथ बदलें mulss, addss, subssया divssआपूर्ति संकार्य के अनुसार। इनपुट स्ट्रिंग को पार्स करने के लिए एक छोटी सी ट्रिक का भी उपयोग किया जाता है।

विधानसभा के साथ उत्पन्न:

float f (char* s)
{
    int x;
    for (x=0; *s != '!'; s++) {
        x=10*x + (*s-'0');
    }
    unsigned char op = (__builtin_ctz(*(unsigned int *)s ^ 0xa1212121)-1) >> 3;
    if (x == 0 && op == 0) {
        return 1;
    }
    unsigned int lookup = 0x5e5c5859;
    unsigned char new_code = ((unsigned char*)&lookup)[op];
    asm("movb %0, 0x15(%%rip)" : : "r" (new_code));
    float sum;
    for (sum = x--; x>0; x--) {
        sum = x / sum;
    }
    return sum;
}

— योआन
स्रोत

2

हास्केल, 105 102 98 96 बाइट्स

0!3=0
x!y=foldr([(*),(+),(-),(/)]!!y)([1,0,0,1]!!y)[1..x]
f s|[(n,b)]<-lex s=read n!(length b-1)

जार्ग और निम्मी को 9 बाइट्स दिए गए।

इसे ऑनलाइन आज़माएं।

— क्रिस्टियन लुपस्कू
स्रोत

@Zgarb तुम सही हो। फिक्स्ड।

— क्रिस्टियन लुपस्कू

मुझे लगता है कि आप आसपास के पार्न्स को भी गिरा सकते हैं read n, और हमारे नियमों केf= अनुसार अनावश्यक है ।

— जर्गर्ब

@Zgarb फिर से :)। धन्यवाद!

— क्रिस्टियन लुपस्कू

एक नामित फ़ंक्शन पर वापस स्विच करना और उपयोग करना lexदो बाइट्स बचाता है f s|[(n,b)]<-lex s=read n!(length b-1):।

— nimi

@ नमि वाह, धन्यवाद! मैं हास्केल के लिए इतना नया हूं कि मुझे इसके बारे में पता भी नहीं था lex। वह तो कमाल है! :) मैं नहीं देखता कि कैसे बाइट्स बचाता है - मुझे इसके बाद 99 बाइट्स मिलते हैं।

— क्रिस्टियन लुपस्कू

1

गैया , 26 25 बाइट्स

ẋ)@d┅v;l“×+⁻÷”=“ₔ⊢”+e¤ḥ!∨

इसे ऑनलाइन आज़माएं!

व्याख्या

ẋ                          Split the input into runs of the same character.
 )                         Get the last one (the !'s).
  @                        Push an input (since there's none left, use the last one).
   d                       Parse as number (ignores the !'s).
    ┅v                     Get the reverse range: [n .. 1]
      ;                    Copy the ! string
       l“×+⁻÷”=            Get its length and index into this string of operators.
               “ₔ⊢”+       Append 'ₔ⊢' to the operator.
                    e      Eval the resulting string, which is "reduce by <operator> with
                            swapped arguments." Reducing an empty list gives 0.
                     ¤     Bring the !'s back to the top.
                      ḥ!   Remove the first character and check if it's empty.
                        ∨  Logical OR; turns 0 from 0! to 1, doesn't change anything else.

— बिजनेस कैट
स्रोत

1

जेली , 28 बाइट्स

×
+
_
÷
³ċ”!
ḟ”!VRṚ¢ŀ@/¢Ị¤¹?

इसे ऑनलाइन आज़माएं!

-2 बाइट्स के लिए जोनाथन एलन के जवाब से लाइनों को अलग करने का विचार आया ।

— आउटगोल्फ को एरिक करें
स्रोत

1

APL (Dyalog) , 30 बाइट्स

Lstefano के समाधान से प्रेरित है ।

{0::0⋄(⍎'×+-⌹'⊃⍨≢⍵~⎕D)/⍳⍎⍵∩⎕D}

इसे ऑनलाइन आज़माएं!

{… } अनाम फ़ंक्शन जहां तर्क द्वारा दर्शाया गया है ⍵:

0:: यदि कोई त्रुटि होती है:

0 शून्य लौटाओ

⋄ अब कोशिश करो:

⍵∩⎕D चौराहे के तर्क और डी igits के सेट (विस्मयादिबोधक अंक निकालता है)

⍎ उस पर अमल करें (इसे संख्या में बदल देता है)

⍳ ɩ कि ndices

(… )/ सम्मिलित करें (एपीएल सही सहयोगी है, आवश्यकतानुसार) निम्न पदों के बीच कार्य:

⍵~⎕Dडी igits के बिना तर्क (विस्मयादिबोधक अंक छोड़ देता है)

≢ टैली कि (यानी कितने विस्मयादिबोधक बिंदु)

'×+-⌹'⊃⍨ प्रतीकों की सूची से लेने के लिए उपयोग करें *

⍎ निष्पादित (एक समारोह में प्रतीक बदल जाता है)

⌹(मैट्रिक्स विभाजन) का उपयोग ÷(सामान्य विभाजन) के बजाय एक खाली सूची में त्रुटि के लिए किया जाता है

— एडम
स्रोत

::डीएफएन में क्या करता है?

— ज़चारि

यह एक त्रुटि रक्षक है । यदि त्रुटि गार्ड सेट होने के बाद किसी भी संख्या के साथ एक त्रुटि (0 = 1… 999, 1000 = 1001…) ::होती है, तो बाईं ओर के दाईं ओर मान ::तुरंत लौटा दिया जाता है।

— 22

खैर, मैं इसके बारे में कभी नहीं जानता था, धन्यवाद!

— ज़ाचरी

0

पर्ल 5 , 96 बाइट्स

s/(\d+)//;@a=1..$1;$"=qw|* + -( /(|[$l=-1+length];$_=$1?"@a".($l>1?')'x($1-1):''):$l?0:1;$_=eval

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

0

Dyalog एपीएल, कम से कम 29 वर्ण

{(⍎i⊃'×+-÷')/⍳⍎⍵↓⍨-i←+/'!'=⍵}

अभिव्यक्ति ALMOST सही है। यह सभी परीक्षण मामलों को पारित करता है, 0!!!!जिसके लिए यह 1आवश्यक के बजाय देता है 0और ऐसा इसलिए है क्योंकि एपीएल में एक खाली वेक्टर की कमी को कम करने के लिए उपयोग किए जाने वाले फ़ंक्शन के लिए तटस्थ तत्व को वापस करना चाहिए। इस भागफल के लिए कि 1. इस समय मेरे पास कोशिश करने और इसे ठीक करने का समय नहीं है, लेकिन मैं इसे बारिश के दिन के लिए छोड़ दूँगा।

— lstefano
स्रोत

बारिश हो रही है: {0::0⋄(⍎'×+-⌹'⊃⍨≢⍵~⎕D)/⍳⍎⍵∩⎕D} इसे ऑनलाइन आज़माएं!

— 17

बहुत ही शांत! अगर आप इसे अपने समाधान के रूप में दावा करते हैं, तो मुझे कोई आपत्ति नहीं है, यह देखते हुए कि मतभेद समानता से अधिक हैं।

— lstefano

किया हुआ।

— 8

0

05AB1E , 25 24 बाइट्स

þDLðýs¹'!¢<"*+-/"ès<×J.V

इसे ऑनलाइन आज़माएं!

— जादू ऑक्टोपस Urn
स्रोत

0

मैथेमेटिका, 152 बाइट्स

(T=ToExpression;If[#=="0!!!!",0,s=T@StringCount[#,"!"];t=T@StringDrop[#,-s];{#!,i~Sum~{i,#},Sum[-i(-1)^i,{i,#}],N@Product[1/i^(-1)^i,{i,#}]}[[s]]&[t]])&

— J42161217
स्रोत

0

जावास्क्रिप्ट, 111 163 बाइट्स

s=>([a,b]=s.split(/\b/),c=b.length,a==0&c==1||eval((p=[...Array(+a+1).keys()].slice(1).join(c-1?c-2?c-3?'/(':'-(':'+':'*'))+')'.repeat((p.match(/\(/g)||[]).length)))

पठनीय संस्करण

s=>([a,b]=s.split(/\b/),c=b.length,a==0&c==1||eval((p=
[...Array(+a+1).keys()].slice(1).join(c-1?c-2?c-3?'/(':'-
(':'+':'*'))+')'.repeat((p.match(/\(/g)||[]).length)))

— SuperStormer
स्रोत

अतिरिक्त तथ्य!

चुनौती

उत्पादन

परीक्षण के मामलों:

जावास्क्रिप्ट (ईएस 6), 88 बाइट्स

परीक्षण के मामलों

प्रारूपित और टिप्पणी की गई

भूसी , 15 बाइट्स

व्याख्या

सी # (.NET कोर) , 134 130 128 बाइट्स

पर्ल 5 , 62 बाइट्स

आर , 113 111 बाइट्स

पायथन 3, 124 130 121 119 बाइट्स

अजगर , 34 30 बाइट्स

व्याख्या

05AB1E , 27 बाइट्स

रूबी , 83 80 79 बाइट्स

स्पष्टीकरण:

जावा 8, 141 136 134 बाइट्स

जेली , २४ २३ २६ 25 बाइट्स

कैसे?

स्व-संशोधित x86_64 मशीन कोड, 123 बाइट्स

हास्केल, 105 102 98 96 बाइट्स

गैया , 26 25 बाइट्स

व्याख्या

जेली , 28 बाइट्स

APL (Dyalog) , 30 बाइट्स

पर्ल 5 , 96 बाइट्स

Dyalog एपीएल, कम से कम 29 वर्ण

05AB1E , 25 24 बाइट्स

मैथेमेटिका, 152 बाइट्स

जावास्क्रिप्ट, 111 163 बाइट्स