এটাই প্রায় লিস্প!

14

চ্যালেঞ্জ

আপনার চ্যালেঞ্জটি হ'ল লিসপ-জাতীয় ভাষার জন্য একজন দোভাষীকে ডিজাইন করা, যা এখান থেকে তৈরি করা হবে: জিএলিস্প । GLisp এর প্রোগ্রাম কোডটি নীচের আকারে বন্ধনীর সাহায্যে নির্বিচারে পরিমাণে নেস্টেড এক্সপ্রেশন নিয়ে গঠিত:

(func arg1 arg2 ...)

নোট করুন যে দোভাষীকে অবশ্যই বন্ধনী, ফাংশন এবং তর্কগুলির আগে এবং পরে এক্সট্রান্সিয়াস হোয়াইটস্পেস অক্ষরের জন্য মঞ্জুরি দিতে হবে।

প্রকারভেদ

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

ক্রিয়াকলাপ

নিম্নলিখিত ফাংশনগুলি প্রয়োগ করা প্রয়োজন এবং এটি ফাংশন , আরটি ফর্ম্যাটটিতে রয়েছে । যদি একটি আরটিটি nপ্লাস চিহ্ন দ্বারা এগিয়ে যায়, তবে সেগুলি nবা আরও আর্গুমেন্টকে বোঝায় । আপনি ধরে নিতে পারেন যে কোনও ফাংশনে প্রদত্ত সমস্ত আর্গুমেন্ট একই ধরণের, অন্যথায় নির্দিষ্ট না করে unless আপনি এটি ধরেও নিতে পারেন যে যদি কোনও ক্রিয়াকলাপটি কোনও ক্রিয়াকলাপী টাইপের জন্য নির্দিষ্ট না করা থাকে, তবে আপনি ধরে নিতে পারেন যে সেই ফাংশনের কোনও যুক্তি কখনই সেই ধরণের হবে না। নিম্নলিখিত চিত্রের মতো যুক্তিগুলি উল্লেখ করা হবে:

(func argument1 argument2 ... argumentn)

  • + , 2+

    • সমস্ত যুক্তি যদি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই আর্গুমেন্টের যোগফলটি ফেরত দিতে হবে
    • সমস্ত আর্গুমেন্ট যদি তালিকার ধরণের হয় তবে আপনাকে অবশ্যই আর্গুমেন্টের সংবর্ধনাটি ক্রমবর্ধমান ক্রমে ফিরে আসতে হবে ( arg1+arg2+ ...)
    • যদি সমস্ত আর্গুমেন্ট বুলিয়ান ধরণের হয় তবে আপনাকে অবশ্যই যুক্তিগুলির ক্রম সমস্ত লজিকালটি ফিরিয়ে দিতে হবে
    • (+ 1 2 3 4 5) -> 15
    • (+ (list 1 2) (list 3 4)) -> (list 1 2 3 4)
    • (+ true true true) -> true

  • - , 2+

    • সমস্ত যুক্তি যদি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই আর্গুমেন্টের পার্থক্যটি ফিরিয়ে দিতে হবে ( arg1-arg2- ...)
    • যদি সমস্ত আর্গুমেন্ট বুলিয়ান ধরণের হয় তবে আপনাকে অবশ্যই যুক্তিগুলির অনুক্রমের লজিক্যাল যেকোনটি দিতে হবে
    • (- 8 4 3) -> 1
    • (- 0 123) -> -123
    • (- true false false true false) -> true

  • * , 2+

    • সমস্ত যুক্তি যদি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই যুক্তির পণ্যটি ফিরিয়ে দিতে হবে
    • যদি একটি যুক্তি তালিকার ধরণের থাকে এবং অন্যটি পূর্ণসংখ্যার টাইপের হয় (আপনি ধরে নিতে পারেন যে এগুলি কেবলমাত্র প্রদত্ত আর্গুমেন্টই হবে), আপনাকে অবশ্যই বারবার আইটেমগুলির সাথে একটি নতুন তালিকা ফিরিয়ে দিতে হবে ।arg1arg2
    • (* 1 2 3 4 5) -> 120
    • (* (list 1 2 3) 2) -> (list 1 2 3 1 2 3)

  • / , 2+

    • সমস্ত যুক্তি যদি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই আর্গুমেন্টের ভাগফলটি ফেরত দিতে হবে ( arg/arg2/ ...) (আপনি ধরে নিতে পারেন যে বিভাগটি ধারাবাহিকভাবে সম্পন্ন হয়েছে এবং প্রতিটি পদক্ষেপের দশমিক অংশটি কাটা হয়েছে)
    • যদি একটি যুক্তি তালিকার ধরণের এবং অন্যটি ফাংশন টাইপের হয় তবে আপনাকে অবশ্যই প্রতিটি মানের সাথে মানচিত্র তৈরি করার পরে ফলাফলটি তালিকাটি ফিরিয়ে দিতে হবেarg2
    • (/ 100 10 3) -> 3
    • (/ (list 1 2 3) inc) -> (list 2 3 4)

  • % , 2

    • সমস্ত যুক্তি যদি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই আর্গুমেন্টের মডুলাসটি ফিরিয়ে দিতে হবে
    • (% 4 2) -> 0

  • = , 2+

    • সমস্ত আর্গুমেন্টের ধরণ এবং মান উভয়ই যদি এক হয় তবে আপনাকে অবশ্যই সত্য ফিরে আসতে হবে। অন্যথায়, মিথ্যা ফিরে।
    • (= 0 0 0) -> true
    • (= 0 false (list)) -> false

  • তালিকা , 0+

    • প্রকার নির্বিশেষে আপনাকে অবশ্যই সমস্ত আর্গুমেন্টের একটি তালিকা ফেরত দিতে হবে। যদি কোনও যুক্তি না দেওয়া হয়, তবে আপনাকে অবশ্যই একটি খালি তালিকা ফিরিয়ে দিতে হবে
    • (list 3 4 (list 5)) -> (list 3 4 (list 5))

  • ইনক , 1

    • যদি আর্গুমেন্টটি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই একের দ্বারা পূর্ণসংখ্যার পূর্ণসংখ্যা ফেরত দিতে হবে
    • যদি আর্গুমেন্ট তালিকার প্রকারের হয় তবে আপনাকে অবশ্যই তালিকাটি ঘড়ির কাঁটার বিপরীতে একক ঘোরানো উচিত
    • (inc 1) -> 2
    • (inc (list 1 2 3)) -> (list 3 1 2)

  • ডিস , ২

    • যদি আর্গুমেন্টটি পূর্ণসংখ্যার ধরণের হয় তবে আপনাকে অবশ্যই এক এক করে পূর্ণসংখ্যাটি ফেরত দিতে হবে
    • যদি আর্গুমেন্ট তালিকার ধরণের হয় তবে আপনাকে অবশ্যই তালিকাটি ঘোরার ঘড়ির কাঁটার বিপরীতে একক ঘোরানো উচিত
    • (dec 1) -> 0
    • (dec (list 1 2 3)) -> (list 2 3 1)

  • যদি , 3

    • যদি কোনও প্রকারের তিনটি আর্গুমেন্ট দেওয়া হয় : সত্যতার মানটি যদি সত্য হয় তবে arg1ফিরে arg2আসুন, অন্যথায় ফিরে আসুনarg3
    • (if (not (list 1)) 8 false) -> false

  • না , 1

    • যদি কোনও ধরণের আর্গুমেন্ট দেওয়া হয়, এর সত্য মান arg1যদি মিথ্যা হয় তবে ফিরে যান true, অন্যথায় ফিরে আসুন false।
    • (not (list)) -> true

  • লেন , ২

    • যদি তালিকার প্রকারের একটি আর্গুমেন্ট দেওয়া হয় তবে এর দৈর্ঘ্যটি ফিরিয়ে দিনarg1
    • (len (list 4 2 true (list 3) (list))) -> 5

সত্য সারণী :, 0, (list), false -> falseযেখানে (list)একটি খালি তালিকা বোঝায়। আর সব কিছু true।

আপনার দোভাষী হ'ল একটি সম্পূর্ণ প্রোগ্রাম হতে পারে যা স্টিডিন বা কোনও ফাইল থেকে উত্স ইনপুট পড়বে বা এমন কোনও ফাংশন যা উত্সটিকে স্ট্রিং হিসাবে গ্রহণ করে এবং আউটপুট মানটি ফেরত দেয়।

তাহলে সাবেক নির্বাচন, জন্য আউটপুট পূর্ণসংখ্যার কেবল সংখ্যা, জন্য Booleans হয় trueবা false, এবং তালিকার জন্য একটি স্থান বন্ধনী (যেমন। মধ্যে লেখা মান ক্রম পৃথক হয়েছে (1 2 3 4 (5 6 7))-এর মানে (list 1 2 3 4 (list 5 6 7)))।

যদি পরবর্তীটি বেছে নেওয়া হয় তবে মানটি অবশ্যই প্রয়োগের ভাষার অনুরূপ প্রকারে প্রত্যাবর্তন করতে হবে, বা যদি একই ধরণের কোনও উপস্থিত না থাকে তবে একটি কাস্টম প্রকার। তালিকাসমূহ যদি ভাষাটির নেই বিন্যাস বা ভেক্টর হিসেবে ফিরে যেতে পারে তালিকা ধরন, Booleans ভাষায় একটি বুলিয়ান টাইপ, অথবা যদি ভাষা তাদের সমর্থন করে না একটি কাস্টম প্রকার ফিরিয়ে দিতে হবে।

পরীক্ষার মামলা

(list 1 2 3 (list 4 5 true))  -> (1 2 3 (4 5 true))
(/ 4000 (+ 1 2 3 4 (* 5 8)))  -> 80
(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)  -> true
(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))  -> 5

ব্যাখ্যা

  • আপনার দোভাষী আপনি যে কোনওভাবেই অবৈধ ইনপুটটি মোকাবেলা করতে পারেন, তবে এটি অবশ্যই একটি ব্যতিক্রম ছুঁড়ে ফেলবে না (যদিও এটি কোনও ত্রুটি বার্তা প্রিন্ট করতে পারে এবং সহজেই প্রস্থান করতে পারে)
  • কার্যকারিতা সর্বদা আর্গুমেন্টের বাম থেকে ডানদিকে মূল্যায়ন করবে
  • অবৈধ ইনপুট হ'ল এমন কোনও ইনপুট যা সিন্টেক্সিকভাবে ভুল। এর মধ্যে মেলে না এমন বন্ধনী, শূন্য দ্বারা বিভাগ এবং আংশিক প্রয়োগিত ফাংশন (বোনাস না দিয়ে) অন্তর্ভুক্ত রয়েছে তবে এতে সীমাবদ্ধ নয়
  • কারণ =, যদি মানগুলির কোনও আলাদা হয় বা প্রকারগুলির কোনও পৃথক হয় তবে ফিরে আসুনfalse

বোনাসেস

  • আপনি আংশিক প্রয়োগিত ফাংশন সমর্থন করলে * 0.8 স্কোর করুন । উদাহরণস্বরূপ, ((+ 2) 3)হিসাবে একই হবে (+ 2 3), কিন্তু যেমন জিনিস জন্য অনুমতি দেয় (/ (list 1 2 3) (+ 2))। আপনি ধরে নিতে পারেন যে কোনও ফাংশন তার ন্যূনতম সংখ্যার চেয়ে কম আর্গুমেন্ট গ্রহণ করলে আংশিকভাবে প্রয়োগ করা হয় is
  • স্কোর * 0.85 আপনি যদি আর্গুমেন্টগুলি ifফেরত না দেওয়া হয় তবে তা প্রয়োগ না করে যদি তা মূল্যায়ন না করেন

এটি কোড-গল্ফ, সুতরাং সর্বনিম্ন বাইট গণনা সহ দোভাষী!

code-golf  interpreter  lisp 
— globby
সূত্র
একজন কীভাবে ব্যাখ্যা করে (if (not (array 1)) 8 false) -> false?
— 6'15
@ ফেয়ারসাম ভাল ক্যাচ, 8 এর কথা মনে করা হচ্ছে
— গ্লোবাই
1
আমাদের মূল্যায়ন কীভাবে করা উচিত (+ 3 (if false 5))? সাধারণভাবে বলতে গেলে, আসলে "কিছুই ফিরিয়ে দিচ্ছেন না"? পুনরায় যোগ করার জন্য আপনি কোনও ইউনিটের ধরণ উল্লেখ করেননি
— গর্বিত হাসেলেলার
3
1. কেন (+ bool bool...)লজিক্যাল অ্যান্ড এবং (- bool bool...)লজিক্যাল ওআর? মানক রিং স্বরলিপিটি +ও ও এ্যান্ড এর জন্য ব্যবহার করবে *। ২. "অবৈধ ইনপুট" এর মতো বিষয়গুলি (/ 2 0)কী সিন্ট্যাক্টিকভাবে সঠিকভাবে প্রচ্ছন্ন করার উদ্দেশ্যে করা হয়েছে ? ৩. কারণ =, মানগুলি যদি একই রকম না হয় তবে এটি কি ফিরে আসা উচিত false? ৪. সংজ্ঞাটি notপিছনের দিকে উপস্থিত বলে মনে হয়। 5. টোকেনগুলি কী কী? আপনি বলছেন যে দোভাষীকে অবশ্যই অতিরিক্ত শ্বেতস্পেস পরিচালনা করতে হবে, তবে আপনি কোন সাদা স্থানের উপর নির্ভর করতে পারবেন তা বলবেন না। এই জাতীয় জটিল প্রশ্নের জন্য আপনার সত্যিকার অর্থে স্যান্ডবক্স ব্যবহার করা উচিত যাতে স্পেকটি পরীক্ষা করা যায়।
— পিটার টেলর
1
আংশিক প্রয়োগ কীভাবে কাজ করা উচিত তা পরিষ্কার নয়: ((+ 2 3) 4)সমান 9বা ত্রুটি? উল্লেখযোগ্যভাবে, ভার-আরগ ফাংশনগুলির জন্য, কখনই আবেদনটি আংশিক বিবেচনা করা উচিত তা স্পষ্ট নয়। এটি ((if true (+ 2 3) (- 5)) 4)
— এমটনিভিউমার্ক

উত্তর:

6

হাস্কেল, 1370 1263 1179 1128 1163 1107 1084 বাইট * 0.8 * 0.85 = 737.12

import Text.Parsec
data V=I Int|L[V]|T|F|P[V]|X|A|S|M|D|U|E|Q|J|K|C|N|W deriving Eq
m Q=0;m C=3;m f|f`elem`[J,K,N,W]=1;m _=2
l=length
x v=[n|I n<-v]
y v=[l|L l<-v]
z v=[0<1|T<-v]++[1<0|F<-v]
(&)f=l.f>>=(.l).(==)
b a|a=T|0<1=F
s(I n)=show n
s(L v)='(':tail(v>>=(' ':).s)++")"
s T=d!!0;s F=d!!1;s _="error"
i(L v)=e$i%v
i v=v
e(P v:a)=e$v++a
e(f:a)|m f>l a=P(f:a)
e(A:a)|x&a=I$sum$x a|y&a=L$concat$y a|z&a=b$and$z a
e(S:a)|x&a=I$f$x a|z&a=b$or$z a
e(M:a)|x&a=I$product$x a
e[M,v,I n]=e$A:replicate n v
e(D:a)|x&a=I$v$x a
e[D,L v,f]=L$map(\a->e[f,a])v
e[U,I a,I b]=I$a`mod`b
e(E:a:v)=b$all(==a)v
e(Q:a)=L a
e[J,I a]=I$a+1
e[J,L[]]=L[]
e[J,L v]=L$last v:init v
e[K,I a]=I$a-1
e[K,L v]=L$drop 1 v++take 1 v
e[C,a,b,c]|a`elem`[I 0,L[],F]=c|0<1=b
e[N,a]=e[C,a,F,T]
e[W,L v]=I$l v
e _=X
f(a:b)=a-sum b
v(a:b)=foldl div a b
(%)f=fmap f
p=k$choice$try%([(I .read)%many1 digit,L%between(w"(")(k$w")")(many$try p)]++zipWith((.return).(>>).w)d[T,F,A,S,M,D,U,E,Q,J,K,C,N,W])
k=(spaces>>)
w=string
d=words"true false + - * / % = list inc dec if not len"
g=either show(s.i).parse p""
main=interact g

সম্পূর্ণ প্রোগ্রাম, পড়া stdinএবং লিখতে stdout। gএছাড়াও ফাংশন সংস্করণ।

আংশিক ফাংশন এবং অলস মূল্যায়ন উভয়ই কার্যকর করে if।

নমুনা রান (ফাংশন সংস্করণ):

λ: g "(list 1 2 3 (list 4 5 true))"
(1 2 3 (4 5 true))

λ: g "(/ 4000 (+ 1 2 3 4 (* 5 8)))"
80

λ: g "(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)"
true

λ: g "(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))"
5

λ: g "(if false (/ 1 0) 5)"
5

λ: g "((+ 2) 3)"
5

λ: g "(/ (list 1 2 3) (+ 2))"
(3 4 5)

এখন বর্ণনা থেকে সমস্ত ইউনিট পরীক্ষা আছে:

λ: runTests 
passed: g "(+ 1 2 3 4 5)" ==> 15
passed: g "(+ (list 1 2) (list 3 4))" ==> (1 2 3 4)
passed: g "(+ true true true)" ==> true
passed: g "(- 8 4 3)" ==> 1
passed: g "(- 0 123)" ==> -123
passed: g "(- true false false true false)" ==> true
passed: g "(* 1 2 3 4 5)" ==> 120
passed: g "(* (list 1 2 3) 2)" ==> (1 2 3 1 2 3)
passed: g "(/ 100 10 3)" ==> 3
passed: g "(/ (list 1 2 3) inc)" ==> (2 3 4)
passed: g "(% 4 2)" ==> 0
passed: g "(= 0 0 0)" ==> true
passed: g "(= 0 false (list))" ==> false
passed: g "(list 3 4 (list 5))" ==> (3 4 (5))
passed: g "(inc 1)" ==> 2
passed: g "(inc (list 1 2 3))" ==> (3 1 2)
passed: g "(dec 1)" ==> 0
passed: g "(dec (list 1 2 3))" ==> (2 3 1)
passed: g "(if (not (list 1)) 8 9)" ==> 9
passed: g "(not (list))" ==> true
passed: g "(len (list 4 2 true (list 3) (list)))" ==> 5
passed: g "(list 1 2 3 (list 4 5 true))" ==> (1 2 3 (4 5 true))
passed: g "(/ 4000 (+ 1 2 3 4 (* 5 8)))" ==> 80
passed: g "(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)" ==> true
passed: g "(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))" ==> 5
passed: g "(if false (/ 1 0) 5)" ==> 5
passed: g "((+ 2) 3)" ==> 5
passed: g "(/ (list 1 2 3) (+ 2))" ==> (3 4 5)
— MtnViewMark
সূত্র
খ ক্ষেত্রে e[K,L _]আপনি ব্যবহার করতে পারে drop 1 একটি নিরাপদ সংস্করণ হিসেবে tailএবং ব্যবহার takeএকটি নিরাপদ সংস্করণের জন্য headদুটি সংজ্ঞা যোগদানe[K,L _]
— গর্বিত haskeller
আপনি ফাংশনটি ব্যবহার করতে পারেন। notElemঅন্য টিপ: আপনি এটি করতে পারেন s=stringএবং এটি উভয় stringএবং char( s"C"বনাম char 'C') এর পরিবর্তে ব্যবহার করতে পারেন । অন্য টিপ: ifএস
— গর্বিত হাস্কেলারের
আর একটি জিনিস যা আমি ভেবেছিলাম: আপনি Maybeতালিকা অনুসারে মানগুলি এনকোড করতে পারেন । Nothingহয় []এবং Just xহয় [x]। এই দীর্ঘ কনস্ট্রাকটর পরিত্রাণ পায় এবং আরো কিছু বৈশিষ্ট্য যোগ করেছেন: if p then Just x else Nothingহয় [x|p], (==Nothing)হয় null, তালিকা একসংখ্যা যেমন হয়তো একসংখ্যা, এবং তাই ঘোষণা একই হয়ে যায়।
— গর্বিত হাসেল্লার
ধন্যবাদ
— এমটিএনভিউমার্ক
4

পাইথন 2, 1417 * 0.8 * 0.85 = 963.56

from operator import*
A=type;K="list"
def E():print"E";exit()
def R(G):
 len(G)or E();T=G.pop(0);L=[]
 if"("==T:
  G or E()
  while")"!=G[0]:L+=[R(G)];G or E()
  G.pop(0);return L
 if")"==T:E()
 try:
  x=eval(T.title())
  if Q(x)<2:return x
  E()
 except:return T
H="+ - * / = % if inc dec not len"
Z=lambda y:lambda x:reduce(y,x)
D=dict(zip(H.split(),[[sum,any,0,lambda x:sum((y[1:]for y in x),[K])],[Z(sub)],[Z(mul),all,0,lambda x:x[0][:1]+x[0][1:]*x[1]],[Z(div),lambda x:[K]+map(lambda z:S([x[1],z]if Q(x[1])==2else x[1]+[z]),x[0][1:])],[lambda x:len(set(map(str,x)))<2]*6,[lambda x:x[0]%x[1]],[lambda x:S(x[2])if S(x[0])in[0,[K]]else S(x[1])]*6,[lambda x:x[0]+1,0,0,lambda x:x[0][:1]+x[0][-1:]+x[0][1:-1]],[lambda x:x[0]-1,0,0,lambda x:x[0][:1]+x[0][2:]+[x[0][1]]],[lambda x:x[0]in[0,[K]]]*6,[0]*3+[lambda x:len(x)-1]]))
H=H[:15]+H+" if"
def Q(x):
 t=A(x);w=int,bool,str
 if t in w:return w.index(t)
 if t==list and x:return 5-(2*(x[0]==K)+(str==A(x[0])and len(x)<H.count(x[0])+1))
 E()
def S(G):
 if Q(G)<2:return G
 G or E();c=G[0];r=G[1:];c==K or r or E()
 if c!="if":r=[x if Q(x)in{2,4}else S(x)for x in r]
 if c==K:return[c]+r
 k=map(Q,r);m=min(k);M=max(k);v=[m,[-1,3][{m,M}=={4,5}]][m!=M]
 try:return D[c][v](r)
 except:E()
def C(x):return"(%s)"%" ".join(map(C,x))if A(x)==list else str(x).lower()
def I(G):
 for c in"+-*/%=()":G=G.replace(c," %s "%c)
 return C(S(R(G.strip().split())))
print I(raw_input())

সম্পূর্ণ ওভারহল। আপনি যদি পূর্ববর্তী সংস্করণগুলি দেখতে চান তবে সম্পাদনার ইতিহাসটি দেখুন ।

গল্ফ করার মতো আরও অনেক কিছু আছে। আমি আস্তে আস্তে এটি নিয়ে কাজ করছি।

Zlib / বেস 64 এর সাথে আমরা 1093 * 0.8 * 0.85 = 743.24 পেয়েছি :

import base64,zlib
exec zlib.decompress(base64.b64decode("eJx9VE1P4zAQvedXGEuV7MbttgX2kOADAtSugANbTljWKqSuNku+5Lg0BfHfd8ZJCwjt9tLpdN6bmTczXtuqIFVtbOIqS7KirqwbBufS7WoTX0uaZ42jwcqsyRXjUW2z0tErGps2c4x7/08251FAclOCARwQF9/L+biuajbh8Y1UOiDZmjIq5T0EkjnposDc/s5yQzk9knM10dFNKBXS6fhDzIHJGrexJbnxbNyz+Qhnd0jbSvOc5Ox+7DKXG8YRm63JHWv52SzqwS04Pci0qand3n0fLCQNyYgMyTciyQCBWZmSlUlJWTlsjgYPMk+Kx1VCdlFvtIBfbVLDdqLlwaVcZaljL1nNFuOmzlEhoVSzKURS7sREHFDgYmynppFeQ5s7SEVaCL3WXAv1wJrNY2cUm5yLJM8/YlsQSkVTHXoDKIatmmofvsqe+Xsg0IVFUrPe8RItmcJQ8aI7WcDmUs5M3hiCP0L1ornY02IFBy4cbmMcQ77GWeiWg6h6+P1DDAIHfS0H5xLSzDSHhGhNwCrVBDvVPu2yq+IrUTiFnv/Z9Qjq2/c/+pwQvaP/gmeAVR1Yf4EeyvMlTfTwOPysQssxISzXQi6A81SHi5DiQvpbwGWDXXTyHIx4K+FaxGNV5QJEw7UlDme93a/ddpyVK9Myx7s/pcRzI0m58qvlY05HbDb02kl5zUOUXyI9iomBXVFni3FabUrX+cMpbv9Vf6DL7kD90OcfbmEeHE4xTv0Bxha+QFv4Ka/xL3s4Q0CnR5JCo5GVqt1fVla+zsTJ236YHPe5xR6t7jBA1OdTqQ5BhCeJS3QnLI8LWWQle+LxLfhaNJ6lKgSMVxxr9VqI2zcpX0/E6ZvWqjiSt7o79r7+S2BUz5rZ93Pet3yBc+jCKBs0nA4ooeM/FaTD7Be4wFAdTqnX3HcA2oJnnFdbY3umH5142FcKfdFwNPw2kIzTaA5vnDV1nsD9p4KSQUPoIIVa+vIu2JLBYzYGUngR+P5FgE/gn1Ggtsn2V1bWG3T/BUW+qRU="))

দ্রষ্টব্য: আপনি যদি আমার স্কোর উপরে উঠতে দেখেন তবে সম্ভবত আমি কয়েকটি বাগ খুঁজে পেয়েছি

— Sp3000
সূত্র
কোড গল্ফের চেয়ে কোড চ্যালেঞ্জের বেশি তবে এখনও, 4872 * 0.8 = 3897,6
— ডিফ
3

কমন লিস্প, 868 বাইট * 0.85 = 737.8

এটি লিস্পের সাথে লিস্প বাস্তবায়ন করার জন্য প্রতারণা করছে? এখনও এখানে অনুকূলিত করার জন্য প্রচুর।

(SETF (READTABLE-CASE *READTABLE*) :PRESERVE)(PRINC(LABELS((B(X)(FIND X'(true false)))(R(X)(IF X'true'false))(V(X)(MEMBER X'(0()false)))(A(&REST X)(R(NOTANY #'V X)))(O(&REST X)(R(NOTEVERY #'V X)))(E(X &KEY N)(IF(LISTP X)(ECASE(FIRST X)(+(APPLY(IF(EVERY'NUMBERP #1=(MAPCAR(IF N #'IDENTITY #'E)(CDR X)))'+(IF(EVERY'LISTP #1#)'APPEND #'A))#1#))(-(APPLY(IF(EVERY'NUMBERP #1#)'- #'O)#1#))(*(IF(LISTP #2=(CAR #1#))(LOOP FOR I TO(1-(CADR #1#))APPEND #2#)(APPLY'* #1#)))(/(IF(LISTP #2#)(LOOP FOR I IN #2#COLLECT(E `(,(CADR #1#),I):N T))(REDUCE'FLOOR #1#)))(%(APPLY'MOD #1#))(=(R(LOOP FOR I IN(CDR #1#)ALWAYS(EQUAL I #2#))))(list #1#)(inc(IF(LISTP #2#)(APPEND(LAST #2#)(BUTLAST #2#))(1+ #2#)))(dec(IF(LISTP #2#)(APPEND(CDR #2#)`(,(FIRST #2#)))(1- #2#)))(if(IF(V(E(CADR X)))(E(CADDDR X))(E(CADDR X))))(not(R(V #2#)))(len(LENGTH #2#)))X)))(OR(IGNORE-ERRORS(OR(E(READ))"()")):E))

ইনপুটটিতে ত্রুটির ক্ষেত্রে একটি ই প্রিন্ট করে। নমুনা রান:

$ sbcl --script glisp.lisp
(list 1 2 3 (list 4 5 true))
(1 2 3 (4 5 true))

$ sbcl --script glisp.lisp
(/ 4000 (+ 1 2 3 4 (* 5 8)))
80

$ sbcl --script glisp.lisp
(+ (not (- (len (list 5 6 7)) (/ 10 3))) true)
true

$ sbcl --script glisp.lisp
(if (           len (list )  ) 4 (if    (+ (= 8 8    8) (not (list 4))) 8 5))
5

$ sbcl --script glisp.lisp
(this is an error)
E

$ sbcl --script glisp.lisp
(if (% 4 2) (this is an error) 42)
42
— jlahd
সূত্র
2
যতক্ষণ না এটি এক ধরণের ওভাল ফাংশন নয় ...
— Def
2

হাস্কেল, 972

r=fst.f
f('(':s)|(f:a,b)<-g s=(f%filter(/="")a,b)
f s=span(`notElem`" ()")s
j=dropWhile(==' ')
g""=([],"")
g s|')':l<-r=([x],l)|(y,t)<-g$j r=(x:y,t)where(x,r)=f$j s
"%"%c=show$foldr(mod.read)(maxBound::Int)c
"+"%c|t(c!!0)<1="(list "++tail(c>>=(' ':).drop 6.init)++")"|t(c!!0)<2=show$sum$map read c|0<1=i$all((=='t').head)c
"-"%c|t(c!!0)<2=show$foldl1(-)$map read c|0<1=i$any((=='t').head)c
"*"%c=fst$f$"(+ "++unwords([1..read$last c]>>init c)++")"
"="%c=i$all(==c!!0)c
"/"%c|t(c!!0)<1,[a,b]<-c="list"%map(\x->b%[x])(fst$g$drop 6 a)|0<1=show$foldl1 div$map read c
"if"%[p,a,b]|elem p["0","()","false"]=b|0<1=a
"list"%c="(list "++unwords c++")"
"len"%[c]=show$length(words c)-1
"inc"%[c]|t c>0=show$read c+1|([],_)<-g$drop 6 c="(list)"|(x,_)<-g$drop 6 c="list"%(last x:init x)
"dec"%[c]|t c<1,(x,_)<-g$drop 6 c="list"%(drop 1 x++take 1 x)|0<1=show$read c-1
"not"%[c]="if"%[c,"false","true"]
s%c="?"
i p|p="true"|0<1="false"
t('(':_)=0
t(c:s)|c<':',c>'/'=1|elem c"th"=2
t _=3

বেশ হ্যাকি সমাধান এটি আউটপুট-রেডি আকারে স্ট্রিং হিসাবে সবকিছু সঞ্চয় করে - তাদের ধরণগুলি তাদের প্রথম অক্ষর দ্বারা আলাদা করা যায় - 0..9সংখ্যার (জন্য, তালিকার জন্য,tf জন্য বা বুলিয়ানদের জন্য, এবং সমস্ত কিছুর জন্য।

rফাংশন ব্যবহার চালাতে ।

— গর্বিত হাসেলেলার
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.