गोल्फ फिक्सिंग पॉइंट कॉम्बिनेटर

Question

अपनी पसंद की भाषा में यथासंभव कुछ बिंदुओं पर एक निश्चित बिंदु कॉम्बिनेटर लिखें ।

• मुक्त रूप ( यानी , जो भी सबसे छोटा है): संपूर्ण कार्यक्रम, वास्तविक कार्य, कोड स्निपेट
• यदि आपके पास यह है तो आप अपने मानक पुस्तकालय का उपयोग नहीं कर सकते हैं
• हालाँकि आप इसे अन्य उच्च-स्तरीय कार्यों से निकाल सकते हैं, जो आप इसे आधारों से बनाने के बजाय करेंगे

कृपया एक पुनरावर्ती तथ्य या फिबोनाची को शामिल करें जो इसे डेमो के रूप में उपयोग करता है।

इस प्रश्न में, स्व-संदर्भ स्वीकार्य है, इसका उद्देश्य केवल उस पुनरावर्ती कार्य से इसे हटाना है जो यह लागू होगा।

Comments

क्या एक आलसी-भाषा कार्यान्वयन ठीक है? (क्या आप स्वीकार करेंगे (define Y(lambda(f)(f(Y f))))?)

— बारह

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

— जेबी

यदि मैं गलत नहीं हूं, तो सख्ती से बोलना, शब्द "वाई कॉम्बीनेटर" विशेष रूप से हास्केल करी, λf द्वारा खोजे गए एक सिंगल पॉइंट कॉम्बिनेटर को संदर्भित करता है। (λx.f (xx)) (λx.f (xx))।

— जॉय एडम्स

@ एक्सएक्सएक्स: जाहिर है कि दोनों जवाब अब तक (ओपी के खुद के जवाब सहित) धोखा देने वाले तरीके का उपयोग करते हैं, इसलिए, मुझे लगता है कि यह ठीक है। :-P व्यक्तिगत रूप से, मैं @ जॉय के दृष्टिकोण के साथ जाऊंगा और कहूंगा कि केवल वास्तविक (गैर-आत्म-संदर्भित) वाई कॉम्बीनेटर ही करेगा। ;-)

— क्रिस जस्टर-यंग

@ क्रिस: ओह माय। शुरू में मेरे मन में यही था, और फिर मैं ... रास्ते में भूल गया। अब बदलने में बहुत देर हो चुकी है, हमें एक और सवाल खोलना होगा।

— जेबी

Answer 1

हास्केल: 10 अक्षर

y f=f$y f

फैक्टरियल या एनटी-फिबोनाची की पुनरावर्ती परिभाषा बनाने के लिए उपयोग का उदाहरण:

> map ( y(\f n->if n <= 1 then 1 else n*f(n-1)) ) [1..10]
[1,2,6,24,120,720,5040,40320,362880,3628800]

> map ( y(\f n->if n <= 1 then 1 else f(n-1)+f(n-2)) ) [0..10]
[1,1,2,3,5,8,13,21,34,55,89]

हालांकि, उपयोग करने का एक अधिक सामान्य तरीका yइन अनुक्रमों को सीधे कार्य के बजाय उत्पन्न करना होगा:

> take 10 $ y(\p->1:zipWith (*) [2..] p)
[1,2,6,24,120,720,5040,40320,362880,3628800]

> take 11 $ y(\f->1:1:zipWith (+) f (tail f))
[1,1,2,3,5,8,13,21,34,55,89]

बेशक, हास्केल के साथ, यह एक बैरल में मछली की शूटिंग की तरह एक सा है! Data.Functionपुस्तकालय इस समारोह, कहा जाता है fixवरबोस रूप में दर्शा कुछ हद तक लागू किया, हालांकि,।

Answer 2

पर्ल, ३,

sub f{my$s=$_[0];sub{$s->(f($s),@_)}}

तथ्यात्मक प्रदर्शन:

sub fact {
  my ($r, $n) = @_;
  return 1 if $n < 2;
  return $n * $r->($n-1);
}
print "Factorial $_ is ", f(\&fact)->($_), "\n" for 0..10;

फिबोनाची प्रदर्शन:

sub fib {
  my ($r, $n) = @_;
  return 1 if $n < 2;
  return $r->($n-1) + $r->($n-2);
}
print "Fibonacci number $_ is ", f(\&fib)->($_), "\n" for 0..10;

Answer 3

जीएनयू सी - 89 चार्ट

#define fix(f,z)({typeof(f)__f=(f);typeof(__f(0,z))x(typeof(z)n){return __f(x,n);}x(z);})

उदाहरण:

#define lambda2(arg1, arg2, expr) ({arg1;arg2;typeof(expr)__f(arg1,arg2){return(expr);};__f;})

int main(void)
{
    /* 3628800 */
    printf("%ld\n", fix(lambda2(
        long factorial(int n), int n, 
            n < 2 ? 1 : n * factorial(n-1)
        ), 10));

    /* 89 */
    printf("%ld\n", fix(lambda2(
        long fibonacci(int n), int n, 
            n < 2 ? 1 : fibonacci(n-1) + fibonacci(n-2)
        ), 10));

    return 0;
}

Answer 4

k2, 12 चार

स्पष्ट आत्म-संदर्भित कार्यान्वयन सबसे कम है। यह अच्छी भाषा डिजाइन का संकेत है। दुर्भाग्य से, K आलसी नहीं है, इसलिए हम केवल कॉल-बाय-वैल्यू का प्रबंधन कर सकते हैं।

Y:{x[Y[x]]y}

इस परिभाषा को बिना परेशानी के k4 और q में भी काम करना चाहिए, हालांकि मैं नीचे के उदाहरणों के लिए k2 मान रहा हूं।

  Y:{x[Y[x]]y}
  fac: {[f;arg] :[arg>0; arg*f[arg-1]; 1]}
  Y[fac] 5
120
  fib: {[f;arg] :[arg>1; f[arg-1] + f[arg-2]; arg]}
  Y[fib]' !10
0 1 1 2 3 5 8 13 21 34

एक अधिक विनम्र 18 अक्षर हमें (λx. x x) (λxyz. y (x x y) z)K में वास्तव में स्थानांतरित करने देता है ।

{x[x]}{y[x[x;y]]z}

शायद किसी दिन (k7?), ऐसा लग सकता है Y:{x Y x}।

Answer 5

पायथन 3, 30 बाइट्स

Y=lambda f:lambda a:f(Y(f))(a)

डेमो:

Y=lambda f:lambda a:f(Y(f))(a)
quicksort = Y(
lambda f:
    lambda x: (
        f([item for item in x if item < x[0]])
        + [y for y in x if x[0] == y]
        + f([item for item in x if item > x[0]])
    ) if x
    else []
)
print(quicksort([1, 3, 5, 4, 1, 3, 2]))

क्रेडिट: https://gist.github.com/WoLpH/17552c9508753044e44f

Comments

पायथन 3 में फिल्टर है। इसके अलावा मुझे खेद है कि मैंने उस टिप्पणी को मजाक के रूप में चिन्हित करने की उपेक्षा की

— साइओस

पायथन 3 का फ़िल्टर फ़िल्टर ऑब्जेक्ट देता है और सूची नहीं। फ़िल्टर का उपयोग करना कम पठनीय या पायथोनिक होगा।

— लैबो

यह पाइथोनिक कम होगा, लेकिन लाइन में अधिक कार्यात्मक-प्रोग्रामिंग था, जो मेरी बात थी

— साइओस