श्रृंखला नियम कल्पना

10

परिभाषा

दो कार्यों के साथ श्रृंखला नियम बताता है कि:

D[f(g(x))] = f'(g(x)) * g'(x)

या, वैकल्पिक रूप से:

D[f1(f2(x))] = f1'(f2(x)) * f2'(x)

तीन कार्यों के साथ श्रृंखला नियम बताता है कि:

D[f(g(h(x)))] = f'(g(h(x))) * g'(h(x)) * h'(x)

या, वैकल्पिक रूप से:

D[f1(f2(f3(x)))] = f1'(f2(f3(x))) * f2'(f3(x)) * f3'(x)

Et cetera।

कार्य

  • 2 और 21 के बीच एक पूर्णांक को देखते हुए, चेन नियम को कई कार्यों के साथ आउटपुट करता है, या तो पहले रूप में या दूसरे रूप में।
  • कृपया निर्दिष्ट करें कि क्या आप दूसरे फॉर्म का उपयोग कर रहे हैं।

चश्मा

  • स्ट्रिंग का प्रारूप ठीक वैसा ही होना चाहिए जैसा कि ऊपर कहा गया है:
    1. सभी रिक्त स्थान बरकरार रहे
    2. एक पूंजीकृत D
    3. एक वर्ग ब्रैकेट तुरंत निम्नलिखित D
    4. तारांकन बरकरार रखा
  • एक अतिरिक्त अनुगामी स्थान (U + 0020) की अनुमति है।
  • दूसरे रूप में फ़ंक्शन नामों में अग्रणी शून्य (जैसे के f01बजाय f1) की अनुमति है।

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

यदि आप पहले फॉर्म का उपयोग करते हैं:

input output
2     D[f(g(x))] = f'(g(x)) * g'(x)
3     D[f(g(h(x)))] = f'(g(h(x))) * g'(h(x)) * h'(x)

यदि आप दूसरे फॉर्म का उपयोग करते हैं:

input output
2     D[f1(f2(x))] = f1'(f2(x)) * f2'(x)
3     D[f1(f2(f3(x)))] = f1'(f2(f3(x))) * f2'(f3(x)) * f3'(x)

लीडरबोर्ड

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

code-golf  ascii-art  kolmogorov-complexity 
— लीक नन
स्रोत
क्या फ़ंक्शन नाम लोअरकेस होना चाहिए?
— बेट्सग जूल 26'16
@betseg हां बिल्कुल।
— लीक नन

जवाबों:

6

पायथन 2, 79 बाइट्स

f=lambda n:0**n*"D[x] ="or f(n-1).replace("x","f%d(x)"%n)+1%n*" *"+" f%d'(x)"%n

गिने हुए कार्यों के साथ आउटपुट।

प्रत्येक xको बार-बार बदलकर fn(x), फिर जोड़कर आउटपुट का निर्माण करता है * fn'(x)। *के लिए छोड़ दिया जाता है n==1।

पुनरावृति कार्यक्रम की तुलना (92 बाइट्स):

r="D[x] = ";n=0
exec'n+=1;r=r.replace("x","f%d(x)"%n)+"f%d\'(x) * "%n;'*input()
print r[:-3]

96 बाइट्स:

n=input();r='';s='x'
while n:s='f%d(%%s)'%n%s;r=" * f%d'"%n+s[2:]+r;n-=1
print"D[%s] = "%s+r[3:]

गिने हुए कार्यों के साथ आउटपुट।

नेस्टेड समारोह जम जाता है f1(f2(f3(x)))में sऔर में दाएँ हाथ की ओर अभिव्यक्ति r। स्ट्रिंग स्वरूपण क्लंकी है; 3.6 से f- स्ट्रिंग्स बेहतर होता।

— XNOR
स्रोत
5

सेसोस , 49 बाइट्स

0000000: 2ac992 63fb92 245fb6 6c57be 255bbe 2cc9bf 6d49da  *..c..$_.lW.%[.,..mI.
0000015: 025e7f fdced0 fd67f8 fcde33 b6a7b2 643d4f 65597e  .^.....g...3...d=OeY~
000002a: f77a72 dd73cf fe                                  .zr.s..

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

disassembled

set numin
add 68   ; 'D'
put
sub 7    ; '=' - 'D'
fwd 1
add 32   ; ' '
fwd 1
add 91   ; '['
put
add 2    ; ']' - '['
fwd 1
add 102  ; 'f'
fwd 1
add 40   ; '('
fwd 3
add 120  ; 'x'
rwd 2
get
jmp
    jmp
        fwd 1
        add 1
        rwd 3
        put
        add 1
        fwd 1
        put
        fwd 1
        sub 1
    jnz
    sub 1
    rwd 1
    add 1    ; ')' - '('
    fwd 3
    put
    rwd 1
    jmp
        rwd 3
        sub 1
        fwd 1
        put
        fwd 1
        add 1
        fwd 1
        sub 1
    jnz
    rwd 4
    put
    get
    add 41   ; ')'
    rwd 1
    put
    rwd 1
    put
    get
    add 42   ; '*'
    fwd 1
    put
    fwd 2
    put
    add 1
    fwd 1
    sub 2    ; '\'' - ')'
    put
    add 1    ; '(' - '\''
    put
    fwd 1
jnz
fwd 2
put
rwd 5
put
— एंडर्स कसीगोर
स्रोत
3

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

f=n=>--n?f(n).replace(/x/g,`${c=(n+15).toString(36)}(x)`)+` * ${c}'(x)`:`D[f(x)] = f'(x)`

या दूसरे फॉर्म का उपयोग करके 75 बाइट्स:

f=n=>n>1?f(n-1).replace(/x/g,`f${n}(x)`)+` * f${n}'(x)`:`D[f1(x)] = f1'(x)`

या अगर मुझे अतिरिक्त 1 *अवधि की अनुमति हो तो 82/64 बाइट्स :

f=n=>n?f(n-1).replace(/x/g,`${c=(n+14).toString(36)}(x)`)+` * ${c}'(x)`:`D[x] = 1`
f=n=>n?f(n-1).replace(/x/g,`f${n}(x)`)+` * f${n}'(x)`:`D[x] = 1`
— नील
स्रोत
1
आप अपने मुख्य के रूप में 73-बाइट संस्करण क्यों नहीं डालते हैं?
— लीकी नून
1
यदि आप पुनरावर्ती हो रहे हैं, तो आपको आवश्यकता है f=अन्यथा आपका कार्यक्रम काम नहीं करेगा।
— वैल्यू इंक।
2
@ केविनलाउ-केनीबाई, मैं हमेशा ऐसा करना भूल जाता हूं।
— नील
1

रूबी, 72 बाइट्स

दूसरा रूप। @Neil जवाब से रूबी को पोर्ट।

f=->n{n>1?f[n-1].gsub(?x,"f#{n}(x)")+" * f#{n}'(x)":"D[f1(x)] = f1'(x)"}
— मूल्य स्याही
स्रोत
1

जूलिया, 66 बाइट्स

!x=x>1?replace(!~-x,"x","f$x(x)")*" * f$x'(x)":"D[f1(x)] = f1'(x)"

@ नील के ES6 उत्तर का पोर्ट। दूसरे रूप का उपयोग करता है।

— मामा फन रोल
स्रोत
0

पायथन 2, 174 बाइट्स

i=input()+1
a=lambda x:'('.join(['f%d'%e for e in range(x,i)])+'(x'+')'*(i-x)
print'D[%s] = %s'%(a(1),' * '.join(["f%d'%s%s)"%(e+1,'('*(i-e-2>0),a(e+2))for e in range(i-1)]))

यहाँ रहने के लिए बहुत सारे कमरे बचे हैं। दूसरा रूप (का उपयोग करता है f1, f2, आदि)।

— तांबा
स्रोत
0

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

n=>{s="D[";for(i=1;i<=n;i++)s+="f"+i+"(";s+="x";s+=")".repeat(n);s+="] = ";for(i=1;i<=n;i++){s+="f"+i+"'(";for(j=i+1;j<=n;j++)s+="f"+j+"(";s+="x";s+=")".repeat(n-i+1);if(i-n)s+=" * ";}return s;}

31 बाइट्स @LeakyNun की बदौलत बच गए।

यह एक अनाम मेमने का कार्य है। मुझे यकीन है कि इसे छोटा करने का कोई तरीका है ...

Ungolfed

var chain = function(n) {
    var str = "D["; // derivative symbol
    for (var i = 1; i <= n; i++) {
        str += "f"+i+"("; // put in n functions, each labeled f1(, f2(, etc.
    }
    str += "x"; // add in the function input, usually "x"
    for (var i = 0; i < n; i++) {
        str += ")"; // add in n end parentheses
    }
    str += "] = "; // add in the end bracket and the equals operator
    for (var i = 1; i <= n; i++) {
        str += "f"+i+"'("; // add in all n of the outer functions with the prime operator
        for (var j = i+1; j <= n; j++) {
            str += "f"+j+"("; // add in all of the inner functions
        }
        str += "x"; // add in the input, "x"
        for (var j = 1; j <= n; j++) {
            str += ")"; // close the parentheses
        }
        if (i !== n) {
            str += " * "; // the multiplication of all of the outer primed functions
        }
    }
    return str;
};
— क्रिश्चियन को आकर्षित किया
स्रोत
बदले strमें s।
— लीक नून
ठीक है, मैं इसे बदलना भूल गया। लोल
— ड्रू क्रिस्टेन्सन
बदलें for(j=i;j<=n;j++)s+=")";करने के लिएs+=")".repeat(n-i+1);
— लीकी नून
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.