অন্ধ বাইনারি সংযোজক


10

কল্পনা করুন আপনার দুটি বাক্স রয়েছে B(x)এবং B(y)প্রত্যেকটিতে একটি অজানা বিট রয়েছে - 0 বা 1 এবং এমন একটি মেশিন Fযা সেগুলিকে এক্স-রে করতে পারে এবং B(x^y)( জোর ) এর জন্য একটি তৃতীয় বাক্স তৈরি করতে পারে । ( এবং ) F গণনা করতে পারে । প্রকৃতপক্ষে, মেশিনগুলি যে একক ক্রিয়াকলাপটি সম্পাদন করতে পারে তার কেবলমাত্র বিশেষ ঘটনা - প্রতিটি অভ্যন্তর পণ্য , নীচে দিয়ে বোঝানো।B(x*y)F()

দুটি একই দৈর্ঘ্যের অ্যারে

[B(x[0]), B(x[1]), ..., B(x[n-1])]
[B(y[0]), B(y[1]), ..., B(y[n-1])]

অভ্যন্তরীণ পণ্য হিসাবে সংজ্ঞায়িত করা হয়

B(x[0]*y[0] ^ x[1]*y[1] ^ ... ^ x[n-1]*y[n-1])

" প্রতিটি " অর্থ F()একাধিক জোড়া প্রক্রিয়া করতে পারি x[], y[]এক বারেই। x[]এবং y[]এক জোড়া থেকে একই দৈর্ঘ্যের হতে হবে; x[]-s এবং y[]-s বিভিন্ন জোড়া থেকে অগত্যা প্রয়োজন হয় না।

বাক্সগুলি অনন্য পূর্ণসংখ্যার আইডি দ্বারা প্রতিনিধিত্ব করা হয়।

জাভাস্ক্রিপ্ট প্রতিটি অভ্যন্তরীণ পণ্য একটি বাস্তবায়ন এর মত দেখতে হতে পারে

var H=[0,1];          // hidden values, indexed by boxId
function B(x) {       // seal x in a new box and return the box id
  return H.push(x)-1;
}
function F(pairs) {   // "inner product each"
  return pairs.map(function (pair) {
    var r = 0, x = pair[0], y = pair[1];
    for (var i = 0; i < x.length; i++) r ^= H[x[i]] * H[y[i]];
    return B(r);
  })
}

(দয়া করে উপরোক্ত আপনার পছন্দমতো ভাষা অনুবাদ করুন।)

F()আপনার ভাষার জন্য উপযুক্ত হিসাবে একটি প্রয়োগকরণে অ্যাক্সেস দেওয়া হয়েছে (তবে কোনও অ্যাক্সেস নেই Hবা নেই B()) এবং দুটি আইডির 16-বিট বাইনারি উপস্থাপনা গঠনের বাক্স আইডির দুটি অ্যারে দেওয়া হয়েছে aএবং b, আপনার কাজটি 16-বিট বাইনারি উপস্থাপনার জন্য বক্স আইডি উত্পাদন করা এর a+bন্যূনতম নম্বর দিয়ে (খারিজ ওভারফ্লো) F()কল।

যে সমাধানটি F()সর্বাধিক সময়কে কল করে তা জয়ী হয়। টাইস মোট সংখ্যা বেড়ে চলেছে দ্বারা ভাঙ্গা হবে x[],y[]জোড়া F()দিয়ে বলা হয় - তার চেয়ে কম উত্তম। এখনও বাঁধা থাকলে, আপনার কোডের আকার (বাস্তবায়ন F()এবং এর সাহায্যকারীদের বাদে ) traditionalতিহ্যবাহী কোড গল্ফ পথে বিজয়ীকে নির্ধারণ করে। আপনার উত্তরের জন্য দয়া করে "মাই ল্যাং, 123 কল, 456 জোড়া, 789 বাইট" এর মতো একটি শিরোনাম ব্যবহার করুন।

একটি ফাংশন বা একটি সম্পূর্ণ প্রোগ্রাম লিখুন। ইনপুট / আউটপুট / আর্গুমেন্ট / ফলাফলটি কোনও যুক্তিসঙ্গত বিন্যাসে অন্তর্ভুক্ত অ্যারে হয়। বাইনারি উপস্থাপনা অল্প- বা বড়-এন্ডিয়ান হতে পারে - একটি চয়ন করুন।


পরিশিষ্ট 1: চ্যালেঞ্জটি কিছুটা সহজ করার জন্য, আপনি ধরে নিতে পারেন যে আইডিস 0 এবং 1 সহ বাক্সগুলিতে 0 এবং 1 মান রয়েছে। এটি আপনাকে ধ্রুবক দেয়, উপকারী উদাহরণস্বরূপ উপেক্ষার জন্য ( x^1"নয়")। অবশ্যই ধ্রুবকের অভাবের বিভিন্ন উপায় ছিল অবশ্যই, তবে চ্যালেঞ্জের বাকি অংশগুলি যাইহোক যথেষ্টই শক্ত, তাই আসুন আমরা এই বিভ্রান্তি দূর করি।


পরিশিষ্ট 2: অনুগ্রহ অর্জন করতে, আপনাকে নিম্নলিখিতগুলির একটি করতে হবে:

  • আপনার স্কোর (কল, জোড়, বাইট) এবং আপনার কোডটি সময়সীমার আগে পোস্ট করুন

  • সময়সীমার আগে আপনার স্কোর এবং আপনার কোডের একটি শ 256 হ্যাশ পোস্ট করুন; তারপরে সময়সীমার 23 ঘন্টা পরে আসল কোডটি পোস্ট করুন


যদি আমি এটি আমার পছন্দের ভাষায় (হাস্কেল) অনুবাদ করি তবে আমি মান পুনরাবৃত্তি ব্যবহার করতে এবং Fকেবল একবার কল করতে পারি । এটি অবশ্যই প্রতারণা করবে, তবে আমি নিশ্চিত নই যে এটি ভাল প্রতারণা বা খারাপ প্রতারণা হবে কিনা I'm
খ্রিস্টান সিভর্স

আমি জানি যে হ্যাশকেলে বৈশ্বিক রাষ্ট্র স্বাগত নয়, তবে আমাকে এটি একটি চিন্তার পরীক্ষা হিসাবে জিজ্ঞাসা করুন: আমি যদি এফ বাস্তবায়নে কোনও বৈশ্বিক কাউন্টার বাড়িয়েছি, তবে শেষ পর্যন্ত এটি কতটা বৃদ্ধি পেয়েছে? - এটি "কলগুলির সংখ্যা" সম্পর্কে আমার বোঝাপড়া।
এনজিএন

আমি ঠিক এটি করতে পারি, এবং এটি বলবে 1। তবে এটি আপনার কোড ব্যবহার করে জাভাস্ক্রিপ্টে ফিরে অনুবাদ করা যায়নি। মূলত আমি বলি y=f(x)এবং xউপর নির্ভর করি y
খ্রিস্টান সিভর্স

আমি ভয় করি আমি বুঝতে পারি না কীভাবে এটি কাজ করবে। আপনি কি নমুনা কোড দেখাতে পারেন? আমার হাস্কেল দরিদ্র, তবে আমি নিশ্চিত যে কোডটি নিয়ে খেলতে পারলে আমি এটি নির্ধারণ করতে পারি।
এনজিএন

সম্ভবত আমরা এই সমস্যার মডেল করতে নিম্নলিখিত ধরণের ব্যবহার করতে পারি? data Box = B Int deriving (Show); f :: [[[Box]]] -> [Box]কীভাবে প্রয়োগ করতে হবে তা নির্ধারণ করার জন্য আমার আরও সময় প্রয়োজন f(হাস্কেল এখানে ছোট হাতের চাপ প্রয়োগ করে ) - আমি আগামীকাল এটি চেষ্টা করব।
এনজিএন

উত্তর:


6

পাইথন 3 , 5 কল, 92 জোড়া, 922 বাইট

পাইথন 3 , 5 কল, 134 জোড়া, 3120 বাইট

পাইথন 3 , 6 কল, 106 জোড়া, 2405 বাইট

[জাভাস্ক্রিপ্ট (নোড.জেএস)], 9 টি কল, 91 জোড়া, 1405 বাইট

জাভাস্ক্রিপ্ট (নোড.জেএস), 16 কল, 31 জোড়া, 378 বাইট

def add(F,a,b):r=[];p=lambda x:(x,x);q=lambda u,v,t:([u,v]+t[0],[u,v]+t[1]);s=lambda c,k,n:([e[j][n]for j in range(k,-1,-1)]+[f[n]],[c]+f[n-k:n+1]);t=lambda c,k,n:q(a[n],b[n],s(c,k,n-1));z=F([p([a[i],b[i]])for i in range(16)]+[([a[i]],[b[i]])for i in range(16)]);e=[z[0:16]];f=z[16:32];r+=[e[0][0]];c=f[0];z=F([p([a[1],b[1],c]),([e[0][1],f[1]],[c,f[1]])]+[([e[0][i]],[e[0][i-1]])for i in range(3,16)]);r+=[z[0]];c=z[1];e+=[[0]*3+z[2:15]];z=F([p([a[2],b[2],c]),t(c,0,3),s(c,1,3)]+[([e[j][i]],[e[1][i-j-1]])for j in range(2)for i in range(6+j,16)]);r+=z[0:2];c=z[2];e+=u(2,4,z[3:]);z=F([p([a[4],b[4],c])]+[t(c,i,i+5)for i in range(0,3)]+[s(c,3,7)]+[([e[j][i]],[e[3][i-j-1]])for j in range(4)for i in range(12+j,16)]);r+=z[0:4];c=z[4];e+=u(4,8,z[5:]);z=F([p([a[8],b[8],c])]+[t(c,i,i+9) for i in range(0,7)]);return r+z
def u(b,e,z):
	j=0;w=[0]*(e-b)
	for i in range(b,e):w[i-b]=[0]*(i+e)+z[j:j+16-(i+e)];j+=16-(i+e)
	return w

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

প্রথম সংস্করণ ঠিক আছে যে গল্ফ হয় না। এটি কেবলমাত্র @Ngn এর কোডের একটি অভিযোজন।

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

সম্পাদনা : এখনও গল্ফ না। জোড়ের সংখ্যা অবশ্যই হ্রাস পেতে পারে, এবং সম্ভবত কলগুলির সংখ্যাও। সিম্পির সাথে একটি "প্রমাণ" পাওয়ার জন্য https://gist.github.com/jferard/864f4be6e4b63979da176bff380e6c62 দেখুন ।

2 সম্পাদনাটি পাইথনে স্যুইচ করা হয়েছে কারণ এটি আমার পক্ষে আরও পঠনযোগ্য। এখন আমি সাধারণ সূত্রটি পেয়েছি, আমি মনে করি আমি 5 (সম্ভবত 4) কলের সীমাতে পৌঁছে যেতে পারি।

সম্পাদনা 3 এখানে প্রাথমিক ইট রয়েছে:

alpha[i] = a[i] ^ b[i]
beta[i] = a[i] * b[i]
c[0] = beta[0]
r[0] = alpha[0]

সাধারণ সূত্রটি হ'ল:

c[i] = alpha[i]*c[i-1] ^ beta[i]
r[i] = a[i] ^ b[i] ^ c[i-1]

প্রসারিত সংস্করণটি হ'ল:

c[0] = beta[0]
c[1] = alpha[1]*beta[0] ^ beta[1]
c[2] = alpha[2]*alpha[1]*beta[0] ^ alpha[2]*beta[1] ^ beta[2]
c[3] = alpha[3]*alpha[2]*alpha[1]*beta[0] ^ alpha[3]*alpha[2]*beta[1] ^ alpha[3]*beta[2] ^ beta[3]
...
c[i] = alpha[i]*...*alpha[1]*beta[0] ^ alpha[i]*...*alpha[2]*beta[1] ^ .... ^ alpha[i]*beta[i-1] ^ beta[i]

5 টি কল আমার জন্য সীমাবদ্ধ বলে মনে হচ্ছে। এখন জোড়গুলি সরানোর এবং এটি গল্ফ করার জন্য আমার একটু কাজ আছে!

4 সম্পাদনা করুন আমি এটিকে গল্ফ করেছি।

অবরুদ্ধ সংস্করণ:

def add(F, a, b):
    r=[]
    # p is a convenient way to express x1^x2^...x^n
    p = lambda x:(x,x)
    # q is a convenient way to express a[i]^b[i]^carry[i-1]
    q = lambda u,v,t:([u,v]+t[0],[u,v]+t[1])

    # step1: the basic bricks
    z=F([p([a[i],b[i]]) for i in range(16)]+[([a[i]],[b[i]]) for i in range(16)])
    alpha=z[0:16];beta=z[16:32]
    r.append(alpha[0])
    c = beta[0]

    # step 2
    z=F([
        p([a[1],b[1],c]),
        ([alpha[1],beta[1]],[c,beta[1]])
        ]+[([alpha[i]],[alpha[i-1]]) for i in range(3,16)])
    r.append(z[0])
    c = z[1] # c[1]
    alpha2=[0]*3+z[2:15]
    assert len(z)==15, len(z)

    # step 3
    t0=([alpha[2],beta[2]],[c,beta[2]])
    t1=([alpha2[3],alpha[3],beta[3]],[c,beta[2],beta[3]])
    z=F([
        p([a[2],b[2],c]),
        q(a[3],b[3],t0),
        t1]+
        [([alpha[i]],[alpha2[i-1]]) for i in range(6,16)]+
        [([alpha2[i]],[alpha2[i-2]]) for i in range(7,16)])
    r.extend(z[0:2])
    c = z[2] # c[3]
    alpha3=[0]*6+z[3:13]
    alpha4=[0]*7+z[13:22]
    assert len(z)==22, len(z)

    # step 4
    t0=([alpha[4],beta[4]],[c,beta[4]])
    t1=([alpha2[5],alpha[5],beta[5]],[c,beta[4],beta[5]])
    t2=([alpha3[6],alpha2[6],alpha[6],beta[6]],[c,beta[4],beta[5],beta[6]])
    t3=([alpha4[7],alpha3[7],alpha2[7],alpha[7],beta[7]],[c,beta[4],beta[5],beta[6],beta[7]])
    z=F([
        p([a[4],b[4],c]),
        q(a[5],b[5],t0),
        q(a[6],b[6],t1),
        q(a[7],b[7],t2),
        t3]+
        [([alpha[i]],[alpha4[i-1]]) for i in range(12,16)]+
        [([alpha2[i]],[alpha4[i-2]]) for i in range(13,16)]+
        [([alpha3[i]],[alpha4[i-3]]) for i in range(14,16)]+
        [([alpha4[i]],[alpha4[i-4]]) for i in range(15,16)])
    r.extend(z[0:4])
    c = z[4] # c[7]
    alpha5 = [0]*12+z[5:9]
    alpha6 = [0]*13+z[9:12]
    alpha7 = [0]*14+z[12:14]
    alpha8 = [0]*15+z[14:15]
    assert len(z) == 15, len(z)

    # step 5
    t0=([alpha[8],beta[8]],[c,beta[8]])
    t1=([alpha2[9],alpha[9],beta[9]],[c,beta[8],beta[9]])
    t2=([alpha3[10],alpha2[10],alpha[10],beta[10]],[c,beta[8],beta[9],beta[10]])
    t3=([alpha4[11],alpha3[11],alpha2[11],alpha[11],beta[11]],[c,beta[8],beta[9],beta[10],beta[11]])
    t4=([alpha5[12],alpha4[12],alpha3[12],alpha2[12],alpha[12],beta[12]],[c,beta[8],beta[9],beta[10],beta[11],beta[12]])
    t5=([alpha6[13],alpha5[13],alpha4[13],alpha3[13],alpha2[13],alpha[13],beta[13]],[c,beta[8],beta[9],beta[10],beta[11],beta[12],beta[13]])
    t6=([alpha7[14],alpha6[14],alpha5[14],alpha4[14],alpha3[14],alpha2[14],alpha[14],beta[14]],[c,beta[8],beta[9],beta[10],beta[11],beta[12],beta[13],beta[14]])
    t7=([alpha8[15],alpha7[15],alpha6[15],alpha5[15],alpha4[15],alpha3[15],alpha2[15],alpha[15],beta[15]],[c,beta[8],beta[9],beta[10],beta[11],beta[12],beta[13],beta[14],beta[15]])

    z=F([
        p([a[8],b[8],c]),
        q(a[9],b[9],t0),
        q(a[10],b[10],t1),
        q(a[11],b[11],t2),
        q(a[12],b[12],t3),
        q(a[13],b[13],t4),
        q(a[14],b[14],t5),
        q(a[15],b[15],t6)
    ])
    r.extend(z)
    return r

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


খুব ভাল :) আপনি দুটি সহজ অপটিমাইজেশন পেয়েছি যা আমি উদ্দেশ্য করে রেখেছিলাম। "আমি সন্দেহ করি আপনি जोडগুলির সংখ্যা উল্লেখযোগ্যভাবে হ্রাস করতে পারবেন" - নোট করুন যে জয়ের প্রথম মানদণ্ডটি হল কল করার সংখ্যা F()। আমি গ্যারান্টি দিচ্ছি যে সেগুলি উল্লেখযোগ্যভাবে হ্রাস করার একটি উপায় রয়েছে (এটি এই চ্যালেঞ্জের সবচেয়ে শক্ত অংশ), এবং তারপরে জোড় সংখ্যার অনুকূলকরণের জন্য অবশেষ থাকবে এবং অবশেষে কোডটি গল্ফ করা (তবে এটি সর্বনিম্ন গুরুত্বপূর্ণ মাপদণ্ড)।
ngn

ঠিক আছে, আমি বুঝতে পেরেছি! আজ না হোক কাল, আপনি যে ভালো কিছু করেছেন: ... + x * y * z + ...। আমরা Fএটি মূল্যায়ন করতে ব্যবহার করতে পারি না , তবে আমরা যদি x * yআগের Fকলটির সাথে তুলনা করি তবে আমাদের কেবল এটি করতে হবে: ... + (x * y) * z + ...(এটি এর ফর্ম্যাটটির সাথে মেলে F)। সিম্পির সাথে খেলতে, আমি একটি কল ছাড়তে সক্ষম হয়েছি (স্টেপ 1: কমপুট আর 0, সি 0, আর 1; স্টেপ 2: কমপুট সি 1 এবং কিছু অক্স মান; স্টিপি 3: গণনা আর 2, সি 2, আর 3, সি 3), এবং আমি এখন একজন জেনারেলের পক্ষে খুঁজছি সমাধান।
jferard

হ্যাঁ, অন্য কথায়: আউটপুট বিটগুলি ইনপুট বিটগুলিতে 2 এর চেয়ে বেশি ডিগ্রির বহুবচন হয়। অভ্যন্তরীণ পণ্যটি একটি এম-ডিগ্রি এবং এন-ডিগ্রি বহুবর্ষকে এক (এম + এন)-ডিগ্রি বহুপদীতে একত্রিত করতে পারে at তাড়াহুড়া করবেন না - কয়েক ঘন্টার মধ্যে আমি একটি অনুগ্রহ স্থাপন করতে সক্ষম হব :)
ngn

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

2
রেকর্ডের জন্য, পাঁচটিরও কম কল ব্যবহার করা অসম্ভব, যেহেতু সমাধানটির জন্য ডিগ্রি 32 বহুবচন প্রয়োজন। (ইনপুট বিটের কোনও ফাংশনের সাথে সম্পর্কিত
বহুভুজটি

2

হাস্কেল, 1 কল (প্রতারণামূলক ???), 32 জোড়া (উন্নত করা যেতে পারে), 283 বাইট (একই)

দয়া করে আমার সাথে রাগ করবেন না, আমি এটি দিয়ে জিততে চাই না, তবে আমি কী বলছিলাম তা ব্যাখ্যা করার চ্যালেঞ্জের মন্তব্যে আমাকে উত্সাহিত করা হয়েছিল।

আমি বাক্স এবং গণনা কল এবং জোড়গুলিকে সংযোজন করার জন্য রাজ্য মোনাডকে ব্যবহার করার চেষ্টা করেছি এবং এটি কার্যকর হয়েছিল, তবে আমি আমার সেটিংটিতে আমার সমাধানটি কাজ করার ব্যবস্থা করতে পারি নি। সুতরাং আমি মন্তব্যে যা প্রস্তাবিত হয়েছিল তা-ই করেছি: কেবল কোনও ডেটা কনস্ট্রাক্টরের পিছনে ডেটা লুকিয়ে রাখুন এবং উঁকি দেবেন না। (পরিষ্কার উপায়টি হ'ল কোনও পৃথক মডিউল ব্যবহার করা হবে এবং নির্মাণকারীর রফতানি না করা হবে)) এই সংস্করণটি আরও সহজ হওয়ার সুবিধা রয়েছে।

যেহেতু আমরা বিটের বাক্সগুলির বিষয়ে কথা বলছি, আমি Boolতাদের মধ্যে মান রেখেছি । আমি zeroশূন্য বিট সহ প্রদত্ত বাক্স হিসাবে সংজ্ঞায়িত করি - একটি oneপ্রয়োজন হয় না।

import Debug.Trace

data B = B { unB :: Bool }

zero :: B
zero = B False

f :: [([B],[B])] -> [B]
f pairs =  trace ("f was called with " ++ show (length pairs) ++ " pairs") $
           let (B i) &&& (B j) = i && j
           in map (\(x,y) ->  B ( foldl1 (/=) (zipWith (&&&) x y))) pairs

আমরা traceকতবার fডাকা হয়েছিল এবং কতগুলি জোড় যুক্ত রয়েছে তা দেখতে আমরা ডিবাগিং ফাংশনটি ব্যবহার করছি । &&&প্যাটার্ন মিলের সাহায্যে বাক্সগুলিতে /= তাকান, Boolমানগুলিতে ব্যবহৃত অসমতা xor

bits :: Int -> [Bool]
bits n = bitsh n 16
  where bitsh _ 0 = []
        bitsh n k = odd n : bitsh (n `div` 2) (k-1)

test :: ( [B] -> [B] -> [B] ) -> Int -> Int -> Bool
test bba n m = let x = map B (bits n)
                   y = map B (bits m)
                   r = bba x y
                   res = map unB r
               in res==bits(n+m)

testফাংশন প্রথম আর্গুমেন্ট হিসাবে একটি অন্ধ বাইনারি যোজক লাগে, এবং তারপর দুটি সংখ্যার যার জন্য উপরন্তু পরীক্ষা করা হয়। এটি Boolপরীক্ষাটি সফল হয়েছিল কিনা তা সূচিত করে returns প্রথমে ইনপুট বাক্সগুলি তৈরি করা হয়, তারপরে সংযোজককে বলা হয়, ফলাফলটি আনবক্সড (সাথে unB) হয় এবং প্রত্যাশিত ফলাফলের সাথে তুলনা করা হয়।

আমি দুটি সংযোজকগুলির নমুনা সমাধান প্রয়োগ করেছিলাম simpleযাতে আমরা দেখতে পাই যে ডিবাগ আউটপুটটি সঠিকভাবে কাজ করে এবং মান পুনরাবৃত্তি ব্যবহার করে আমার সমাধান valrec

simple a b = let [r0] = f [([a!!0,b!!0],[a!!0,b!!0])]
                 [c]  = f [([a!!0],[b!!0])]
             in loop 1 [r0] c
             where loop 16 rs _ = rs
                   loop i  rs c = let [ri] = f [([a!!i,b!!i,c],[a!!i,b!!i,c])]
                                      [c'] = f [([a!!i,b!!i,c],[b!!i,c,a!!i])]
                                  in loop (i+1) (rs++[ri]) c'

valrec a b =
    let res = f (pairs res a b)
    in [ res!!i | i<-[0,2..30] ]
  where pairs res a b =
           let ts = zipWith3 (\x y z -> [x,y,z])
                             a b (zero : [ res!!i | i<-[1,3..29] ]) in
           [ p | t@(h:r) <- ts, p <- [ (t,t), (t,r++[h]) ] ]

আমি resনিজের শর্তে কীভাবে সংজ্ঞা দিচ্ছি ? এটি গিঁট বেঁধে নামেও পরিচিত ।

এখন আমরা দেখতে পাচ্ছি যে কীভাবে fকেবল একবার ডাকা হয়:

*Main> test valrec 123 456
f was called with 32 pairs
True

বা প্রতিস্থাপন valrecদ্বারা simpleদেখতে f32 বার বলা হচ্ছে।

এটি অনলাইন চেষ্টা করুন! (ট্রেসিং আউটপুট "ডিবাগ" এর অধীনে প্রদর্শিত হবে)


এখানে কোনও রাগ নেই :) সুতরাং, আমি যদি সঠিকভাবে বুঝতে পারি তবে যুক্তিটি fএকটি অলস, সম্ভাব্য অসীম তালিকা যা এর মাধ্যমে পুনরাবৃত্তি হওয়ার সাথে সাথে ঘটে? আমি আশঙ্কা করি যে এটি চ্যালেঞ্জের i+1চেতনাবিরোধী - এটি আপনাকে -২০ তম অনুসারে ফলাফল প্রাপ্তির পরে -st যুক্তি হিসাবে কী পাস হবে সে সম্পর্কে সিদ্ধান্ত স্থগিত করতে দেয় ifপুরোপুরি বাস্তবায়িত, অবিচ্ছেদ্য যুক্তি দিয়ে আপনার কতগুলি কল প্রয়োজন তা জানতে আরও বেশি আকর্ষণীয় :)
এনজিএন

আমি রাজী. @ জেফেরার্ড আশ্চর্যজনক কাজ করেছেন যা এ জাতীয় কৌশল দ্বারা অবৈধ হওয়া উচিত নয়। fঅসীম ইনপুট নেওয়ার সময় (অসীম বিট স্ট্রিম যোগ করুন, হ্যাঁ!), এটি বিন্দু নয়। ওহ, এবং প্রকৃতপক্ষে traceবার্তাটি নিশ্চিত করে যে দৈর্ঘ্য সীমাবদ্ধ এবং শুরুতে এটি পরিচিত। এছাড়াও, আমি এটাও বলব না যে একটি স্থগিত সিদ্ধান্ত রয়েছে: সময়ের আগেই সবকিছু পরিকল্পনা করা হয়েছিল, যেমন দাবি করা হয়েছিল আমি ঠিক অন্ধভাবে বাক্সগুলিকে বদল করছি। এবং নোট করুন এটি আর্গুমেন্টের ক্রম সম্পর্কে নয়: আমি এটিকে পরিবর্তন করতে পারলাম যাতে resপ্রথমে ফলাফল এবং তারপরে ক্যারি বিট থাকে।
খ্রিস্টান সিভর্স

"আমি কেবল অন্ধভাবে বাক্সগুলি বদলে চলেছি" - মনে করুন আপনি কলিং থেকে কোনও বাক্স পেয়েছেন f; আপনি কি সেই কলটিকে একই কলটিতে অন্য যুক্তি হিসাবে খাওয়াবেন f?
এনজিএন

হ্যাঁ আমি করেছি. মান পুনরাবৃত্তি সব কি এটি। আপনার অধিকার ছিল: এটি অলসতা এবং সত্য যে আমি যুক্তিগুলি ব্যবহার করতে পারি যা পুরোপুরি বাস্তবায়িত হয় না (আমি সেই বিবরণটি পছন্দ করি)। চ্যালেঞ্জের সুস্পষ্ট চেতনা দেওয়া, এটি - যেমন ঘোষণা করা হয়েছে - স্পষ্টভাবে প্রতারণা করছে। যদি কেউ মনে করেন এটি উদ্ভাবক বা লক্ষণীয়, কেউ যুক্তি দিতে পারে যে এটি ভাল প্রতারণা।
খ্রিস্টান সিভর্স

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

0

জাভাস্ক্রিপ্ট, 32 কল, 32 জোড়া, 388 বাইট

ডায়ালগ এপিএল, 32 কল, 32 জোড়া, 270 বাইট

এটি একটি নিষ্পাপ নমুনা সমাধান যা একটি টেম্পলেট হিসাবে পরিবেশন করতে পারে।

নোট করুন যে বাইট কাউন্টে অবশ্যই "বিগিন / এন্ড সলিউশন" দিয়ে ঘেরা অংশটি অন্তর্ভুক্ত থাকতে হবে।

ব্যাখ্যা:

আমি লিটল-এন্ডিয়ান বিট অর্ডারটি বেছে নিয়েছি ( x[0]এটি সর্বনিম্ন গুরুত্বপূর্ণ বিট)।

লক্ষ্য করুন যে একক-বিট সংযোজন মোড 2 হিসাবে উপলব্ধ করা যেতে পারে F([[[x,y],[x,y]]])(যা: x*x ^ y*y- গুণন মোড 2 আদর্শবান) এবং বাইনারি গুণিত হিসাবে F([[[x],[y]]])

আমরা বিটগুলি কমপক্ষে তাত্পর্যপূর্ণ থেকে অত্যন্ত তাৎপর্যপূর্ণ এবং প্রতিটি ধাপে একটি ফলাফল বিট এবং একটি ক্যারি গণনা করি।

#!/usr/bin/env node
'use strict'
let H=[0,1]
,B=x=>H.push(x)-1
,nCalls=0
,nPairs=0
,F=pairs=>{
  nCalls++;nPairs+=pairs.length
  return pairs.map(([x,y])=>{let s=0;for(let i=0;i<x.length;i++)s^=H[x[i]]*H[y[i]];return B(s)})
}

// -----BEGIN SOLUTION-----
var f=(a,b)=>{
  var r=[], c // r:result bits (as box ids), c:carry (as a box id)
  r[0]=F([[[a[0],b[0]],[a[0],b[0]]]])          // r0 = a0 ^ b0
  c=F([[[a[0]],[b[0]]]])                       // c = a0*b0
  for(var i=1;i<16;i++){
    r.push(F([[[a[i],b[i],c],[a[i],b[i],c]]])) // ri = ai ^ bi ^ c
    c=F([[[a[i],b[i],c],[b[i],c,a[i]]]])       // c = ai*bi ^ bi*c ^ c*ai
  }
  return r
}
// -----END SOLUTION-----

// tests
let bits=x=>{let r=[];for(let i=0;i<16;i++){r.push(x&1);x>>=1}return r}
,test=(a,b)=>{
  console.info(bits(a))
  console.info(bits(b))
  nCalls=nPairs=0
  let r=f(bits(a).map(B),bits(b).map(B))
  console.info(r.map(x=>H[x]))
  console.info('calls:'+nCalls+',pairs:'+nPairs)
  console.assert(bits(a+b).every((x,i)=>x===H[r[i]]))
}

test(12345,6789)
test(12,3)
test(35342,36789)

ডায়ালগ এপিএলে একই (তবে এলোমেলো বক্স আইডস ব্যবহার করে):

⎕io←0⋄K←(V←⍳2),2+?⍨1e6⋄B←{(V,←⍵)⊢K[≢V]}⋄S←0⋄F←{S+←1,≢⍵⋄B¨2|+/×/V[K⍳↑⍉∘↑¨⍵]}
⍝ -----BEGIN SOLUTION-----
f←{
  r←F,⊂2⍴⊂⊃¨⍺⍵        ⍝ r0 = a0 ^ b0
  c←⊃F,⊂,¨⊃¨⍺⍵        ⍝ c = a0*b0
  r,⊃{
    ri←⊃F,⊂2⍴⊂⍺⍵c     ⍝ ri = ai ^ bi ^ c
    c⊢←⊃F,⊂(⍺⍵c)(⍵c⍺) ⍝ c = ai*bi ^ bi*c ^ c*ai
    ri
  }¨/1↓¨⍺⍵
}
⍝ -----END SOLUTION-----
bits←{⌽(16⍴2)⊤⍵}
test←{S⊢←0⋄r←⊃f/B¨¨bits¨⍺⍵
      ⎕←(↑bits¨⍺⍵)⍪V[K⍳r]⋄⎕←'calls:' 'pairs:',¨S
      (bits⍺+⍵)≢V[K⍳r]:⎕←'wrong!'}
test/¨(12345 6789)(12 3)(35342 36789)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.