ন্যানড লজিক গেটগুলি ব্যবহার করে একটি বিট-কাউন্টিং তুলক তৈরি করুন

Question

একটি বিট-কাউন্টিং comparator (বিসিসি) একটি যুক্তিবিজ্ঞান সার্কিট যে কাউন্টিং ইনপুট কিছু সংখ্যা লাগে A1, A2, A3, ..., Anসেইসাথে ইনপুট B1, B2, B4, B8, ...একটি সংখ্যা উপস্থাপন করে। তখনই আয় 1মোট সংখ্যা যদি Aযে হয় ইনপুট চেয়ে বড় সংখ্যা দ্বারা বাইনারি প্রতিনিধিত্ব করা হয় Bইনপুট (যেমন B1, B2এবং B8সংখ্যা হবে 11), এবং 0অন্যথায়।

উদাহরণস্বরূপ, একটি বিট-কাউন্টিং comparator যে লাগে জন্য 5, ইনপুট যার A2, A4, A5, এবং B2সেট করা হয় 1, ফিরে আসবে 1কারণ 3 Aইনপুট যে, যা তার চেয়ে অনেক বেশী 2(নম্বর শুধুমাত্র দ্বারা প্রতিনিধিত্ব B2হওয়ার)।

আপনার কাজটি হ'ল একটি বিট-কাউন্টিং তুলনাকারী তৈরি করা যা মোট 16 Aইনপুট এবং 4 Bইনপুট নেয় (এতে বিটগুলি উপস্থাপন 1করে 8), কেবল দুটি ইনপুট ন্যানড গেট ব্যবহার করে এবং যতটা সম্ভব ন্যানড গেট ব্যবহার করে। জিনিসগুলি সরল করার জন্য, আপনি নীচের সাথে সম্পর্কিত স্কোর সহ আপনার চিত্রের মধ্যে অ্যান্ড, ও, না, এবং এক্সওআর গেটগুলি ব্যবহার করতে পারেন:

• NOT: 1
• AND: 2
• OR: 3
• XOR: 4

এই স্কোরগুলির প্রতিটি ন্যাং গেটের সংখ্যার সাথে সম্পর্কিত যা এটি সম্পর্কিত গেটটি নির্মাণ করতে লাগে।

যুক্তিযুক্ত সার্কিট যা সঠিক নির্মাণ জয়ের উত্পাদন করতে সবচেয়ে কম NAND গেট ব্যবহার করে।

Comments

সুতরাং কোনও উত্তর যা মোটেই ন্যানড গেট ব্যবহার করে না জিতবে? এটি সহজ হওয়া উচিত। আমি কি 16 টি ইনপুট সহ অ্যান্ড গেটগুলি ব্যবহার করতে পারি?

— r3mainer

আপনি কি এই প্রশ্নটি পড়েছেন? এবং গেটগুলি আপনার স্কোরগুলিতে 2 যোগ করে।

— রেইনবোল্ট

@ স্কোয়ামিশোসিফ্রেজ ওয়ান AND== দুইNAND

— টিমটেক

@ স্কোয়ামিশোসিফ্রেজ, " কেবল ন্যানড গেট ব্যবহার করে "। অন্যান্য গেটের জন্য স্কোরগুলি এগুলি নির্মাণের জন্য ন্যূনতম গেটগুলির ন্যূনতম সংখ্যা; মূলত এটি কিছু সুবিধা ম্যাক্রো সংজ্ঞায়িত করছে।

— পিটার টেলর

@ ইউজার 80551 আপনার 16 বিট প্রয়োজন 16 বিট চালু আছে বা বন্ধ আছে তা জানাতে। 4 বিট সংখ্যার প্রতিনিধিত্ব করতে আপনার 4 টি বিট দরকার। ওএন বিটের সংখ্যা অবশ্যই 4 বিটের সংখ্যার চেয়ে বেশি হতে হবে। আমি কেন সত্যিই বুঝতে পারি না যে এটি এত কঠিন কেন। প্রশ্নের অংশটি দেখুন যা বলেছে যে "মোট ইনপুট যেগুলি চলছে তা বি ইনপুটগুলির দ্বারা প্রতিনিধিত্ব করা সংখ্যার চেয়ে বেশি" " ?

— রেইনবোল্ট

Answer 1

169 ন্যানড

এ {1,2,4,8,16} পাওয়ার জন্য এগুলি যুক্ত করে} তারপরে বিএস এর সাথে বাইনারি তুলনা করে।

আমি আরও কয়েকটি বিল্ডিং ব্লক ব্যবহার করি:

• এফএ = পূর্ণ সংযোজক, 9 টি ন্যান্ড ( এখান থেকে )
• এইচএ = অর্ধ সংযোজক, 7 টি ন্যান্ড (একই রেফ)
• EQ = সমতা, 5 টি দরজা (ওরফে এক্সনোর)

অর্ধেক এবং পূর্ণ সংযোজনকারীদের 2 আউটপুট রয়েছে - তারা ফলাফলের জন্য আর এবং বহন করার জন্য সি দিয়ে আলাদা হয়।

একটি {1,2,4,8,16। অর্ধ সংযোজকগুলির আউটপুট।

Comments

কি দারুন. এইমাত্র. মনে রাখবেন যে অর্ধ সংযোজকটি কেবলমাত্র 5 টি গেটে তৈরি করা যেতে পারে: কোডগল্ফ.স্ট্যাকেক্সেঞ্জার / এ / 10848/9498 , জোরের জন্য 4 এবং জোরের প্রথম ন্যানডকে উল্টাতে 1 টি। সুতরাং আমরা একটি xor এবং একটি পেতে এবং। ছবি: i.stack.imgur.com/qCFxa.png

— জাস্টিন

@ কুইনকুনস: ধন্যবাদ, আরও ভাল অর্ধ সংযোজনকারী গণনাটি ১ to১ এ কমিয়েছে I আমি মনে করি না যে আমাদের কোয়ার্টাস ডায়াগ্রামের দরকার আছে, তবে আপনি যদি চান তবে আমি উত্তরটি এটির সাথে আপডেট করতে পারি।

— কীথ র্যান্ডাল

Answer 2

751 ন্যান্ড গেট

module BitCountingComparator(A, B, O);
    input [15:0] A;
    input [3:0] B;
    output O;

    wire [15:1] is;
    assign is[1] = A[0] | A[1] | A[2] | A[3] | A[4] | A[5] | A[6] | A[7] | A[8] | A[9] | A[10] | A[11] | A[12] | A[13] | A[14] | A[15];

    wire [14:0] and2;
    assign and2[0] = A[0] & A[1];
    assign and2[1] = A[1] & A[2];
    assign and2[2] = A[2] & A[3];
    assign and2[3] = A[3] & A[4];
    assign and2[4] = A[4] & A[5];
    assign and2[5] = A[5] & A[6];
    assign and2[6] = A[6] & A[7];
    assign and2[7] = A[7] & A[8];
    assign and2[8] = A[8] & A[9];
    assign and2[9] = A[9] & A[10];
    assign and2[10] = A[10] & A[11];
    assign and2[11] = A[11] & A[12];
    assign and2[12] = A[12] & A[13];
    assign and2[13] = A[13] & A[14];
    assign and2[14] = A[14] & A[15];

    wire [13:0] and3;
    assign and3[0] = and2[0] & A[2];
    assign and3[1] = and2[1] & A[3];
    assign and3[2] = and2[2] & A[4];
    assign and3[3] = and2[3] & A[5];
    assign and3[4] = and2[4] & A[6];
    assign and3[5] = and2[5] & A[7];
    assign and3[6] = and2[6] & A[8];
    assign and3[7] = and2[7] & A[9];
    assign and3[8] = and2[8] & A[10];
    assign and3[9] = and2[9] & A[11];
    assign and3[10] = and2[10] & A[12];
    assign and3[11] = and2[11] & A[13];
    assign and3[12] = and2[12] & A[14];
    assign and3[13] = and2[13] & A[15];

    wire [12:0] and4;
    assign and4[0] = and3[0] & A[3];
    assign and4[1] = and3[1] & A[4];
    assign and4[2] = and3[2] & A[5];
    assign and4[3] = and3[3] & A[6];
    assign and4[4] = and3[4] & A[7];
    assign and4[5] = and3[5] & A[8];
    assign and4[6] = and3[6] & A[9];
    assign and4[7] = and3[7] & A[10];
    assign and4[8] = and3[8] & A[11];
    assign and4[9] = and3[9] & A[12];
    assign and4[10] = and3[10] & A[13];
    assign and4[11] = and3[11] & A[14];
    assign and4[12] = and3[12] & A[15];

    wire [11:0] and5;
    assign and5[0] = and4[0] & A[4];
    assign and5[1] = and4[1] & A[5];
    assign and5[2] = and4[2] & A[6];
    assign and5[3] = and4[3] & A[7];
    assign and5[4] = and4[4] & A[8];
    assign and5[5] = and4[5] & A[9];
    assign and5[6] = and4[6] & A[10];
    assign and5[7] = and4[7] & A[11];
    assign and5[8] = and4[8] & A[12];
    assign and5[9] = and4[9] & A[13];
    assign and5[10] = and4[10] & A[14];
    assign and5[11] = and4[11] & A[15];

    wire [10:0] and6;
    assign and6[0] = and5[0] & A[5];
    assign and6[1] = and5[1] & A[6];
    assign and6[2] = and5[2] & A[7];
    assign and6[3] = and5[3] & A[8];
    assign and6[4] = and5[4] & A[9];
    assign and6[5] = and5[5] & A[10];
    assign and6[6] = and5[6] & A[11];
    assign and6[7] = and5[7] & A[12];
    assign and6[8] = and5[8] & A[13];
    assign and6[9] = and5[9] & A[14];
    assign and6[10] = and5[10] & A[15];

    wire [9:0] and7;
    assign and7[0] = and6[0] & A[6];
    assign and7[1] = and6[1] & A[7];
    assign and7[2] = and6[2] & A[8];
    assign and7[3] = and6[3] & A[9];
    assign and7[4] = and6[4] & A[10];
    assign and7[5] = and6[5] & A[11];
    assign and7[6] = and6[6] & A[12];
    assign and7[7] = and6[7] & A[13];
    assign and7[8] = and6[8] & A[14];
    assign and7[9] = and6[9] & A[15];

    wire [8:0] and8;
    assign and8[0] = and7[0] & A[7];
    assign and8[1] = and7[1] & A[8];
    assign and8[2] = and7[2] & A[9];
    assign and8[3] = and7[3] & A[10];
    assign and8[4] = and7[4] & A[11];
    assign and8[5] = and7[5] & A[12];
    assign and8[6] = and7[6] & A[13];
    assign and8[7] = and7[7] & A[14];
    assign and8[8] = and7[8] & A[15];

    wire [7:0] and9;
    assign and9[0] = and8[0] & A[8];
    assign and9[1] = and8[1] & A[9];
    assign and9[2] = and8[2] & A[10];
    assign and9[3] = and8[3] & A[11];
    assign and9[4] = and8[4] & A[12];
    assign and9[5] = and8[5] & A[13];
    assign and9[6] = and8[6] & A[14];
    assign and9[7] = and8[7] & A[15];

    wire [6:0] and10;
    assign and10[0] = and9[0] & A[9];
    assign and10[1] = and9[1] & A[10];
    assign and10[2] = and9[2] & A[11];
    assign and10[3] = and9[3] & A[12];
    assign and10[4] = and9[4] & A[13];
    assign and10[5] = and9[5] & A[14];
    assign and10[6] = and9[6] & A[15];

    wire [5:0] and11;
    assign and11[0] = and10[0] & A[10];
    assign and11[1] = and10[1] & A[11];
    assign and11[2] = and10[2] & A[12];
    assign and11[3] = and10[3] & A[13];
    assign and11[4] = and10[4] & A[14];
    assign and11[5] = and10[5] & A[15];

    wire [4:0] and12;
    assign and12[0] = and11[0] & A[11];
    assign and12[1] = and11[1] & A[12];
    assign and12[2] = and11[2] & A[13];
    assign and12[3] = and11[3] & A[14];
    assign and12[4] = and11[4] & A[15];

    wire [3:0] and13;
    assign and13[0] = and12[0] & A[12];
    assign and13[1] = and12[1] & A[13];
    assign and13[2] = and12[2] & A[14];
    assign and13[3] = and12[3] & A[15];

    wire [2:0] and14;
    assign and14[0] = and13[0] & A[13];
    assign and14[1] = and13[1] & A[14];
    assign and14[2] = and13[2] & A[15];

    wire [1:0] and15;
    assign and15[0] = and14[0] & A[14];
    assign and15[1] = and14[1] & A[15];

    wire and16;
    assign and16 = and15[0] & A[15];

    assign is[2] = and2[0] | and2[1] | and2[2] | and2[3] | and2[4] | and2[5] | and2[6] | and2[7] | and2[8] | and2[9] | and2[10] | and2[11] | and2[12] | and2[13] | and2[15];

    assign is[3] = and3[0] | and3[1] | and3[2] | and3[3] | and3[4] | and3[5] | and3[6] | and3[7] | and3[8] | and3[9] | and3[10] | and3[11] | and3[12] | and3[14];

    assign is[4] = and4[0] | and4[1] | and4[2] | and4[3] | and4[4] | and4[5] | and4[6] | and4[7] | and4[8] | and4[9] | and4[10] | and4[11] | and4[13];

    assign is[5] = and5[0] | and5[1] | and5[2] | and5[3] | and5[4] | and5[5] | and5[6] | and5[7] | and5[8] | and5[9] | and5[10] | and5[12];

    assign is[6] = and6[0] | and6[1] | and6[2] | and6[3] | and6[4] | and6[5] | and6[6] | and6[7] | and6[8] | and6[9] | and6[11];

    assign is[7] = and7[0] | and7[1] | and7[2] | and7[3] | and7[4] | and7[5] | and7[6] | and7[7] | and7[8] | and7[10];

    assign is[8] = and8[0] | and8[1] | and8[2] | and8[3] | and8[4] | and8[5] | and8[6] | and8[7] | and8[9];

    assign is[9] = and9[0] | and9[1] | and9[2] | and9[3] | and9[4] | and9[5] | and9[6] | and9[8];

    assign is[10] = and10[0] | and10[1] | and10[2] | and10[3] | and10[4] | and10[5] | and10[7];

    assign is[11] = and11[0] | and11[1] | and11[2] | and11[3] | and11[4] | and11[6];

    assign is[12] = and12[0] | and12[1] | and12[2] | and12[3] | and12[5];

    assign is[13] = and13[0] | and13[1] | and13[2] | and13[4];

    assign is[14] = and14[0] | and14[1] | and14[3];

    assign is[15] = and15[0] | and15[2];

    assign is[16] = and16;


    wire [15:1] eB;
    eB[1] = B[0];
    eB[2] = B[1];
    eB[3] = B[1] & B[0];
    eB[4] = B[2];
    eB[5] = B[2] & B[0];
    eB[6] = B[2] & B[1];
    eB[7] = eB[6] & B[0];
    eB[8] = B[3];
    eB[9] = B[3] & B[0];
    eB[10] = B[3] & B[1];
    eB[11] = eB[10] & B[0];
    eB[12] = B[3] & B[2];
    eB[13] = eB[12] & B[0];
    eB[14] = eB[12] & B[1];
    eB[15] = eB[14] & B[0];

    assign O = is[1] & ~is[2] & ~eB[1] |
        is[2] & ~is[3] & ~eB[2] |
        is[3] & ~is[4] & ~eB[3] |
        is[4] & ~is[5] & ~eB[4] |
        is[5] & ~is[6] & ~eB[5] |
        is[6] & ~is[7] & ~eB[6] |
        is[7] & ~is[8] & ~eB[7] |
        is[8] & ~is[9] & ~eB[8] |
        is[9] & ~is[10] & ~eB[9] |
        is[10] & ~is[11] & ~eB[10] |
        is[11] & ~is[12] & ~eB[11] |
        is[12] & ~is[13] & ~eB[12] |
        is[13] & ~is[14] & ~eB[13] |
        is[14] & ~is[15] & ~eB[14] |
        is[15] & ~eB[15];
endmodule

এটি এখনও পুরোপুরি গল্ফ হয় না। আমি ভেরিলগে উত্তরটি দিয়েছি কারণ এইভাবে, আমি প্রতিটি বিভাগকে আউটপুট করার জন্য একটি প্রোগ্রাম লিখতে সক্ষম হয়েছি। যদি কোন চিত্র দিয়ে উত্তর দেওয়া বাধ্যতামূলক হয় তবে দয়া করে আমাকে জানান। তারা সমতুল্য। &হয় এবং ~হয়, এবং |হয় বা হয়।

আমার কৌশল:

• নিতে Aএবং সব সরাতে করা 1মধ্যে, কম নম্বর গুলি দোকান is। (এটি প্রোগ্রামের সর্বাধিক)
• Bএটিকে 16 টি বিট করে নিন এবং আনপ্যাক করুন (আমি এটি eBপ্রসারিত জন্য ডেকেছি B)
• একটি সহজ চেক করুন।