টাইপড ল্যাম্বদা ক্যালকুলাসের জন্য একজন দোভাষী লিখুন

Question

চ্যালেঞ্জটি হ'ল যতক্ষণ সম্ভব কম অক্ষরে অক্ষরযুক্ত ল্যাম্বডা ক্যালকুলাসের জন্য একটি অনুবাদক লিখুন । আমরা টাইপযুক্ত ল্যাম্বডা ক্যালকুলাসটি নিম্নলিখিতভাবে সংজ্ঞায়িত করেছি:

বাক্য গঠন

নিম্নলিখিত তিন ধরণের অভিব্যক্তি রয়েছে:

• একটি ল্যাম্বডা এক্সপ্রেশন ফর্ম রয়েছে (λ x. e)যেখানে xকোনও আইনি পরিবর্তনশীল নাম এবং eকোনও আইনি অভিব্যক্তি হতে পারে । এখানে xপ্যারামিটার eবলা হয় এবং ফাংশন বডি বলা হয়।

  সরলতার স্বার্থে আমরা আরও বিধিনিষেধ যোগ করি যে xবর্তমানে একই নামের সাথে কোনও ভেরিয়েবল থাকা উচিত নয় । একটি ভেরিয়েবল স্কোপে থাকা শুরু হয় যখন এর নামটি এর মাঝে উপস্থিত হয় (λএবং .এটি সংশ্লিষ্ট স্কোপ হতে থামে )।

• ফাংশন আবেদনপত্র হয়েছে (f a)যেখানে fএবং aআইনি অভিব্যক্তি রয়েছে। এখানে fফাংশন aবলা হয় এবং আর্গুমেন্ট বলা হয়।
• একটি ভেরিয়েবলের এমন ফর্ম রয়েছে xযেখানে xআইনী ভেরিয়েবলের নাম।

শব্দার্থবিদ্যা

একটি যুক্তি যুক্তি দিয়ে ফাংশন বডিটিতে প্রতিটি পরামিতি প্রতিস্থাপন করে একটি ফাংশন প্রয়োগ করা হয়। আরো আনুষ্ঠানিকভাবে ফর্ম একটি অভিব্যক্তি ((λ x. e) a), যেখানে xএকটি পরিবর্তনশীল নাম এবং eএবং aএক্সপ্রেশন, মূল্যায়ণ (অথবা হ্রাস করা) অভিব্যক্তি হয় e'যেখানে e'প্রতিটি সংঘটন প্রতিস্থাপন ফল xমধ্যে eদিয়ে a।

একটি সাধারণ ফর্ম একটি অভিব্যক্তি যা আরও মূল্যায়ন করা যায় না।

চ্যালেঞ্জ

আপনার মিশনটি, আপনি যদি এটি গ্রহণ করতে চান, তবে এমন একটি দোভাষী লিখতে হবে যা তার ইনপুট হিসাবে কোনও টাইপযুক্ত ল্যাম্বডা ক্যালকুলাসের কোনও মুক্ত ভেরিয়েবল থাকে না এবং তার আউটপুট হিসাবে প্রকাশের স্বাভাবিক রূপ (বা তার সাথে আলফা-সম্মিলিত) উত্পাদন করে takes । যদি অভিব্যক্তির কোনও সাধারণ ফর্ম না থাকে বা এটি কোনও বৈধ এক্সপ্রেশন না হয় তবে আচরণটি সংজ্ঞায়িত।

ক্ষুদ্রতম সংখ্যক অক্ষরের সাথে সমাধানটি জিততে পারে।

কয়েকটি নোট:

• ইনপুট হয় স্টিডিন বা কমান্ড লাইন আর্গুমেন্ট হিসাবে দেওয়া ফাইলের নাম থেকে পড়তে পারে (আপনাকে কেবল একটি বা অন্যটি প্রয়োগ করতে হবে - উভয়ই নয়)। আউটপুট stdout যায়।
• বিকল্পভাবে আপনি কোনও ফাংশন সংজ্ঞায়িত করতে পারেন যা ইনপুটটিকে স্ট্রিং হিসাবে গ্রহণ করে এবং আউটপুটটিকে স্ট্রিং হিসাবে ফিরিয়ে দেয়।
• যদি নন-এসসিআইআই অক্ষরগুলি আপনার পক্ষে সমস্যাযুক্ত হয় তবে আপনি \λ এর পরিবর্তে ব্যাকস্ল্যাশ ( ) অক্ষরটি ব্যবহার করতে পারেন λ
• আমরা বাইটগুলি নয়, অক্ষরের সংখ্যা গণনা করি, সুতরাং আপনার উত্স ফাইলটি ইউনিকোড হিসাবে এনকোড করা থাকলেও one একটি অক্ষর হিসাবে গণনা করা হয়।
• আইনী ভেরিয়েবলের নামগুলিতে এক বা একাধিক লোয়ার কেস বর্ণ থাকে, অর্থাত্ a এবং z এর মধ্যে অক্ষর (অক্ষরগুলির নাম, বড় হাতের অক্ষর বা ল্যাটিন-অক্ষরকে সমর্থন করার প্রয়োজন নেই - যদিও এটি করা আপনার সমাধানটিকে অকার্যকর করবে না)।
• যতদূর এই চ্যালেঞ্জ সম্পর্কিত, কোনও বন্ধনী alচ্ছিক নয়। প্রতিটি ল্যাম্বদা এক্সপ্রেশন এবং প্রতিটি ফাংশন অ্যাপ্লিকেশন হ'ল এক জোড়া বন্ধনী দ্বারা ঘিরে থাকবে। কোনও পরিবর্তনশীল নাম বন্ধনী দ্বারা বেষ্টিত হবে না।
• সিন্ট্যাকটিক চিনির মতো লেখার (λ x y. e)জন্য (λ x. (λ y. e))সমর্থন করার প্রয়োজন নেই।
• যদি কোনও ফাংশনটি মূল্যায়নের জন্য যদি 100 এর বেশি সংখ্যার পুনরাবৃত্তির গভীরতা প্রয়োজন হয়, তবে আচরণটি অনির্ধারিত। এটি সমস্ত ভাষায় অপ্টিমাইজেশন ছাড়াই কার্যকর করার জন্য পর্যাপ্ত পরিমাণের চেয়ে কম হওয়া উচিত এবং এখনও বেশিরভাগ এক্সপ্রেশন কার্যকর করতে সক্ষম হতে হবে large
• আপনি এটি ধরেও নিতে পারেন যে উদাহরণগুলির মধ্যে ব্যবধানটি হবে যেমন, ইনপুটটির শুরু এবং শেষে λবা .কোনও .এবং একটি ফাংশন এবং তার তর্ক এবং এর পরে এবং ঠিক পরে একটি জায়গার আগে কোনও স্থান নেই λ।

নমুনা ইনপুট এবং আউটপুট

• ইনপুট: ((λ x. x) (λ y. (λ z. z)))

  আউটপুট: (λ y. (λ z. z))

• ইনপুট: (λ x. ((λ y. y) x))

  আউটপুট: (λ x. x)

• ইনপুট: ((λ x. (λ y. x)) (λ a. a))

  আউটপুট: (λ y. (λ a. a))

• ইনপুট: (((λ x. (λ y. x)) (λ a. a)) (λ b. b))

  আউটপুট: (λ a. a)

• ইনপুট: ((λ x. (λ y. y)) (λ a. a))

  আউটপুট: (λ y. y)

• ইনপুট: (((λ x. (λ y. y)) (λ a. a)) (λ b. b))

  আউটপুট: (λ b. b)

• ইনপুট: ((λx. (x x)) (λx. (x x)))

  আউটপুট: যে কোনও কিছুই (এটি কোনও অভিব্যক্তির উদাহরণ যা কোনও সাধারণ রূপ নয়)

• ইনপুট: (((λ x. (λ y. x)) (λ a. a)) ((λx. (x x)) (λx. (x x))))

  আউটপুট: (λ a. a)(এটি একটি অভিব্যক্তির একটি উদাহরণ যা আপনি ফাংশন কলের আগে যুক্তিগুলি মূল্যায়ন করলে স্বাভাবিক হয় না এবং দুঃখের সাথে এমন একটি উদাহরণ যার জন্য আমার চেষ্টা করা সমাধান ব্যর্থ হয়েছে)

• ইনপুট: ((λ a. (λ b. (a (a (a b))))) (λ c. (λ d. (c (c d)))))

  আউটপুট: `(λ a. (λ b. (a (a (a (a (a (a (a (a b)))))))))) চার্চ সংখ্যায় এটি 2 ^ 3 গণনা করে।

Comments

আমরা কি ধরে নিতে পারি যে স্ট্রিংটিতে প্রসেসেন্ট বা সংযুক্ত সাদা অংশ থাকবে না এবং সেই সাদা স্থানটি অন্যথায় নমুনা ইনপুটটিতে উল্লিখিত হিসাবে রয়েছে? অর্থাৎ, বন্ধনীগুলির মধ্যে কোনও ডট এবং প্যারামিটারের নাম এবং হোয়াইটস্পেসের অন্যান্য দৃষ্টান্তগুলির মধ্যে কোনও স্পেসস্পেস হুবহু 1 স্থান নয়।

— JPvdMerwe

@ জেপিভিডিমারভে: হ্যাঁ, ভাল কথা, আপনি এটি ধরে নিতে পারেন।

— sepp2k

কোন বিনামূল্যে ভেরিয়েবল আছে? আমি অভিব্যক্তির মতো ল্যাম্বডা দ্বারা আনবাউন্ডে ভেরিয়েবলগুলি বোঝাতে চাইছি (\y. a)।

— FUZxxl

এখানকার অনেকগুলি বা সমস্ত সমাধান ক্যাপচার-এড়ানো বিকল্পটির প্রয়োগ করতে ব্যর্থ হয়! আপনার ((λ f। (Λ x। (Fx)))) (λ y। (Λ x। Y))) এর মতো একটি পরীক্ষার কেস যুক্ত করা উচিত, যা মূল্যায়ন করা উচিত (λ x। (Λ z। X)), নয় (λ x। (λ x। x))।

— অ্যান্ডারস কাসের্গ

@ sepp2k আপনি কি পরীক্ষার কেস হিসাবে ((λ f। (x x। (fx))) (λ y। (λ x। y)) যোগ করা এবং বর্তমান উত্তরটিকে ভুল হিসাবে উত্পন্ন করে (λ x। (λ x। x))?

— অ্যান্ডারস কাসের্গ

Answer 1

নতুন:

আমি এটিকে নিচে চিপা থাকেন 644 অক্ষর , আমি কপি এবং পার মধ্যে সেল অংশগুলি উপাদান; সেলগুলিতে ক্যাশে কল এবং সিডিআর অস্থায়ী স্থানীয় ভেরিয়েবলগুলিতে এবং সেই স্থানীয় ভেরিয়েবলগুলিকে "টার্মিনাল" (অর্থাত্ পুনঃবিবর্তনযোগ্য) ফাংশনে গ্লোবলে স্থানান্তরিত করে। এছাড়াও, দশমিক ধ্রুবকগুলি চরিত্রের অক্ষরের চেয়ে খাটো এবং এই দুষ্টু ব্যবসায় ...

atom(x){
    return m[x]>>5==3;
}

... সঠিকভাবে ছোট হাতের অক্ষর সনাক্ত করে (ASCII অনুমান করে), তবে কোনও accep {|} ~ গ্রহণ করে ~ (ASCII সম্পর্কে একই পর্যবেক্ষণটি ইউটিএফ -8 সম্পর্কে এই দুর্দান্ত ভিডিওতে তৈরি করা হয়েছে ))

এট ভায়োলা: |

#include<stdio.h>
#include<string.h>
#define X m[x]
#define R return
char*n,*m;int u,w,d;C(x,y){w=n-m;n+=sprintf(n,y?"(%s %s)":"(%s)",&X,m+y)+1;R w;}T(x){R X>>5==3;}
L(x){R X==92;}O(x,j){w=n-m;memcpy(n,&X,j);n+=j;*n++=0;R w;}E(x){X==' '?++x:0;R
X==41?0:L(x)?O(x,4):P(x);}P(x){d=0,w=x;do{X==40?d++:X==41?d--:0;++x;}while(d>0);R
O(w,x-w);}D(x){u=E(x+1);R u?E(x+1+strlen(m+u)):0;}V(x){int a=E(x+1),b=D(x);R
T(x)|T(a)?x:L(a)?C(a,V(b)):L(E(a+1))?V(S(V(b),E(a+3),D(a))):V(C(V(a),b?V(b):0));}S(w,y,x){R
T(x)?(X==m[y]?w:x):C(L(w+1)?E(x+1):S(w,y,E(x+1)),D(x)?S(w,y,D(x)):0);}
Y(char*s){n+=strlen(s=strcpy(n,s))+1;printf("%s\n%s\n\n",s,m+V(s-m));n=m+1;}

char*s[]={
"((\\ a. a) (b))",
"((\\ x. x) (\\ y. (\\ z. z)))",
"(\\ x. ((\\ y. y) x))",
"(((\\ x. (\\ y. x)) (\\ a. a)) (\\ b. b))",
"((\\ x. (\\ y. y)) (\\ a. a))",
"(((\\ x. (\\ y. y)) (\\ a. a)) (\\ b. b))",
"((\\x. (x x)) (\\x. (x x)))",0};
#include<unistd.h>
main(){char**k;n=m=sbrk(4096);*n++=0;for(k=s;*k;k++)Y(*k);R 0;}

এর আগে:

আমি কি প্রচেষ্টার জন্য কিছু ভোট পেতে পারি? আমি এই সপ্তাহে দিনরাত কাজ করছি। আমি পল গ্রাহামের দ্য রুটস অফ লিস্পের পরিশিষ্ট পড়ার আগ পর্যন্ত আমি আসল ম্যাকার্থি কাগজটি বের করেছিলাম এবং কাগজে নিজেই একটি বাগ দ্বারা জর্জরিত ছিলাম । আমি এতটাই বিভ্রান্ত হয়ে পড়েছিলাম যে আমি নিজেকে আমার বাড়ির বাইরে তালাবদ্ধ করে রেখেছিলাম, তারপরে রাত্রে 12:30 টায় পুনরায় বাসায় না পৌঁছানো পর্যন্ত সম্পূর্ণরূপে ভুলে গিয়েছিলাম (কাউন্টি থেকে বেরিয়ে আসা বিল্ডিং ম্যানেজারকে ফোন করতে কিছুটা দেরি), এবং ব্যয় করতে হয়েছিল আমার দাদির রাতে (আমার ল্যাপটপের ব্যাটারি শুকানো পর্যন্ত হ্যাকিং দূরে)।

এবং এত কিছুর পরেও এটি বিজয়ী এন্ট্রির কাছাকাছিও নয়!

কীভাবে এটি আরও খাটো করা যায় আমি নিশ্চিত নই; এবং আমি ভাবতে পারি এমন সমস্ত নোংরা কৌশল ব্যবহার করেছি! হতে পারে এটি সি তে করা যাবে না

গণনায় কিছু উদারতার সাথে (প্রথম অংশটি একটি স্ট্রিং নেয় এবং ফলাফলটি মুদ্রণ করে), এটি 778 770 709 694 অক্ষর। তবে এটিকে একা একা করতে, সেই sbrkকলটি করতে হবে। এবং আরও জটিল এক্সপ্রেশন signalপরিচালনা করতে, এটিরও হ্যান্ডলার দরকার needs এবং অবশ্যই এটি ব্যবহারের চেষ্টা করে এমন কোনও কোড সহ মডিউল তৈরি করা যায় না malloc।

হায় আফসোস, এটি এখানে:

#include<stdio.h>
#include<string.h>
#define K(j) strncpy(n,m+x,j);n+=j;goto N;
#define R return
#define X m[x]
#define L =='\\'
char*m,*n;T(x){R islower(X);}V(x){int a=E(x+1);R
T(x)?x:T(a)?x:m[a]L?C(a,V(D(x))):m[E(a+1)]L?V(S(V(D(x)),E(a+3),D(a))):V(C(V(a),D(x)?V(D(x)):0));}
C(x,y){char*t=n;sprintf(n,y?"(%s %s)":"(%s)",m+x,m+y);n+=strlen(n)+1;R
t-m;}Y(char*s){char*t=strcpy(n,s);n+=strlen(n)+1;printf("%s=>%s\n",s,m+V(t-m));n=m+1;}S(x,y,z){R
T(z)?(m[z]==m[y]?x:z):C(m[z+1]L?E(z+1):S(x,y,E(z+1)),D(z)?S(x,y,D(z)):0);}D(x){R
E(x+1)?E(x+strlen(m+E(x+1))+1):0;}E(x){char*t=n,d=0;if(X==' ')++x;if(T(x)){K(1)}if(X
L){K(4)}do{d=X?(X=='('?d+1:(X==')'?d-1:d)):0;*n++=m[x++];}while(d);N:*n++=0;R t-m;}

char*samp[]={
    "a","a","b","b",
    "((\\ a. a) (b))", "(b)",
    "((\\ x. x) (\\ y. (\\ z. z)))", "(\\ y. (\\ z. z))",
    "(\\ x. ((\\ y. y) x))", "(\\ x. x)",
    "(((\\ x. (\\ y. x)) (\\ a. a)) (\\ b. b))", "(\\ a. a)",
    "((\\ x. (\\ y. y)) (\\ a. a))", "(\\ y. y)",
    "(((\\ x. (\\ y. y)) (\\ a. a)) (\\ b. b))", "(\\ b. b)",
    "((\\x. (x x)) (\\x. (x x)))", "undef",
    NULL};
#include<unistd.h>

unsigned sz;
#include<signal.h>
void fix(x){signal(SIGSEGV,fix);brk(m+(sz*=2));}
main(){
    char**t;
    signal(SIGSEGV,fix);
    m=n=sbrk(sz=10*getpagesize());
    *n++=0;
    for(t=samp;*t;t+=2){
        Y(*t);
        printf("s.b. => %s\n\n", t[1]);
    }
    return 0;
}

চূড়ান্ত হ্রাসের ঠিক আগে এখানে ব্লক। এখানে কৌশলগুলি হ'ল পয়েন্টারগুলির পরিবর্তে পূর্ণসংখ্যার কার্সার ('অন্তর্নিহিত অন্তর্নিহিত' আচরণের সুবিধা গ্রহণ করা) এবং 'স্ক্র্যাচ মেমরি' ব্যবহার: char*nমুক্ত স্থানটিতে 'নতুন' বা 'পরবর্তী' পয়েন্টার। তবে কখনও কখনও আমি স্মৃতিতে একটি স্ট্রিং লিখি, তারপরে স্ট্রেন এবং ইনক্রিমেন্ট এন কল করি; মাপটি গণনা করা সহজ করার পরে কার্যকরভাবে মেমরি ব্যবহার করে এবং তার পরে বরাদ্দ। cell()ফাংশন এবং ডেটার স্ট্রিং প্রতিনিধিত্ব মধ্যে কোন ইন্টারফেস ব্যতীত আপনি ম্যাকার্থি কাগজ থেকে এটি বেশ সোজা দেখতে পারেন ।

#include<stdio.h>
#include<string.h>
char*m,*n;  //memory_base, memory_next
atom(x){  // x is an atom if it is a cursor to a lowercase alpha char.
    return x?(islower(m[x])?m[x]:0):0;
}
eq(x,y){  // x and y are equal if they are both atoms, the same atom.
    return x&&y&&atom(x)==atom(y);
}
cell(x){  // return a copy of the list-string by cursor, by parsing
    char*t=n,d=0;
    if(!x||!m[x])
        return 0;
    if(m[x]==' ')
        ++x;
    if(atom(x)){
        *n++=m[x];
        *n++=0;
        return(n-m)-2;
    }
    if(m[x]=='\\'){  // our lambda symbol
        memcpy(n,m+x,4);
        n+=4;
        *n++=0;
        return(n-m)-5;
    }
    do{  // um ...
        d=m[x]?(m[x]=='('?d+1:(m[x]==')'?d-1:d)):0;
        *n++=m[x++];
    }while(d);
    *n++=0;
    return t-m;
}
car(x){  // return (copy of) first element
    return x?cell(x+1):0;
}
cdr(x){  // return (copy of) rest of list
    return car(x)?cell(x+strlen(m+car(x))+1):0;
}
cons(x,y){  // return new list containing first x and rest y
    char*t=n;
    return x?(sprintf(n,y?"(%s %s)":"(%s)",m+x,m+y),n+=strlen(n)+1,t-m):0;
}
subst(x,y,z){  // substitute x for z in y
    if(!x||!y||!z)
        return 0;
    return atom(z)? (eq(z,y)?x:z):
        cons(m[z+1]=='\\'?car(z):
        subst(x,y,car(z)),cdr(z)?subst(x,y,cdr(z)):0);
}
eval(x){  // evaluate a lambda expression
    int a;
    return atom(x)?x:
        atom(a=car(x))?x:
        m[a]=='\\'?cons(a,eval(cdr(x))):
        m[car(a)]=='\\'?eval(subst(eval(cdr(x)),cell(a+3),cdr(a))):
        eval( cons(eval(a),cdr(x)?eval(cdr(x)):0));
}
try(char*s){  // handler
    char*t=strcpy(n,s);
    n+=strlen(n)+1;
    printf("input: %s\n", s);
    printf("eval => %s\n", m+eval(t-m));
    n=m+1;
}

Comments

আমি দু'একটি চরিত্র সংরক্ষণ করতে আরও কয়েকটি কৌশল পেয়েছি, তবে র‌্যাডিক্যাল কিছুই নয়। আমাকে 'পোস্টফিক্স' ম্যাক্রো দিয়ে সমস্ত ইন্ডিয়ারেশনগুলি প্রতিস্থাপন করার পরিবর্তে অ্যারের সিনট্যাক্সটি উল্টানো sprintf(n,...);n+=strlen(n)+1;হিসাবে আরও ভাল ... যা 1 টি সংরক্ষণ করে এবং "ফ্রি" লাইন ব্রেক দেয় যেহেতু টোকেনগুলি পৃথক করার জন্য হোয়াইটস্পেস প্রয়োজনীয়। n+=sprintf(n,...)+1;x[m]m[x]#define M [m]x M

— luser droog

আইওসিসি 1989 থেকে এই এবং জার 2 এক্সলিস্ট 4.0 এর সাথে কিছু মিল রয়েছে বলে মনে হচ্ছে ।

— লুসার droog

আমি এটিকে একটি পূর্ণাঙ্গ লিস্প ইন্টারপ্রেটারে প্রসারিত করার চেষ্টা করেছি ।

— লুসার droog

মন্তব্য // um ...করা কোডটি সঠিক নেস্টিং স্তরে ম্যাচিং বন্ধ-প্যারেন না পাওয়া পর্যন্ত স্ট্রিংয়ের মধ্য দিয়ে লুপিং করছে এবং বন্ধনীগুলি গণনা করছে।

— luser droog

এটি ভুলভাবে মূল্যায়ন করে ((\ f। (\ X। (Fx))) (। Y। () X। Y))) থেকে (\ x। (Fx))।

— অ্যান্ডারস কাসের্গ

Answer 2

বাইনারি ল্যাম্বদা ক্যালকুলাস 186

প্রোগ্রামটি নীচে হেক্স ডাম্পে দেখানো হয়েছে

00000000  18 18 18 18 18 18 44 45  1a 10 18 18 45 7f fb cf  |......DE....E...|
00000010  f0 b9 fe 00 78 7f 0b 6f  cf f8 7f c0 0b 9f de 7e  |....x..o.......~|
00000020  f2 cf e1 b0 bf e1 ff 0e  6f 79 ff d3 40 f3 a4 46  |........oy..@..F|
00000030  87 34 0a a8 d0 80 2b 0b  ff 78 16 ff fe 16 fc 2d  |.4....+..x.....-|
00000040  ff ff fc ab ff 06 55 1a  00 58 57 ef 81 15 bf bf  |......U..XW.....|
00000050  0b 6f 02 fd 60 7e 16 f7  3d 11 7f 3f 00 df fb c0  |.o..`~..=..?....|
00000060  bf f9 7e f8 85 5f e0 60  df 70 b7 ff ff e5 5f f0  |..~.._.`.p...._.|
00000070  30 30 6f dd 80 5b b3 41  be 85 bf ff ca a3 42 0a  |00o..[.A......B.|
00000080  c2 bc c0 37 83 00 c0 3c  2b ff 9f f5 10 22 bc 03  |...7...<+...."..|
00000090  3d f0 71 95 f6 57 d0 60  18 05 df ef c0 30 0b bf  |=.q..W.`.....0..|
000000a0  7f 01 9a c1 70 2e 80 5b  ff e7 c2 df fe e1 15 55  |....p..[.......U|
000000b0  75 55 41 82 0a 20 28 29  5c 61                    |uUA.. ()\a|
000000ba

আপনার প্রস্তাবিত বিন্যাসটি বেশ গ্রহণ করে না। পরিবর্তে, এটি বাইনারি ল্যাম্বদা ক্যালকুলাস (blc) ফর্ম্যাটে একটি ল্যাম্বডা শব্দটি প্রত্যাশা করে। তবে এটি সর্বনিম্ন বন্ধনী ব্যবহার করে সাধারণ ফর্ম হ্রাসের প্রতিটি পদক্ষেপ দেখায়।

উদাহরণ: চার্চ সংখ্যায় 2 ^ 3 গণনা করা

উপরের হেক্স ডাম্পটি xxd -r> প্রতীকী.বিএলসি দিয়ে সংরক্ষণ করুন

থেকে একটি BLC অনুবাদক দখল http://tromp.github.io/cl/uni.c

cc -O2 -DM=0x100000 -m32 -std=c99 uni.c -o uni
echo -n "010000011100111001110100000011100111010" > threetwo.blc
cat symbolic.Blc threetwo.blc | ./uni
(\a \b a (a (a b))) (\a \b a (a b))
\a (\b \c b (b c)) ((\b \c b (b c)) ((\b \c b (b c)) a))
\a \b (\c \d c (c d)) ((\c \d c (c d)) a) ((\c \d c (c d)) ((\c \d c (c d)) a) b)
\a \b (\c (\d \e d (d e)) a ((\d \e d (d e)) a c)) ((\c \d c (c d)) ((\c \d c (c d)) a) b)
\a \b (\c \d c (c d)) a ((\c \d c (c d)) a ((\c \d c (c d)) ((\c \d c (c d)) a) b))
\a \b (\c a (a c)) ((\c \d c (c d)) a ((\c \d c (c d)) ((\c \d c (c d)) a) b))
\a \b a (a ((\c \d c (c d)) a ((\c \d c (c d)) ((\c \d c (c d)) a) b)))
\a \b a (a ((\c a (a c)) ((\c \d c (c d)) ((\c \d c (c d)) a) b)))
\a \b a (a (a (a ((\c \d c (c d)) ((\c \d c (c d)) a) b))))
\a \b a (a (a (a ((\c (\d \e d (d e)) a ((\d \e d (d e)) a c)) b))))
\a \b a (a (a (a ((\c \d c (c d)) a ((\c \d c (c d)) a b)))))
\a \b a (a (a (a ((\c a (a c)) ((\c \d c (c d)) a b)))))
\a \b a (a (a (a (a (a ((\c \d c (c d)) a b))))))
\a \b a (a (a (a (a (a ((\c a (a c)) b))))))
\a \b a (a (a (a (a (a (a (a b)))))))

যেহেতু হেক্সডাম্প বরং অপঠনযোগ্য, তাই এখানে একটি "বিযুক্ত" সংস্করণ

@10\\@10\\@10\\@10\\@10\\@10\@\@\@\@@\@1010\@\\\@10\\@10\@\@@@1111111111101
1110@11111110\@@110@11111110\\\\@1110\@1111110\@@101101111110@111111110\@111
111110\\\\@@110@111111011110@11111011110@@10@1111110\@10110\@@111111110\@111
111110\@110@101111011110@1111111111010@1010\\@1110@11010@\@\@1010\@110@1010\
\@@@@@\@1010\@\\\\@@@10\@@111111111011110\\@@101111111111111110\@@101111110\
@@10111111111111111111111110@@@@1111111110\\110@@@@\@1010\\\\@@10\@@@1111101
11110\\@\@@@10111111101111110\@@1011011110\\@@11111010110\\@111110\@@1011110
1110@111010\10\1011111110@111110\\\@101111111111011110\\@@11111111110@@11111
0111110\10\@@@@11111110\\@10\\1101111101110\@@1011111111111111111111110@@@@1
11111110\\@10\\@10\\11011111101110110\\\@@101110110@1010\\11011111010\@@1011
111111111111110@@@@\@1010\@\\@@@10\@@@1110@10\\\@1011110\\110\\\@10\\\@1110\
@@@11111111110@1111111101010\10\\@\@@@1110\\\@10@1110111110\\1110\110@@@1111
0110@@@1111010\\110\\\@10\\\@@1101111111101111110\\\@10\\\@@1101111110111111
10\\\110@1010110\\101110\\@@11010\\\@@1011111111111110@11110\@@1011111111111
101110\@\@@@@@@@@11010101010101010\\110\\10\\1010\10\\\1010\\1010@@@110\110\
@

00 (ল্যাম্বদা) এর পরিবর্তে with এবং 01 (অ্যাপ্লিকেশন) দিয়ে @ দিয়ে এখন এটি ব্রেইনফাকের মতো প্রায় পঠনযোগ্য :-)

আরো দেখুন http://www.ioccc.org/2012/tromp/hint.html

Comments

বিএলসি কেবল একটি বাইনারি বর্ণমালা ব্যবহার করতে ঘটে। 00 হ'ল ল্যাম্বদা, 01 টি অ্যাপ্লিকেশন এবং 1 ^ un n} 0 অ্যানারিতে পরিবর্তনশীল। এর সাথে কোনও সংকলন জড়িত নেই।

— জন ট্রম্প

আপনি কোথা থেকে এক্স 3 পাবেন? আপনি যে ভাষাগুলিতে বিএফ এর মতো ছোট উত্স বর্ণমালা দিয়ে দন্ডিত হচ্ছেন সেগুলিতে প্রকৃতপক্ষে একটি ভাল বক্তব্য উত্থাপন করুন। ন্যায্য তুলনার জন্য, সমস্ত মাপ বিট মধ্যে প্রকাশ করা উচিত, এবং BF অক্ষর প্রতিটি 3 টি বিট নিতে। সর্বাধিক অন্যান্য ভাষা, হওয়া ASCII 7 বিট প্রয়োজন কিছু সব 8. ব্যবহার

— জন Tromp

বিটিডাব্লু +1 এটি দুর্দান্ত!

— লুসার droog

যদি ফ্র্যাক্ট্রানটিতে ফ্র্যাক্ট্রান গ্রহণযোগ্য হয় তবে আমি কেন দেখতে পাচ্ছি না কেন এটি মোটেও সমস্যা হওয়া উচিত। আপনি এটা পড়তে পারবেন না? আপনি চান? জানুন!

— luser droog

এটিকে আসল ইনপুট ফর্ম্যাটটি পড়তে কী লাগবে? আমি মনে করি আপনি সেখানে সম্ভাব্য উন্নতি হারাচ্ছেন।

— লুসার droog

Answer 3

হাস্কেল, 342 323 317 305 টি অক্ষর

এই লেখার হিসাবে এটিই একমাত্র সমাধান যা ((λ f। (Λ x। (Fx)))) (λ y। (Λ x। Y))) এর সঠিক ফলাফলের (λ x। (Λ z) মূল্যায়ন করে। x)) এর পরিবর্তে (λ x। (λ x। x))। ল্যাম্বডা ক্যালকুলাসের সঠিক প্রয়োগের জন্য ক্যাপচার-এড়ানো বিকল্পের প্রয়োজন , এমনকি এই সমস্যার সরলকরণ গ্যারান্টির আওতায় যে কোনও ভেরিয়েবল তার সুযোগে অন্য পরিবর্তনশীলকে ছায়া দেয়। (আমার প্রোগ্রামটি এই গ্যারান্টি ছাড়াই কাজ করে happens

data T=T{a::T->T,(%)::ShowS}
i d=T(i. \x v->'(':d v++' ':x%v++")")d
l f=f`T`\v->"(λ "++v++". "++f(i(\_->v))%('x':v)++")"
(?)=q.lex
q[(v,s)]k|v/="("=k(maybe T{}id.lookup v)s|'λ':u<-s,[(w,_:t)]<-lex u=t? \b->k(\e->l$b.(:e).(,)w).tail|0<1=s? \f->(?(.tail).k. \x z->f z`a`x z)
main=interact(? \f->(f[]%"x"++))

নোট:

• এটি জিএইচসি .0.০-তে প্রয়োজন অনুসারে চলে, কারণ এই চ্যালেঞ্জটি জানুয়ারী ২০১১ এ সেট করা হয়েছিল। আমাকে জিএইচসি 7..১০ অনুমান করার অনুমতি দেওয়া হলে এটি ১৩ টি অক্ষর সংক্ষিপ্ত হবে।

ডকুমেন্টেশন সহ অবহিত সংস্করণ ।

Comments

আপনার অগ্রগতি ইনডপুট ((\ x। x) (\ y। (। z। z))) "রান সময় ত্রুটি" এমনকি ((\\ x। x) (\\ y। ( \\ z। z))) ... হাস্কেলের "লেক্স" এর অর্থ কী?

— রোজলুপ

@ রোসলুপ আমার প্রোগ্রামটি λ না, accep গ্রহণ করে \

— অ্যান্ডারস কাসের্গ

আইডোন.কম রিটার্নে এই ইমপুট ((λ x। x) (λ y। (λ z। z))) টাইপ করুন: রানটাইম ত্রুটির সময়: 0 মেমরি: 4876 সিগন্যাল: -1

— রোজলুপ

@ রোসলুপ আইডিয়নের মনে হচ্ছে ইউনিকোড সমর্থন নষ্ট হয়ে গেছে। কমান্ড লাইন বা অন্য কোনও অনলাইন অনুবাদক চেষ্টা করুন ( উদাহরণস্বরূপ, এটি রেক্সটেস্টারে কাজ করে )।

— অ্যান্ডার্স কাসের্গ

@ কোডশট প্রশ্ন লেখক ইতিমধ্যে মন্তব্য করেছেন যে ((λ f। (λ x। (fx))) (λ y। (λ x। y))) ↦ (λ x। (λ z। x)) এর জন্য সঠিক এই সমস্যা (ঠিক আসল ল্যাম্বদা ক্যালকুলাসের মতো)

— অ্যান্ডারস ক্যাসরগ

Answer 4

পাইথন - 321 320

এখানে আমার (স্থির) চেষ্টা:

l="("
def S(s):
 if s[0]!=l:return s
 if s[1]=="\\":g=s.find('.');return"(\\ %s. %s)"%(s[3:g],S(s[g+2:-1]))
 i=2;c=s[1]==l
 while c:c+=(s[i]==l)-(s[i]==')');i+=1
 t=S(s[1:i])
 z=s[i+1:-1]
 if l!=t[0]:return"(%s %s)"%(t,S(z))
 g=t.find('.')
 t=S(t[g+2:-1]).replace(t[3:g],z)
 if t!=s:t=S(t)
 return t
print S(raw_input())

Comments

এটি দেখতে দুর্দান্ত লাগছে, তবে কাজ করছে বলে মনে হচ্ছে না। আমি কিছু উদাহরণ ইনপুট এবং আউটপুট যুক্ত করেছি, যার জন্য আপনার কোডটি ভুল ফলাফল তৈরি করে।

— sepp2k 16

এটি ক্যাপচার-এড়ানো বিকল্পটি করতে ব্যর্থ। উদাহরণস্বরূপ, ((\ f। (\ X। (Fx))) (\ y। (\ X। Y))) (\ x। (\ X। X)) এর জন্য ভুলভাবে মূল্যায়ন করে।

— অ্যান্ডারস কাসের্গ

সবেমাত্র কাজ করা হচ্ছে কেন এটি উত্তর হিসাবে চিহ্নিত হয়েছে? আপনি কি লেখক প্রদত্ত ইনপুট এবং আউটপুট ব্যবহার করে দেখেছেন?

— rbaleksandar

লেখকের সরবরাহিত পরীক্ষার কেসগুলি এই উত্তরে বাগগুলি প্রদর্শন করতে অপর্যাপ্ত।

— আন্ডারস কাসের্গ

এই উত্তর না সঠিক বা সংক্ষিপ্ততম। এটি ক্যাপচার এড়াতে ব্যর্থ হয় এবং স্ট্রিং প্রতিস্থাপন বাগ রয়েছে।

— রিচার্ড প্যাডেলি

Answer 5

রুবি 254 টি অক্ষর

f=->u,r{r.chars.take_while{|c|u+=c==?(?1:c==?)?-1:0;u>0}*''}
l=->x{x=~/^(\(*)\(\\ (\w+)\. (.*)/&&(b,v,r=$1,$2,$3;e=f[1,r];(e==s=l[e])?b==''?x:(s=f[2,r];(x==y=b.chop+e.gsub(v,s[2+e.size..-1])+r[1+s.size..-1])?x:l[y]):(b+'(\\ '+v+'. '+s+r[e.size..-1]))||x}

এটি ব্যবহার করা যেতে পারে

puts l["((\\ x. (\\ y. x)) (\\ a. a))"]    # <= (\ y. (\ a. a))

সমাধানটি এখনও পুরোপুরি গল্ফ হয় নি তবে ইতিমধ্যে প্রায় অপঠনযোগ্য।

Comments

হ্যালো হিংসা, আমার পুরানো বন্ধু :)

— লুসার droog

এটি ক্যাপচার-এড়ানো বিকল্পটি করতে ব্যর্থ। উদাহরণস্বরূপ, ((\ f। (\ X। (Fx))) (\ y। (\ X। Y))) (\ x। (\ X। X)) এর জন্য ভুলভাবে মূল্যায়ন করে।

— অ্যান্ডারস কাসের্গ

উপরের ক্যাপচার বাগ ছাড়াও এটি ভুলভাবে মূল্যায়ন করে (\ y। (\ Xx। ((Xx xx) y))) থেকে (\ y। (\ Xx। Yy)), যেখানে অতিমাত্রায় স্ট্রিং প্রতিস্থাপন উত্পাদন করেছে অস্তিত্বের পরিবর্তনশীল yy।

— অ্যান্ডারস কাসের্গ

Answer 6

সম্পাদনা করুন: খাঁটি জাভাস্ক্রিপ্টের আওতায় 250 এর নিচে আমার উত্তরটি পরীক্ষা করুন।

লাইভস্ক্রিপ্ট ব্যবহার করে ২৪৫২ টি 243 টি অক্ষর (কোনও রেজেক্স! পুরো গল্ফড নয় - উন্নত করা যেতে পারে)

L=(.0==\\)
A=->it.forEach?&&it.0!=\\
V=(.toFixed?)
S=(a,b,t=-1,l=0)->|L a=>[\\,S(a.1,b,t,l+1)];|A a=>(map (->S(a[it],b,t,l)),[0 1]);|a==l+-1=>S(b,0,l+-1,0)||a|l-1<a=>a+t;|_=>a
R=(a)->|L a=>[\\,R a.1]|(A a)&&(L a.0)=>R(S(R(a.0),R(a.1)).1)|_=>a

টেস্ট:

a = [\\,[\\,[1 [1 0]]]]
b = [\\,[\\,[1 [1 [1 0]]]]]
console.log R [a, b]
# outputs ["\\",["\\",[1,[1,[1,[1,[1,[1,[1,[1,[1,0]]]]]]]]]]]

যা 3^2=9ওপি-তে বলা হয়েছে।

যদি কেউ আগ্রহী হন তবে এখানে কিছু মন্তব্য সহ একটি বর্ধিত সংস্করণ রয়েছে:

# Just type checking
λ = 100
isλ = (.0==λ)
isA = -> it.forEach? && it.0!=λ
isV = (.toFixed?)

# Performs substitutions in trees
# a: trees to perform substitution in
# b: substitute bound variables by this, if != void
# f: add this value to all unbound variables
# l: internal (depth)
S = (a,b,t=-1,l=0) ->
    switch
    | isλ a             => [λ, (S a.1, b, t, l+1)]
    | isA a             => [(S a.0, b, t, l), (S a.1, b, t, l)]
    | a == l - 1        => (S b, 0, (l - 1), 0) || a
    | l - 1 < a < 100   => a + t
    | _                 => a

# Performs the beta-reduction
R = (a) ->
    switch
    | (isλ a)               => [λ,R a.1]
    | (isA a) && (isλ a.0)  => R(S(R(a.0),R(a.1)).1)
    | _                     => a

# Test
a = [λ,[λ,[1 [1 0]]]]
b = [λ,[λ,[1 [1 [1 0]]]]]
console.log show R [a, b]

Comments

এটি সমস্যা থেকে ইনপুট এবং আউটপুট নির্দিষ্টকরণের সাথে সামঞ্জস্য করে না।

— অ্যান্ডারস কাসের্গ

Answer 7

ওয়াটারহাউস আর্ক - 140 টি অক্ষর

(=
f[is cons?&car._'λ]n[if
atom._ _
f._ `(λ,_.1,n:_.2)(=
c n:_.0
e _)(if
f.c(n:deep-map[if(is
c.1 _)e.1
_]c.2)(map n
_))]λ[n:read:rem #\._])

Comments

আমি কোথায় পানির হাউস আর্ক পেতে পারি?

— অ্যান্ডারস কাসের্গ

দোভাষী হিসাবে অবৈধ কোথাও খুঁজে পাওয়া যায় নি

— বিড়াল

@ আন্ডারস ক্যাসরগ এখানে

— ASCII-

@ এএসসিআইআই-কেবল আমি জানি আর্ক কী, তবে "ওয়াটার হাউস" অংশটি আমাকে পরামর্শ দিয়েছে যে নির্দিষ্ট কিছু উপভাষা প্রয়োজনীয় ছিল। আপনি কি এটি চালানোর জন্য অর্জন করেছেন?

— অ্যান্ডারস কাসরগ

পছন্দ করুন এটি খুঁজে

— এএসসিআইআই-কেবল

Answer 8

সি 1039 বাইট

#define F for
#define R return
#define E if(i>=M||j>=M)R-1;
enum{O='(',C,M=3999};signed char Q[M],D[M],t[M],Z,v,*o=Q,*d=D,*T;int m,n,s,c,w,x,y;K(i,j,k){!Z&&(Z=t[O]=1)+(t[C]=-1);E;if(!o[i]){d[j]=0;R 0;}if((c=t[o[i]]+t[o[i+1]])!=2||o[i+2]!='\\'){d[j++]=o[i++];R K(i,j,i);}F(i+=2,y=w=0;i<M&&o[i]&&c;++i)c+=t[o[i]],!w&&c==1?w=i:0,!y&&o[i]=='.'?y=i+2:0;E;if(c){F(;d[j++]=o[i++];)E;R 0;}F(c=y;c<w;++c)if(o[c]=='\\')F(n=0,m=w+2;m<i;++m){if(o[m]==o[c+2]){F(x=0;o[m+x]&&isalpha(o[m+x])&&o[m+x]==o[c+2+x];++x);if(o[c+2+x]!='.'||isalpha(o[m+x]))continue;if(v>'Z')R-1;F(n=c+2;n<w;++n)if(o[n]==o[m]){F(x=0; o[m+x]&&isalpha(o[m+x])&&o[m+x]==o[n+x];++x);if(o[m+x]=='.'&&!isalpha(o[n+x]))F(;--x>=0;) o[n+x]=v;}++v;}}F(c=y;c<w&&j<M;++c){F(x=0;o[c+x]&&o[c+x]==o[k+4+x]&&isalpha(o[c+x]); ++x);if(o[k+4+x]=='.'&&!isalpha(o[c+x])){F(m=w+2;m<i-1&&j<M;++m)d[j++]=o[m];c+=x-1;}else d[j++]=o[c];}E;Z=2;R K(i,j,i);}char*L(char*a){F(s=n=0;n<M&&(o[n]=a[n]);++n);if(n==M)R 0;v='A';F(;++s<M;){Z=0;n=K(0,0,0);if(Z==2&&n!=-1)T=d,d=o,o=T;else break;}R n==-1||s>=M?0:d;}

ভেরিয়েবলগুলি ছোট হাতের অক্ষর ব্যবহার করে ইনপুট হিসাবে অনুমতি দেয় [a..z থেকে] sys আউটপুটে প্রয়োজনে [A..Z থেকে] বড় হাতের অক্ষর ব্যবহার করে ভেরিয়েবল তৈরি করতে পারে ... ধরে নিন ascii অক্ষর কনফিগারেশন।

#define P printf
main()
{char  *r[]={ "((\\ abc. (\\ b. (abc (abc (abc b))))) (\\ cc. (\\ dd. (cc (cc dd)))))",
              "((\\ fa. (\\ abc. (fa abc))) (\\ yy. (\\ abc. yy)))",
              "((\\ x. x) z)", 
              "((\\ x. x) (\\ y. (\\ z. z)))", 
              "(\\ x. ((\\ y. y) x))", 
              "((\\ x. (\\ y. x)) (\\ a. a))", 
              "(((\\ x. (\\ y. x)) (\\ a. a)) (\\ b. b))",
              "((\\ x. (\\ y. y)) (\\ a. a))",
              "(((\\ x. (\\ y. y)) (\\ a. a)) (\\ b. b))",             
              "((\\ x. (x x)) (\\ x. (x x)))",
              "(((\\ x. (\\ y. x)) (\\ a. a)) ((\\ x. (x x)) (\\ x. (x x))))",
             0}, *p;
 int    w;

 for(w=0; r[w] ;++w)
   {p=L(r[w]);
    P("o=%s d=%s\n", r[w], p==0?"Error ":p);
   }
 R  0;
}

/*1.039*/

Comments

স্পেসিফিকেশনটির জন্য \ বা λ প্রয়োজন, / নয়। এটির জন্য বহু-বর্ণের পরিবর্তনশীল নামের সমর্থন প্রয়োজন।

— অ্যান্ডারস কাসরগ

'' n 'ইত্যাদি প্রতীক' \ 'এর আরও ব্যবহার রয়েছে এটির পরিবর্তে' / 'ব্যবহার করা ভাল

— RosLuP

তবুও, চ্যালেঞ্জটি হল স্পেসিফিকেশনটি সন্তুষ্ট করা, এটি আরও ভাল করা নয়।

— অ্যান্ডার্স কাসের্গ

আমি আরও কিছুটা মেনে

— চলার

932 বাইট

— সিলিংক্যাট

Answer 9

হাস্কেল 456 সি

যদি হাস্কেলের অলস মূল্যায়ন বৈশিষ্ট্যটি পুরোপুরি ব্যবহার করা হয় তবে এটি আরও সংক্ষিপ্ত হতে পারে। দুঃখের বিষয়, আমি কীভাবে এটি করতে জানি না।

এছাড়াও, বহু চরিত্র বিশিষ্ট পদক্ষেপে নষ্ট হয়।

data T=A[Char]|B[Char]T|C T T
(!)=(++)
s(A a)=a
s(B a b)="(λ "!a!". "!s b!")"
s(C a b)='(':s a!" "!s b!")"
e d(A a)=maybe(A a)id(lookup a d)
e d(B a b)=B a.e d$b
e d(C a b)=f d(e d a)(e d b)
f d(B x s)q=e((x,q):d)s
f d p q=C p q
d=tail
p('(':'λ':s)=let(A c,t)=p(d s);(b,u)=p(d.d$t);in(B c b,d u)
p('(':s)=let(a,t)=p s;(b,u)=p(d t)in(C a b,d u)
p(c:s)|elem c" .)"=(A "",c:s)|1<2=let((A w),t)=p s in(A(c:w),t)
r=s.e[].fst.p
main=do l<-getLine;putStrLn$r l

উদার সংস্করণ

data Expression = Literal String 
                | Lambda String Expression
                | Apply Expression Expression
                deriving Show

type Context = [(String, Expression)]

show' :: Expression -> String
show' (Literal a) = a
show' (Lambda x e) = "(λ " ++ x ++ ". " ++ show' e ++ ")"
show' (Apply e1 e2) = "(" ++ show' e1 ++ " " ++ show' e2 ++ ")"

eval :: Context -> Expression -> Expression
eval context e@(Literal a) = maybe e id (lookup a context)
eval context (Lambda x e) = Lambda x (eval context e)
eval context (Apply e1 e2) = apply context (eval context e1) (eval context e2)

apply :: Context -> Expression -> Expression -> Expression
apply context (Lambda x e) e2 = eval ((x, e2):context) e
apply context e1 e2 = Apply e1 e2

parse :: String -> (Expression, String)
parse ('(':'λ':s) = let
    (Literal a, s') = parse (tail s)
    (e, s'') = parse (drop 2 s')
    in (Lambda a e, tail s'')

parse ('(':s) = let
    (e1, s') = parse s
    (e2, s'') = parse (tail s')
    in (Apply e1 e2, tail s'')

parse (c:s) | elem c " .)" = (Literal "", c:s)
            | otherwise    = let ((Literal a), s') = parse s 
                             in (Literal (c:a), s')

run :: String -> String
run = show' . eval [] . fst . parse
main = do
  line <- getLine
  putStrLn$ run line

Comments

এটি ক্যাপচার-এড়ানো বিকল্পটি করতে ব্যর্থ। উদাহরণস্বরূপ, ((λ f। (Λ x। (Fx))) (λ y। (Λ x। Y))) (λ x। (Λ x। X)) এর জন্য ভুলভাবে মূল্যায়ন করে।

— অ্যান্ডারস কাসের্গ

Answer 10

231 পেয়েছে জাভাস্ক্রিপ্ট / কোন রেইজেক্স সহ

(function f(a){return a[0]?(a=a.map(f),1===a[0][0]?f(function d(b,a,e,c){return b[0]?1===b[0]?[1,d(b[1],a,e,c+1)]:2===b[0]?b[1]===c-1?d(a,0,c-1,0)||b:c-1<b[1]?[2,b[1]+e]:b:[d(b[0],a,e,c),d(b[1],a,e,c)]:b}(a[0],a[1],-1,0)[1]):a):a})

2-উপাদান অ্যারে গ্রহণ করে। 1এর জন্য দাঁড়ায় λএবং 2 এর অর্থ ব্রুজন সূচক ভেরিয়েবল।

টেস্ট:

zero = [1,[1,[2,0]]]; // λλ0
succ = [1,[1,[1,[[2,1],[[[2,2],[2,1]],[2,0]]]]]]; // λλλ(1 ((2 1) 0))
console.log(JSON.stringify(reduce([succ,[succ,[succ,zero]]]))); // 0+1+1+1
// Output: [1,[1,[[2,1],[[2,1],[[2,1],[2,0]]]]]] = λλ(1(1(1 0))) = number 3

Comments

এটি সমস্যা থেকে ইনপুট এবং আউটপুট নির্দিষ্টকরণের সাথে সামঞ্জস্য করে না।

— অ্যান্ডারস কাসের্গ

Answer 11

পাইথন: 1266 টি অক্ষর (ডাব্লুসি ব্যবহার করে মাপা)

from collections import *;import re
A,B,y,c=namedtuple('A',['l','r']),namedtuple('B',['i','b']),type,list.pop
def ab(t):c(t,0);p=c(t,0);c(t,0);return B(p,tm(t))
def tm(t):return ab(t)if t[0]=='\\'else ap(t)
def at(t):
    if t[0]=='(':c(t,0);r=tm(t);c(t,0);return r
    if 96<ord(t[0][0])<123:return c(t,0)
    if t[0]=='\\':return ab(t)
def ap(t):
    l = at(t)
    while 1:
        r = at(t)
        if not r:return l
        l = A(l,r)
def P(s):return tm(re.findall(r'(\(|\)|\\|[a-z]\w*|\.)',s)+['='])
def V(e):o=y(e);return V(e.b)-{e.i} if o==B else V(e.l)|V(e.r)if o==A else{e}
def R(e,f,t):return B(e.i,R(e.b,f,t)) if y(e)==B else A(R(e.l,f,t),R(e.r,f,t))if y(e)==A else t if e==f else e
def N(i,e):return N(chr(97+(ord(i[0])-96)%26),e) if i in V(e)else i
def S(i,e,a): return A(S(i,e.l,a),S(i,e.r,a)) if y(e)==A else(e if e.i==i else B(N(e.i,a),S(i,R(e.b,e.i,N(e.i,a)),a)))if y(e)==B else a if e==i else e
def T(e):
    if y(e)==A:l,r=e;return S(l.i,l.b,r)if y(l)==B else A(T(l),r)if y(l)==A else A(l,T(r))
    if y(e)==B:return B(e.i,T(e.b))
    q
def F(e):o=y(e);return r'(\%s. %s)'%(e.i,F(e.b))if o==B else'(%s %s)'%(F(e.l),F(e.r)) if o==A else e
def E(a):
    try: return E(T(a))
    except NameError:print(F(a))
E(P(input()))

দীর্ঘ শট দ্বারা সংক্ষিপ্ততম নয়, তবে এটি আলফা-নামকরণ এবং ওপিএস পোস্টে তালিকাভুক্ত সমস্ত উদাহরণকে সঠিকভাবে পরিচালনা করে।

Comments

আপনি এই ফাংশনটির কিছু নাম সংক্ষিপ্ত করতে পারেন এবং তাদের কয়েকটিকে ল্যাম্বডাসে পরিণত করতে পারেন। আপনার এখানে আরও কিছু অতিরিক্ত শ্বেতস্থান রয়েছে

— জো কিং কিং

(1) একটি স্পেসের সাথে 4-স্পেস ইন্ডেন্টেশন প্রতিস্থাপন করা বেশ কয়েকটি বাইট সংরক্ষণ করবে। (2) আপনি প্রতিস্থাপন করতে পারেন except NameErrorশুধু সঙ্গে except? (3) দ্বি-চরিত্রের ক্রিয়াকলাপের নামটি এক-অক্ষরের নাম পরিবর্তন করা যেতে পারে। (4) কয়েকটি জায়গা রয়েছে যেখানে আপনার অ্যাসাইনমেন্ট রয়েছে যার চারপাশে স্পেস রয়েছে =। (5) if t[0]=='c'সঙ্গে প্রতিস্থাপন করা যেতে পারে if'c'==t[0]।

— ২২:২১

ইন্ডেন্টেশন এবং ল্যাম্বডাসের মতো বেশিরভাগ বিন্যাসের পরিবর্তনের মাধ্যমে 1045 বাইট

— জো কিং

Answer 12

সি ++ (জিসিসি) ,782 766 758 731 বাইট

#include <string>
#include <map>
#define A return
#define N new E
using S=std::string;using C=char;using I=int;S V(I i){A(i>8?V(i/9):"")+C(97+i%9);}S W(C*&s){C*b=s;while(*++s>96);A{b,s};}struct E{I t,i;E*l,*r;E(E&o,I d,I e){t=o.t;i=o.i+(o.i>=d)*e;t?l=N{*o.l,d,e},t-1?r=N{*o.r,d,e}:0:0;}E(I d,std::map<S,I>m,C*&s){t=*s-40?i=m[W(s)],0:*++s-92?l=N{d,m,s},r=N{d,m,++s},++s,2:(m[W(s+=2)]=d,l=N{d+1,m,s+=2},++s,1);}I R(I d){A t?t-1?l->t==1?l->l->s(d,0,*r),*this=*l->l,1:l->R(d)||r->R(d):l->R(d+1):0;}I s(I d,I e,E&v){t?t-1?l->s(d,e,v),r->s(d,e,v):l->s(d,e+1,v):i==d?*this={v,d,e},0:i-=i>d;}S u(I d){A t?t-1?S{"("}+l->u(d)+' '+r->u(d)+')':S{"(\\ "}+V(d)+". "+l->u(d+1)+')':V(i);}};S f(C*s){E a{0,{},s};for(I c=999;a.R(0)&&c--;);A a.u(0);}

এটি অনলাইন চেষ্টা করুন!

এখানে মূল ধারণাটি হ'ল কোডটি ব্রুজন সূচকগুলির ধারণার উপর ভিত্তি করে একটি অভ্যন্তরীণ উপস্থাপনা ব্যবহার করে - কেবলমাত্র বর্ণিত ভেরিয়েবলের বাঁধাইয়ের ল্যাম্বডা-গভীরতা নির্দেশ করতে আমি সূচকগুলি উল্টো করে দিই। কোডে:

• E::tএকটি নোডের প্রকারের প্রতিনিধিত্ব করে - 0 চলক পাতার নোডের জন্য 0, ল্যাম্বডো নোডের জন্য 1 এবং একটি ফাংশন অ্যাপ্লিকেশন নোডের জন্য 2। (বেছে নেওয়া হয়েছে যাতে এটি নোডের আর্টির সাথে মিলে যায় যা কেবল সম্ভব হওয়া সম্ভব)) তারপরে E::lএবং E::rশিশুরা যথাযথভাবে (কেবল E::lএকটি ল্যাম্বডো নোডের জন্য) উপযুক্ত এবং E::iএকটি পরিবর্তনশীল পাত নোডের জন্য ল্যাম্বডা-গভীরতার সূচক।
• কনস্ট্রাক্টর E::E(E&o,int d,int e)একটি subexpression ক্লোনস যা প্রাথমিকভাবে ল্যাম্বডা-গভীরতায় dএকটি নতুন স্থানে আটকানোর জন্য ল্যাম্বদা-গভীরতায় ছিল d+e। এই কম ল্যামডা গভীর এ ভেরিয়েবল সংরক্ষণের জড়িত dযখন অন্তত ল্যামডা গভীর এ ভেরিয়েবল বৃদ্ধিশীল dদ্বারা e।
• E::ssubexpression একটি প্রতিকল্পন করে vপরিবর্তনশীল নম্বরে dমধ্যে *thisযখন তার চেয়ে অনেক বেশী পরিবর্তনশীল সংখ্যা decrementing d(এবং eএকটি অভ্যন্তরীণ ট্র্যাকিং যখন এটি কল করার প্রয়োজন জন্য ল্যামডা গভীর বৃদ্ধি বিস্তারিত E::c)।
• E::Rএএসটি-র মাধ্যমে প্রাক-অর্ডার অনুসন্ধান অনুসারে শীর্ষ-সর্বাধিক বা বাম-সর্বাধিক উদাহরণগুলি পছন্দ করে, সম্পাদন করতে একক বিটা-হ্রাস অনুসন্ধান করে। এটি সম্পাদন করতে কোনও হ্রাস পেলে ননজারো ফিরিয়ে দেয় বা যদি কিছুই না পেয়ে থাকে তবে শূন্য হয়।
• E::uএকটি to_stringটাইপ অপারেশন যা ভেরিয়েবলের জন্য সিন্থেটিক নাম ব্যবহার করে "মানব পাঠযোগ্য" স্ট্রিংটিকে পুনর্গঠন করে। (নোট যে কারণ একটি সামান্য golfing এর Vসাহায্যকারী ফাংশন এটি শুধুমাত্র নাম ধারণকারী উত্পন্ন করবে aমাধ্যমে i।)
• ল্যাম্বদা-গভীরতার সূচকগুলিতে বর্তমানে আবদ্ধ পরিবর্তনশীল নামের ম্যাপিংয়ের উপর ভিত্তি করে কনস্ট্রাক্টর E::E(int d, std::map<std::string, int> m, char*&s)একটি ইনপুট স্ট্রিংকে sএকটি এক্সপ্রেশন এএসটিতে mবিভক্ত করে।
• f প্রশ্নের উত্তর দেওয়ার প্রধান কাজ।

(আপনি Tio লিঙ্ক-এ দেখতে পারেন, কোড একাধিক অক্ষর হ্যান্ডেল পরিবর্তনশীল নামের করে, এবং এটি একটি সঠিক উত্তরের পায় (\ a. (\ b. a))জন্য ((\ f. (\ x. (f x))) (\ y. (\ x. y)))। এছাড়া শুধু তাই যে পার্সিং কোড কোন অতিরিক্ত খরচ পরিবর্তনশীল ছায়াকরণ সব ব্যবস্থা করতে সক্ষম।)

---

-16 ceilingcat দ্বারা ধারণা (যা আমি স্বাধীনভাবে সঙ্গে আসা পর্যন্ত ছিল) কারণে আংশিকভাবে বাইট, এবং আংশিকভাবে কারণে পরিবর্তন E*a=new E;করতে E&a=*new E;এবং তারপর পরিবর্তন a->করার জন্যa.

-8 আরো (আউট এর নিয়োগ ফ্যাক্টর ceilingcat দ্বারা অন্য মন্তব্যের কারণে বাইট a.tতিন থেকে)

পার্সার এবং ক্লোনটির কনস্ট্রাক্টরে রূপান্তরকারী থেকে -27 বাইট E

Answer 13

সি 637 বাইট

#define R return
#define E if(i>=M||j>=M)R-1;
#define H d[j++]
enum{O=40,C,M=3999};signed char Q[M],D[M],t[M],Z,*o=Q,*d=D,*T;int m,n,s,c,w;K(i,j,k){!Z&&(Z=t[O]=1)+(t[C]=-1);E;if(!o[i]){H=0;R 0;}if((c=t[o[i]]+t[o[i+1]])!=2||o[i+2]!=92){H=o[i++];R K(i,j,i);}for(i+=2,w=0;i<M&&o[i]&&c;++i)c+=t[o[i]],!w&&c==1?w=i:0;E;if(c){for(;H=o[i++];)E;R 0;}for(c=k+7,n=j;c<w&&j<M;++c)if(o[c]==o[k+4]){if(o[c+1]==46){d[n++]=o[k++];R K(k,n,k);}for(m=w+2;m<i-1&&j<M;)H=o[m++];}else H=o[c];E;Z=2;R K(i,j,i);}char*L(char*a){for(s=n=0;n<M&&(o[n]=a[n]);++n);if(n==M)R 0;for(;++s<M;){Z=0;if((n=K(0,0,0))!=-1&&Z==2)T=d,d=o,o=T;else break;}R n==-1||s>=M?0:d;}

এই সংস্করণে অ্যাসিলিরি ভেরিয়েবল ব্যবহার করা হয়নি (সুতরাং এটি ল্যাম্বডা ক্যালকুলাস যা বলে 100% তা অনুসরণ করে না ... এখানে আরও অনেকগুলি হিসাবে ...)। প্রতিটি পরিবর্তনশীল 1 অক্ষর দীর্ঘ হতে হবে (অন্য কিছু হিসাবে এখানে)। পরীক্ষার কোড:

#define P printf

main()
{char  *r[]={ "((\\ x. x) z)", 
              "((\\ x. x) (\\ y. (\\ z. z)))", 
              "(\\ x. ((\\ y. y) x))", 
              "((\\ x. (\\ y. x)) (\\ a. a))", 
              "(((\\ x. (\\ y. x)) (\\ a. a)) (\\ b. b))",
              "((\\ x. (\\ y. y)) (\\ a. a))",
              "(((\\ x. (\\ y. y)) (\\ a. a)) (\\ b. b))",
              "((\\ x. (x x)) (\\ x. (x x)))",
              "(((\\ x. (\\ y. x)) (\\ a. a)) ((\\ x. (x x)) (\\ x. (x x))))",
              "((\\ a. (\\ b. (a (a (a b))))) (\\ c. (\\ d. (c (c d)))))",
              "((\\ f. (\\ x. (f x))) (\\ y. (\\ x. y)))",
             0}, *y;
 int    w;

 for(w=0; r[w] ;++w)
   {y=L(r[w]);
    P("o=%s d=%s\n", r[w], y==0?"Error ":y);
   }
 R  0;
}

ফলাফল:

/*
637
o=((\ x. x) z) d=z
o=((\ x. x) (\ y. (\ z. z))) d=(\ y. (\ z. z))
o=(\ x. ((\ y. y) x)) d=(\ x. x)
o=((\ x. (\ y. x)) (\ a. a)) d=(\ y. (\ a. a))
o=(((\ x. (\ y. x)) (\ a. a)) (\ b. b)) d=(\ a. a)
o=((\ x. (\ y. y)) (\ a. a)) d=(\ y. y)
o=(((\ x. (\ y. y)) (\ a. a)) (\ b. b)) d=(\ b. b)
o=((\ x. (x x)) (\ x. (x x))) d=Error
o=(((\ x. (\ y. x)) (\ a. a)) ((\ x. (x x)) (\ x. (x x)))) d=(\ a. a)
o=((\ a. (\ b. (a (a (a b))))) (\ c. (\ d. (c (c d))))) d=(\ b. (\ d. (b (b (b (b (b (b (b (b d))))))))))
o=((\ f. (\ x. (f x))) (\ y. (\ x. y))) d=(\ x. (\ x. x))
*/

এটি আধা উগল্ফ এক:

#define R return
#define E if(i>=M||j>=M)R-1;
#define H d[j++]
enum{O=40,C,M=3999}; // assume ascii
signed char Q[M],D[M],t[M],Z,*o=Q,*d=D,*T;
int m,n,s,c,w;

K(i,j,k)
{!Z&&(Z=t[O]=1)+(t[C]=-1); //inizializza tabelle

 E;if(!o[i]){H=0;R 0;}
 if((c=t[o[i]]+t[o[i+1]])!=2||o[i+2]!=92)
      {H=o[i++]; R K(i,j,i);}
 for(i+=2,w=0;i<M&&o[i]&&c;++i)
         c+=t[o[i]],!w&&c==1?w=i:0;
 E;
 if(c){for(;H=o[i++];)E;R 0;} 
//  01234567w12 i
//  ((/ x. x) z)
//   x                 w              z
// o[k+4]..o[k+5];  o[k+7]..o[w];  o[w+2]..o[i-1]

// sostituzione
// sostituisce a x z in w e lo scrive in d
for(c=k+7,n=j;c<w&&j<M;++c)
      if(o[c]==o[k+4])
         {if(o[c+1]==46) // non puo' sostituire una variabile dove c'e' lambda
             {d[n++]=o[k++]; R K(k,n,k);}
          for(m=w+2;m<i-1&&j<M;++m)
                H=o[m];
         }
      else H=o[c];
 E;
 Z=2;
 R K(i,j,i);
}

char*L(char*a)
{for(s=n=0;n<M&&(o[n]=a[n]);++n);
 if(n==M)R 0;
 for(;++s<M;)
   {Z=0;
    n=K(0,0,0);
//    if(Z==2)printf("n=%d>%s\n", n, d);
    if(Z==2&&n!=-1)T=d,d=o,o=T;
    else break;
   }
 R n==-1||s>=M?0:d; 
}

Comments

স্পেসিফিকেশনটির জন্য \ বা λ প্রয়োজন, / নয়। এটির জন্য বহু-বর্ণের পরিবর্তনশীল নামের সমর্থন প্রয়োজন। অতিরিক্তভাবে (আমি জানি আপনি এটি সম্পর্কে সচেতন, তবে হ্যাঁ, এটি এখনও ভুল), এটি ভুলভাবে মূল্যায়ন করে ((/ / f। (/ X। (Fx)))) (/ y। (/ X। Y))) থেকে ( / x। (/ x। x))।

— অ্যান্ডারস কাসের্গ

আমি পরিবর্তন / টু \ সেখানে বহু অক্ষরকে পরিবর্তনশীল না করার সমস্যা রয়েছে problem যদি পরীক্ষা করে নেওয়া হয় তবে এটি অন্য সমাধানের জন্যও রয়েছে

— রোজলুপি