चर्च घटाव

Question

चर्च घटाव

लैम्ब्डा कैलकुलस हमेशा से मेरा एक आकर्षण रहा है और एक दूसरे में कार्य करने के उद्भव व्यवहार खुशी से जटिल हैं। चर्च अंक एक समारोह के दोहराया आवेदन (आमतौर पर एक निरंतर के अतिरिक्त) से दूषित प्राकृतिक संख्या का प्रतिनिधित्व कर रहे हैं। उदाहरण के लिए, संख्या शून्य x और इनपुट फ़ंक्शन को "अनदेखा करता है", एक है f(x), दो है f(f(x))और इसी तरह:

ident = lambda x: x
zero = lambda f: ident
succ = lambda n: lambda f: lambda x: f(n(f)(x))
one = succ(zero)
add1 = lambda x: x + 1
to_int = lambda f: f(add1)(0)
print(to_int(one))
>>> 1

इससे हम आसानी से यह देख सकते हैं कि पहले फंक्शन को x पर लागू करके पूरा किया जाता है और फिर दूसरे फंक्शन को x पर लागू किया जाता है:

add = lambda m: lambda n: lambda f: lambda x: n(f)(m(f)(x))
print(to_int(add(one)(two)))
>>> 3

जोड़ समझना अपेक्षाकृत आसान है। हालाँकि, एक नवागंतुक के लिए यह सोचना असंभव हो सकता है कि चर्च एन्कोडेड नंबर सिस्टम में घटाव कैसा दिखता है। किसी फ़ंक्शन को अन-लागू करने के लिए संभवतः इसका क्या अर्थ हो सकता है?

चुनौती

एक चर्च एन्कोडेड अंक प्रणाली में घटाव समारोह को लागू करें। जहां घटाव मॉनस ऑपरेशन करता है और एक कार्य nसमय को अनपेक्षित करता है यदि परिणाम शून्य या शून्य से अधिक होगा अन्यथा। यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

इनपुट

दो चर्च अंक जो भाषा की आपकी पसंद में एन्कोड किए गए हैं। इनपुट स्थितिगत या करी जा सकता है। ये हैं सच चर्च अंकों के साबित करने के लिए वे किसी भी समारोह में लेते हैं और उन्हें बार-बार आवेदन करना होगा ( add1उदाहरण में दी गई है, लेकिन यह हो सकता है add25, mult7या किसी भी अन्य एकल कार्य करते हैं।)

उत्पादन

एक चर्च अंक। यह ध्यान देने योग्य है कि अगर m < nउसके बाद m - nहमेशा पहचान समारोह के रूप में एक ही है।

उदाहरण:

minus(two)(one) = one
minus(one)(two) = zero
...

स्वीकार्य भी:

minus(two, one) = one
minus(one, two) = zero

क्रेडिट:

यह गिथुब मुझे चर्च के अंकों का एक अजगर कार्यान्वयन देने के लिए देता है।

Comments

(जिस्ट में टिप्पणी गलत है; पाठ्यक्रम की exp(m, n)गणना m^n।)

— नील

मुझे यकीन नहीं है कि आपका क्या मतलब है कि "इनपुट स्थितिगत या करी हो सकती है"। क्या इसके बजाय मुख्य कार्य lambda m,n,f:apply f m-n times(या यहां तक ​​कि lambda m,n,f,x:apply f m-n times to x) को परिभाषित करना ठीक है lambda m,n:lambda f:...? या यह सिर्फ दो इनपुट पर लागू होता है mऔर n?

— xnor

इसके अलावा, क्या हम तर्क mऔर nदूसरे क्रम में ले सकते हैं ? इससे करीने में मदद मिलेगी।

— xnor

@xnor जब तक आप यह साबित कर सकते हैं कि यह दो चर्च अंकों को घटा देगा तब आप जो चाहें इनपुट्स ले सकते हैं।

— रयान शेफर 13

Answer 1

हास्केल , 35 बाइट्स

(r%s)f x=s(x:)(iterate f x)!!r(+1)0

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

का कहना है कि rऔर sके चर्च एन्कोडिंग हैं mऔर n। हम कुछ प्रारंभिक मूल्य के r%sलिए f m-nसमय लागू करना चाहते हैं x। हम सबसे पहले अनंत सूची बनाते हैं

iterate f x = [x, f x, f (f x), f (f (f x)), ...]

इसके बाद प्रतियों s(x:)को प्रिपेंड करने के लिए उपयोग करें, अर्थात् प्रत्येक मान सूचक को सही पर स्थानांतरित करें :nxn

s(x:)(iterate f x) = [x, x, x, ...,  x, f x, f (f x), f (f (f x)), ...]

हम तब के mरूप में सीधे गणना करते हैं r(+1)0, और mउस सूची के 'तत्व' को लेते हैं !!r(+1)0। अनुक्रमण-मुक्त समाधान इसके बजाय कर सकता है head$r tail$..., कि पहले तत्व mबार ड्रॉप करें और फिर पहला तत्व लें, लेकिन अनुक्रमण सिंटैक्स बहुत छोटा है।

ध्यान दें कि क्लासिक समाधान बिना एक्सटेंशन के हास्केल में काम नहीं करता है क्योंकि इसकी मजबूत टाइपिंग पूर्ववर्ती ऑपरेशन का प्रतिनिधित्व नहीं कर सकती है।

Answer 2

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

eval('!u:!v:v(!n:!f:!x:n(!g:!h:h(g(f)))(!u:x)(!u:u))(u)'.replace('!','lambda '))

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

2 बाइट्स निक कैनेडी के लिए एक संयुक्त राष्ट्र की जरूरत नहीं है।

बेनामी फ़ंक्शन जो माइनस लागू करता है।

अधिकतर यह केवल विकिपीडिया पृष्ठ पर पाई गई परिभाषा को संपीड़ित कर रहा है; ऐसा नहीं है कि मैं वास्तव में अभी तक कोड को समझता हूं। लेकिन दिलचस्प!

Comments

जीपी के उल्लेख के आधार पर, !u:!v:v(!n:!f:!x:n(!g:!h:h(g(f)))(!y:x)(!x:x))(u)2 बाइट्स बचाने के लिए लगता है, लेकिन मुझे वास्तव में कोड समझ में नहीं आता है!

— निक केनेडी

@NickKennedy gettingsharper.de/2012/08/30/... यदि आप रुचि रखते हैं

— रयान शेफ़र

@ रियान शेफ़र: अच्छी "ट्रिक"!

— चास ब्राउन

Answer 3

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

lambda r,s:s(lambda r:lambda f:lambda x:r(lambda(_,x):(x,f(x)))((x,x))[0])(r)

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

हम प्रत्येक पुनरावृत्ति के लिए पिछले मूल्य पर नज़र रखने और अंत में इसे आउटपुट करने के द्वारा चर्च की वृद्धि करते हैं। कोड की लंबाई का 39% है "lambda"...

Comments

अच्छा! मैं एक गोल्फ के अजगर जवाब की प्रतीक्षा कर रहा था जो सिर्फ जीआईएस कार्यान्वयन को नहीं देखता था। क्या आपने इसके बारे में अन्य गोल्फ की तरह उत्तर का उपयोग करने के बारे में सोचा है?

— रियान शेफ़र

@RyanSiplefer मैंने दूसरे उत्तर को देखने के बाद eval / प्रतिस्थापित चीज़ की जाँच की, लेकिन यह वास्तव में 2 बाइट्स है यहाँ 5 लैंबडास को बदलने के लिए है। पायथन दुर्भाग्य से परिभाषित कार्यों और स्ट्रिंग हेरफेर दोनों पर वास्तव में चिंतित है। और इसमें एक अंतर्निहित "रचना" का अभाव है, जो लैम्ब्डा की एक परत को बचाएगा।

— xnor

Answer 4

C ++ (क्लैंग) , 112 बाइट्स

#define L(x,y)[&](auto x){return y;}
auto m=L(u,L(v,v(L(n,L(f,L(x,n(L(g,L(h,h(g(f)))))(L(u,x))(L(u,u))))))(u)));

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

यह अब तक मेरे द्वारा लिखे गए सबसे अयोग्य C ++ कोड है। उस ने कहा, मुझे लगता है कि इस कोड को ungolfing केवल बदतर बना देगा।

Answer 5

अंडरलोड , 37 बाइट्स

(~(((!())~):*^(~!:(:)~*(*)*)~^^!)~^^)

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

भीतरी (((!())~):*^(~!:(:)~*(*)*)~^^!)है predसमारोह, जोड़े के माध्यम से कार्यान्वित किया:

(               ( start pred function )!
  (
    (!())~      ( push zero below argument )!
  ):*^          ( do that twice )!

  (             ( start pair-increasing function )!
    ~!          ( remove second argument)!
    :           ( duplicate first argument )!
    (:)~*(*)*   ( increment first return value )!
  )
  ~^^           ( run pair-increasing function n times )
  !             ( remove first in returned pair )!
)

Answer 6

आर , 86 बाइट्स

eval(parse(t=gsub("!(.)","function(\\1)","!u!vv(!n!f!xn(!g!hh(g(f)))(!ux)(!uu))(u)")))

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

@ ChasBrown के पायथन जवाब का R पोर्ट ताकि एक को भी उखाड़ा जा सके।

Answer 7

जावास्क्रिप्ट (Node.js) , 87 85 81 76 74 बाइट्स

f=>g=>h=>x=>f(([x,[g,a]])=>[g(x),a])([x,g(a=>[x=>x,a])(f(a=>[h,a])())])[0]

इसे ऑनलाइन आज़माएं! किसी भी पुरस्कार को जीतने के लिए नहीं, लेकिन मैंने सोचा कि मैं एक अलग दृष्टिकोण की कोशिश करूंगा।

a=>[h,a]एक ऐसा चरण है जो लागू होता है h, जबकि a=>[x=>x,a]एक ऐसा चरण है जो लागू नहीं होता है h। हम पहले फ़ंक्शन fसमय और दूसरे फ़ंक्शन gबार लागू करते हैं । हम तो उलटा फ़ंक्शन ([f,[g,a]])=>[g(x),a] fसमय लागू करते हैं । यह gदूसरे चरणों से आगे निकल जाता है और f-gपहले चरणों को वांछित के रूप में प्रदर्शित करता है । यह तब अंतिम मूल्य निकालने के लिए बनी हुई है।

टुपल्स को निश्चित रूप से लैम्ब्डा कार्यों में परिवर्तित किया जा सकता है जिसके परिणामस्वरूप निम्नलिखित अभिव्यक्ति होती है:

f=>g=>h=>x=>f(e=>e(x=>d=>d(g=>a=>e=>e(g(x))(a))))(e=>e(x)(g(a=>e=>e(x=>x)(a))(f(a=>e=>e(h)(a))())))(x=>a=>x)

Answer 8

जे , 56 बाइट्स

c=:3 :0
t=.^:y
5!:1<'t'
)
m=.2 :'c 0>.(>:u 5!:0->:v 5!:0)0'

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

नोट: TIO के लिए -3 बाइट्स की गिनती बंदm=.

J में उच्च क्रम फ़ंक्शन क्रिया विशेषणों और संयोजनों का उपयोग करके प्राप्त किया जाता है। यहां एक चर्च अंक "क्रिया" (जो बार-बार एक क्रिया को लागू करता है) और एक पूर्णांक के संयोजन से गठित क्रिया विशेषण का gerund रूप है। निम्नलिखित क्रिया c("बनाने" के लिए) एक पूर्णांक को ऐसे गेरुंड में बदलने के लिए J के परमाणु प्रतिनिधित्व का उपयोग करती है :

c=:3 :0
t=.^:y
5!:1<'t'
)

हमारा "माइनस" ऑपरेटर (जो एक संयोग है) बाएं से दाएं गेरुंड चर्च अंक को घटाता है। हालांकि, यह हमारे cक्रिया से एक सहित चर्च के अंकों के किसी विशेष कार्यान्वयन को नहीं मानता है । इसके बजाय, यह सामान्य परिभाषा पर निर्भर करता है और प्रत्येक गेरुंड चर्च के अंक को एक क्रिया विशेषण में बदल देता है 5!:0, और फिर उस क्रिया को वृद्धि क्रिया में लागू करता है, और फिर उसको 0 पर >:लागू करता है।

यह फिर घटाता है और 0 के साथ अधिकतम लेता है, और cअंतिम परिणाम प्राप्त करने के लिए लागू होता है: एक नया गेरुंड चर्च अंक।

Answer 9

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 55 48 47 39 बाइट्स (33 अक्षर)

#2[(fx#[g#@g@f&][x&][#&])&]@#&

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

A प्रतीक 0xF4A1 है, एक विशेष गणितीय कोड बिंदु है जो इसके लिए एक सही तीर को दर्शाता है \[Function]। अधिक स्पष्टीकरण के लिए यहां देखें । यह वही है जो कोड के रूप में दिखता है

हम इसे 40 बाइट्स / 32 अक्षरों में कर सकते हैं, जो माप योजना के आधार पर छोटा हो सकता है:#2[n⟼f⟼x⟼n[g⟼#@g@f&][x&][#&]]@#&

गैर-गोल्फ संस्करण पूर्व की शास्त्रीय परिभाषा का शाब्दिक अनुवाद है :

pred = n \[Function] f \[Function] x \[Function] n[g \[Function] h \[Function] h[g[f]]][u \[Function] x][u \[Function] u];
subtract[m_, n_] := n[pred][m]

जो गणितज्ञों के सामने अंत में इस तरह दिखता है:

इस घटाव समारोह के साथ परिभाषित चर्च अंकों के साथ काम करता है

c@0=#& &;c@n_=#@*c[n-1][#]&

(अन-golfed: c[0] = Identity &; c[n_] = Function[a, a@*c[n-1][a]])

ताकि हमारे पास है

Table[c[n][f][x], {n, 0, 6}]
(*    {x, f[x], f[f[x]], f[f[f[x]]], f[f[f[f[x]]]], f[f[f[f[f[x]]]]], f[f[f[f[f[f[x]]]]]]}    *)

तथा

subtract[c[7],c[5]][f][x]
(*    f[f[x]]    *)