আপনার সংস্থাটি একটি প্রকল্পে সবে শুরু হচ্ছে, এবং প্রথমবার আপনি কোনও কার্যনির্বাহী প্রোগ্রামিং কোড-স্টাইল ব্যবহার করার সিদ্ধান্ত নিয়েছেন। তবে আপনার বস সত্যই স্বতন্ত্র এবং বিল্ট-ইন ফাংশনগুলি ব্যবহার করতে চান না এবং আপনার নিজের প্রধান কার্যাদি বাস্তবায়ন করা প্রয়োজন। বিশেষ করে আপনি ফাংশন লিখতে প্রয়োজন: Map, Nest, Apply, Range, Foldএবং Tableআপনার পছন্দের একটি ভাষায়। বস একজন সত্যই ব্যস্ত মানুষ এবং তিনি যতটা সম্ভব সংক্ষেপিত অনুষ্ঠানগুলি চান, তাই তিনি পড়াতে সময় নষ্ট করেন না। তিনি চাইবেন যে আপনি লুপ ব্যবহার করবেন না, তাই লুপ ব্যবহার না করার জন্য আপনার বাইট গণনায় 10% হ্রাস হবে।

ফাংশনগুলির বিস্তারিত প্রয়োজনীয়তা নীচে রয়েছে:

মানচিত্র

Mapফাংশন দুটি প্যারামিটার নেয়: fএবং listযেখানে fএকটি ফাংশন এবং listমূল্যবোধের একটি তালিকা রয়েছে। এটি fপ্রতিটি উপাদান প্রয়োগ করা উচিত list। সুতরাং এটি যেমন কাজ করবে:

Map(f,{a,b,c})

আয়

{ f(a), f(b), f(c) }

এবং

Map(f, {{a,b},{b,c}})

আয়

{ f({a,b}), f({b,c})}

নীড়

Nestফাংশন তিন পরামিতি পাশাপাশি লাগে: f, arg, timesযেখানে fএকটি ফাংশন, argতার শুরু যুক্তি, এবং timesকতবার ফাংশন প্রয়োগ করা হয়। এতে fপ্রয়োগের timesসময়গুলির সাথে একটি অভিব্যক্তি ফেরত দেওয়া উচিত arg। সুতরাং এটি যেমন কাজ করবে:

Nest(f, x, 3)

আয়

f(f(f(x)))

এবং

Nest(f, {a,b}, 3)

আয়

f(f(f({a,b})))

প্রয়োগ করা

Applyফাংশন দুটি প্যারামিটার নেয়: fএবং argsযেখানে fএকটি ফাংশন এবং argsএকটি তালিকা। এটি প্রয়োগ fকরা উচিত args। অতএব:

Apply(f, {a,b,c})

আয়

f(a,b,c)

পরিসর

Rangeফাংশন এক পূর্ণসংখ্যা লাগে rএবং যে সংখ্যা পর্যন্ত পূর্ণসংখ্যার আউটপুট। অতএব:

Range(5)

আয়

{ 1, 2, 3, 4, 5}

ভাঁজ

Foldফাংশন তিন প্যারামিটার নেয় f, arg, othersযেখানে fএকটি ফাংশন, argসহজ পরামিতি, এবং othersএকটি তালিকা। এটি যেমন কাজ করবে:

Fold(f, x, {a, b, c, d})

আয়

f(f(f(f(x,a),b),c),d)

টেবিল

সারণী ফাংশনগুলিতে একটি ফাংশন নেওয়া উচিত f, এবং একটি পরামিতি iteratorআকারে ডাকা : {iMin, iMax}যেখানে iMinএবং iMaxপূর্ণসংখ্যা হয়। আপনার fনির্দিষ্ট রেঞ্জের উপরে আবেদন করা উচিত । অতএব:

Table(f, {0, 5})

আয়

{f(0), f(1), f(2), f(3), f(4), f(5)}

আমি গাণিতিক ফাংশনাল প্রোগ্রামিং পৃষ্ঠা থেকে এই ফাংশনগুলির সংজ্ঞাটি ব্যবহার করেছি , সুতরাং আপনার যদি আরও কোনও গাইডেন্সের প্রয়োজন হয় তবে সেখানে যান। মনে রাখবেন যে আপনাকে সেই পৃষ্ঠায় প্রদর্শিত ফাংশনগুলির সমস্ত সংস্করণটি প্রয়োগ করতে হবে না, তবে কেবলমাত্র এই পোস্টে লিখিত রয়েছে।

স্ট্যান্ডার্ড লুফোলগুলি যথারীতি অনুমোদিত নয়।

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

এটি কোড গল্ফ তাই সংক্ষিপ্ততম কোডটি জয়ী। শুভকামনা !!!

code-golf functional-programming

— WizardOfMenlo
সূত্র

এটা সত্যিই দারুন! +1 তবে, আমি Tableএখানে কীভাবে কাজ করে তা সত্যিই পাই না । আপনার উদাহরণ অনুমিত হয় Table(f, {x, 0, 5})? আমি এটার উদ্দেশ্যও মোটেও পাই না x, কারণ এটি কেবলমাত্র সীমাতে ফাংশনটি প্রয়োগ করে।

— kirbyfan64sos

@ kirbyfan64sos ধন্যবাদ! হ্যাঁ এটি একটি টাইপো ছিল, আমি গণিতের একটি রেফারেন্স হিসাবে এক্স রেখেছিলাম, যা এটি প্রতীকী ভবিষ্যতের হিসাবে ব্যবহার করে, তবে আমি মনে করি আমি এটি বের করতে পারব

— উইজার্ডঅফমেনলো

আরও একটি প্রশ্ন: আমরা ফাংশনগুলির নাম কীভাবে দেব? আমাদের কি তাদের সঠিক নাম দিতে হবে? একক অক্ষর?

— kirbyfan64sos

@ kirbyfan64sos যেহেতু এটি কোড-গল্ফ, তাই আমি একক অক্ষরের নামগুলি অনুমতি দেব, তবে আপনার উত্তরে প্রতিটি ফাংশনের উপরে একটি শিরোনাম রাখব যাতে আমরা জানি এটি কোনটি। সংঘর্ষের অক্ষর ব্যবহার করবেন না।

— উইজার্ডঅফমেন্লো

একটি লুপ হিসাবে গণনা সম্পর্কে আপনি আরও নির্দিষ্ট হতে পারেন?

— xnor

9

হাস্কেল, আগের অনেকগুলি বাইট 127 * 0.9 = 114.3 বাইট গণনা করে

f#(a:b)=f a:f#b;f#x=x
(f&x)0=x;(f&x)i=f$f&x$i-1
i=id
r x=i%(1,x)
(g?x)(a:b)=g(g?x$b)a;(g?x)y=x
f%(a,b)|a>b=[]|1<2=f a:f%(a+1,b)

কোন লুপ নেই, কেবল পুনরাবৃত্তি।

#মানচিত্র: (*2) # [1,2,3]->[2,4,6]

&নীড়: ((*2) & 3) 4->48

iপ্রয়োগ করা হয়: i (*2) 7->14

rব্যাপ্তি: r 4->[1,2,3,4]

?ভাঁজ হয়: ((+) ? 0) [1,2,3,4]->10

%টেবিল: (*2) % (2,4)->[4,6,8]

মতামত সহ একটি দালাল সংস্করণ অনুরোধ। দ্রষ্টব্য, &এবং ?টেরিনারি ইনফিক্স অপারেটরগুলি, যখন ডাকা হয় বা প্যাটার্ন মেলে যখন অতিরিক্ত বন্ধনী প্রয়োজন।

f # (a:b) = f a : f#b        -- map on a list (a->head, b->tail) is f a in front of mapping f to b
f # x     = x                -- map on the empty list is the empty list
                             -- (non empty lists are caught in the line before) 

(f & x) 0 = x                -- nesting zero times is x
(f & x) i = f $ f&x $ i-1    -- nesting i times is f (nesting one time less)

i=id                         -- apply in Haskell is just the identity function 

r x = i % (1,x)              -- defined via the "table" of the identity function from 1 to x

(g ? x) (a:b) = g (g?x$b) a  -- folding g into a list (a->head, b->tail) is g applied to (folding g into b) and a
(g ? x) y     = x             -- folding the empty list is x
                             --  again, y must be the empty list, else it would have been handled by the previous line

f % (a,b)                    
  |a>b       = []                -- if iMin is greater than iMax, the table is empty
  |otherwise = f a : f%(a+1,b)   --  otherwise f a in front of the table with iMin increased by one

কিছু দরকারী ইঙ্গিতের জন্য @ ডিফিউয়ার এবং @ জগারবকে ধন্যবাদ

— nimi
সূত্র

আমি হ্যাশেল এ নতুন, এটি দেখতে বেশ ভাল লাগছে, তবে আপনি কী করছেন তার একটি ব্যাখ্যা যুক্ত করতে পারেন?

— উইজার্ডঅফমেন্লো

1

@ উইজার্ডঅফমেনলো: কিছু মন্তব্য যুক্ত করেছেন

— নিমি

ঠিক বুঝতে পেরেছেন হাস্কেল কত মার্জিত, আসল ভাল!

— উইজার্ডঅফমেন্লো

1

অসীম তালিকা এবং দক্ষতা উপেক্ষা m#q=reverse$f((:).m)[]q,। এটি আপনার সমান দৈর্ঘ্য, তবে পড়া খুব শক্ত।

— dfeuer

আপনি খাটো করতে পারেন !একটি অপারেটর পরিবর্তে এটির একটি নাম করে: i f=f।

— dfeuer

5

পাইথন 2, 305.1 বাইট (-10% 376 369 366 349 339 বাইট)

exec'e=eval;q=len;m=@,l:e("["+"f(l.pop()),"*q(l)+"][::-1]");n=@,x,l:e("f("*l+"*x"+")"*l);r=@:e("r(f-1)+"*(f>1)+"[f]");a=@,a:e("f(a["+`r(q(a))`[1:-1]$",","-1],a[")+"-1])");f=@,x,l:e("f("*q(l)+"x,["+`r(q(l))`[1:-1]$",","-1]),l[")+"-1])");t=@,n,x:e("[f("+`r(x)[n-1:]`$",","),f(")[1:-1]+")]")'.replace("@","lambda f").replace("$",".replace(")

প্রসারিত হলে এর সমতুল্য:

e=eval;q=len
m=lambda f,l:e("["+"f(l.pop()),"*q(l)+"][::-1]")
n=lambda f,x,l:e("f("*l+"*x"+")"*l)
r=lambda i:e("r(i-1)+"*(i>1)+"[i]")
a=lambda f,a:e("f(a["+`r(q(a))`[1:-1].replace(",","-1],a[")+"-1])")
f=lambda f,x,l:e("f("*q(l)+"x,["+`r(q(l))`[1:-1].replace(",","-1]),l[")+"-1])")
t=lambda f,n,x:e("[f("+`r(x)[n-1:]`.replace(",","),f(")[1:-1]+")]")

লুপ নেই!

ঠিক আছে, এটি প্রচুর পরিমাণে evalআইএনজি করে এবং যদি আপনার বস লুপগুলি দাঁড়াতে না পারেন তবে তারা অবশ্যই ঘৃণা করবে। কিন্তু, তারা এটি সহ্য করতে হবে

rangeল্যাম্বডায় করার একটি উপায় প্রশংসা করা হয়েছে তাই আমার কোনও ক্রিয়াকলাপ করতে হবে না (শুড্ডার))।

ব্যাখ্যা:

m=lambda f,l:eval("["+"f(l.pop()),"*len(l)+"][::-1]")
- একটি স্ট্রিং তৈরি করুন যা তালিকা থেকে উপাদানগুলিকে টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো।
n=lambda f,x,l:eval("f("*l+"*x"+")"*l)
- নেস্টিংয়ের সাহায্যে স্ট্রিংটি ম্যানুয়ালি তৈরি করুন, এবং এটি খোল!
r=lambda i:e("r(i-1)+"*(i>1)+"[i]")
- একটি স্ট্রিং তৈরি করুন যা evalসম্পাদনা করা হয়, হয় [0]পূর্ববর্তী ফলাফলগুলি পেতে পুনরাবৃত্তি বা পুনরাবৃত্তি ব্যবহার করে এবং বর্তমান সূচিকে তালিকায় যুক্ত করে। এটি প্রমাণ করে।
a=lambda f,a:eval("f(a["+আর (lên (ক))[1:-1].replace(",","-1],a[")+"-1])")
- সূচিপত্রগুলি 1-লেন (তালিকা) পেতে পরিসীমা ফাংশন ব্যবহার করে। তালিকার সঠিক সূচক পাওয়ার জন্য স্ট্রিংযুক্ত তালিকার কমাগুলি প্রতিস্থাপন করে a। এটা প্রমাণ!
f=lambda f,x,l:eval("f("*len(l)+"x,["+আর (lên (ঠ))[1:-1].replace(",","-1]),l[")+"-1])")
- বন্ধ হিসাবে বন্ধনী, কমা এবং তালিকা সূচক শুরু করে কমাগুলি প্রতিস্থাপন ব্যতীত একই প্রয়োগ।
t=lambda f,n,x:eval("[f("+দ (x) এর [এন-1:].replace(",","),f(")[1:-1]+")]")
- ফাংশনটি শেষ করে এবং নতুনটিকে কল করে প্রতিস্থাপন করা ছাড়া একই প্রয়োগ এবং ভাঁজ। এটা প্রমাণ!

মানচিত্র, নীড়, ব্যাপ্তি, প্রয়োগ, ভাঁজ, সারণী।

পরিসরের জন্য ল্যাংড্ডার জন্য @ জগারবকে ধন্যবাদ!

— নীল
সূত্র

আমার বস তার ডেস্কে আমার মাথা রাখবেন :) আপনি দয়া করে একটি সংক্ষিপ্ত বিবরণ যোগ করতে পারেন?

— উইজার্ডঅফমেনলো

কীভাবে r=lambda i:[]if i<1 else r(i-1)+[i]? কোনও লুপ নেই, কেবল পুনরাবৃত্তি।

— জাগারব

1

অবশ্যই, আমি এটি আপাতত নেব তবে evalলুপগুলির জন্য কীভাবে খারাপ না হয় তা দেখানোর জন্য বসকে আরও বেশি প্রয়োজন :)

— ব্লু

হা! আর একটি সংস্করণ ব্যবহার করছে e=eval:r=lambda i:e("r(i-1)+"*(i>1)+"[i]")

— জাগারব

আপনি কি 60% বোনাস থেকে 10% এ পরিবর্তন করতে পারেন দয়া করে? আমি প্রশ্নের স্পেসিফিকেশনটি সংশোধন করেছি, তাই এটি আরও সুন্দর করার জন্য

— উইজার্ডঅফমেনলো

5

জাভাস্ক্রিপ্ট ES6, 197 * 0.9 = 177.3 বাইট

M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)
N=(f,x,n)=>f(--n?N(f,x,n):x)
A=(f,l)=>f(...l)
R=n=>n--?[...R(n),n+1]:[]
F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x
T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))

মানচিত্র ( `M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)`):

ব্যবহার ভাঁজ ফলাফল CONCAT করতে fপ্রতিটি সদস্য প্রয়োগ lএকটি খালি তালিকা সম্মুখের দিকে। অন্তর্নির্মিত ফাংশনগুলি M=(f,l)=>l.map(f)ব্যবহার করে এটি এটিকে হ্রাস করে (এটি ব্যবহার করা হয়নি বলে মনে হচ্ছে এটি সস্তা ...?)।

নীড় ( `N=(f,x,n)=>f(--n?N(f,x,n):x)`):

0 এ হ্রাস fনা হওয়া পর্যন্ত পুনরাবৃত্তির সাথে প্রয়োগ করুন n।

প্রয়োগ করুন ( `A=(f,l)=>f(...l)`):

স্প্রেড (ব্যবহার ...) অপারেটর আবেদন করতে lসম্মুখের f।

পরিসর ( `R=n=>n--?[...R(n),n+1]:[]`):

রেঞ্জেরn পুনরাবৃত্তির কলকে কনক্যাটn 0 এ না হওয়া পর্যন্ত ।

ভাঁজ ( `F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x`):

এর recursive কল প্রয়োগ ফোল্ড এবং n'এর ম উপাদান lথেকে fযতক্ষণ নাn ব্যবহার 0. decremented হয় বিল্ট-ইন ফাংশন এই হ্রাস F=(f,x,l)=>l.reduce(f,x)(... আবার, মনে হলো সস্তা)।

টেবিল ( `T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))`):

প্রথম সূচনা nএবং xiMin এবং IMAX ডেসট্রাকচারিং (ব্যবহার করার [n,x]=i), তারপর ব্যবহার বিন্যাস IMAX করার iMin থেকে মানগুলির টেবিল গঠন করা। fতারপরে মানচিত্রটি ব্যবহার করে টেবিলের উপরে প্রয়োগ করা হয় এবং ফলাফলটি ফিরে আসে।

— Dendrobium
সূত্র

আমার দর্শন জানতে চান? "যদি এটি সস্তা হয় তবে এটি কিনুন।" এটি চশমাগুলিতে বলে না যে আপনি বিল্টিনগুলি (এখনও) ব্যবহার করতে পারবেন না, সুতরাং সেগুলি ব্যবহার করুন!

— মামা ফান রোল

4

পাইথন 3, 218 বাইট

অপঠনযোগ্য সংস্করণ:

exec("P!:[f(_)for _ in x];Y!,z:Y(f,f(x),z-1)if z else x;T!:f(*x);H!=0:(H(f-1)if~-f else[])+[f];O!,z:O(f,f(x,z[0]),z[1:])if z else x;N!:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]".replace("!","=lambda f,x"))

(আরও) পঠনযোগ্য সংস্করণ:

P=lambda f,x:[f(_)for _ in x]
Y=lambda f,x,z:Y(f,f(x),z-1)if z else x
T=lambda f,x:f(*x)
H=lambda f,x=0:(H(f-1)if~-f else[])+[f]
O=lambda f,x,z:O(f,f(x,z[0]),z[1:])if z else x
N=lambda f,x:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]

এটি একবারে এক লম্বা হলেও চলছে:

মানচিত্র ফাংশন `P`

P=lambda f,x:[f(_)for _ in x]
কেবল একটি সাধারণ পুনরাবৃত্তি। এখানে খুব বেশি বলার কিছু নেই.

বাসা ফাংশন `Y`

Y=lambda f,x,z:Y(f,f(x),z-1)if z else x
প্রতিবার zপ্রয়োগ fকরে শূন্য হিট না হওয়া পর্যন্ত পুনরাবৃত্তি করা হচ্ছে । শেষে যদি ক্লজটি অনুভূত হয়; পুনরাবৃত্তিটি শেষ করার আরও ভাল উপায় হতে পারে।

ফাংশন প্রয়োগ করুন `T`

T=lambda f,x:f(*x)
পাইথনের কাছে আমার জন্য ভারী সমস্ত উত্তোলনের সমস্ত কাজ করার জন্য একটি দুর্দান্ত সম্প্রসারণ অপারেটর রয়েছে।

ব্যাপ্তি ফাংশন `H`

H=lambda f,x=0:(H(f-1)if~-f else[])+[f]
এইটি আমার প্রত্যাশার চেয়ে কঠিন ছিল। পুনরাবৃত্তির পদ্ধতির গ্রহণ করে শেষ হয়েছে। আবার, যদি-অন্য নির্মাণে প্রচুর পরিমাণে বাইটস লাগে এবং আমি মনে করি এটি উন্নত করা যায়। কেন এটি একটি ডামি আছে x=0, আপনি জিজ্ঞাসা? এটি এমন যে আমি যখন এটি সংকুচিত করি তখন আমি ন্যায়বিচারের পরিবর্তে execপ্রতিস্থাপন করতে পারি ।=lambda f,x=lambda f

ভাঁজ ফাংশন `O`

O=lambda f,x,z:O(f,f(x,z[0]),z[1:])if z else x
এই এক সঙ্গে খুব খুশি। আর যতক্ষণ না বাকী থাকে ততক্ষণ প্রতিবার অ্যারের প্রথম উপাদানটি পুনরাবৃত্তি করে।

টেবিল ফাংশন `N`

N=lambda f,x:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]
এটি এক ভয়ঙ্কর এবং আমি নিশ্চিত যে উন্নতির কোনও জায়গা আছে। পূর্বে এক map(f,range(x,y))ধরণের নির্মাণের জন্য নির্ধারিত পরিসীমা এবং মানচিত্রের ফাংশনগুলি ব্যবহার করার চেষ্টা করা হয়েছিল , তবে খুব বেশি সাফল্য ছাড়াই। ভয়ানক কাজ শেষ পুনরাবৃত্তির পদ্ধতির মাধ্যমে যা পরিসরের কার্যের সাথে কিছুটা সাদৃশ্য শেয়ার করে।

সকল lambdas একটি ইন আচ্ছন্ন হয় execএকটি সঙ্গে replaceবাইট গণনা উল্লেখযোগ্যভাবে কমান করতে।

— Tryth
সূত্র

আমি এমন মন্তব্য করতে যাচ্ছিলাম যা [f(_)for _ in x]সংক্ষিপ্ত করা যেতে পারে map(f,x)তবে আমি তখন চ্যালেঞ্জটি কী তা মনে করলাম

— সাইয়েস

4

জুলিয়া, 181 বাইট

আমার জন্য কোনও বোনাস নেই; আমি লুপগুলি উদারভাবে ব্যবহার করেছি। দুঃখিত বস, তবে জুলিয়ায় লুপগুলি দক্ষ!

M(f,x)=[f(i...)for i=x]
N(f,x,n)=(for i=1:n x=f(x...)end;x)
A(f,x)=f(x...)
R(n)=(i=0;x={};while i<n push!(x,i+=1)end;x)
F(f,x,a)=(for b=a x=f(x,b)end;x)
T(f,i)=[f(j)for j=i[1]:i[2]]

কোনও ফাংশনে আর্গুমেন্টের পরে উপবৃত্তগুলি যুক্ত করা একটি অ্যারে, টিপল বা নিয়মিত ফাংশন আর্গুমেন্টে আপনাকে কী ভাঙে। অন্যথায় ফাংশনটি ভাববে আপনি কোনও অ্যারে (বা টিপল ইত্যাদি) পাস করার চেষ্টা করছেন। একক যুক্তিগুলির জন্য এটির কোনও প্রভাব নেই।

ফাংশন নাম:

মানচিত্র: M
নীড়: N
প্রয়োগ করুন: A
ব্যাপ্তি: R
ভাঁজ: F
টেবিল: T

— অ্যালেক্স এ।
সূত্র

4

টিনাইলিস্প , 325 * 0.9 = 292.5

ভাষা প্রশ্নের চেয়েও নতুন, তবে এটি কোনওভাবেই জিততে পারে না।

(d @(q(a a)))(d Q(q((l)(i l(c(@(q q)(h l))(Q(t l)))l))))(d A(q((f a)(v(c(q f)(Q a))))))(d M(q((f l)(i l(c(A f(@(h l)))(M f(t l)))l))))(d N(q((f a x)(i x(A f(@(N f a(s x 1))))a))))(d ,(q((m a b)(i(l b a)m(,(c b m)a(s b 1))))))(d R(q((a)(,()1 a))))(d T(q((f r)(M f(A ,(c()r))))))(d F(q((f a l)(i l(F f(A f(@ a(h l)))(t l))a))))

দু'জন সহায়ক ফাংশন সহ ফাংশন A(প্রয়োগ), M(মানচিত্র), N(নীড়), R(পরিসর), T(টেবিল) এবং F(ভাঁজ) সংজ্ঞায়িত করে ।Tএর দ্বিতীয় তর্কটির জন্য দুটি পূর্ণসংখ্যার একটি তালিকা প্রত্যাশা করে।

টিনাইলিস্পে কোনও লুপ নির্মাণও নেই; পুনরাবৃত্তি ব্যবহার করে সমস্ত কিছুই সম্পন্ন হয়। এর মধ্যে বেশ কয়েকটি ফাংশন পুচ্ছ-পুনরাবৃত্তিযোগ্য নয় , সুতরাং আপনি যদি তাদের বড় তালিকায় কল করেন তবে তারা সম্ভবত কল স্ট্যাকটি ফুঁকবে। এগুলি সমস্ত লেজ পুনরাবৃত্তির সাথে প্রয়োগ করা যেতে পারে ... তবে এতে আরও বাইট লাগবে, এবং এটি কোড গল্ফ।

নামগুলির জন্য শ্বেত স্পেস এবং আসল শব্দগুলির সাথে এখানে একটি প্রসারিত সংস্করণ রয়েছে, যা আপনি লিপ্পের সাথে পরিচিত হলে খুব পঠনযোগ্য হওয়া উচিত। (আমি q(উদ্ধৃতি) এবং i(যদি) ব্যতীত বেশিরভাগ টিনাইলিস্প বিল্টইন রেখেছি )

(d define d)
(define cons c)
(define car h)
(define cdr t)
(define subtract s)
(define less l)
(define eval v)

(define lambda
  (q (()
      (arglist expr)
      (list arglist expr))))

(define list (lambda args args))

(define quote-all
  (lambda (lyst)
    (i lyst
       (cons
         (list (q q) (car lyst))
         (quote-all (cdr lyst)))
       lyst)))

(define Apply
  (lambda (func arglist)
    (eval (cons (q func) (quote-all arglist)))))

(define Map
  (lambda (func lyst)
    (i lyst
       (cons
         (Apply func (list (car lyst)))
         (Map func (cdr lyst)))
       lyst)))

(define Nest
  (lambda (func arg times)
    (i times
       (Apply func
              (list (Nest func arg (subtract times 1))))
       arg)))

(define range*
  (lambda (accumulator a b)
    (i (less b a)
       accumulator
       (range* (cons b accumulator) a (subtract b 1)))))

(define Range
  (lambda (x)
    (range* 1 x)))

(define Table
  (lambda (func iterator)
    (Map func
         (Apply range* (cons () iterator)))))

(define Fold
  (lambda (func arg lyst)
    (i lyst
       (Fold func
             (Apply func (list arg (car lyst)))
             (cdr lyst))
       arg)))

অনুরোধ অনুসারে আরও ব্যাখ্যা উপলব্ধ।

নমুনা আউটপুট

আমার রেফারেন্স বাস্তবায়ন থেকে আরপিএল পরিবেশ ব্যবহার করে। আমি qঅ্যানারি ফাংশনের জন্য (উদ্ধৃতি) এবং sএই উদাহরণগুলির জন্য বাইনারি ফাংশন হিসাবে (বিয়োগ) ব্যবহার করেছি, পাশাপাশি ফাংশন @(এই কোডটিতে সংজ্ঞায়িত) যা তার আর্গুমেন্টগুলির একটি তালিকা ফেরত দেয়।

tl> [line of definitions goes here]
@
Q
A
M
N
,
R
T
F
tl> (A s (@ 10 7))
3
tl> (M q (@ 1 2 3 4))
((q 1) (q 2) (q 3) (q 4))
tl> (N q 123 4)
(q (q (q (q 123))))
tl> (R 5)
(1 2 3 4 5)
tl> (T q (@ 3 7))
((q 3) (q 4) (q 5) (q 6) (q 7))
tl> (F s 10 (@ 4 3 2))
1

— DLosc
সূত্র

2

পাইথন 2.x: 450.6 বাইট (10% ছাড়ের আগে 493 বাইট)

গল্ফ উত্তর:

y=len
z=lambda a,b:a.append(b)
_=lambda a:a if a is not None else[]
def M(a,b,c=None):
 c=_(c);d=y(b)
 if d:z(c,A(a,b[0]))
 return M(a,b[1:],c)if d else c
def N(a,b,c):d=A(a,b);return N(a,d,c-1)if c>1 else d
A=lambda a,b:a(*b)if type(b)is list else a(b)
def R(a,b=None):b=_(b);b.insert(0,a);return b if a<=1 else R(a-1,b)
def F(a,b,c):d=a(b,c[0]);return F(a,d,c[1:])if y(c)>1 else d
def T(a,b,c=None,d=None):
 if c is None:c=b[0];d=[]
 z(d,a(c));return T(a,b,c+1,d)if c<b[1]else d

এই প্রশ্ন মজা ছিল। আমি পাইথন সমতুল্য ব্যবহার না করে আমার ফাংশনগুলি লেখার সিদ্ধান্ত নিয়েছি (যদিও এটি একটি বৈধ লুফোল হতে পারে) এবং ফাংশনগুলি লিখতে যেমন পাইথন লেজ পুনরাবৃত্তি সমর্থন করে। এই কাজটি করতে, আমি প্রচুর optionচ্ছিক প্যারামিটার ব্যবহার করেছি যা প্রয়োজনীয় কলগুলি এখনও কাজ করতে দেয়।

নীচে আমি প্রতিটি ফাংশন জন্য অগল্ফড তালিকা আছে।

Apply:

A = lambda function, arguments: function(*arguments) if type(arguments) is list else function(arguments)

Map:

def M(function, arguments, result=None):
    result = result if result is not None else []
    length = len(arguments)
    if length != 0:
        result.append(A(function, arguments[0]))
    return M(function, arguments[1:], result) if length != 0 else result

Nest:

def N(function, arguments, times):
    result = A(function, arguments)
    return N(function, result, times - 1) if times > 1 else result

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

Range:

def R(ceiling, result=None):
    result = result if result is not None else []
    result.insert(0, ceiling)
    return result if ceiling <= 1 else R(ceiling - 1, result)

Fold:

def F(function, initial, rest):
    result = function(initial, rest[0])
    return F(function, result, rest[1:] if len(rest) > 1 else result

Table:

def T(function, iterator, current=None, result=None):
    if current is None:
        current = iterator[0]
        result = []
    result.append(function(current))
    return T(function, iterator, current + 1, result) if current < iterator[1] else result

নীচের সহায়ক ফাংশনগুলি ব্যবহার করে এখানে নমুনা আউটপুট দেওয়া হচ্ছে:

square = lambda x: x * x
def add(*args):
    addTwo = lambda a, b: a + b
    if len(args) == 1 and type(args[0]) is list:
        return F(addTwo, 0, args[0])
    else:
        return F(addTwo, 0, args)

>>> M(square, R(10))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> M(add, [R(i) for i in R(10)])
[1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
>>> T(square, [0, 10])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> N(square, 2, 4)
65536
>>> N(lambda *args: F(lambda a, b: a * b, 1, args) if len(args) > 1 else str(args[0]) + 'a', R(5), 10)
'120aaaaaaaaa'

— sadakatsu
সূত্র

বাহ, দেখতে অনেক সুন্দর!

— উইজার্ডঅফমেন্লো

এটিকে নন্দনতত্ত্বের তীব্র বোধের মতো মনে হয়; ) আমি পড়া প্রথম পাইথন বইটি যেহেতু পাইথন কীভাবে পাঠ্যতা কার্যকর করে তোলে তা নিয়ে কথা বলে আমি সর্বদা গল্ফ পাইথনটি দেখতে আকর্ষণীয় মনে করি।

— সদাকাতসু

আমার কাছে নন্দনতত্ত্বের

— সত্যই ত্রুটি আছে

আমি অন্য লোকদের স্কোর দ্বারা বিভ্রান্ত। আমি প্রয়োজনীয় প্রতিটি ফাংশনের স্কোরের 10% নিয়েছি যা কোনও লুপ ব্যবহার করে না (যা সবকটি ছিল), তবে অন্যান্য লোকেরা প্রতিটি ফাংশনের জন্য পুরো স্কোরের 10% নিয়েছিল যা লুপ ব্যবহার করে না (যা হতে পারে 60% অবধি)। সঠিক পন্থা কোনটি?

— সদাকাতসু

আপনার যাবার সঠিক উপায়, আমার অবাস্তব প্রত্যাশা ছিল এবং তাই প্রাথমিকভাবে আমার মনে হয়েছিল 60% পদ্ধতির কথা, তবে এখন আমি মনে করি যে 10% আরও উত্তেজক হবে এবং দুজনের মধ্যে

— কঠোর হবে

2

সিলোন, 370 * 0.9 = 333 364 * 0.9 = 327.4

সেগুলির বেশিরভাগ ফাংশন ইতিমধ্যে সিলোন এর ভাষা প্যাকেজে পাওয়া যায় (যদিও মাঝে মাঝে কিছুটা আলাদা স্বাক্ষর সহ) তবে আমরা সেগুলিকে এখানে সংজ্ঞায়িত করার মতো সংজ্ঞায়িত করছি।

alias I=>Integer;R[]m<A,R>(R(A)g,A[]l)=>f((R[]x,A y)=>x.append([g(y)]),[],l);A n<A>(A(A)g,A a,I t)=>f((A x,I y)=>g(x),a,r(t));R y<A,R>(Callable<R,A>g,A v)given A satisfies Anything[]=>g(*v);I[]r(I i)=>t((j)=>j,[1,i]);A f<A,O>(A(A,O)g,A a,O[]o)=>if(nonempty o)then f(g,g(a,o[0]),o.rest)else a;R[]t<R>(R(I)g,[I,I]i)=>i[1]<i[0]then[]else[g(i[0]),*t(g,[i[0]+1,i[1]])];

প্রকৃতপক্ষে কেবল দুটি ফাংশন ( tএবং f) প্রকৃতপক্ষে পুনরাবৃত্তি (তালিকাগুলি এবং পূর্ণসংখ্যার উপর যথাক্রমে) ব্যবহার করছে, অন্যগুলি এর উপর ভিত্তি করে। (প্রয়োগ হ'ল কিছুটা আউটলার, এটি অন্যের সাথে সত্যিই সম্পর্কিত নয়))

আমি "তালিকা "টিকে সিলোন এর সিক্যুয়ালিয়াল টাইপ হিসাবে ব্যাখ্যা করি, যা একটি স্থাবর অর্ডার (সম্ভবত খালি) উপাদানগুলির ক্রম। [R*]এর অর্থ দাঁড়ায় Sequential<R>- কোনও কারণে আমরা R[]এটিকেও লিখতে পারি , যা এক বাইট ছোট।

একটি ফাংশন টাইপ Callable<R, A>, যেখানে Aআর্গুমেন্টগুলির জন্য একটি টিপল টাইপ [X, Y, Z](যেমন কিছু উপ-প্রকার Anything[])। একটি শর্টকাট হিসাবে আমরা R(X,Y,Z)পরিবর্তে লিখতে পারেন Callable<R,[X,Y,Z]>।

আমি ওরফে Integerযেমন Iকিছু বাইট সংরক্ষণ করুন।

এখানে একটি ফর্ম্যাট করা (এবং কিছুটা মন্তব্য করা) সংস্করণ রয়েছে:

// implement functional paradigms
//
// Question: http://codegolf.stackexchange.com/q/58588/2338
// My Answer: http://codegolf.stackexchange.com/a/64515/2338

alias I => Integer;

// map – based on fold.
R[] m<A, R>(R(A) g, A[] l) =>
        f((R[]x,A y) => x.append([g(y)]), [], l);

// nest – based on fold + range, throwing away the second
//        argument in a proxy function.
A n<A>(A(A) g, A a, I t) =>
        f((A x, I y) => g(x), a, r(t));

// apply – this looks quite heavy due to type safety.
//         This uses the "spread operator" *.
R y<A, R>(Callable<R,A> g, A v)
        given A satisfies Anything[] =>
        g(*v);

// range – based on table (using the identity function)
I[] r(I i) =>
        t((j) => j, [1, i]);

// fold – a plain list recursion.
A f<A, O>(A(A, O) g, A a, O[] o) =>
        if (nonempty o) then f(g, g(a, o[0]), o.rest) else a;

// table – an integer recursion.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        i[1] < i[0] then [] else [g(i[0]), *t(g, [i[0] + 1, i[1]])];

"লুপস" ব্যবহার

টেবিল এবং মানচিত্র লুপগুলি ব্যবহার করে আরও খাটো প্রয়োগ করা যেতে পারে (আসলে, একটি ক্রম বোঝা):

// map – using a sequence comprehension:
R[] m<A, R>(R(A) g, A[] l) =>
        [for(a in l) g(a)];

// table – map with an integer range.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        m(g, i[0]..i[1]);

যদিও আমি নিশ্চিত নই যে পূর্ণসংখ্যা ব্যাপ্তির জন্য ..অপারেটরের ব্যবহার একটি অন্তর্নির্মিত ফাংশনটি হিসাবে গণনা করা হয়েছে। যদি এটি অনুমোদিত হয় তবে ফলাফল কোডটি এখানে 312 দৈর্ঘ্য:

alias I=>Integer;R[]m<A,R>(R(A)g,A[]l)=>[for(a in l)g(a)];A n<A>(A(A)g,A a,I t)=>f((A x,I y)=>g(x),a,r(t));R y<A,R>(Callable<R,A>g,A v)given A satisfies Anything[]=>g(*v);I[]r(I i)=>t((j)=>j,[1,i]);A f<A,O>(A(A,O)g,A a,O[]o)=>if(nonempty o)then f(g,g(a,o[0]),o.rest)else a;R[]t<R>(R(I)g,[I,I]i)=>m(g,i[0]..i[1]);

(এটি সংজ্ঞায়িত করে আরও ছোট করা যেতে পারে r(I i) => 1..i, যার ফলস্বরূপ 301 স্কোর score যদিও এটি আরও প্রতারণার মতো দেখায় looks)

যদি ..অনুমতি না পায় তবে আমাদের আবার এটি প্রয়োগ করতে হবে। আমরা এই প্রয়োগগুলি ব্যবহার করতে পারি rএবং t( mউপরের সাথে):

// range – based two-limit range 
I[] r(I i) =>
        q(1, i);

// two-limit range implemented recursively
I[] q(I i, I j) =>
        j < i then [] else [i, *q(i + 1, j)];


// table – map with an integer range.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        m(g, q(i[0], i[1]));

এটি 348 বাইটে প্রাপ্ত হয়, সম্পূর্ণ পুনরাবৃত্ত সংস্করণের চেয়ে ভাল তবে বোনাস প্রয়োগের পরে নয়।

— পাওলো ইবারম্যান
সূত্র

0

গ্রোভি (146 বাইট) (146 * 90% = 131.4)

পিএস আমি জানি না আপনি এই প্রসঙ্গে 'লুপ' হিসাবে কী বিবেচনা করছেন, আমি কেবল ওপি কর্তৃক আমার মন্তব্যে বলার পরে বোনাসটি প্রয়োগ করেছি এবং যদি অতিরিক্ত 2-3 জন ব্যবহারকারী এই সংগ্রহের কাজগুলি এবং পুনরাবৃত্তি বলে তবে আমি সরিয়ে ফেলব লুপ হয় এবং আমি বোনাস প্রাপ্য না। এছাড়াও, আপনি যদি আমার 1..it ব্যবহারের জন্য আমাকে কল করতে চান তবে দয়া করে এটি করুন এবং আমি এটি পুনরায় কাজ করব / আমার বাইটোকন্ট আপডেট করব।

m={f,l->l.collect{f(it)}}            // Map
n={f,x,n->n.times{x=f(x)};x}         // Nest
a={f,l->f(l)}                        // Apply
r={1..it}                            // Range (Is this cheating?)
f={f,x,l->l.each{x=f(x,it)};x}       // Fold
t={f,l->(l[0]..l[1]).collect{f(it)}} // Table

উদাহরণ ইনপুট / আউটপুট

f1={2*it}
f2={a,b,c,d,e->a*b*c*d*e}
f3={a,b->a*b}
l=[1,2,3,4,5]
l2=[1,9]
y=5
x=1
println m(f1,l)
println n(f1,x,y)
println a(f2,l)
println r(y)
println f(f3,x,l)
println t(f1,l2)

আউটপুট

MAP:   [2, 4, 6, 8, 10]
NEST:  32
APPLY: 120
RANGE: [1, 2, 3, 4, 5]
FOLD:  120
TABLE: [2, 4, 6, 8, 10, 12, 14, 16, 18]

নিজে চেষ্টা করে দেখুন: https://groovyconsole.appspot.com/edit/5203951758606336

— ম্যাজিক অক্টোপাস উরন
সূত্র

এই প্রযুক্তিগতভাবে লুপ ব্যবহার করে না, তাই বোনাস মনে রাখবেন! অন্যথায়, দুর্দান্ত উত্তর!

— উইজার্ডঅফমেনলো

প্রযুক্তিগতভাবে কোন লুপ নেই ?! সত্যি ?! .আচ {} .টাইমস {ol .কলেক্ট {} পুনরাবৃত্ত হয়।

— ম্যাজিক অক্টোপাস উরান

ক্রিয়ামূলক প্রোগ্রামিং প্যারাডিমগুলি প্রয়োগ করুন

মানচিত্র

নীড়

প্রয়োগ করা

পরিসর

ভাঁজ

টেবিল

হাস্কেল, আগের অনেকগুলি বাইট 127 * 0.9 = 114.3 বাইট গণনা করে

পাইথন 2, 305.1 বাইট (-10% 376 369 366 349 339 বাইট)

জাভাস্ক্রিপ্ট ES6, 197 * 0.9 = 177.3 বাইট

মানচিত্র ( M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)):

নীড় ( N=(f,x,n)=>f(--n?N(f,x,n):x)):

প্রয়োগ করুন ( A=(f,l)=>f(...l)):

পরিসর ( R=n=>n--?[...R(n),n+1]:[]):

ভাঁজ ( F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x):

টেবিল ( T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))):

পাইথন 3, 218 বাইট

মানচিত্র ফাংশন P

বাসা ফাংশন Y

ফাংশন প্রয়োগ করুন T

ব্যাপ্তি ফাংশন H

ভাঁজ ফাংশন O

টেবিল ফাংশন N

জুলিয়া, 181 বাইট

টিনাইলিস্প , 325 * 0.9 = 292.5

নমুনা আউটপুট

পাইথন 2.x: 450.6 বাইট (10% ছাড়ের আগে 493 বাইট)

সিলোন, 370 * 0.9 = 333 364 * 0.9 = 327.4

"লুপস" ব্যবহার

গ্রোভি (146 বাইট) (146 * 90% = 131.4)

উদাহরণ ইনপুট / আউটপুট

আউটপুট

মানচিত্র ( `M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)`):

নীড় ( `N=(f,x,n)=>f(--n?N(f,x,n):x)`):

প্রয়োগ করুন ( `A=(f,l)=>f(...l)`):

পরিসর ( `R=n=>n--?[...R(n),n+1]:[]`):

ভাঁজ ( `F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x`):

টেবিল ( `T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))`):

মানচিত্র ফাংশন `P`

বাসা ফাংশন `Y`

ফাংশন প্রয়োগ করুন `T`

ব্যাপ্তি ফাংশন `H`

ভাঁজ ফাংশন `O`

টেবিল ফাংশন `N`