30

सबसे छोटा कोड लिखें जो किसी भी वास्तविक संख्या को इनपुट के रूप में 1 से अधिक ले जाएगा और इसका सकारात्मक उलटा तथ्यात्मक उत्पादन करेगा। दूसरे शब्दों में, यह इस सवाल का जवाब देता है कि "संख्या संख्या क्या इस संख्या के बराबर है?"। यहाँ वर्णित किसी भी वास्तविक संख्या के लिए भाज्य की परिभाषा का विस्तार करने के लिए गामा फ़ंक्शन का उपयोग करें ।

उदाहरण के लिए:

input=6 output=3 
input=10 output=3.390077654

क्योंकि 3! = 6और3.390077654! = 10

नियम

यह फैक्टरियल फ़ंक्शंस या गामा फ़ंक्शंस, या फ़ंक्शंस में उपयोग करने से मना किया जाता है जो इन फ़ंक्शंस पर भरोसा करते हैं।
कार्यक्रम इसे 5 दशमलव अंकों की गणना करने में सक्षम होना चाहिए, किसी भी सटीक की गणना करने की सैद्धांतिक क्षमता के साथ (इसमें एक संख्या शामिल होनी चाहिए जिसे मनमाना परिशुद्धता प्राप्त करने के लिए मनमाना बड़ा या छोटा बनाया जा सकता है)
किसी भी भाषा की अनुमति है, वर्णों में सबसे छोटा कोड जीतता है।

मैंने यहां एक काम का उदाहरण दिया । एक नज़र देख लो।

code-golf math factorial

— जेन्स रेंडर्स
स्रोत

2

यह कुछ और परीक्षण मामलों का उपयोग कर सकता है, विशेष रूप से शून्य और नकारात्मक इनपुट को कवर करने के लिए।

— पीटर टेलर

मैंने संपादित किया कि इनपुट 1 से अधिक होना चाहिए क्योंकि अन्यथा मुल्तानी उत्तर हो सकते हैं।

— जेन्स रेंडर्स

1

वैसे भी कई उत्तर हो सकते हैं जब तक कि आप एक आवश्यकता भी नहीं जोड़ते हैं कि आउटपुट 1 से अधिक होना चाहिए

— पीटर टेलर

जब 24 इनपुट किया जाता है तो आपका काम करने का उदाहरण 3.99999 है। तो क्या ऐसा समाधान स्वीकार्य है?

— रुबिक

हाँ, क्योंकि इसे 4, से 5 दशमलव स्थानों तक सही देखा जा सकता है

— जेन्स रेंडर्स

13

जावास्क्रिप्ट (116)

यहाँ काले जादू! कुछ मिलीसेकंड में एक परिणाम देता है ।
केवल प्राथमिक गणित कार्यों के लिए इस्तेमाल किया: ln, pow,exponential

x=9;n=prompt(M=Math);for(i=1e4;i--;)x+=(n/M.exp(-x)/M.pow(x,x-.5)/2.5066/(1+1/12/x+1/288/x/x)-1)/M.log(x);alert(x-1)

बहुत बुरा LaTeX कोडगॉल्फ पर समर्थित नहीं है, लेकिन मूल रूप से, मैंने गामा और डिगामा कार्यों के लिए एक न्यूटन सॉल्वरf(y)=gamma(y)-n=0 और x=y-1(क्योंकि x!है gamma(x+1)) और सन्निकटन के लिए कोडित किया है ।

गामा सन्निकटन स्टर्लिंग सन्निकटन है
दिगम्मा सन्निकटन का उपयोग यूलर मैकलॉरीन सूत्र
का उपयोग करते हैं। डिगामा फ़ंक्शन गामा फ़ंक्शन द्वारा विभाजित गामा फ़ंक्शन का व्युत्पन्न है:f'(y)=gamma(y)*digamma(y)

अधूरा:

n = parseInt(prompt());
x = 9; //first guess, whatever but not too high (<500 seems good)

//10000 iterations
for(i=0;i<10000;i++) {

  //approximation for digamma
  d=Math.log(x);

  //approximation for gamma
  g=Math.exp(-x)*Math.pow(x,x-0.5)*Math.sqrt(Math.PI*2)*(1+1/12/x+1/288/x/x);

  //uncomment if more precision is needed
  //d=Math.log(x)-1/2/x-1/12/x/x+120/x/x/x/x;
  //g=Math.exp(-x)*Math.pow(x,x-0.5)*Math.sqrt(Math.PI*2)*(1+1/12/x+1/288/x/x-139/51840/x/x/x);

  //classic newton, gamma derivative is gamma*digamma
  x-=(g-n)/(g*d);
}

alert(x-1);

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

10 => 3.390062988090518
120 => 4.99999939151027
720 => 6.00000187248195
40320 => 8.000003557030217
3628800 => 10.000003941731514

— माइकल एम।
स्रोत

बहुत अच्छा जवाब पूरी तरह से यह आवश्यक परिशुद्धता को पूरा नहीं करता है और यह केवल 706 से कम संख्या के लिए काम करता है

— जेन्स रेंडर्स

@JensRenders, ठीक है, मैंने न्यूटन सॉल्वर के कुछ पुनरावृत्तियों को जोड़ा है, प्रारंभिक अनुमान और गामा फ़ंक्शन के लिए एक बेहतर सन्निकटन बदल दिया है। कि अब नियमों को फिट करना चाहिए। अब मुझे बताएं कि क्या यह ठीक है :)

— माइकल एम।

हां, अब यह सही है, मैंने इसे वोट दिया :)

— जेन रेंडर्स

1

आप 1 char को बचा सकते हैं:n=prompt(M=Math)

— Florent

एक बड़ी संख्या जैसे $ 10 ^ {10 ^ 6} $ पर अपना कोड चलाने का प्रयास करें, और यह सुनिश्चित करें कि आपको पूर्णांक परिणाम मिले

— डेविड जी। स्टॉर्क

13

गणितज्ञ - 74 54 49

उचित तरीका होगा

f[x_?NumberQ]:=NIntegrate[t^x E^-t,{t,0,∞}]
x/.FindRoot[f@x-Input[],{x,1}]

यदि हम परीक्षण को छोड़ देते ?NumberQहैं, तो यह अभी भी काम करेगा, लेकिन कुछ बुरा चेतावनियों को फेंक दें, जो कि अगर हम प्रतीकात्मक एकीकरण पर स्विच करते हैं तो चले जाएंगे Integrate, लेकिन यह अवैध होगा (मुझे लगता है), क्योंकि फ़ंक्शन स्वचालित रूप से Gammaफ़ंक्शन में परिवर्तित हो जाएगा । इसके अलावा, हम उस तरह से बाहरी फ़ंक्शन से छुटकारा पा सकते हैं।

वैसे भी

x/.FindRoot[Integrate[t^x E^-t,{t,0,∞}]-Input[],{x,1}]

उचित इनपुट के साथ हेक करने के लिए, बस फंक्शन डेफिनिशन (माटलैब को जीतने नहीं दे सकते)

x/.FindRoot[Integrate[t^x E^-t,{t,0,∞}]-#,{x,1}]&

यदि बिल्ट-इन तथ्यात्मक अनुमति दी गई थी

N@InverseFunction[#!&]@Input[]

ऊपर एक पूर्णांक नहीं दिया गया है (जो कि एक वास्तविक तथ्यात्मक फ़ंक्शन के लिए तर्क है)। निम्नलिखित करता है:

Floor[InverseFunction[Gamma][n]-1]

— बेंत की मार
स्रोत

आह उन सभी कार्यों में निर्मित! मुझे नहीं लगता कि यह एक समान तरीके को छोड़कर यह बीटेबल है।

— रुबिक

4

गणित की सामग्री के लिए गणितज्ञ इतना अनुचित है! : डी

— माइकल एम।

1

नाम से ही MATHematica

— Dadan

क्या NumberQपैटर्न टेस्ट आवश्यक है? या में पारेंस E^(-t)? क्या यह धोखा NIntegrateहै Integrate? शायद ... :)

— ओरियन

यह एक वास्तविक चुनौती में बदल रहा है;)

— 13

6

ised: 72 46 वर्ण

यह लगभग सही फिट है ... वहाँ एक "भाषा" है जो गणित गोल्फ के लिए सटीक रूप से प्रतीत होती है: ईश । इसका ओफ़्सेटेड सिंटैक्स एक बहुत ही संक्षिप्त कोड (कोई नामांकित चर, बस पूर्णांक मेमोरी स्लॉट और बहुत सारे बहुमुखी सिंगल चार ऑपरेटर) के लिए बनाता है। एक अभिन्न का उपयोग करके गामा फ़ंक्शन को परिभाषित करते हुए, मुझे यह 80 प्रतीत होता है यादृच्छिक वर्णों के लिए मिला

@4{:.1*@+{@3[.,.1,99]^x:*exp-$3}:}@6{:@{$4::@5avg${0,1}>$2}$5:}@0,0@1,99;$6:::.

यहां, मेमोरी स्लॉट $ 4 एक फैक्टोरियल फंक्शन है, मेमोरी स्लॉट $ 6 बिसफेक्शन फंक्शन और मेमोरी स्लॉट $ 2 इनपुट पर सेट होने की उम्मीद है (इस कोड को सोर्स करने से पहले दिया गया है)। स्लॉट $ 0 और $ 1 बिसनेस सीमाएं हैं। कॉल उदाहरण (ऊपर कोड मानकर फ़ाइल में है inversefactorial.ised)

bash> ised '@2{556}' --f inversefactorial.ised
556
5.86118

बेशक, आप बिलिन का उपयोग कर सकते हैं! ऑपरेटर, जिस स्थिति में आप 45 वर्ण तक नीचे जाते हैं

@6{:@{{@5avg${0,1}}!>$2}$5:}@0,0@1,99;$6:::.

सावधानीपूर्वक, ऑपरेटर की प्राथमिकता कभी-कभी अजीब होती है।

संपादित करें: उन्हें सहेजने के बजाय कार्यों को इनलाइन करने के लिए याद किया गया। 72 पात्रों के साथ गणितज्ञ को हराया!

@0,0@1,99;{:@{{:.1*@+{@3[.,.1,99]^x:*exp-$3}:}::@5avg${0,1}>$2}$5:}:::.

और का उपयोग कर! बिलिन आप 41 मिलता है।

एक साल का अतिदेय अद्यतन:

मैंने महसूस किया कि यह अत्यधिक अक्षम था। गोल्फ-डाउन से 60 अक्षर:

@0#@1,99;{:@{.1*@3[.,.1,99]^@5avg${0,1}@:exp-$3>$2}$5:}:::.

अगर utf-8 का उपयोग किया जाता है (Mathematica इसे भी करता है), तो हम 57 तक पहुँचते हैं:

@0#@1,99;{:@{.1*@3[.,.1,99]^@5avg${0,1}·exp-$3>$2}$5:}∙.

थोड़ा अलग रीराइटाइट इसे 46 तक काट सकता है (या अगर बिलिन का उपयोग कर रहा है!):

{:x_S{.5@3[.,.1,99]^avgx·exp-$3*.1<$2}:}∙∓99_0

यदि आप दो बार उत्तर मुद्रित करने के साथ ठीक हैं, तो अंतिम दो वर्णों को हटाया जा सकता है।

— ओरियन
स्रोत

मुझे आश्चर्य होगा अगर मैं किसी को यह देखूं: o

— जेन्स रेंडर्स

@ जेनरेंडर्स: मैंने अभी किया;)

— एममबॉस

सटीकता के बारे में चर्चा को स्पष्ट करने के लिए: यह .1 (एकीकरण चरण) और 99 (एकीकरण सीमा) द्वारा निर्धारित है। Bisection मशीन परिशुद्धता के लिए जाता है। जब तक आप ऊपर (99!) इनपुट नंबर नहीं चाहते तब तक bisection की सीमा @ 1,99 99 पर रखी जा सकती है।

— ओरियन

@mmumboss आपको फिर से मिला :)

— orion

5

MATLAB 54 47

अगर मैं सही चुनौतियां उठाता हूं तो MATLAB गोल्फिंग के लिए बहुत अच्छा है :)। मेरे कोड में मुझे समीकरण (ux!) = 0 का समाधान मिला है जिसमें यू उपयोगकर्ता इनपुट है, और चर को हल करने के लिए x। इसका मतलब है कि u = 6 से x = 3, आदि हो जाएगा ...

@(x)fsolve(@(y)u-quad(@(x)x.^y./exp(x),0,99),1)

इंटीग्रल की ऊपरी सीमा को बदलकर सटीकता को बदला जा सकता है, जो 99 पर सेट है। इसे कम करने से आउटपुट की सटीकता निम्नानुसार बदल जाएगी। 10 के इनपुट के लिए उदाहरण के लिए:

upper limit = 99; answer = 3.390077650833145;
upper limit = 20; answer = 3.390082293675363;
upper limit = 10; answer = 3.402035336604546;
upper limit = 05; answer = 3.747303578099607;

आदि।

— mmumboss
स्रोत

आपको सटीकता के लिए विकल्प निर्दिष्ट करना चाहिए क्योंकि यह नियमों में आवश्यक है! "इसमें एक संख्या होनी चाहिए जिसे मनमाना सटीक प्राप्त करने के लिए मनमाना बड़ा या छोटा बनाया जा सकता है"

— जेन्स रेंडर्स

मैं इसे ईश और गणितज्ञ समाधान में नहीं देखता? लेकिन मैं इस पर गौर करूँगा ..

— mmumboss

1

मैं आइस्ड संस्करण में 99 की संख्या देखता हूं, और गणित का संस्करण वैसे भी पीटा जाता है

— जेन्स रेंडर्स

कोड में स्थिति को देखते हुए, यह शायद अभिन्न के लिए ऊपरी सीमा है। मेरे कोड में यह inf है। तो हाँ, अगर मैं इस प्रकार को 99 में बदल देता हूं, तो मेरा उत्तर कम सटीक हो जाता है, जिसका अर्थ है कि यह संख्या सटीक को प्रभावित करती है, और इसलिए मैं नियमों को पूरा करता हूं। अगर मैं इसे 99 में बदल

— दूं

लेकिन 99 को बदलने के बाद यह आवश्यक परिशुद्धता को पूरा करता है?

— रूबिक

3

पायथन - 199 वर्ण

ठीक है, तो आपको ढेर सारी जगह और बहुत समय की आवश्यकता होगी, लेकिन हे, यह वहां मिलेगा!

from random import *
from math import e
def f(x,n):
    q=randint(0,x)+random()
    z=0
    d=0.1**n
    y=d
    while y<100:
            z+=y**q*e**(-y)*d
            y+=d
    return q if round(z,n)==x else f(x,n)

यहाँ और भी अधिक पुनरावृत्ति के साथ एक और दृष्टिकोण है।

from random import *
from math import e
def f(x,n):
    q=randint(0,x)+random()
    return q if round(h(q,0,0.1**n,0),n)==x else f(x,n)
def h(q,z,d,y):
    if y>100:return z
    else:return h(q,z+y**q*e**(-y)*d,d,y+d)

इन दोनों का परीक्षण किया जा सकता है >>>f(10,1)बशर्ते आप 10000 के आसपास पुनरावृत्ति सीमा निर्धारित करें। सटीकता के एक से अधिक दशमलव स्थान संभवतः किसी भी यथार्थवादी पुनरावर्तन सीमा के साथ पूर्ण नहीं होंगे।

टिप्पणियों और कुछ संशोधनों को शामिल करते हुए, 199 वर्णों तक नीचे।

from random import*
from math import*
def f(x,n):
    q=random()*x+random()
    z=y=0
    while y<100:
            z+=y**q*e**-y*0.1**n
            y+=0.1**n
    return q if round(z,n)==x else f(x,n)

— intx13
स्रोत

2

यह एक code-golfसवाल है, इसलिए आपको अपने समाधान की लंबाई बताते हुए, सबसे छोटा उत्तर देने की आवश्यकता है।

— 18

एक अच्छा तरीका है, लेकिन समस्या यह है कि आप इस बात का जवाब नहीं दे सकते हैं कि यह कभी भी जवाब पा लेगा ... इसके अलावा, यह कोडगुल्ल ज़ो है जो आप चरित्र के उपयोग को कम करने की कोशिश कर सकते हैं।

— जेन्स रेंडर्स

1

पायथन के यादृच्छिक () में मेरसेन ट्विस्टर का उपयोग किया गया है, जो मुझे लगता है कि पायथन की फ़्लोट्स के स्थान पर चलता है, इसलिए इसे हमेशा सहन करना चाहिए अगर सहनशीलता के भीतर कोई उत्तर है।

— intx13

क्या आपका मतलब है कि किसी को दोहराने से पहले यह हर फ्लोट वैल्यू लौटाता है? अगर इस कोड की तुलना में यह मान्य होगा तो यदि आप जहां ओवरफ्लो को दूर करने में सक्षम हैं

— जेन्स रेंडर्स

2

कोड सक्षम है, यह सिर्फ इतना है कि आपके और मेरे पास इसे पूरा करने के लिए समय और न ही कंप्यूटर संसाधन हो सकते हैं;)

— intx13

3

पायथन 2.7 - 215 189 वर्ण

f=lambda t:sum((x*.1)**t*2.71828**-(x*.1)*.1for x in range(999))
n=float(raw_input());x=1.;F=0;C=99
while 1:
 if abs(n-f(x))<1e-5:print x;break
 F,C,x=f(x)<n and(x,C,(x+C)/2)or(F,x,(x+F)/2)

उपयोग:

# echo 6 | python invfact_golf.py
2.99999904633
# echo 10 | python invfact_golf.py
3.39007514715
# echo 3628800 | python invfact_golf.py
9.99999685376

परिशुद्धता को बदलने के लिए: 1e-5अधिक सटीकता के लिए छोटी संख्या में परिवर्तन , बदतर परिशुद्धता के लिए बड़ी संख्या। बेहतर परिशुद्धता के लिए आप शायद एक बेहतर मूल्य देना चाहते हैं e।

यह सिर्फ फैक्टोरियल फ़ंक्शन को लागू करता है f, और फिर इनपुट के व्युत्क्रम के सबसे सटीक मान पर बाइनरी खोज करता है। मान लें कि उत्तर 99 से कम या उसके बराबर है (यह सुनिश्चित करने के लिए 365 के उत्तर के लिए काम नहीं करेगा, मुझे एक गणित अतिप्रवाह त्रुटि मिलती है)। बहुत ही उचित स्थान और समय का उपयोग, हमेशा समाप्त होता है।

वैकल्पिक रूप से, की जगह if abs(n-f(x))<=10**-5: print x;breakके साथ print xबंद दाढ़ी बनाने के लिए 50 अक्षर । यह हमेशा के लिए लूप देगा, आपको अधिक से अधिक सटीक अनुमान देगा। यकीन नहीं है कि अगर यह नियमों के साथ फिट होगा।

— Claudiu
स्रोत

मुझे नहीं पता था कि चेरों को गिनने के लिए वह साइट है। मैं हमेशा उपयोग करता हूं cat file | wc -c।

— माणिक

@rubik: ओह अच्छा, का उपयोग करने के लिए नहीं सोचा था। वे दोनों मैच =)

— क्लाउडी

2

डीजी - 131 133 बाइट्स

o,d,n=0,0.1,float$input!
for w in(-2..9)=>while(sum$map(i->d*(i*d)**(o+ 10**(-w))/(2.718281**(i*d)))(0..999))<n=>o+=10**(-w)
print o

चूंकि dg CPython bytecode का उत्पादन करता है इसलिए इसे पायथन के लिए भी गिनना चाहिए, लेकिन ओह ... कुछ उदाहरण:

$ dg gam.dg 
10
3.3900766499999984
$ dg gam.dg 
24
3.9999989799999995
$ dg gam.dg 
100
4.892517629999997
$ dg gam.dg 
12637326743
13.27087070999999
$ dg gam.dg  # i'm not really sure about this one :P it's instantaneous though
28492739842739428347929842398472934929234239432948923
42.800660880000066
$ dg gam.dg  # a float example
284253.232359
8.891269689999989

संपादित करें: दो बाइट्स जोड़े गए क्योंकि मुझे याद नहीं था कि इसे तैरना भी स्वीकार करना चाहिए!

— रूबिक
स्रोत

मेरा देता है 42.8006566063, इसलिए वे परिशुद्धता के 5 अंकों के भीतर मेल खाते हैं!

— क्लाउडी

एक दम बढ़िया! मुझे नहीं पता कि ऊपरी सीमा कहां है, लेकिन यह कहीं न कहीं टूटना चाहिए। इसके लिए 1e100यह देता है: इसके 69.95780520000001लिए 1e150यह आउटपुट करता है 96.10586423000002, जबकि इसके लिए 1e200यह बढ़ता है। लेकिन वास्तव में मुझे नहीं पता कि वे परिणाम विश्वसनीय हैं या नहीं ...

— रुबिक

1

आर , 92 बाइट्स

एक फ़ंक्शन, gजो इनपुट लेता है zऔर उस संख्या के व्युत्क्रम में आउटपुट करता है

_{इसमें से लगभग निश्चित रूप से बाहर निकलना है, इसलिए यदि आपको कुछ ऐसा दिखाई देता है जिसे मैं सुधार सकता हूं, तो कृपया मुझे बताएं।}

library(pryr)
g=f(z,uniroot(f(a,integrate(f(x,x^a*exp(-x)),0,Inf)$v-z),c(0,z+1),tol=1e-9)$r)

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

Ungolfed और टिप्पणी की

library(pryr)                     # Add pryr to workspace
inv.factorial = f(z,              # Declare function which  
  uniroot(                        # Finds the root of
    f(a, integrate(               # The integral of 
      f(x, x^a*exp(-x))           # The gamma function
        ,0 ,Inf                   # From 0 to Infinity
      )$value-z                   # Minus the input value, `z`
    ), c(0, z+1),                 # On the bound of 0 to z+1
    tol = 1e-323                  # With a specified tolerance
  )$root                          # And outputs the root
)                                 # End function

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

— टेलर स्कॉट
स्रोत

0

जावास्क्रिप्ट (लूप का उपयोग किए बिना!)

ऐसा करने के लिए, मैंने स्टर्लिंग फैक्टरियल सन्निकटन के व्युत्क्रम का एक सुविख्यात संख्यात्मक अंदाज़ा लगाया, और इससे प्रेरणा भी मिली .. ठीक है .. खांसी .. किसी और का कोड ...)

function f(n){
    if(n==1) return 1;
    else if(n==2) return 2;
    else if(n==6) return 3;
    else if(n==24) return 4;
    else{
        return Math.round((((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))/Math.log((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))))/Math.log((((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))/Math.log((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))))))/Math.log((((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))/Math.log((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))))/Math.log((((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592))+(Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))/Math.log((Math.log(n)/Math.LN10 *  Math.log(10.) - .5 * Math.log(2.*3.141592)))))))))
    }
}

— एंटोनियो रैगनिन
स्रोत

भाज्य के व्युत्क्रम की गणना करें

जावास्क्रिप्ट (116)

गणितज्ञ - 74 54 49

ised: 72 46 वर्ण

MATLAB 54 47

पायथन - 199 वर्ण

पायथन 2.7 - 215 189 वर्ण

डीजी - 131 133 बाइट्स

आर , 92 बाइट्स

Ungolfed और टिप्पणी की

जावास्क्रिप्ट (लूप का उपयोग किए बिना!)