ความท้าทายของคุณคือการตีความแผนภาพวงจรพร้อมด้วยประตูตรรกะ

ประตูลอจิก (คุณไม่จำเป็นต้องรู้ว่าสิ่งเหล่านี้ทำอะไร / มีความท้าทายนี้):

• และประตู: a
• หรือประตู: o
• ประตู nand: A
• หรือประตู: O
• ประตู xor: x
• ประตู xnor: X
• ไม่ใช่ประตู: ~

แต่ละเกท แต่อันสุดท้ายใช้สองอินพุต อินพุตมาจาก.มุมบนซ้ายและมุมล่างซ้ายของ 3 โดย 3 ตรงกลางที่ประตู ไม่เช่นนั้นอินพุตจะอยู่ทางด้านซ้ายโดยตรง เอาท์พุทคือ.ตรงไปทางขวา

สายจะถูกแทนด้วย -|\/.=

• - เชื่อมสายสองเส้นเส้นหนึ่งไปทางขวาและอีกเส้นหนึ่งอยู่ทางซ้าย: c-c

• | ติดต่อสองสายหนึ่งข้างบนและข้างล่างหนึ่ง:

  c
  |
  c
  

• /และ\ทำงานดังนี้:

  c        c
   \      /
    c    c
  

• . ติดต่อทุกสายรอบ:

  ccc
  c.c
  ccc
  

• =เป็นพิเศษ มันเชื่อมต่อสายไฟที่อยู่ติดกันข้ามมัน:

  -=-
  

  เชื่อมต่อสายทั้งสอง ในเรื่องดังต่อไปนี้

  \|/
  -=-
  /|\
  

  แต่ละเส้นลวดเชื่อมต่อกัน แต่ไม่ใช่สายอื่น (นี่คือที่ที่มันแตกต่างจาก.)

• เพื่อให้กระแสไหลทั้งสองสายจะต้องเชื่อมต่อกับอีกสายหนึ่งดังนั้นใน|-กระแสไม่ไหล

ตัวอย่างการเดินสาย:

      .-.
     =   \
 .--. .---=---
-.   =     .--
 .--. .-------

อินพุตถูกแบ่งออกเป็นสองสายแล้วแยกออกเป็นสามสาย ในการแยกนี้เส้นลวดด้านล่างจะเลื่อนไปที่ตรงกลางและรอยแยกด้านล่างของเส้นลวดด้านบนจะปรากฏที่ด้านล่าง ถัดไปด้านบนของทั้งสามสายจะถูกย้ายไปที่กลาง

สายไฟตัวอย่างด้วยประตู:

--.
   o..~..
--.      o.---
   a.---.
--.

รูปแบบอินพุต:

• แต่ละสายป้อนข้อมูลจะถูกระบุด้วยตัวเลข ในตอนท้าย (ขวาก่อนขึ้นบรรทัดใหม่) แต่ละเอาต์พุตจะมีป้ายกำกับด้วย:(และลวดจะเสมอไปทางขวาคือ-:หรือ.:หรือ=:)
• อินพุตจะถูกต้องเสมอ จะไม่มีลูปหรือสายไฟรวมเข้าด้วยกันโดยไม่มีประตู โปรดทราบว่าสามารถมีสายที่มีปลายหลวม
• = จะถูกใช้เมื่อจำเป็นเท่านั้น

รูปแบบผลลัพธ์:

• แต่ละอินพุตมีการอ้างอิงด้วยหมายเลขที่สอดคล้องกัน
• การแสดงออกจะถูกส่งออก ตัวอย่างเช่นถ้าสายคำนวณการป้อนข้อมูลที่ 1 และอินพุต 2 1a2ผลลัพธ์คือ
• ฟังก์ชันใดก็ตามที่เอาต์พุตต้องสอดคล้องกับลอจิกเกตที่จุดเริ่มต้น
• เพื่อไม่แสดงให้ใส่~ก่อนหน้าสถานที่ที่ถูกต้อง

• สำหรับฟังก์ชั่นหลายอย่างให้ใช้วงเล็บเพื่อแสดงลำดับของการดำเนินการ สามารถใช้วงเล็บได้เมื่อมีเพียงฟังก์ชันเดียว ตัวอย่างเช่น,

  1-.~.-.
         A.~.-:
        .
  2-.  /
     x.
  3-.
  

  มีหนึ่งผลลัพธ์ที่เป็นไปได้ของ ~((2x3)A(~1))

• เอาต์พุตหลายรายการต้องคั่นด้วยบรรทัดใหม่ (หรือเทียบเท่า)

ตัวอย่างอินพุต:

1--.---.
    x.  \
2--.  x.-=---------.
     .    .~.       X.--.
3---. .      a.----.   /
       O.~.-.       \ /
      .              =
4-.  /              / .-:
   X.              .----:
5-.

หนึ่งเอาต์พุตที่สอดคล้องกันที่เป็นไปได้:

(~1)a(~(3O(4X5))
((1x2)x3)X((~1)a(~(3O(4X5))))

Python 2488 1567 806 706 697 657 653

Yay สำหรับ gzip + exec!

import zlib,base64;exec zlib.decompress(base64.b64decode('eNp1U8FuqzAQvPMV7sm2gBSuuFupX9BLD5UoBxNMMAkEgQmJVPXb364Daiu9ntaznt2dWYzthvPo2HSbgsrU7E3so0FmAWtgnyeFshjSImC2Zs1Tws4js/fQPMPJ9KKTlFrPeVPIbDRuHnvOA3YByuS2UCNwrloYqOMRQ1ooDY0qwaoKRJxGSZRKP+QCwBn/0YRyzPYcYq77irUATVbGcIytGkN4E7mOyiLayx/MT888AthMx9DGDTLj/zIfPz44emUGqC/Zoio1UdFzohzFp0TNNA7xQhFxDWJiNGNG98L54yLVYUsv3+kZx9G8/uyEoQFk8NELrDeIIggf5Cb3b3/I3nnFNdZe0QOrCHl4+4ZsgVyH16gMb4XHq4IrwA0gkV7kAwyZH7Fs7f0S/O7IbnZX7jelzy+v13f8LsAFD0kVfrQyTklZyCUPL+F2Ef66WHug7i9f/bWyfnOIsrNTZQ/WCXxCcAnY/QmwMeggLwIyeCKD+FB3k6tsj/K6nR4G01fiZCcnTlIGBkw/d2bUzvgSG2kqMvhOkU+ZNirvGS1XgyWKy/xS2TDa3uE/kNuoJX0UC/kP8j/kmA=='))

ข้อ จำกัด และสมมติฐาน

เนื่องจากรองรับเฉพาะอินพุตสูงสุด 9 ตัวเท่านั้น - มีการจัดการตัวเลขหลายหลักอย่างไม่ถูกต้อง เนื่องจากข้อมูลจำเพาะระบุว่าอินพุตมีป้ายกำกับด้วยตัวเลขไม่ใช่จำนวนจึงอนุญาตให้ทำได้

อินพุตและเอาต์พุต

อินพุตถูกใช้ผ่านทางเข้ามาตรฐานและเอาท์พุทผ่านออกมาตรฐาน

การทดสอบ

ตัวอย่างอินพุตและเอาต์พุต:

1--.---.
    x.  \
2--.  x.-=---------.
     .    .~.       X.--.
3---. .      a.----.   /
       O.~.-.       \ /
      .              =
4-.  /              / .-:
   X.              .----:
5-.

(~(1))a(~((3)O((4)X(5))))
(((1)x(2))x(3))X((~(1))a(~((3)O((4)X(5)))))

ทดสอบที่นี่: http://ideone.com/gP4CIq

อัลกอริทึม

มันเป็น DFS ที่ค่อนข้างไร้เดียงสาจากเอาต์พุต สำหรับแต่ละเอาต์พุตมันจะเริ่มจากตัวอักษรตัวหนึ่งไปทางซ้ายแล้วลากเส้นรอยแยก (และเพิ่มไปยังนิพจน์) ที่ประตูทุกบาน เมื่อมันมาถึงอินพุตมันจะเพิ่มเข้าไปในนิพจน์และ backtracks ไปยังจุดสุดท้ายที่แยกออกไปเนื่องจากเรามั่นใจได้ว่าการแตกแขนงนั้นเป็นไปไม่ได้หากไม่มีประตู และแน่นอนกรณีที่ไม่ถูกต้องจะถูกยกเลิก ไม่มีอะไรพิเศษสำหรับมัน - และดังนั้นจึงน่าจะนานกว่าที่ควรจะเป็น

หมายเหตุ

ขนาดอาจจะลดลงเล็กน้อยด้วยการปรับโครงสร้าง แต่ฉันใช้เวลากับมันมากพอสำหรับวันนี้ รุ่นที่ตีกอล์ฟด้วยตนเองคือรุ่นที่ถูกบีบอัด

การบีบอัด gzip ทำให้การเล่นกอล์ฟน่าสนใจเพราะการแคชบางอย่าง (เช่นd=(-1,0,1)) ใช้พื้นที่มากกว่าการให้อัลกอริทึมการบีบอัดดูแล อย่างไรก็ตามฉันเลือกที่จะตีกอล์ฟด้วยตัวเองเท่าที่จะทำได้แทนที่จะใช้การบีบอัดให้เหมาะสมที่สุด

เล่นกอล์ฟด้วยตนเอง ( 909 895 840 803):

import sys
def T(c,p):
 h=c[0];i=c[1]
 if h<0 or i<0 or h>=len(m)or i>=len(m[h]):return''
 v=m[h][i];r='';j=p[0];k=p[1];a=h;b=i;d=(-1,0,1)
 if v==' ':return''
 if v in'=-'and j==h:b-=k-i;r+=T([a,b],c)
 if v in'=|'and k==i:a-=j-h;r+-T([a,b],c)
 if v in'=/\\':
  e=j==h or k==i;s=j-h>0;t=j-h<0;u=k-i>0;w=k-i<0;f=(s and u)or(t and w);g=(s and w)or(t and u)
  if not(e or v=='/'and f or v=='\\'and g):a-=j-h;b-=k-i;r+=T([a,b],c)
 if v=='.':
  for x in d:
   for y in d:
    w=[a+x,b+y]
    if not(x==y==0)and w!=p:r+=T(w,c)
 if j==h and k-i>0:
  if v in'aoAOxX':r='('+T([a-1,b-1],c)+')'+v+'('+T([a+1,b-1],c)+')'
  if v=='~':r='~('+T([a,b-1],c)+')'
 if v.isdigit():r=v
 return r
m=[]
for l in sys.stdin:
 m.append(list(l))
e=enumerate
for i,a in e(m):
 for j,b in e(a):
  if b==':':
   print T([i,j-1],[i,j])

เต็ม ungolfed (2488):

import sys

def findOuts(c):
    for i, iVal in enumerate(c):
        for j, jVal in enumerate(iVal):
            if jVal == ':':
                yield [i, j]

def trace(pos, prev):
    if pos[0] < 0 or pos[1] < 0 or pos[0] >= len(circuit) or pos[1] >= len(circuit[pos[0]]):
        return ''
    val = circuit[pos[0]][pos[1]]
    if val == ' ':
        return ''
    next = pos[:]
    ret = ''
    if val in '=-':
        if prev[0] == pos[0]:
            next[1] -= prev[1] - pos[1]
            ret += trace(next, pos)
    if val in '=|':
        if prev[1] == pos[1]:
            next[0] -= prev[0] - pos[0]
            ret += trace(next, pos)
    if val in '=/\\':
        # top-bottom, left-right
        tblr = prev[0] == pos[0] or prev[1] == pos[1]
        # top-left, bottom-right
        tlbr = (prev[0] - pos[0] == 1 and prev[1] - pos[1] == 1) or (prev[0] - pos[0] == -1 and prev[1] - pos[1] == -1)
        # top-right, bottom-left
        trbl = (prev[0] - pos[0] == 1 and prev[1] - pos[1] == -1) or (prev[0] - pos[0] == -1 and prev[1] - pos[1] == 1)
        if not ((val == '/' and (tlbr or tblr)) or (val == '\\' and (trbl or tblr)) or (val == '=' and tblr)):
            next[0] -= prev[0] - pos[0]
            next[1] -= prev[1] - pos[1]
            ret += trace(next, pos)

    if val == '.':
        for x in (-1,0,1):
            for y in (-1,0,1):
                if x == y == 0:
                    continue

                w = [next[0] + x, next[1] + y]
                if w == prev:
                    continue

                # only one of them should return anything
                ret += trace(w, pos)

    # assumption that a logic gate always has a . on its connections, as according to spec
    if val in 'aoAOxX':
        # only from the right/output
        if not (prev[0] == pos[0] and prev[1] == pos[1] + 1):
            return ret
        ret = '(' + trace([next[0] - 1, next[1] - 1], pos) + ')' + val + '(' + trace([next[0] + 1, next[1] - 1], pos) + ')'

    if val == '~':
        # only from the right/output
        if not (prev[0] == pos[0] and prev[1] == pos[1] + 1):
            return ret
        ret = '~(' + trace([next[0], next[1] - 1], pos) + ')'

    if val in '123456789':
        ret = val

    return ret

circuit = []
for line in sys.stdin.readlines():
    # padding added to prevent index out of bounds later
    circuit.append(list(line))

for out in findOuts(circuit):
    next = out[:]
    next[1] -= 1
    print trace(next, out)

Java: 1523 1512 ตัวอักษร

import java.util.*;class W{int v=99;Map<Integer,String>t;boolean k;public static void main(String[]y){new W().d();}W(){try{java.io.InputStream i=new java.io.File("r").toURL().openStream();t=new HashMap<>();int a=0,x=0,y=0;while((a=i.read())>-1){if(a==10){y++;x=0;continue;}q(x,y,(a>47&a<58?"!":"")+(char)a);x++;}}catch(Exception e){}}void d(){while(!k){k=!k;for(Map.Entry<Integer,String>g:t.entrySet())e(g.getKey(),g.getValue());}for(String b:t.values())if(b.startsWith("$"))System.out.println(b.substring(1));}void e(int a,String s){if(s==null||!s.startsWith("!"))return;int x=a/v,y=a%v;s=s.substring(1);b(s,x,y,x-1,y+1);b(s,x,y,x,y+1);b(s,x,y,x+1,y+1);b(s,x,y,x-1,y);b(s,x,y,x+1,y);b(s,x,y,x-1,y-1);b(s,x,y,x,y-1);b(s,x,y,x+1,y-1);}void b(String p,int m,int n,int x,int y){String s=t.get(x*v+y);if(s==null)return;boolean g=y==n+1;boolean h=y==n-1;boolean i=x==m+1;boolean j=x==m-1;if(z(s,"-=")&n==y){if(i)b(p,x,y,x+1,y);if(j)b(p,x,y,x-1,y);}if(z(s,"|=")&m==x){if(g)b(p,x,y,x,y+1);if(h)b(p,x,y,x,y-1);}if(z(s,"/=")){if(j&g)b(p,x,y,x-1,y+1);if(i&h)b(p,x,y,x+1,y-1);}if(z(s,"\\=")){if(i&g)b(p,x,y,x+1,y+1);if(j&h)b(p,x,y,x-1,y-1);}if(z(s,".")){q(x,y,"!"+p);u();}if(z(s,"~")){q(x,y,"!~("+p+")");u();}if((s.charAt(0)=='%'&n==y-1)|(s.charAt(0)=='&'&n==y+1)){q(x,y,"!("+p+")"+s.charAt(1)+"("+s.substring(2)+")");u();}if(z(s,"OoAaXx")){q(x,y,(n==y+1?"%":"&")+s+p);u();}if(z(s,":")){q(x,y,"$"+p);u();}}void q(int x,int y,String z){t.put(x*v+y,z);}void u(){k=false;}boolean z(String s,String c){return c.indexOf(s)>-1;}}

มันให้ผลลัพธ์นี้สำหรับตัวอย่างอินพุต:

(~(((5)X(4))O(3)))a(~(1))
((~(((5)X(4))O(3)))a(~(1)))X(((2)x(1))x(3))

เพื่อบีบขนาดของมัน:

• มันไม่ได้ทำการตรวจสอบข้อผิดพลาดการจัดการข้อผิดพลาดหรือการตรวจสอบการป้อนข้อมูลสมมติว่าอินพุตนั้นถูกต้อง
• จำกัด อินพุตเพียง 99 บรรทัด
• ไฟล์อินพุตของมันต้องถูกเรียกว่า just rโดยไม่มีนามสกุลไฟล์ใด ๆ ในชื่อ
• มันไม่ได้ใช้ความพยายามในการตรวจสอบว่าวงเล็บเป็นหรือไม่จำเป็น มันอนุมานว่าพวกมันมีความจำเป็นเสมอและเนื่องจากข้อสันนิษฐานนี้เป็นเท็จจึงมีวงเล็บมากกว่าที่จำเป็น แต่เนื่องจากมันไม่ได้ทำให้สเป็คล้มเหลวอยู่ดีมันก็ไม่มีปัญหา
• ลำดับของพารามิเตอร์สำหรับตัวดำเนินการไบนารีแต่ละตัวนั้นโดยทั่วไปไม่แน่นอนเนื่องจากขึ้นอยู่กับความเร็วที่ค่านั้นแพร่กระจายและจากลำดับการสแกนเซลล์ แต่เนื่องจากตัวดำเนินการไบนารีทั้งหมดเป็นแบบคอมมิททีทีฟจึงไม่มีปัญหา

ฉันแน่ใจว่ามันควรจะเป็นไปได้ที่จะลดมันมากขึ้น แต่เพียงเล็กน้อย

ล่ามจะดำเนินการในรูปแบบของเซลลูลาร์ออโตมาตา มันสแกนค่าการตั้งค่าฟิลด์ทั้งหมดซ้ำหลาย ๆ ครั้งตามที่จำเป็นจนกว่าจะไม่ตรวจพบการเปลี่ยนแปลง

นี่คือรุ่นที่ไม่ได้รับการอวด:

import java.util.*;

class Wiring {

    int maxLines = 99;
    Map<Integer, String> circuitState;
    boolean finished;

    public static void main(String[] args) {
        new Wiring().interpret();
    }

    Wiring() {

        try {
            // Always read the input from the "r" file, and do not check if it even
            // exists. BTW, the toURL() method is deprecated, but we don't care about
            // this in code-golfing.
            java.io.InputStream stream = new java.io.File("r").toURL().openStream();

            circuitState = new HashMap<>();
            int byteRead = 0, cellX = 0, cellY = 0;

            while ((byteRead = stream.read()) > -1) {

                // Check for line break;
                if (byteRead == 10) {
                    cellY++;
                    cellX = 0;
                    continue;
                }

                // Populate the circuit cell. Precede numbers with an exclamation mark.
                setCircuitCell(cellX, cellY, (byteRead >= '0' & byteRead <= '9' ? "!" : "") + (char) byteRead);
                cellX++;
        } catch (Exception e) {
        }
    }

    void interpret() {
        while (!finished) {
            finished = !finished; // i.e. finished = false;
            for (Map.Entry<Integer, String> entry : circuitState.entrySet()) {
                analyzeCell(entry.getKey(), entry.getValue());
            }
        }

        // Now print the output. To do that scan for cells marked with "$".
        for (String cell : circuitState.values()) {
            if (cell.startsWith("$")) System.out.println(cell.substring(1));
        }
    }

    void analyzeCell(int cellIndex, String cellValue) {
        // Only the cells with a value marked with "!" are worth to analyze.
        if (cellValue == null || !cellValue.startsWith("!")) return;

        // Convert the cellIndex to a bidimensional coordinate.
        int x = cellIndex / maxLines, y = cellIndex % maxLines;

        // Remove the "!".
        cellValue = cellValue.substring(1);

        // Propagate the cell value to neighbouring cells.
        propagateCellData(cellValue, x, y, x - 1, y + 1);
        propagateCellData(cellValue, x, y, x, y + 1);
        propagateCellData(cellValue, x, y, x + 1, y + 1);
        propagateCellData(cellValue, x, y, x - 1, y);
        propagateCellData(cellValue, x, y, x + 1, y);
        propagateCellData(cellValue, x, y, x - 1, y - 1);
        propagateCellData(cellValue, x, y, x, y - 1);
        propagateCellData(cellValue, x, y, x + 1, y - 1);
    }

    void propagateCellData(String cellValue, int sourceX, int sourceY, int targetX, int targetY) {
        String targetContent = circuitState.get(targetX * maxLines + targetY);

        // If the target cell does not exist, just ignore.
        if (targetContent == null) return;

        boolean targetBelowSource = targetY == sourceY + 1;
        boolean targetAboveSource = targetY == sourceY - 1;
        boolean targetRightToSource = targetX == sourceX + 1;
        boolean targetLeftToSource = targetX == sourceX - 1;

        // Propagate horizontally through wires.
        if (isStringContained(targetContent, "-=") & sourceY == targetY) {
            if (targetRightToSource) propagateCellData(cellValue, targetX, targetY, targetX + 1, targetY);
            if (targetLeftToSource) propagateCellData(cellValue, targetX, targetY, targetX - 1, targetY);
        }

        // Propagate vertically.
        if (isStringContained(targetContent, "|=") & sourceX == targetX) {
            if (targetBelowSource) propagateCellData(cellValue, targetX, targetY, targetX, targetY + 1);
            if (targetAboveSource) propagateCellData(cellValue, targetX, targetY, targetX, targetY - 1);
        }

        // Propagate in the diagonal x=-y.
        if (isStringContained(targetContent, "/=")) {
            if (targetLeftToSource & targetBelowSource) {
                propagateCellData(cellValue, targetX, targetY, targetX - 1, targetY + 1);
            }
            if (targetRightToSource & targetAboveSource) {
                propagateCellData(cellValue, targetX, targetY, targetX + 1, targetY - 1);
            }
        }

        // Propagate in the diagonal x=y.
        if (isStringContained(targetContent, "\\=")) {
            if (targetRightToSource & targetBelowSource) {
                propagateCellData(cellValue, targetX, targetY, targetX + 1, targetY + 1);
            }
            if (targetLeftToSource & targetAboveSource) {
                propagateCellData(cellValue, targetX, targetY, targetX - 1, targetY - 1);
            }
        }

        // If we got a dot, store the value there.
        // Do not forget to mark it with "!", so we can rescan it later.
        if (isStringContained(targetContent, ".")) {
            setCircuitCell(targetX, targetY, "!" + cellValue);
            markThatStateChanged();
        }

        // If we got a "~", store the inverted value there.
        // Do not forget to mark it with "!", so we can rescan it later.
        if (isStringContained(targetContent, "~")) {
            setCircuitCell(targetX, targetY, "!~(" + cellValue + ")");
            markThatStateChanged();
        }

        // If we found a binary logical port with one of the values set and
        // we can set the another value, do it. Use "%" and "&" to know which
        // one was already defined.
        // BTW, do not forget to mark it with "!", so we can rescan it later.
        if ((targetContent.charAt(0) == '%' & sourceY == targetY - 1)
                | (targetContent.charAt(0) == '&' & sourceY == targetY + 1))
        {
            setCircuitCell(targetX, targetY,
                    "!(" + cellValue + ")"
                    + targetContent.charAt(1)
                    + "(" + targetContent.substring(2) + ")");
            markThatStateChanged();
        }

        // Found a binary logical port without any value setted, so set it.
        // Use "%" and "&" to mark which one was setted.
        if (isStringContained(targetContent, "OoAaXx")) {
            setCircuitCell(targetX, targetY, (sourceY == targetY + 1 ? "%" : "&") + targetContent + cellValue);
            markThatStateChanged();
        }

        // If we found an output, store the value there.
        // Mark it with "$", so we will print it in the future.
        if (isStringContained(targetContent, ":")) {
            setCircuitCell(targetX, targetY, "$" + cellValue);
            markThatStateChanged();
        }
    }

    void setCircuitCell(int cellX, int cellY, String cellContents) {
        circuitState.put(cellX * maxLines + cellY, cellContents);
    }

    void markThatStateChanged() {
        finished = false;
    }

    boolean isStringContained(String searchingString, String searchTarget) {
        return searchTarget.indexOf(searchingString) > -1;
    }
}