আমি সি # তে একটি অ্যালগরিদম লিখেছি যা তাদের Nor 3->1 Xor 2->1 Nand 2->1এবং প্রতিটি সম্ভাব্য সংমিশ্রণের চেষ্টা করে Decoder 3->8।
এটি 7½ মিলিয়ন বছর 2 ঘন্টা চালানোর পরে , এটি 42 টি ভুয়া ফিরে এসেছে । আমি বিশ্বাস করি যে এই প্রবাদগুলিতে প্রশ্নের কোনও উত্তর নেই কারণ এই অ্যালগরিদম প্রতিটি সম্ভাব্য সংমিশ্রণটি পরীক্ষা করে। :)
আমাকে এটি বর্ণনা করতে বলা হয়েছিল, সুতরাং পরবর্তী অংশটি কোডের অংশগুলির অংশবিশেষ, একটি অংশে ব্যাখ্যা। টিএল; ডিআর - আপনি কেবল কোডটি এখানে রেখে যেতে পারেন :)
আসুন ইনপুট লাইনগুলি সম্পর্কে কথা বলি, তাদের 0 বা 1 টি রাজ্য রয়েছে এবং সম্ভাব্য প্রতিটি ইনপুটগুলির জন্য (0 থেকে 15) তাদের আলাদা মান থাকে:
প্রথম লাইনের জন্য এটির মতো দেখাচ্ছে: 0 1 0 1 0 1 ... দ্বিতীয়টি: 0 0 1 1 0 0 1 1 ... তৃতীয়: 0 0 0 0 1 1 1 1 .... বাইনারি মত গণনা ... আপনি ধারণা পেয়েছেন: পি
সুতরাং আমি এমন একটি বস্তু তৈরি করেছি যা তার প্রতিটি রাজ্যের প্রতিটি রেখাকে প্রতিনিধিত্ব করে:
class BitLine{
bool[] IsActiveWhenInputIs = new bool[16];
}
যেমনটি বিটলাইন বলে .আইএসএটিভটিভেন ইনপুট []] ইনপুট 5 ছিল তখন লাইনটি সক্রিয় ছিল কিনা তা ফিরিয়ে দেয়।
এটি এমন একটি কোড যা পুরোপুরি ইনপুট লাইন তৈরি করে:
var bitLineList = new BitLine[6]; // initialize new array of bitLines
for (int i = 0; i < 6; i++) bitLineList [i] = new BitLine(); // initialize each bitLine
for (int i = 0; i < 16; i++)
{
for (int j = 0; j < 4; j++)
{
int checker = 1 << j; // check whether the j-th bit is activated in the binary representation of the number.
bitLineList[j].IsActiveWhenInputIs[i] = ((checker & i) != 0); // if it's active, the AND result will be none zero, and so the return value will be true - which is what we need :D
}
}
ধ্রুবক "0" ইনপুট বা "1" ইনপুট সরবরাহ করতে আমরা পাশাপাশি "সর্বদা সত্য" এবং "সর্বদা মিথ্যা" বিট লাইন তৈরি করব।
for (int i = 0; i < 16; i++){
bitLineList[4].IsActiveWhenInputIs[i] = false;
bitLineList[5].IsActiveWhenInputIs[i] = true;
}
এখন আপনি যদি খেয়াল করেন যে আমরা যা খুঁজছি তা হ'ল একটি নির্দিষ্ট বিটলাইন যা সত্য তখন সত্য যখন ইনপুট 0, 7, 14 হয় Let's আসুন এটি আমাদের শ্রেণিতে উপস্থাপন করুন:
var neededBitLine = new BitLine();
for (int i = 0; i < 16; i++){
neededBitLine.IsActiveWhenInputIs[i] = ((i % 7) == 0); // be true for any number that is devideble by 7 (0,7,14)
}
এটি জিনিসগুলিকে সত্যই সহজ করে তুলেছে: আমরা আসলে যা খুঁজছি তা হ'ল ইনপুট বিট লাইন থেকে এই প্রয়োজনীয় বিটলাইনকে "জালিয়াতি" দেওয়ার একটি উপায় (আমি কীভাবে আমার আউটপুটটি চাই তা কীভাবে আমি আমার প্রোগ্রামটিতে প্রতিনিধিত্ব করি)।
এখন, এই আমরা কিভাবে যান: প্রতিটি সময় আমরা মতো আমাদের bitLines কিছু যৌক্তিক উপাদান ব্যবহার Xor, Nor, Nandবা এমনকি Decoder, আমরা আসলে একটি নতুন bitLine তৈরি করছেন \ s। আমরা প্রতিটি সম্ভাব্য ইনপুটগুলিতে 0 থেকে 15 পর্যন্ত প্রতিটি রেখার মান জানি, সুতরাং আমরা প্রতিটি বিস্তৃত ইনপুটগুলিতেও নতুন বিটলাইন এর মান গণনা করতে পারি!
নন্দ নর এবং জোর সকলেই সোজা:
void Xor(BitLine b1, BitLine b2, BitLine outputBitLine)
{
for (var i = 0; i < 16; i++)
{
outputBitLine.IsActiveWhenInputIs[i] = b1.IsActiveWhenInputIs[i] != b2.IsActiveWhenInputIs[i];
}
}
void Nand(BitLine b1, BitLine b2, BitLine outputBitLine)
{
for (var i = 0; i < 16; i++)
{
outputBitLine.IsActiveWhenInputIs[i] = !(b1.IsActiveWhenInputIs[i] && b2.IsActiveWhenInputIs[i]);
}
}
void Nor(BitLine b1, BitLine b2, BitLine b3, BitLine outputBitLine)
{
for (var i = 0; i < 16; i++)
{
outputBitLine.IsActiveWhenInputIs[i] = !(b1.IsActiveWhenInputIs[i] || b2.IsActiveWhenInputIs[i] || b3.IsActiveWhenInputIs[i]);
}
}
প্রতিটি সম্ভাব্য ইনপুটটির জন্য, এটি নতুন বিটলাইন কীভাবে কাজ করবে তা উপস্থাপন করে।
ডিকোডারটি সামলানো কিছুটা জটিল, তবে ধারণাটি "" যদি ইনপুটটিতে বিটগুলি বাইনারিতে এক্স সংখ্যাটি উপস্থাপন করে, তবে এক্স-তম আউটপুট বিট লাইনটি সত্য হবে, অন্য সমস্তটি মিথ্যা হবে the ফাংশন, এই এক বিটলাইন একটি অ্যারে পায়, এবং অ্যারে 8 নতুন বিটলাইন যোগ করুন।
void Decoder(BitLine b1, BitLine b2, BitLine b3, List<BitLine> lines, int listOriginalLength)
{
for (int optionNumber = 0; optionNumber < 8; optionNumber++)
{
for (var i = 0; i < 16; i++)
{
int sum = 0;
if (b1.IsActiveWhenInputIs[i]) sum += 4;
if (b2.IsActiveWhenInputIs[i]) sum += 2;
if (b3.IsActiveWhenInputIs[i]) sum += 1;
lines[listOriginalLength+optionNumber].IsActiveWhenInputIs[i] = (sum == optionNumber);
}
}
}
এখন আমাদের কাছে আমাদের সমস্ত মৌলিক উপাদান রয়েছে, সুতরাং আসুন আমরা আলগোরিদিম সম্পর্কে কথা বলি:
আমরা একটি পুনরাবৃত্তির অ্যালগরিদম করতে যাচ্ছি, প্রতিটি গভীরতার সাথে এটি বর্তমানে উপলব্ধ বিটলাইনগুলিতে অন্য উপাদানগুলি (না nor নান্দ \ এক্সোর or ডিকোডার) ব্যবহার করার চেষ্টা করবে এবং তারপরে পরবর্তী পুনরাবৃত্ত গভীরতার জন্য উপাদানটিকে অকেজো হিসাবে সেট করবে। যখনই আমরা নীচে পৌঁছেছি এবং আমাদের ব্যবহার করার মতো আর কোনও উপাদান নেই, আমরা আমাদের এটির জন্য একটি বিটলাইন আছে কিনা তা যাচাই করব।
এই কোডটি যে কোনও সময় লাইনগুলির বর্তমান গোষ্ঠীটিতে আমরা খুঁজছি রেখাটি অন্তর্ভুক্ত রয়েছে কিনা তা পরীক্ষা করে দেখুন:
bool CheckIfSolutionExist(List<BitLine> lines, int linesLength BitLine neededLine)
{
for(int i = 0; i<linesLength; i++){
if (lines[i].CheckEquals(neededLine))
{
return true;
}
}
return false;
}
দুটি লাইন সমান কিনা তা যাচাই করতে এটি এটি ব্যবহার করে:
bool CheckEquals(BitLine other)
{
for (var i = 0; i < 16; i++)
{
if (this.IsActiveWhenInputIs[i] != other.IsActiveWhenInputIs[i])
{
return false;
}
}
return true;
}
ঠিক আছে, সুতরাং এখন মূল অংশটির জন্য এটিই মূল অ্যালগোরিদম:
bool Solve(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if ((!nand) && (!nor) && (!xor) && (!decoder))
{
return CheckIfSolutionExist(lines, listLength, neededLine);
}
else
{
if (HandleNand(lines, nand, nor, xor, decoder, neededLine,listLength))
{
return true;
}
if (HandleNor(lines, nand, nor, xor, decoder, neededLine,listLength))
{
return true;
}
if (HandleXor(lines, nand, nor, xor, decoder, neededLine,listLength))
{
return true;
}
if (HandleDecoder(lines, nand, nor, xor, decoder, neededLine,listLength))
{
return true;
}
return false;
}
}
এই ফাংশনটি উপলব্ধ বিটলাইনগুলির একটি তালিকা, তালিকার দৈর্ঘ্য, প্রতিটি উপাদান বর্তমানে উপলব্ধ কিনা তা প্রতিনিধিত্ব করে এমন একটি বুলিয়ান (xor / nor / nand / decoder) এবং আমরা যে বিটলাইনটি অনুসন্ধান করছি তার একটি বিটলাইন পেয়েছে।
প্রতিটি পর্যায়ে, এটি পরীক্ষা করে যে আমাদের ব্যবহার করার মতো আরও কিছু উপাদান আছে কি না - এটি আমাদের প্রয়োজনীয় বিটলাইনটি সংরক্ষণাগারভুক্ত কিনা তা পরীক্ষা করে।
যদি এখনও আমাদের কাছে আরও উপাদান থাকে তবে প্রতিটি উপাদানটির জন্য এটি এমন একটি ফাংশন কল করে যা সেই উপাদানগুলি ব্যবহার করে নতুন বিটলাইন তৈরি করতে এবং পরবর্তী পুনরুক্তিযোগ্য গভীরতার পরে কল করবে।
পরবর্তী হ্যান্ডলার ফাংশনগুলি সমস্ত সোজা সোজা, তাদের "উপলভ্য বিটলাইনগুলি থেকে 2 choose 3 চয়ন করতে এবং প্রাসঙ্গিক উপাদানটি ব্যবহার করে একত্রিত করতে অনুবাদ করা যেতে পারে Then তারপরে পুনরাবৃত্তির পরবর্তী গভীরতাটি কল করুন, কেবলমাত্র এই বারটি এতে থাকবে না এই উপাদান! "।
সেগুলি হল:
bool HandleNand(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (nand)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
BitLine.Nand(lines[i], lines[j],lines[listLength]);
if (Solve(lines,listLength+1, false, nor, xor, decoder, neededLine))
{
return true;
}
}
}
}
return false;
}
bool HandleXor(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (xor)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
BitLine.Xor(lines[i], lines[j],lines[listLength]);
if (Solve(lines,listLength+1, nand, nor, false, decoder, neededLine))
{
return true;
}
}
}
}
return false;
}
bool HandleNor(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (nor)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
for (int k = j; k < listLength; k++)
{
BitLine.Nor(lines[i], lines[j], lines[k],lines[listLength]);
if (Solve(lines,listLength+1, nand, false, xor, decoder, neededLine))
{
return true;
}
}
}
}
}
return false;
}
bool HandleDecoder(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (decoder)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
for (int k = j; k < listLength; k++)
{
BitLine.Decoder(lines[i], lines[j], lines[k],lines,listLength);
if (Solve(lines,listLength+8, nand, nor, xor, false, neededLine))
{
return true;
}
}
}
}
}
return false;
}
এবং এটি হ'ল আমরা এই ফাংশনটিকে প্রয়োজনীয় লাইনের সাথে কল করছি যা আমরা খুঁজছি এবং এটি বৈদ্যুতিক অংশগুলির প্রতিটি সম্ভাব্য সংমিশ্রণটি পরীক্ষা করে যাতে এটি এমনভাবে সংহত করা সম্ভব হয় যে শেষ পর্যন্ত একটি একক লাইন হবে check প্রয়োজনীয় মান সহ আউটপুট করা।
* লক্ষ্য করুন যে আমি সর্বদা একই তালিকা ব্যবহার করি, তাই আমার সর্বদা নতুন বিটলাইন উদাহরণ তৈরি করার প্রয়োজন হবে না। আমি এ কারণে 200 এর একটি বাফার দিই।
এটি সম্পূর্ণ প্রোগ্রাম:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp2
{
public class BitLine
{
public bool[] IsActiveWhenInputIs = new bool[16];
public static void Xor(BitLine b1, BitLine b2, BitLine outputBitLine)
{
for (var i = 0; i < 16; i++)
{
outputBitLine.IsActiveWhenInputIs[i] = b1.IsActiveWhenInputIs[i] != b2.IsActiveWhenInputIs[i];
}
}
public static void Nand(BitLine b1, BitLine b2, BitLine outputBitLine)
{
for (var i = 0; i < 16; i++)
{
outputBitLine.IsActiveWhenInputIs[i] = !(b1.IsActiveWhenInputIs[i] && b2.IsActiveWhenInputIs[i]);
}
}
public static void Nor(BitLine b1, BitLine b2, BitLine b3, BitLine outputBitLine)
{
for (var i = 0; i < 16; i++)
{
outputBitLine.IsActiveWhenInputIs[i] = !(b1.IsActiveWhenInputIs[i] || b2.IsActiveWhenInputIs[i] || b3.IsActiveWhenInputIs[i]);
}
}
public static void Decoder(BitLine b1, BitLine b2, BitLine b3, List<BitLine> lines, int listOriginalLength)
{
for (int optionNumber = 0; optionNumber < 8; optionNumber++)
{
for (var i = 0; i < 16; i++)
{
int sum = 0;
if (b1.IsActiveWhenInputIs[i]) sum += 4;
if (b2.IsActiveWhenInputIs[i]) sum += 2;
if (b3.IsActiveWhenInputIs[i]) sum += 1;
lines[listOriginalLength + optionNumber].IsActiveWhenInputIs[i] = (sum == optionNumber);
}
}
}
public bool CheckEquals(BitLine other)
{
for (var i = 0; i < 16; i++)
{
if (this.IsActiveWhenInputIs[i] != other.IsActiveWhenInputIs[i])
{
return false;
}
}
return true;
}
}
public class Solver
{
bool CheckIfSolutionExist(List<BitLine> lines, int linesLength, BitLine neededLine)
{
for (int i = 0; i < linesLength; i++)
{
if (lines[i].CheckEquals(neededLine))
{
return true;
}
}
return false;
}
bool HandleNand(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (nand)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
BitLine.Nand(lines[i], lines[j], lines[listLength]);
if (Solve(lines, listLength + 1, false, nor, xor, decoder, neededLine))
{
return true;
}
}
}
}
return false;
}
bool HandleXor(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (xor)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
BitLine.Xor(lines[i], lines[j], lines[listLength]);
if (Solve(lines, listLength + 1, nand, nor, false, decoder, neededLine))
{
return true;
}
}
}
}
return false;
}
bool HandleNor(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (nor)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
for (int k = j; k < listLength; k++)
{
BitLine.Nor(lines[i], lines[j], lines[k], lines[listLength]);
if (Solve(lines, listLength + 1, nand, false, xor, decoder, neededLine))
{
return true;
}
}
}
}
}
return false;
}
bool HandleDecoder(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if (decoder)
{
for (int i = 0; i < listLength; i++)
{
for (int j = i; j < listLength; j++)
{
for (int k = j; k < listLength; k++)
{
BitLine.Decoder(lines[i], lines[j], lines[k], lines, listLength);
if (Solve(lines, listLength + 8, nand, nor, xor, false, neededLine))
{
return true;
}
}
}
}
}
return false;
}
public bool Solve(List<BitLine> lines, int listLength, bool nand, bool nor, bool xor, bool decoder, BitLine neededLine)
{
if ((!nand) && (!nor) && (!xor) && (!decoder))
{
return CheckIfSolutionExist(lines, listLength, neededLine);
}
else
{
if (HandleNand(lines, listLength, nand, nor, xor, decoder, neededLine))
{
return true;
}
if (HandleNor(lines, listLength, nand, nor, xor, decoder, neededLine))
{
return true;
}
if (HandleXor(lines, listLength, nand, nor, xor, decoder, neededLine))
{
return true;
}
if (HandleDecoder(lines, listLength, nand, nor, xor, decoder, neededLine))
{
return true;
}
return false;
}
}
}
class Program
{
public static void Main(string[] args)
{
List<BitLine> list = new List<BitLine>();
var bitLineList = new BitLine[200];
for (int i = 0; i < 200; i++) bitLineList[i] = new BitLine();
// set input bit:
for (int i = 0; i < 16; i++)
{
for (int j = 0; j < 4; j++)
{
int checker = 1 << j;
bitLineList[j].IsActiveWhenInputIs[i] = ((checker & i) != 0);
}
}
// set zero and one constant bits:
for (int i = 0; i < 16; i++)
{
bitLineList[4].IsActiveWhenInputIs[i] = false;
bitLineList[5].IsActiveWhenInputIs[i] = true;
}
list.AddRange(bitLineList);
var neededBitLine = new BitLine();
for (int i = 0; i < 16; i++)
{
neededBitLine.IsActiveWhenInputIs[i] = (i%7==0); // be true for any number that is devideble by 7 (0,7,14)
}
var solver = new Solver();
Console.WriteLine(solver.Solve(list, 6, true, true, true, true, neededBitLine));
Console.ReadKey();
}
}
}
আশা করি এবার এটি বৈধ ব্যাখ্যা: পি