मैंने C # में एक एल्गोरिथ्म लिखा है जो उन लोगों के हर संभव संयोजन की कोशिश करता है Nor 3->1 Xor 2->1 Nand 2->1और Decoder 3->8।
इसे 7 years मिलियन वर्ष 2 घंटे चलाने के बाद , इसने 42 फाल्स लौटा दिए । मेरा मानना है कि इस सवाल का कोई जवाब नहीं है क्योंकि यह एल्गोरिथम हर संभव संयोजन की जांच करता है। :)
मुझे इसका वर्णन करने के लिए कहा गया था, इसलिए अगला भाग कोड के कुछ हिस्सों का एक विवरण है, भाग द्वारा। टीएल; डीआर - आप अंत में कोड को छोड़ सकते हैं :)
आइए इनपुट लाइनों के बारे में बात करते हैं, उनके पास 0 या 1 राज्य हैं और प्रत्येक संभावित इनपुट (0 से 15) के लिए वे अलग-अलग मान रखते हैं:
पहली पंक्ति के लिए ऐसा दिखता है: 0 1 0 1 0 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];
}
जैसा कि यह कहा जाता है कि बिटलाइन .sActiveWhenInputIs [5] वापसी करें कि क्या इनपुट 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. है। चलो इसे हमारी कक्षा में दर्शाते हैं:
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)
}
इससे चीजें वास्तव में सरल हो गईं: हम वास्तव में जिस चीज की तलाश कर रहे हैं वह इनपुट बिट लाइन से इस जरूरत को "जाली" बनाने का एक तरीका है (यह है कि मैं अपने कार्यक्रम का प्रतिनिधित्व करता हूं कि मैं अपना आउटपुट क्या चाहता हूं)।
अब, यह है कि हम कैसे चलते हैं: हर बार जब हम अपने बिटलाइन पर कुछ तार्किक तत्व का उपयोग करते हैं Xor, जैसे Nor, Nandया यहां तक कि Decoder, हम वास्तव में एक नया बिटलाइन बना रहे हैं। हम प्रत्येक संभावित इनपुट में 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]);
}
}
प्रत्येक संभावित इनपुट के लिए, यह दर्शाता है कि नया बिटलाइन कैसे कार्य करेगा।
डिकोडर को संभालना थोड़ा मुश्किल है, लेकिन विचार यह है कि "यदि इनपुट पर बिट्स बाइनरी में संख्या x का प्रतिनिधित्व करते हैं, तो x-th आउटपुट बिट लाइन सही होगी, जबकि अन्य सभी झूठे होंगे। दूसरे के विपरीत। फ़ंक्शन, यह एक बिटलाइन की एक सरणी प्राप्त करता है, और सरणी में 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);
}
}
}
अब हमारे पास हमारे सभी मूल तत्व हैं, तो आइए एल्गोरिथ्म के बारे में बात करते हैं:
हम एक पुनरावर्ती एल्गोरिथ्म करने जा रहे हैं, प्रत्येक गहराई पर यह वर्तमान में उपलब्ध बिटलाइन्स पर अन्य तत्वों (न ही \ nand \ xor \ decoder) का उपयोग करने की कोशिश करेगा, और फिर अगले पुनरावर्ती गहराई के लिए अनुपयोगी तत्व को सेट करेगा। जब भी हम नीचे पहुंचते हैं और हमारे पास उपयोग करने के लिए और कोई तत्व नहीं होते हैं, तो हम जांच करेंगे कि क्या हमारे पास बिटलाइन है या नहीं।
यह कोड किसी भी समय की जाँच करता है कि क्या वर्तमान समूह में वह पंक्ति है जिसमें हम देख रहे हैं:
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 \ 3" चुनने और संबंधित तत्व का उपयोग करके उन्हें संयोजित करने के लिए अनुवादित किया जा सकता है। फिर पुनरावृत्ति की अगली गहराई को कॉल करें, बस इस बार इसमें शामिल नहीं होगा। यह तत्व! ”।
वे कार्य हैं:
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;
}
और यह वह है, हम इस फ़ंक्शन को केवल उस आवश्यक पंक्ति के साथ कहते हैं जिसे हम ढूंढ रहे हैं, और यह विद्युत भागों के हर संभव संयोजन की जांच करता है कि क्या उन्हें इस तरह से संयोजित करना संभव है कि अंत में एक ही लाइन होगी आवश्यक मूल्यों के साथ उत्पादन किया।
* ध्यान दें कि मैं हर समय एक ही सूची का उपयोग करता हूं, इसलिए मुझे हर समय नए बिटलाइन इंस्टेंस बनाने की आवश्यकता नहीं होगी। मैं इसे उस कारण से 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();
}
}
}
आशा है कि इस बार यह एक मान्य स्पष्टीकरण है: पी