Diagram gerbang logika ASCII-seni

12

Saya menantang Anda untuk menulis kode untuk membuat diagram gerbang logika ASCII-art (diperluas) untuk jumlah produk berupa persamaan.

Gunakan notasi berikut untuk mewakili gerbang:

DAN 
    INPUT───|&&
            |&&───OUTPUT
    INPUT───|&&
ATAU 
    INPUT───|OR
            |OR───OUTPUT
    INPUT───|OR
Gerbang dengan lebih dari 2 input 
    INPUT───|OR
            |OR
    INPUT───|OR───OUTPUT
            |OR
    INPUT───|OR
TIDAK 
    INPUT───│>o───OUTPUT

Set karakter

Perhatikan bahwa │itu bukan tanda pipa ASCII tetapi karakter kotak-gambar . Gunakan karakter menggambar kotak seperti ─ │ ┌ ┐ └ ┘untuk koneksi.

Contoh

Memasukkan 
    A'*B'+B*C
Keluaran 
    A────│>o────│&&
                │&&─────┐
    B────│>o────│&&     └│OR
                         │OR─────A*B+B*C
    B───────────│&&     ┌│OR
                │&&─────┘
    C───────────│&&

Pemenang

Pemenangnya adalah jawaban dengan suara terbanyak dalam 5 hari

popularity-contest ascii-art Mukul Kumar
sumber
1
Hanya ada 95 karakter ASCII yang dapat dicetak, dan mereka tidak termasuk salah satu dari ini: ─ │ ┌ ┐ └ ┘. Saya pikir Anda mengacu pada set karakter MS-DOS . Juga, bukankah seharusnya contoh Anda memiliki satu Binput input antara dua gerbang AND? Dan dapatkah kita berasumsi bahwa kabel tidak perlu dilintasi di mana pun?
r3mainer
2
Saya suka bagaimana Anda mengatakan "STRICTLY an ASCII art" dan meminta kami untuk menggunakan rangkaian karakter non-ASCII.
Kendall Frey
@squeamishossifrage Saya pikir ada 128 karakter ASCII dan 256 setelah perpanjangan grafik ascii kunjungi di sini juniper.net/techpubs/en_US/idp5.1/topics/reference/general/…
Mukul Kumar
@squeamishossifrage: Tidak, ia merujuk ke beberapa karakter ASCII yang diperluas . Saya telah mengedit pertanyaan untuk menjelaskannya. Extended ASCII mencakup semua karakter ASCII tujuh-bit, serta beberapa karakter lainnya.
ProgramFOX
1
Mengingat persyaratan untuk menggunakan karakter menggambar kotak, tampaknya aneh bahwa Anda membuat koneksi ─│daripada ─┤.
Peter Taylor

Jawaban:

16

C ++ 11

Akhirnya selesai. Dan itu hanya menghabiskan sebagian besar hari saya.

Sebelum saya mencantumkan kode dan contoh output, beberapa catatan cepat:

Hal-hal yang didukung oleh program ini

  • Sejumlah istilah, masing-masing dengan sejumlah input
  • Menggunakan kembali input
  • Menghilangkan representasi gerbang AND / OR saat hanya satu input yang akan hadir
  • Penggunaan kedua karakter gambar garis codepage 437 dan karakter ramah ASCII 7-bit (gunakan -DCP437 atau apa pun yang setara dengan kompiler Anda adalah untuk dukungan codepage 437)

Hal-hal yang tidak didukung oleh program ini

  • Pengelompokan dengan tanda kurung (karena, serius?)
  • Banyak yang mencatat
  • Setiap spasi putih yang bukan ruang ASCII biasa
  • Golfifikasi yang tepat (meskipun saya memang menghapus semua komentar dalam semangat)
  • Praktek pengkodean yang sehat
  • Melakukan kontak mata dengan kode parsing input
  • Karakter gambar garis Unicode yang portabel. Saya tidak dapat mendukung Unicode karena logika render bergantung pada kemampuan untuk menggambar "turun" charbuffer dua dimensi .

Kode

#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <stdexcept>
#include <set>
#include <map>
#include <valarray>
#include <cmath>

using namespace std;

vector<string> split(const string str, const string delim)
{
    vector<string> v;

    set<char> d;
    for (char c : delim) d.insert(c);

    string current {};
    for (char c : str)
    {
        if (d.find(c) != d.end())
        {
            v.push_back(current);
            current = "";
        }
        else
        {
            current += c;
        }
    }
    v.push_back(current);

    return v;
}

using Input = string;
struct TermInput
{
    Input name;
    int ypos;
    bool neg;
};
using Term = vector<TermInput>;
using Expr = vector<Term>;

#ifdef CP437
constexpr char VERT    = '\xB3';
constexpr char HORIZ   = '\xC4';
constexpr char RBRANCH = '\xC3';
constexpr char LUP     = '\xD9';
constexpr char LDOWN   = '\xBF';
constexpr char RUP     = '\xC0';
constexpr char RDOWN   = '\xDA';
#else
constexpr char VERT    = '|';
constexpr char HORIZ   = '-';
constexpr char RBRANCH = '}';
constexpr char LUP     = '\'';
constexpr char LDOWN   = '.';
constexpr char RUP     = '`';
constexpr char RDOWN   = ',';
#endif

string repeat(string s, int n)
{
    stringstream ss;
    for (int i = 0; i < n; i++)
    {
        ss << s;
    }

    return ss.str();
}
string repeat(char c, int n)
{
    stringstream ss;
    for (int i = 0; i < n; i++)
    {
        ss << c;
    }

    return ss.str();
}

enum class Direction
{
    RIGHT,
    DOWN
};

void matrixPut(char *matrix, int h, int w, int x, int y, const string s, Direction dir)
{
    if (x >= w || y >= h)
    {
        stringstream ss;
        ss << "matrixPut: point (" << x << ", " << y << ") out of matrix bounds!";
        throw new out_of_range(ss.str());
    }

    char *ins = matrix + (y * w) + x;
    char *end = matrix + (h * w);
    for (char c : s)
    {
        if (ins >= end) break;
        *ins = c;

        if (dir==Direction::RIGHT)
        {
            ins++;
        }
        else
        {
            ins += w;
        }
    }
}

void matrixPrint(char *matrix, int h, int w)
{
    for (int i = 0; i < (h * w); i++)
    {
        cout << matrix[i];
        if ((i+1)%w == 0) cout << endl;
    }
}

int main (int argc, char *argv[])
{
    string expression;

    if (argc == 1)
    {
        cout << "Enter expression:" << endl;
        getline(cin, expression);
    }
    else
    {
        expression = argv[1];
    }

    expression.erase(remove(expression.begin(), expression.end(), ' '), expression.end());

    Expr expr {};
    auto inputs = set<Input>();
    auto termInputs = multimap<Input, TermInput>();

    int inputYPos = 0;

    auto e = split(expression, "+");
    for (string term : e)
    {
        Term currTerm {};

        auto t = split(term, "*");
        for (string in : t)
        {
            bool neg = false;
            if (in.back() == '\'')
            {
                in.pop_back();
                neg = true;
            }

            Input currInput {in};
            inputs.insert(currInput);

            TermInput ti {currInput, inputYPos, neg};
            currTerm.push_back(ti);

            termInputs.insert(pair<Input, TermInput>{in, ti});
            inputYPos++;
        }

        expr.push_back(currTerm);
        inputYPos++;
    }


    int height = inputs.size() + termInputs.size() + expr.size() - 1;

    int width = 0;

    width += max_element(inputs.begin(), inputs.end(), [](Input a, Input b){ return a.length() < b.length(); })->length() + 2;
    int inputWidth = width;
    width += inputs.size()*2;

    int notAndStart = width;

    width += 7;
    width += expr.size()+1;

    int orStart = width;

    width += 4;

    width += 4;

    width += expression.length();

    char matrix[height * width];
    for (int i = 0; i < height*width; i++) matrix[i] = ' ';

    int  baseY = inputs.size();

    {
        int x = width - 4 - expression.length();
        int y = baseY + ((height-baseY) / 2);
        matrixPut(matrix, height, width, x, y, repeat(HORIZ, 4) + expression, Direction::RIGHT);
    }

    {
        int x = orStart;
        int y = baseY + (height-baseY)/2 - expr.size()/2;

        if (expr.size() == 1)
        {
            matrixPut(matrix, height, width, x, y, repeat(HORIZ, 4), Direction::RIGHT);
        }
        else {
            matrixPut(matrix, height, width, x  , y, repeat(HORIZ, expr.size()), Direction::DOWN);
            matrixPut(matrix, height, width, x+1, y, repeat(VERT , expr.size()), Direction::DOWN);
            matrixPut(matrix, height, width, x+2, y, repeat('O'  , expr.size()), Direction::DOWN);
            matrixPut(matrix, height, width, x+3, y, repeat('R'  , expr.size()), Direction::DOWN);
        }
    }

    {
        int x = notAndStart;
        int y = baseY;
        for (Term t : expr)
        {
            string layer[7];
            for (TermInput ti : t)
            {
                layer[0] += HORIZ;
                layer[1] += (ti.neg ? '>' : HORIZ);
                layer[2] += (ti.neg ? 'o' : HORIZ);
                layer[3] += HORIZ;
                layer[4] += (t.size() > 1 ? VERT : HORIZ);
                layer[5] += (t.size() > 1 ? '&' : HORIZ);
                layer[6] += (t.size() > 1 ? '&' : HORIZ);
            }

            for (int i = 0; i < 7; i++)
            {
                matrixPut(matrix, height, width, x+i, y, layer[i], Direction::DOWN);
            }

            y += t.size() + 1;
        }
    }

    {
        int x = 0;
        int y = 0;

        for (Input i : inputs)
        {
            string str = i + ": ";
            str += repeat(HORIZ, inputWidth - str.length());

            matrixPut(matrix, height, width, x, y, str, Direction::RIGHT);

            y++;
        }
    }

    {
        int x = inputWidth;
        int num = 0;
        int offset = inputs.size() * 2 - 1;

        for (Input in : inputs)
        {
            int y = 0;
            int len = inputs.size() * 2 - 1;
            auto it = inputs.find(in);
            while (it != inputs.begin())
            {
                it--;
                y++;
                len -= 2;
            }
            matrixPut(matrix, height, width, x, y, repeat(HORIZ, len) + LDOWN, Direction::RIGHT);
        }

        for (Input in : inputs)
        {
            auto yBreakRange = termInputs.equal_range(in);
            valarray<int> yBreaks(termInputs.count(in));
            int idx = 0;
            for (auto ti = yBreakRange.first; ti != yBreakRange.second; ti++)
            {
                yBreaks[idx++] = baseY + ti->second.ypos;
            }

            for (int y : yBreaks)
            {
                matrixPut(matrix, height, width, x+offset, y, repeat(HORIZ, inputs.size()*2 - offset), Direction::RIGHT);
            }

            int y = num + 1;
            int maxBreak = yBreaks.max();
            string branch = repeat(VERT, maxBreak - y + 1);

            for (int i : yBreaks)
            {
                branch[i-y] = RBRANCH;
            }
            branch.back() = RUP;

            matrixPut(matrix, height, width, x+offset, y, branch, Direction::DOWN);

            offset -= 2;
            num++;
        }
    }

    {
        int x = notAndStart + 7;
        int outY = baseY + (height-baseY)/2 - expr.size()/2;
        int breakx = expr.size()/2;

        for (Term t : expr)
        {
            int inY = baseY + (t.front().ypos + t.back().ypos) / 2;

            matrixPut(matrix, height, width, x, inY, repeat(HORIZ, abs(breakx)+1), Direction::RIGHT);

            matrixPut(matrix, height, width, x+abs(breakx)+1, outY, repeat(HORIZ, expr.size()-abs(breakx)), Direction::RIGHT);

            if (inY < outY)
            {
                string branch = LDOWN + repeat(VERT, outY-inY-1) + RUP;
                matrixPut(matrix, height, width, x+abs(breakx)+1, inY, branch, Direction::DOWN);
            }
            else if (inY > outY)
            {
                string branch = RDOWN + repeat(VERT, inY-outY-1) + LUP;
                matrixPut(matrix, height, width, x+abs(breakx)+1, outY, branch, Direction::DOWN);
            }

            outY++;
            breakx--;
        }
    }

    cout << endl;
    matrixPrint(matrix, height, width);
    cout << endl;
}

Output sampel

$ ./gates "A'*B'+B*C"

A: -----.
B: ---. |
C: -. | |
    | | `->o-|&&--.
    | }--->o-|&&  `-|OR
    | |          ,--|OR----A'*B'+B*C
    | `------|&&-'
    `--------|&&

$ ./gates "A*B'*C+B*D'+F*C'*D+G*E*A'+F"

A: -------------.
B: -----------. |
C: ---------. | |
D: -------. | | |
E: -----. | | | |
F: ---. | | | | |
G: -. | | | | | |
    | | | | | | }----|&&
    | | | | | }--->o-|&&---.
    | | | | }--------|&&   |
    | | | | | | |          |
    | | | | | `------|&&--.|
    | | | }------->o-|&&  ||
    | | | | |   |         |`---|OR
    | }--------------|&&  `----|OR
    | | | | `----->o-|&&-------|OR----A*B'*C+B*D'+F*C'*D+G*E*A'+F
    | | | `----------|&&  ,----|OR
    | | |       |         |,---|OR
    `----------------|&&  ||
      | `------------|&&--'|
      |         `->o-|&&   |
      |                    |
      `--------------------'

Output sampel (dengan CP437 diaktifkan)

A: ─────────────┐
B: ───────────┐ │
C: ─────────┐ │ │
D: ───────┐ │ │ │
E: ─────┐ │ │ │ │
F: ───┐ │ │ │ │ │
G: ─┐ │ │ │ │ │ │
    │ │ │ │ │ │ ├────│&&
    │ │ │ │ │ ├───>o─│&&───┐
    │ │ │ │ ├────────│&&   │
    │ │ │ │ │ │ │          │
    │ │ │ │ │ └──────│&&──┐│
    │ │ │ ├───────>o─│&&  ││
    │ │ │ │ │   │         │└───│OR
    │ ├──────────────│&&  └────│OR
    │ │ │ │ └─────>o─│&&───────│OR────A*B'*C+B*D'+F*C'*D+G*E*A'+F
    │ │ │ └──────────│&&  ┌────│OR
    │ │ │       │         │┌───│OR
    └────────────────│&&  ││
      │ └────────────│&&──┘│
      │         └─>o─│&&   │
      │                    │
      └────────────────────┘
kereta gantung
sumber
4
+10 untuk tekad mantap belaka :-)
r3mainer
Itu bukan hasil yang saya inginkan tetapi, +1 untuk kerja keras Anda (secara pribadi, saya menghargainya). Juga sebutkan bahasa Anda!
Mukul Kumar
Pujian. Ini sangat bagus, CP437 atau tidak.
Jonathan Van Matre
Saya membuat beberapa pengeditan untuk posting (bukan kode) berdasarkan umpan balik di atas. Saya juga mendapat MinGW untuk bekerja pada sistem saya sehingga saya bisa membangunnya dengan dukungan CP437 asli, jadi saya menambahkan beberapa contoh formulir keluaran itu.
curtmack
Pada baris 202 saya mendapatkan kesalahan kompilasi di VisualExpress: tinggi int dan lebar int: Ekspresi harus memiliki nilai konstan. Anda juga hilang#include <vector>
Jack Cole
5

C ++

Wah! Dilakukan dalam 1 hari 12 jam !!!
Kode ini hanya menangani array

INPUT (JENIS)

  • Hanya SOP (jumlah produk) yang terbentuk.

  • Hanya penambahan istilah dengan dua variabel yang dikalikan

    EXAMPLES :-

    A*B'+B*A+C*D  

    X*Y+Z'*A'*V*D+B*G+C'*A'

  • Dapat menangani sejumlah istilah, variabel.

    KODE: -

    #include<iostream>
using namespace std;
int main()
{
int i,j,k,l,m=0;
char arr[80][80],expr[45];
cout<<"enter the SOP(Sum Of products) expression : ";
cin>>expr;
cout<<"\n\n";
for(i=0;expr[i]!='\0';i++)
if(expr[i]=='*')m++;
for(i=0;i<80;i++)
    for(j=0;j<80;j++)
        arr[i][j]=' ';
for(i=0,j=0;i<80,expr[j]!='\0';j++)
{
    if(expr[j]<=90&&expr[j]>=65||expr[j]<=122&&expr[j]>=97)
    {
        arr[i][0]=expr[j];
        i+=2;
    }
}
for(i=0,j=1;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j-1]<=90&&arr[i][j-1]>=65||arr[i][j-1]<=122&&arr[i][j-1]>=97)
    {
        for(k=0;k<7;k++)
            arr[i][j+k]=196;
        arr[i][j+k]=180;
    }
}
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j]==(char)180&&arr[i][j+1]==' ')
    {
        arr[i][j+1]=38;
    }
}
for(i=0,j=0,k=1;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i-1][j]==(char)180&&arr[i+1][j]==(char)180)
    {
        if(arr[i-1][j+1]==(char)38&&arr[i+1][j+1]==(char)38&&k)
        {
            arr[i][j]=179;arr[i][j+1]=38;
            for(l=2;l<4;l++)
            {
                arr[i][j+l]=196;
            }
            k--;
        }
        else if(k==0)
        {
            k=1;
        }
    }
}
l=m;
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j-1]==(char)196&&arr[i][j+1]==' '&&arr[i][j-2]==(char)38)
        {
        if(arr[i+3][j-2]==(char)38)
        {
            for(k=0;k<l;k++)
                arr[i][j+k]=(char)196;
            arr[i][j+k-1]=(char)191;

            l--;
        }
        else
        {
            for(k=0;k<m;k++)
            arr[i][j+k]=(char)196;
        }
    }
}
for(i=0,j=0,k=1;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j]==(char)191&&arr[i][j-1]==(char)196)
    {
        for(;arr[i+k][j]==' ';k++)
        {
            arr[i+k][j]=(char)179;
        }
    k=1;
    }
}
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j]==(char)179&&arr[i][j-3]==(char)38&&arr[i+1][j]==(char)196)
    {
        arr[i][j]=(char)192;
        for(k=1;arr[i-k][j+k]==(char)179;k++)
        {
            arr[i-k][j+k]=(char)192;
        }
    }
}
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j-1]==(char)192)
    {
        for(k=0;arr[i][j+k]!=' ';k++)
            arr[i][j+k]=(char)196;
    }
}
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j-1]==(char)192&&arr[i][j]==' '||arr[i][j-1]==(char)196&&arr[i][j]==' ')
    {
        arr[i][j]=(char)180;
        arr[i][j+1]='O';
        arr[i][j+2]='R';
    }
}
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j-1]=='R'&&arr[i+1][j-1]==' ')
    {
        for(k=0;k<3;k++)
            arr[i][j+k]=(char)196;
        j+=k;
        for(k=0;expr[k]!='\0';k++)
        {
            arr[i][j+k]=expr[k];
        }
    }
}
for(i=0,k=0;i<80,expr[k]!='\0';k++)
{
    if((expr[k]<='z'&&expr[k]>='a'||expr[k]<='Z'&&expr[k]>='A'))
    {
        if(expr[k+1]=='\'')
            arr[i][1]='\'';
        i+=2;
    }
}
for(i=0,j=0;i<80;j++)
{
    if(j==80){i++;j=0;}
    if(arr[i][j]=='\''&&arr[i][j+1]==(char)196)
    {
        arr[i][j+3]=(char)180;
        arr[i][j+4]=(char)62;
        arr[i][j+5]='o';
    }
}
for(i=0;i<35;i++)
{
    for(j=0;j<80;j++)
        cout<<arr[i][j];
    cout<<'\n';
}
return 0;
}

KELUARAN

masukkan deskripsi gambar di sini

Mukul Kumar
sumber