Xây dựng Bộ kiểm tra kết nối 4 đỉnh bằng cổng NAND


12

Một kết nối đồ thị là một đồ thị có chứa một con đường giữa hai đỉnh.

Thử thách

Xây dựng mạch [Cổng NAND 2 đầu vào] để xác định xem đồ thị 4 đỉnh có được kết nối hay không.
(2 đầu vào của một cổng có thể là cùng một bit đầu vào hoặc cổng khác.)
Đầu ra Đúng nếu biểu đồ được kết nối và Sai khác.

Đầu vào

Sáu cạnh có thể của đồ thị đơn giản với 4 đỉnh:

[ 0 e 1 , 0 e 2 , 1 e 2 , 0 e 3 , 1 e 3 , 2 e 3 ]

trong đó a e b đại diện cho dù có cạnh giữa đỉnh ab

Kết nối tương đương với các điều kiện sau:

  • Nếu ít hơn 3 đầu vào là True thì đầu ra Sai.

  • Nếu có nhiều hơn 3 đầu vào là True thì đầu ra True.

  • Nếu chính xác 3 đầu vào là True và chúng tạo thành một hình tam giác thì đầu ra Sai.

  • Nếu không, đầu ra True.

Câu trả lời sử dụng ít cổng nhất sẽ thắng. Các mối quan hệ sẽ bị phá vỡ bởi
độ sâu mạch thấp nhất (độ dài của đường dẫn dài nhất từ ​​đầu vào đến đầu ra).


Bạn có thể chỉ định định dạng đầu vào hơn nữa?
LegionMammal978

iej là Đúng hoặc Sai tùy theo việc có hay không có cạnh từ đỉnh i đến đỉnh j.

Đầu vào có thể được thực hiện như 01? Làm thế nào về đầu ra?
TheCoffeeCup

3
@TheCoffeeCup Đây là một vấn đề thiết kế mạch logic, không phải mã golf .
lirtosiast

@ThomasKwa Rất tiếc, không để ý.
TheCoffeeCup

Câu trả lời:


4

30 NAND

Thay vì hỏi khi nào chúng ta nhận được 1, tôi đã hỏi câu hỏi khi nào chúng ta nhận được 0. Tốt hơn là nên hỏi theo cách này bởi vì có ít hơn 0 so với 1.

Đây là phân phối theo số cạnh (hàng thứ 6 của tam giác pascal)

Edges     0  1  2  3  4  5  6
Frequency 1  6 15 20 15  6  1 (total 64)
Output    0  0  0  *  1  1  1
* = 0 if triangle (4 possibilities) 1 if claw (4 possibilities) 
1 if two opposite edges and one other (12 possibilities)

Đặt câu hỏi theo cách này, chúng ta có sơ đồ và biểu thức sau

 ___D___
|\     /|
| E   F |
|  \ /  |
A   X   C
|  / \  |
| /   \ |
|/__B__\|

(A|C|D|B)&(A|D|E)&(D|B|E|F)&(C|B|E)&(A|C|E|F)&(D|F|C)&(A|F|B) 

Chúng tôi giả sử đầu ra sẽ mặc định là 1, nhưng sẽ thay đổi thành 0 theo bất kỳ điều kiện nào sau đây

1.A 0 cho ba cạnh liền kề (kiểm tra 3 đầu vào)

2.A 0 cho hai cặp cạnh đối diện (kiểm tra 4 đầu vào)

Các điều khoản ở trên đã được sắp xếp theo cách cho phép chúng được nhóm lại như dưới đây. (Ngẫu nhiên, phiên bản biểu thức này đối xứng xoay quanh đỉnh của AFB.)

((A|D)|((C|B)&E))&((B|E)|((D|F)&C))&((C|F)|((A|E)&D))&(A|F|B)    =6 inverters
   1      1  1       1      1  1       1      1  1      1        =10 (7 OR with both inputs inverted, 3 NAND)
      2                 2                 2               2      =8  (4 OR with one input inverted)
                 2                 2                 2           =6  (3 AND) 
                                                        Total    =30

Điểm cho mỗi &hoặc |được đặt bên dưới biểu tượng và được chứng minh như sau:

Cấp độ 0: Chúng tôi đầu tư vào một biến tần cho mỗi đầu vào: 6 NANDS

Cấp độ 1: Chúng ta có thể xây dựng OR từ cổng NAND bằng cách đặt biến tần ở đầu vào (tổng 3 NANDS) nhưng vì chúng ta đã đầu tư vào 6 NANDS trong bước trước, chúng ta có thể tạo 7 cổng OR từ 7 cổng NAND. Chúng tôi cũng cần 3 cổng VÀ. Đối với những điều này, chúng tôi sẽ chỉ sử dụng NAND và để đầu ra đảo ngược. 10 NAND

Cấp 2: Một lần nữa chúng tôi xây dựng 4 cổng OR từ cổng NAND. Trong mỗi trường hợp, chúng tôi có 1 đầu vào từ một cổng OR, vì vậy chúng tôi phải đảo ngược điều đó. Nhưng đầu vào khác đã bị đảo ngược (đến từ một trong các NAND ở bước trước tương ứng với một &ký hiệu trong ba trường hợp và từ một biến tần trong cái cuối cùng), vì vậy chúng ta chỉ cần 2 cổng cho mỗi chức năng OR. 4 * 2 = 8

Cấp độ 3: Bây giờ chúng ta cần VÀ bốn đầu ra cùng nhau. Điều này đòi hỏi 3 cổng AND, mỗi cổng được xây dựng từ 2 NAND, 3 * 2 = 6

Đó là tổng cộng 30 cổng NAND, với độ sâu tối đa là 2 + 2 + 4 = 8 NAND cho các nhánh có |cấp 1 hoặc 3 + 1 + 4 = 8 NAND cho các nhánh có &cấp 1.

Tập lệnh Ruby sau đây xác nhận trực quan rằng biểu thức trên là hợp lệ.

64.times{|i|
  a=i%2
  b=i/2%2
  c=i/4%2
  d=i/8%2
  e=i/16%2 
  f=i/32%2

puts i, ((a|d)|((c|b)&e))&((b|e)|((d|f)&c))&((c|f)|((a|e)&d))&(a|f|b)

puts " ___#{d}___
|\\     /|
| #{e}   #{f} |
|  \\ /  |
#{a}   X   #{c}
|  / \\  |
| /   \\ |
|/__#{b}__\\|


"
}

7

19 NAND

Không có mạch đơn giản hơn thế này.

Có mã để thử nghiệm nó bên dưới hình ảnh. Để hiểu nó, đó là khó khăn. Có một vài cổng IF ở đó và các đầu vào được nhóm thành một hình tam giác với các dòng góc miễn phí được thêm vào để phân tích từng cái một, nhưng không phải là một cách đơn giản. Nếu bất cứ ai quản lý để hiểu nó, tôi sẽ bị ấn tượng.

nhập mô tả hình ảnh ở đây

Mã Verilog với thử nghiệm:

// 4-vertex Connectedness Tester                                                                  
// Minimal at 19 NANDs                                                                            
//                                                                                                
// By Kim Øyhus 2018 (c) into (CC BY-SA 3.0)                                                      
// This work is licensed under the Creative Commons Attribution 3.0                               
// Unported License. To view a copy of this license, visit                                        
// https://creativecommons.org/licenses/by-sa/3.0/                                                
//                                                                                                
// This is my entry to win this Programming Puzzle & Code Golf                                    
// at Stack Exchange:                                                                             
// /codegolf/69912/build-a-4-vertex-connectedness-tester-using-nand-gates/                                                                                      
//                                                                                                
// I am sure there are no simpler solutions to this problem.                                      
// It has a logical depth of 11, which is deeper than                                             
// circuits using a few more NANDs.                                                               

module counting6 ( in_000, in_001, in_002, in_003, in_004, in_005, in_006, out000 );
  input  in_000, in_001, in_002, in_003, in_004, in_005, in_006;
  output out000;
  wire   wir000, wir001, wir002, wir003, wir004, wir005, wir006, wir007, wir008, wir009, wir010, wir011, wir012, wir013, wir014, wir015, wir016, wir017;

  nand gate000 ( wir000, in_000, in_000 );
  nand gate001 ( wir001, in_001, in_003 );
  nand gate002 ( wir002, wir001, wir000 );
  nand gate003 ( wir003, in_002, wir002 );
  nand gate004 ( wir004, wir002, wir002 );
  nand gate005 ( wir005, wir004, in_002 );
  nand gate006 ( wir006, wir005, wir004 );
  nand gate007 ( wir007, in_005, wir006 );
  nand gate008 ( wir008, in_003, wir006 );    
  nand gate009 ( wir009, in_004, wir003 );
  nand gate010 ( wir010, wir003, wir009 );
  nand gate011 ( wir011, wir009, wir000 );
  nand gate012 ( wir012, wir011, in_001 );
  nand gate013 ( wir013, wir008, wir012 );
  nand gate014 ( wir014, wir013, in_005 );
  nand gate015 ( wir015, wir006, wir013 );
  nand gate016 ( wir016, wir015, wir007 );
  nand gate017 ( wir017, wir016, wir010 );
  nand gate018 ( out000, wir014, wir017 );
endmodule


module connecting6_test;
   reg [5:0] X;
   wire a;

  counting6 U1 (
  .in_000 (X[0]),
  .in_001 (X[1]),
  .in_002 (X[2]),
  .in_003 (X[3]),
  .in_004 (X[4]),
  .in_005 (X[5]),
  .in_006 (X[6]),
  .out000 (a )
  );

  initial begin
    X = 0;
  end

  always
    #10  X = X+1;

 initial  begin
    $display("\t\t     \t_");
    $display("\t\ttime,\t \\db/_,\tconnected");
    $monitor("%d,\t%b,\t%d",$time, X, a );
  end

  initial
   #630  $finish;

endmodule

// iverilog -o hello hello.v                                                                      
// vvp hello                                                                                      

Kim husyhus


Bạn đã chứng minh điều này tối thiểu, và nếu vậy làm thế nào?
lirtosiast

Tôi đã sử dụng thử nghiệm thống kê để có được bằng chứng rằng nó là tối thiểu. Đối với các mạch tương đối đơn giản, như thế này, các bài kiểm tra khá chắc chắn.
KimOyhus

1

Toán học, 17 cổng

Chúng ta chỉ cần liệt kê tất cả các quy tắc, xây dựng hàm boolean và thu nhỏ nó NANDdưới dạng.

#->If[Total@#<3||
       MemberQ[{{1,1,1,0,0,0},{1,0,0,1,1,0},{0,1,0,1,0,1},{0,0,1,0,1,1}},#]
       ,0,1] /.{1->True,0->False}& /@
     Tuples[{0,1},6];
BooleanMinimize[BooleanFunction[rule], "NAND"]

Kết quả :

(#1⊼#2⊼#4)⊼(#1⊼#2⊼#5)⊼(#1⊼#2⊼#6)⊼(#1⊼#3⊼#4)⊼ \
(#1⊼#3⊼#5)⊼(#1⊼#3⊼#6)⊼(#1⊼#4⊼#6)⊼(#1⊼#5⊼#6)⊼ \
(#2⊼#3⊼#4)⊼(#2⊼#3⊼#5)⊼(#2⊼#3⊼#6)⊼(#2⊼#4⊼#5)⊼ \
(#2⊼#5⊼#6)⊼(#3⊼#4⊼#5)⊼(#3⊼#4⊼#6)⊼(#4⊼#5⊼#6)&

, trong đó #1...#6có 6 vị trí cho các đối số.


Các trường hợp thử nghiệm :

f=%; (* assign the function to symbol f *)

f[True, True, True, True, False, False]
(* True *)

f[True, True, False, True, False, False]
(* True *) (*, three Trues do not form a triangle *)

f[True, True, True, False, False, False]
(* False *) (*, three Trues form a triangle *)

Pq⊼r có nghĩa là not (p&q&r)gì? Kết quả cuối cùng của bạn là gì?

@RickyDemer Có, p⊼q⊼rcó nghĩa là (p⊼q)⊼r, tương đương với !(p&&q&&r).
njpipe tổ chức

Cắm sai, sai, đúng xuất hiện cho thấy (p⊼q)⊼rkhông tương đương với !(p&&q&&r).

@RickyDemer Đó là một vấn đề ... Tôi coi đó là điều hiển nhiên.
njpipe tổ chức

Ngoài ra, ít nhất là phiên bản wolframalpha của BooleanMinizing [expr, "NAND"] không nhất thiết phải giảm thiểu số lượng NANDS. (Hãy thử BooleanMinizing [(((a NAND b) NAND (c NAND d)) NAND ((e NAND f) NAND (g NAND h))), "NAND"].) Việc chạy nó trên Mathematica có cho ra không có nhiều nhất 7 NANDS?

1

64 NAND

Sáu cạnh có thể được chia thành ba cặp cạnh đối diện. Để biểu đồ được kết nối, phải có hai cạnh đối diện cũng như cạnh thứ ba hoặc ba cạnh được kết nối với cùng một đỉnh.

       •
       U

   Z   •   Y  
    V     W 
 •     X     •

Các cặp đối diện là UX, VY, WZ, vì vậy:

A = U+V   ;3 gates
B = W+X
C = Y+Z

D = UV(B+C)  ;2+2+3=7 gates
E = WX(A+C)
F = YZ(C+A)

Result = D+E+F+UVW+UYZ+XVZ+XWY ; 18 + 16 = 34 gates

Xây dựng cổng AND và OR theo cách thông thường, tổng số cổng được sử dụng là 3*3+7*3+34= 64.


[Đúng, Đúng, Sai, Đúng, Sai, Sai] đưa ra biểu đồ được kết nối mà không có bất kỳ cạnh đối diện nào.

@RickyDemer Tôi nghĩ rằng nó hoạt động ngay bây giờ ...
lirtosiast
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.