你好!蒋韦杰-（烟雨平生）

代码编辑器1.7.1

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
#define pass
#define PASS
#define UP                                      72
#define DOWN                                    80
#define LEFT                                    75
#define RIGHT                                   77
#define H                                       29
#define W                                       114
 
#define helps "\
                                       \n\
                                           \n\
                                           \n\
<'!'>                                           \n\
                                           \n\
                                       \n\
                                       \n\
 num                                 \n\
       num                                 \n\
 str                                 \n\
\'> str                                 \n\
 num                                 \n\
<\'{\'>     num,begin,step                      \n\
<\">        num,begin,step                      \n\
     num,begin,step,+ str                \n\
     num,begin,step,- num                \n\
<\'/\'>                                         \n\
       str                                 \n\
       str,color                           \n\
     \n command                          \n\
                                         \n\
                                         \n\
     str1,str2                           \n\
   str                                 \n\
Ctrl + A                                        \n\
Ctrl + B                                        \n\
Ctrl + D                                        \n\
Ctrl + E                                        \n\
Ctrl + F                                        \n\
Ctrl + L                                        \n\
Ctrl + O                                        \n\
Ctrl + R                                        \n\
Ctrl + S                                        \n\
Ctrl + T                                        \n\
Ctrl + U                                        \n\
CTRL + Enter                                    \n\
F1                                              \n\
F2                                              \n\
F3                                              \n\
F4                                              \n\
F5                                              \n\
F6                                              \n\
"
 
#ifndef min
#define min(a, b) ({                                                                                            \
    typeof(a) x = (a);                                                                                          \
    typeof(b) y = (b);                                                                                          \
    x < y ? x : y;                                                                                              \
})
#endif
 
#ifndef max
#define max(a, b) ({                                                                                            \
    typeof(a) x = (a);                                                                                          \
    typeof(b) y = (b);                                                                                          \
    x > y ? x : y;                                                                                              \
})
#endif
 
#define color(tc)                               SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), tc)
 
#define gotoxy(xx, yy)                                                                                          \
    do{                                                                                                         \
        COORD position = {xx, yy};                                                                              \
        SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), position);                                  \
    }while(false)
 
typedef signed char                             int8;
typedef signed short                            int16;
typedef signed long                             int32;
typedef signed long long                        int64;
typedef unsigned char                           uint8;
typedef unsigned short                          uint16;
typedef unsigned long                           uint32;
typedef unsigned long long                      uint64;
typedef unsigned char                           byte_t;
typedef unsigned short                          word_t;
typedef unsigned long                           iterator;
typedef void*                                   pointer_t;
 
template  class vector {
    public:
        type* p;
        size_t Len;
        size_t Size;
        vector () {
            p = NULL;
            Len = 0;
            Size = 0;
        }
        ~vector () {
            delete[] p;
        }
        size_t size () {
            return Size;
        }
        size_t len () {
            return Len;
        }
        void exp () {
            Len = (Len << 1) + 1;
            if (p == NULL) {
                p = new type [ Len ];
            } else {
                type *tp = new type [ Len ];
                for (size_t it = 0; it < Size; it++)
                    tp[ it ] = p[ it ];
                delete[] p;
                p = tp;
            }
            return;
        }
        void exp (size_t ts) {
            while (ts >= Len)
                exp ();
            return;
        }
        type& operator [] (size_t it) {
            if (it >= Len)
                exp (it);
            return p[ it ];
        }
        type at (size_t it) {
            if (it >= Len)
                exp (it);
            return p[ it ];
        }
        void push_back (type& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void push_back (type&& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void push_back (vector & vc) {
            for (size_t i = 0; i < vc.size(); i++)
                push_back (vc[i]);
            return;
        }
        void pop_back () {
            if (Size > 0)
                Size--;
            return;
        }
        void pop_back (size_t ts) {
            if (Size >= ts)
                Size -= ts;
            else
                Size = 0;
            return;
        }
        void insert (size_t it, type& x) {
            if (Size == Len) exp ();
            for (size_t it_t = Size; it_t > it; it_t--)
                p[ it_t ] = p[it_t - 1];
            p[ it ] = x;
            Size++;
            return;
        }
        void insert (size_t it, type&& x) {
            if (Size == Len)
                exp ();
            for (size_t it_t = Size; it_t > it; it_t--)
                p[ it_t ] = p[it_t - 1];
            p[ it ] = x;
            Size++;
            return;
        }
        void erase (size_t it) {
            Size--;
            for (size_t it_t = it; it_t < Size; it_t++)
                p[ it_t ] = p[it_t + 1];
            return;
        }
        void reverse () {
            for (size_t it = 0; it < (Size >> 1); it++) {
                type tt = p[ it ];
                p[ it ] = p[Size - it - 1];
                p[Size - it - 1] = tt;
            }
            return;
        }
        void operator ++ () {
            if (Size == Len)
                exp ();
            Size++;
            return;
        }
        void operator ++ (int) {
            if (Size == Len)
                exp ();
            Size++;
            return;
        }
        void operator += (type& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void operator += (type&& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void operator += (vector & vc) {
            for (size_t i = 0; i < vc.size(); i++)
                push_back (vc[i]);
            return;
        }
        void operator -- () {
            if (Size > 0)
                Size--;
            return;
        }
        void operator -- (int) {
            if (Size > 0)
                Size--;
            return;
        }
        void operator -= (size_t ts) {
            if (Size >= ts)
                Size -= ts;
            else Size = 0;
            return;
        }
        void operator = (vector & vc) {
            for (size_t i = 0; i < vc.size(); i++)
                push_back (vc[i]);
            return;
        }
};
template  struct node {
    type v;
    node * pre;
    node * next;
    node () {
        pre = next = NULL;
    }
};
template  class list {
    public:
        node * head;
        node * tail;
        list () {
            head = new node ;
            tail = new node ;
            head -> next = tail;
            tail -> pre = head;
        }
        ~list () {
            node * fn = head;
            node * sn = head;
            while (fn !=NULL) {
                sn = sn -> next;
                delete fn;
                fn = sn;
            }
        }
        node * begin () {
            return head;
        }
        node * end () {
            return tail;
        }
        void push_back (type& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void push_back (type&& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void push_back (list & tl) {
            node * tn = tl.begin();
            tn = tn -> next;
            while (tn != tl.end()) {
                push_back(tn -> v);
                tn = tn -> next;
            }
            return;
        }
        void pop_back () {
            node * tn = tail -> pre;
            if (tn != head) {
                tail -> pre = tn -> pre;
                tn -> pre -> next = tail;
                delete tn;
            }
            return;
        }
        void insert (node * in, type& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = in;
            tn -> next = in -> next;
            in -> next -> pre = tn;
            in -> next = tn;
            return;
        }
        void insert (node * in, type&& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = in;
            tn -> next = in -> next;
            in -> next -> pre = tn;
            in -> next = tn;
            return;
        }
        void erase (node * en) {
            node * tn = en -> next;
            if (tn != tail) {
                en -> next = tn -> next;
                tn -> next -> pre = en;
                delete tn;
            }
            return;
        }
        void operator += (type& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void operator += (type&& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void operator += (list & tl) {
            node * tn = tl.begin();
            tn = tn -> next;
            while (tn != tl.end()) {
                push_back(tn -> v);
                tn = tn -> next;
            }
            return;
        }
        void operator -- () {
            node * tn = tail -> pre;
            if (tn != head) {
                tail -> pre = tn -> pre;
                tn -> pre -> next = tail;
                delete tn;
            }
            return;
        }
        void operator = (list & tl) {
            node * tn = tl.begin();
            tn = tn -> next;
            while (tn != tl.end()) {
                push_back(tn -> v);
                tn = tn -> next;
            }
            return;
        }
};

namespace snake {
    #define X 23
    #define Y 40
    #define MAXLEN 75
    #define MINTIME 75
    unsigned int snake[MAXLEN][2];
    unsigned int len;
    unsigned int lastt[2];
    unsigned int score;
    unsigned int max_score;
    unsigned int way;
    double wait;
    int input;
    unsigned int food[2];
    bool empty=true;
    void welcome    ();
    void init       ();
    void drawmap    ();
    void drawsnake  ();
    void move       ();
    void clt        ();
    void getin      ();
    void putfood    ();
    void eatfood    ();
    bool gameover   ();
    int start       ();
    #undef X
    #undef Y
    #undef MAXLEN
    #undef MINTIME
}
 
struct Pos {
    char                                        ch;
    byte_t                                      cl;
};
 
list  >                           doc;
node  >*                          ty;
iterator                                        tx;
node  >*                          py;
iterator                                        px;
short                                           cnt;
bool                                            lock;
size_t                                          lines;
 
char                                            name[W];
char                                            path[W];
bool                                            isat[256];
Pos                                             preout[H][W];
Pos                                             thisout[H][W];
 
std::map                   keyword;
 
void whelp          ();
void rpath          ();
void rdocu          (int argc, char* argv);
void init           (int argc, char** argv);
void save           ();
void doccopy        (const char* from, const char* to);
void cppcopy        (const char* to);
void output         ();
bool cfn            (int ch);
bool cctrl          (int ch);
bool ccom           (int ch);
void input          ();
 
int main (int argc, char** argv) {
    system ("title FastCode 1.7.1");
    system ("mode con lines=31 cols=120");
    whelp ();
    rpath ();
    init (argc, argv);
    input ();
    return 0;
}
 
void whelp () {
    FILE* fp = fopen ("FCDOC\\help.txt", "w");
    fprintf (fp, helps);
    fclose (fp);
    return;
}
void rpath () {
    FILE*                                       fp = fopen ("FCDOC\\path.txt", "r");
    if (fp == NULL) {
        printf ("编译器路径:");
        gets (path);
        FILE*                                   sf = fopen ("path.txt", "w");
        fprintf (sf, "%s", path);
        fclose (sf);
    } else {
        fscanf (fp, "%s", path);
    }
    fclose (fp);
}
void rdocu (int argc, char* argv) {
    int                                         ch;
    vector                                tv;
    FILE*                                       fp = fopen (argv, "r");
    printf ("读取中...\n");
    iterator                                    nt = strlen (argv) - 1;
    for (; nt > 0; nt--) { 
        if (argv[nt - 1] == '\\')
            break;
    }
    if (argc != 1) {
        for (iterator it = 0; argv[nt] != '\0'; it++) {
            name[it]                            = argv[nt];
            nt++;
        }
    }
    ch                                          = fgetc (fp);
    while (ch != EOF) {
        if (ch == 10) {
            node  >* tn           = new node  >;
            for (iterator it = 0; it < tv.size(); it++)
                tn -> v.push_back (tv[it]);
            tn -> pre                           = doc.tail -> pre;
            tn -> next                          = doc.tail;
            doc.tail -> pre -> next             = tn;
            doc.tail -> pre                     = tn;
            while (tv.size () != 0)
                tv.pop_back ();
        } else if (ch == 9) {
            do {
                tv                              += ' ';
            } while (tv.size () % 4 != 0);
        } else {
            tv                                  += ch;
        }
        printf ("%c", ch);
        ch                                      = fgetc(fp);
    }
    if (tv.size () != 0) {
        node  >*                  tn = new node  >;
        for (iterator it = 0; it < tv.size(); it++)
            tn -> v.push_back (tv[it]);
        tn -> pre                               = doc.tail -> pre;
        tn -> next                              = doc.tail;
        doc.tail -> pre -> next                 = tn;
        doc.tail -> pre                         = tn;
    }
    fclose (fp);
    return;
}
void init (int argc, char** argv) {
    printf ("初始化...\n");
    if (argc != 1) {
        rdocu (argc, argv[1]);
    } else {
        system ("cls");
        printf ("文件名:");
        gets (name);
        FILE*                                   fp = fopen (name, "r");
        if (fp) {
            fclose (fp);
            rdocu (argc, name);
        } else {
            vector                        tv;
            doc                                 += tv;
        }
    }
    char                                        ts[W];
    sprintf (ts, "title %s", name);
    system (ts);
    ty                                          = doc.begin () -> next;
    tx                                          = 0;
    py                                          = doc.begin () -> next;
    px                                          = 0;
    lock                                        = true;
    for (iterator yi = 0; yi < H - 1; yi++) {
        for (iterator xi = 0; xi < W - 7; xi++) {
            preout[yi][xi].cl                   = 15;
            preout[yi][xi].ch                   = ' ';
        }   
    }
    for (iterator yi = 0; yi < H - 1; yi++) {
        for (iterator xi = 0; xi < W - 7; xi++) {
            thisout[yi][xi].cl                  = 15;
            thisout[yi][xi].ch                  = ' ';
        }   
    }
    CONSOLE_CURSOR_INFO cursor_info = {1, 0};
    SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
    isat['~']                                   = true;
    isat['!']                                   = true;
    isat['%']                                   = true;
    isat['^']                                   = true;
    isat['&']                                   = true;
    isat['*']                                   = true;
    isat['(']                                   = true;
    isat[')']                                   = true;
    isat['-']                                   = true;
    isat['+']                                   = true;
    isat['=']                                   = true;
    isat['{']                                   = true;
    isat['}']                                   = true;
    isat['[']                                   = true;
    isat[']']                                   = true;
    isat['|']                                   = true;
    isat[':']                                   = true;
    isat[';']                                   = true;
    isat['<']                                   = true;
    isat['>']                                   = true;
    isat[',']                                   = true;
    isat['.']                                   = true;
    isat['?']                                   = true;
    isat['/']                                   = true;
    keyword["alignas"]                          = 11;
    keyword["alignof"]                          = 11;
    keyword["and"]                              = 11;
    keyword["and_eq"]                           = 11;
    keyword["asm"]                              = 11;
    keyword["auto"]                             = 11;
    keyword["bitand"]                           = 11;
    keyword["bitor"]                            = 11;
    keyword["bool"]                             = 11;
    keyword["break"]                            = 11;
    keyword["case"]                             = 11;
    keyword["catch"]                            = 11;
    keyword["char"]                             = 11;
    keyword["char16_t"]                         = 11;
    keyword["char32_t"]                         = 11;
    keyword["class"]                            = 11;
    keyword["compl"]                            = 11;
    keyword["const"]                            = 11;
    keyword["constexpr"]                        = 11;
    keyword["const_cast"]                       = 11;
    keyword["continue"]                         = 11;
    keyword["decltype"]                         = 11;
    keyword["default"]                          = 11;
    keyword["delete"]                           = 11;
    keyword["do"]                               = 11;
    keyword["double"]                           = 11;
    keyword["dynamic_cast"]                     = 11;
    keyword["else"]                             = 11;
    keyword["enum"]                             = 11;
    keyword["explicit"]                         = 11;
    keyword["export"]                           = 11;
    keyword["extern"]                           = 11;
    keyword["false"]                            = 11;
    keyword["float"]                            = 11;
    keyword["for"]                              = 11;
    keyword["friend"]                           = 11;
    keyword["goto"]                             = 11;
    keyword["if"]                               = 11;
    keyword["inline"]                           = 11;
    keyword["int"]                              = 11;
    keyword["long"]                             = 11;
    keyword["mutable"]                          = 11;
    keyword["namespace"]                        = 11;
    keyword["new"]                              = 11;
    keyword["noexcept"]                         = 11;
    keyword["not"]                              = 11;
    keyword["not_eq"]                           = 11;
    keyword["nullptr"]                          = 11;
    keyword["operator"]                         = 11;
    keyword["or"]                               = 11;
    keyword["or_eq"]                            = 11;
    keyword["private"]                          = 11;
    keyword["protected"]                        = 11;
    keyword["public"]                           = 11;
    keyword["register"]                         = 11;
    keyword["reinterpret_cast"]                 = 11;
    keyword["return"]                           = 11;
    keyword["short"]                            = 11;
    keyword["signed"]                           = 11;
    keyword["sizeof"]                           = 11;
    keyword["static"]                           = 11;
    keyword["static_assert"]                    = 11;
    keyword["static_cast"]                      = 11;
    keyword["struct"]                           = 11;
    keyword["switch"]                           = 11;
    keyword["template"]                         = 11;
    keyword["this"]                             = 11;
    keyword["thread_local"]                     = 11;
    keyword["throw"]                            = 11;
    keyword["true"]                             = 11;
    keyword["try"]                              = 11;
    keyword["typedef"]                          = 11;
    keyword["typeid"]                           = 11;
    keyword["typeof"]                           = 11;
    keyword["typename"]                         = 11;
    keyword["union"]                            = 11;
    keyword["unsigned"]                         = 11;
    keyword["using"]                            = 11;
    keyword["virtual"]                          = 11;
    keyword["void"]                             = 11;
    keyword["volatile"]                         = 11;
    keyword["wchar_t"]                          = 11;
    keyword["while"]                            = 11;
    keyword["xor"]                              = 11;
    keyword["xor_eq"]                           = 11;
    system ("cls");
    return;
}
void save () {
    FILE*                                       fp = fopen(name, "w");
    node  >*                      sp = doc.begin () -> next;
    while (sp != doc.end ()) {
        for (iterator it = 0; it < sp -> v.size(); it++)
            fputc (sp -> v[it], fp);
        fputc ('\n', fp);
        sp = sp -> next;
    }
    fclose(fp);
    return;
}
void doccopy (const char* from, const char* to) {
    FILE*                                       fp = fopen (from, "r");
    if (fp == NULL) {
        printf ("打开失败!\n");
        return;
    }
    FILE*                                       tp = fopen (to, "w");
    char                                        ch;
    ch                                          = fgetc (fp);
    while (ch != EOF) {
        fputc (ch, tp);
        ch                                      = fgetc (fp);
    }
    fclose (fp);
    fclose (tp);
    printf ("成功!\n");
    return;
}
void cppcopy (const char* to) {
    FILE*                                       fp = fopen (name, "r");
    FILE*                                       tp = fopen (to, "w");
    char                                        ch;
    ch                                          = fgetc (fp);
    while (ch != EOF) {
        fputc (ch, tp);
        ch                                      = fgetc (fp);
    }
    fclose (fp);
    fclose (tp);
    printf ("成功!\n");
    return;
}
void output () {
    node  >* pt                   = py;
    for (iterator yy = 0; yy < H - 1 && pt != doc.end (); yy++) {
        byte_t                                  cl;
        iterator                                xx;
        std::string                             ks;
        bool                                    isinc   = false;
        bool                                    isstr   = false;
        bool                                    isch    = false;
        bool                                    isnum   = false;
        for (xx = 0; xx < W - 7 && xx + px < pt -> v.size (); xx++) {
            char                                putch   = pt -> v.at(xx + px);
            if ((!isinc) && (!isstr) && (!isch)) {
                if ((putch >= 'A' && putch <= 'Z') || (putch >= 'a' && putch <= 'z') || (putch >= '0' && putch <= '9') || putch == '_')
                    ks += putch;
                else {
                    if (keyword[ks] != 0) {
                        for (iterator it = 0; it < ks.size(); it++) {
                            if (pt == ty && xx + px - ks.size() + it == tx)
                                thisout[yy][xx + px - ks.size() + it].cl = 240;
                            else
                                thisout[yy][xx + px - ks.size() + it].cl = keyword[ks];
                        }
                    }
                    ks = "";
                }
            } else {
                ks = "";
            }
            if (putch == ' ' || isat[(int)putch] == true || xx + px == 0) {
                isnum                           = true;
            } else if(putch < '0' || putch > '9') {
                isnum                           = false;
            }
            if ((!isstr) && (!isch)  && (isinc || putch == '#'))  {
                cl                              = 10;
                isinc                           = true;
            } else if ((!isinc) && (!isch)  && (isstr || putch == '\"')) {
                cl                              = 11;
                if (pt -> v[xx + px] == '\"')
                    isstr                       = !isstr;
            } else if ((!isinc) && (!isstr) && (isch  || putch == '\'')) {
                cl                              = 14;
                if (pt -> v[xx + px] == '\'')
                    isch                        = !isch;
            } else if ((!isinc) && (!isstr) && (!isch) && (isnum) && (putch >= '0' && putch <= '9')) {
                cl                              = 11;
            } else if (isat[(int)putch] == true) {
                cl                              = 9;
            } else {
                cl                              = 15;
            }
            if (pt == ty && xx + px == tx) {
                cl                              = 240;
            }
            thisout[yy][xx].cl                  = cl;
            thisout[yy][xx].ch                  = putch;
        }
        cl                                      = 15;
        if (pt == ty && tx == pt -> v.size ()) {
            cl                                  = 240;  
        }
        thisout[yy][xx].cl                      = cl;
        thisout[yy][xx].ch                      = ' ';
        pt                                      = pt -> next;
    }
    pt                                          = py;
    gotoxy (0, 0);
    for (iterator yy = 0; yy < H - 1 && pt != doc.end(); yy++) {
        color (112);
        printf ("%4d ", (int)(lines + yy));
        for (iterator xx = 0; xx < W - 6; xx++) {
            if (thisout[yy][xx].ch != preout[yy][xx].ch || thisout[yy][xx].cl != preout[yy][xx].cl) {
                gotoxy ((short)(xx + 5), (short)yy);
                color (thisout[yy][xx].cl);
                printf ("%c", thisout[yy][xx].ch);  
            }
        }
        color (12);
        gotoxy ((short)(W - 2), (short)yy);
        if (pt -> v.size() > W - 8) {
            printf (" > ");
        } else {
            printf ("   ");
        }
        printf ("\n");
        pt                                      = pt -> next;
    }
    color (15);
    printf ("%114c", ' ');
    memcpy (preout, thisout, sizeof (preout));
    for (iterator yi = 0; yi < H - 1; yi++) {
        for (iterator xi = 0; xi < W - 7; xi++) {
            thisout[yi][xi].cl                  = 15;
            thisout[yi][xi].ch                  = ' ';
        }   
    }
    return;
}
bool cfn (int ch) {
    if (ch == 0) {
        char                                    prt[W + 7];
        memset(prt, '\b', sizeof(prt));
        prt[W + 6] = '\0';
        printf("%s", prt);
        ch                                      = getch ();
        switch (ch) {
            case 59: {
                printf (helps);
                system ("pause");
                break;
            }
            case 60: {
                save ();
                char                            calls[W];
                sprintf (calls, "%s -o3 %s -m32 -std=gnu++14", path, name);
                printf ("%s\n", calls);
                system (calls);
                system ("start 3.exe");
                system ("pause");
                break;
            }
            case 61: {
                save ();
                char                            calls[W];
                sprintf (calls, "%s -o3 %s -m32 -std=gnu++14 -lwsock32", path, name);
                printf ("%s\n", calls);
                system (calls);
                system ("3.exe");
                system ("pause");
                break;
            }
            case 62: {
                save ();
                char                            calls[W];
                sprintf (calls, "%s -o3 %s -m32 -std=gnu++14 -lwsock32", path, name);
                printf ("%s\n", calls);
                system (calls);
                system ("pause");
                break;
            }
            case 63: {
                system ("start 3.exe");
                system ("pause");
                break;
            }
            case 64: {
                system ("3.exe");
                system ("pause");
                break;
            }
            case 65: {
                save ();
                system (name);
                system ("pause");
                break;
            }
            default:
                break;
        }
        for (iterator yi = 0; yi < H - 1; yi++) {
            for (iterator xi = 0; xi < W - 7; xi++) {
                preout[yi][xi].cl               = 15;
                preout[yi][xi].ch               = ' ';
            }   
        }
        system ("cls");
        return true;
    }
    return false;
}
bool cctrl (int ch) {
    if (ch == 1) {
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 'u');
        tx++;           ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 2) {
        ty -> v.insert (tx, 'b');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 4) {
        ty -> v.insert (tx, 'd');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'u');
        tx++;
        ty -> v.insert (tx, 'b');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 5) {
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'x');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 6) {
        ty -> v.insert (tx, 'f');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 12) {
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 15) {
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'p');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 18) {
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, 'i');
        tx++;
        ty -> v.insert (tx, 's');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 19) {
        ty -> v.insert (tx, 's');
        tx++;
        ty -> v.insert (tx, 'i');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'd');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 20) {
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'm');
        tx++;
        ty -> v.insert (tx, 'p');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 21) {
        ty -> v.insert (tx, 'u');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 's');
        tx++;
        ty -> v.insert (tx, 'i');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'd');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    }
    return false;
}
bool ccom (int ch) {
    if (ch == 10) {
        char                                    prt[W + 7];
        memset(prt, '\b', sizeof(prt));
        prt[W + 6]                              = '\0';
        printf("%sFastCode:>  ", prt);
        ch                                      = getchar ();
        switch (ch) {
            case 'h':
            case 'H':
            case '?': {
                printf (helps);
                system ("pause");
                break;
            }
            case 's':
            case 'S': {
                save ();
                break;
            }
            case 'q':
            case 'Q': {
                save ();
                exit (0);
            }
            case '!': {
                exit (0);
            }
            case 'o':
            case 'O': {
                save ();
                char                            calls[W];
                sprintf (calls, "%s -o3 %s -m32 -std=gnu++14 -lwsock32", path, name);
                printf("%s\n", calls);
                system (calls);
                system ("start 3.exe");
                system ("pause");
                break;
            }
            case 'r':
            case 'R':
            case ':': {
                save ();
                char                            calls[W];
                sprintf (calls, "%s -o3 %s -m32 -std=gnu++14 -lwsock32", path, name);
                printf("%s\n", calls);
                system (calls);
                system ("3.exe");
                system ("pause");
                break;
            }
            case 't':
            case 'T':
            case '^': {
                tx                              = 0;
                cnt                             = 0;
                lines                           = 0;
                ty                              = doc.begin () -> next;
                py                              = doc.begin () -> next;
                break;
            }
            case 'l':
            case 'L':
            case 'y':
            case 'Y':
            case '@': {
                unsigned int    linenum;
                scanf ("%d", &linenum);
                tx                              = 0;
                cnt                             = 0;
                lines                           = 0;
                ty                              = doc.begin () -> next;
                py                              = doc.begin () -> next;
                for (iterator it = 0; it < linenum; it++) {
                    if (ty -> next != doc.end ()) {
                        ty                      = ty -> next;
                        py                          = py -> next;
                        lines++;
                    }
                }
                break;
            }
            case 'x':
            case 'X': {
                unsigned int                    colnum;
                scanf ("%d", &colnum);
                tx                              = colnum;
                if (tx < 0) {
                    tx                          = 0;
                }
                if (tx > ty -> v.size()) {
                    tx                          = ty -> v.size();
                }
                break;
            }
            case 'u':
            case 'U':
            case '<': {
                int                             len;
                bool                            okk;
                char                            word[W];
                getchar ();
                gets (word);
                len                             = strlen(word);
                while (ty -> pre != doc.begin()) {
                    tx                          = 0;
                    ty                          = ty -> pre;
                    cnt--;
                    for (; (signed int)tx < (signed int)ty -> v.size() - len; tx++) {
                        okk                     = true;
                        for (iterator it = 0; it < len; it++) {
                            if (word[it] != ty -> v[tx + it]) {
                                okk             = false;
                                break;
                            }
                        }
                        if (okk) {
                            goto                FL_END;
                        }
                    }
                }
                break;
FL_END:
                break;
            }
            case 'b':
            case 'B':
            case '>': {
                int                             len;
                bool                            okk;
                char                            word[W];
                getchar ();
                gets (word);
                len                             = strlen(word);
                while (ty -> next != doc.end()) {
                    tx                          = 0;
                    ty                          = ty -> next;
                    cnt++;
                    for (; (signed int)tx < (signed int)ty -> v.size() - len; tx++) {
                        okk = true;
                        for (iterator it = 0; it < len; it++) {
                            if (word[it] != ty -> v[tx + it]) {
                                okk             = false;
                                break; 
                            }
                        }
                        if (okk) {
                            goto                FR_END;
                        }
                    }
                }
                break;
FR_END:
                break;
            }
            case 'e':
            case 'E':
            case '-': {
                int                             num;
                scanf ("%d", &num);
                for (iterator it = 0; it < num; it++) {
                    if (tx > 0) {
                        tx--;
                        ty -> v.erase (tx);
                    }
                }
                break;
            }
            case '{': {
                int                             num;
                int                             step;
                int                             begin;
                char                            word[W];
                scanf ("%d,%d,%d", &num, &begin, &step);
                for (iterator it = 0; it < num; it++) {
                    sprintf (word, "%d", it * step + begin);
                    for (iterator i = 0; word[i] != '\0'; i++) {
                        ty -> v.insert (tx, word[i]);
                        tx++;
                    }
                    ty -> v.insert (tx, ',');
                    tx++;
                    ty -> v.insert (tx, ' ');
                    tx++;
                }
                break;
            }
            case '\"': {
                int                             num;
                int                             step;
                char                            begin;
                scanf ("%d,%c,%d", &num, &begin, &step);
                for (iterator it = 0; it < num; it++) {
                    ty -> v.insert (tx, (char)(it * step) + begin);
                    tx++;
                }
                break;
            }
            case 'f':
            case 'F':
            case '|': {
                int                             num;
                int                             deln;
                int                             step;
                int                             begin;
                char                            ch;
                char                            str[W];
                node  >*  tn = ty;
                scanf ("%d,%d,%d,%c", &num, &begin, &step, &ch);
                if (ch == '-') {
                    scanf ("%d", &deln);
                    tx                          -= deln;
                    while (tx < 0) {
                        tx++;
                        deln--;
                    }
                } else if (ch == '+') {
                    getchar ();
                    gets (str);
                }
                for (iterator it = 0; it < num; it++) {
                    if (ch == '-') {
                        for (iterator it = 0; it < deln; it++)
                            tn -> v.erase (tx);
                    } else if (ch == '+') {
                        for (iterator l = 0; str[l] != '\0'; l++)
                            tn -> v.insert (l + tx, str[l]);
                    }
                    for (iterator l = 0; l < step; l++) {
                        if (tn -> next != doc.end())
                            tn                  = tn -> next;
                        else
                            goto    LF_END;
                    }
                }
                break;
LF_END:
                break;
            }
            case '/': {
                ty -> v.insert (0, '#');
                ty -> v.insert (0, '/');
                ty -> v.insert (0, '/');
                tx                              = 0;
                break;
            }
            case 'k':
            case 'K': {
                char                            word[W];
                scanf ("%s", word);
                keyword[word]                   = 11;
                break;
            }
            case 'p':
            case 'P': {
                unsigned int        tcolor;
                char                word[W];
                scanf ("%s", word);
                scanf ("%d", &tcolor);
                keyword[word]                   = (byte_t)tcolor;
                break;
            }
            case 'w':
            case 'W':
            case '$': {
                char                            calls[W];
                getchar ();
                gets (calls);
                system (calls);
                system ("pause");
                break;
            }
            case 'c':
            case 'C':
            case '=': {
                std::string                     TempBin;
                HGLOBAL                         hMemBin = NULL;
                PCHAR                           LockBin = NULL;
                node  >*  tn = doc.begin () -> next;
                OpenClipboard(NULL);
                EmptyClipboard();
                while (tn != doc.end ()) {
                    for (iterator it = 0; it < tn -> v.size (); it++)
                        TempBin                 += tn -> v[it];
                    TempBin                     += '\n';
                    tn                          = tn -> next;
                }
                hMemBin                         = GlobalAlloc(GMEM_MOVEABLE, TempBin.size() + 1);
                LockBin                         = (PCHAR)GlobalLock(hMemBin);
                RtlMoveMemory(LockBin, TempBin.c_str(), TempBin.size() + 1);
                GlobalUnlock(hMemBin);
                LockBin                         = NULL;
                SetClipboardData(CF_TEXT, hMemBin);
                CloseClipboard();
                break;
            }
            case 'v':
            case 'V':
            case '~': {
                lock                            = !lock;
                break;
            }
            case 'm':
            case 'M':
            case '%': {
                char                            from[W];
                char                            to[W];
                getchar ();
                gets (from);
                gets (to);
                doccopy (from, to);
                system ("pause");
                break;
            }
            case 'd':
            case 'D':
            case ';': {
                char                            to[W];
                getchar ();
                gets (to);
                save ();
                cppcopy (to);
                system ("pause");
                break;
            }
            case 'g':
            case 'G': {
                int                             no;
                scanf ("%d", &no);
                switch (no) {
                    case 0: {
                        snake::start ();
                        break;
                    }
                    default:
                        break;
                }
                system ("title FastCode");
                break;
            }
            default:
                break;
        }
        CONSOLE_CURSOR_INFO cursor_info = {1, 0};
        SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
        for (iterator yi = 0; yi < H - 1; yi++) {
            for (iterator xi = 0; xi < W - 7; xi++) {
                preout[yi][xi].cl                   = 15;
                preout[yi][xi].ch                   = ' ';
            }   
        }
        system ("cls");
        return true;
    }
    return false;
}
void input () {
    int                                         ch;
    output ();
    while (true) {
        if (kbhit () != 0) {
            while (kbhit () != 0) {
                ch                              = getch ();
                if (cfn (ch)) {
                    pass;
                } else if (cctrl (ch)) {
                    pass;
                } else if (ch == 8) {
                    if (tx == 0) {
                        if (ty -> pre != doc.begin ()) {
                            ty = ty -> pre;
                            tx = ty -> v.size();
                            for (iterator it = 0; it < ty -> next -> v.size (); it++)
                                ty -> v += ty -> next -> v[it];
                            doc.erase (ty);
                            cnt--;
                        }
                    } else {
                        ty -> v.erase (tx - 1);
                        tx--;
                    }
                } else if (ch == 9) {
                    do {
                        ty -> v.insert (tx, ' ');
                        tx++;
                    } while (tx % 4 != 0);
                } else if (ccom (ch)) {
                    pass;
                } else if (ch == 13) {
                    node  >* tn = new node  >;
                    for (iterator it = tx; it < ty -> v.size (); it++)
                        tn -> v += ty -> v[it];
                    ty -> v                     -= (ty -> v.size() - tx);
                    tn -> pre                   = ty;
                    tn -> next                  = ty -> next;
                    ty -> next -> pre           = tn;
                    ty -> next                  = tn;
                    ty                          = ty -> next;
                    tx                          = 0;
                    cnt++;
                } else if (ch == 27) {
                    save ();
                    return;
                } else if (lock && ch == '(')  {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, ')');
                } else if (lock && ch == '[')  {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, ']');
                } else if (lock && ch == '{')  {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, '}');
                } else if (lock && ch == '\"') {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, '\"');
                } else if (lock && ch == '\'') {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, '\'');
                } else if (ch == 224) {
                    ch = getch ();
                    switch (ch) {
                        case UP: {
                            if (ty -> pre != doc.begin ()) {
                                ty              = ty -> pre;
                                tx              = min (tx, ty -> v.size ());
                                cnt--;
                            }
                            break;
                        }
                        case DOWN: {
                            if (ty -> next != doc.end ()) {
                                ty              = ty -> next;
                                tx              = min (tx, ty -> v.size ());
                                cnt++;
                            }
                            break;
                        }
                        case LEFT: {
                            if (tx > 0) {
                                tx--;
                            }
                            break;
                        }
                        case RIGHT: {
                            if (tx < ty -> v.size ()) {
                                tx++;
                            }
                            break;
                        }
                    }
                } else {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                }
                while (cnt > H - 2) {
                    lines++;
                    cnt--;
                    py                          = py -> next;
                }
                while (cnt < 0) {
                    lines--;
                    cnt++;
                    py                          = py -> pre;
                }
            }
            output ();
        }
    }
    return;
}

namespace snake {
    #define X 23
    #define Y 40
    #define MAXLEN 75
    #define MINTIME 75
    void welcome () {
        printf  ("游戏规则:\n");
        printf  ("w,a,s,d,控制移动\n");
        getch   ();
        system  ("cls");
        return;
    }
    void init () {
        system ("title 贪吃蛇");
        CONSOLE_CURSOR_INFO cursor_info = {1, 0};
        SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
        std::fstream in ("score.txt", std::ios::in);
        if (!in.fail ())
            in >> max_score;
        else
            welcome ();
        in.close ();
        len = 4;
        snake[0][0] = X >> 1;
        snake[0][1] = Y >> 1;
        snake[1][0] = (X >> 1) + 1;
        snake[1][1] = Y >> 1;
        snake[2][0] = (X >> 1) + 2;
        snake[2][1] = Y >> 1;
        snake[3][0] = (X >> 1) + 3;
        snake[3][1] = Y >> 1;
        way = UP;
        wait = 150.0;
        return;
    }
    void drawmap (){
        color (255);
        for (unsigned int xx = 0; xx < X; xx++){
            gotoxy (0, (short)xx);
            printf ("  ");
            gotoxy ((short)(Y * 2 - 2), (short)xx);
            printf ("  ");
        }
        for (unsigned int yy = 0; yy < Y; yy++){
            gotoxy ((short)(yy * 2), 0);
            printf ("  ");
            gotoxy ((short)(yy * 2), (short)(X - 1));
            printf ("  ");
        }
        return;
    }
    void drawsnake (){
        color (255);
        gotoxy (0,0);
        printf ("  ");
        color (10);
        gotoxy ((short)(snake[0][1] * 2), (short)snake[0][0]);
        printf ("□");
        gotoxy ((short)(snake[1][1] * 2), (short)snake[1][0]);
        printf ("■");
        return;
    }
    void move () {
        lastt[0] = snake[len-1][0];
        lastt[1] = snake[len-1][1];
        for (unsigned int tc = len - 1; tc > 0; tc--){
            snake[tc][0] = snake[tc-1][0];
            snake[tc][1] = snake[tc-1][1];
        }
        switch (way) {
            case UP: {
                snake[0][0]--;
                break;
            }
            case DOWN: {
                snake[0][0]++;
                break;
            }
            case LEFT: {
                snake[0][1]--;
                break;
            }
            case RIGHT: {
                snake[0][1]++;
                break;
            }
        }
        return;
    }
    void clt () {
        color (0);
        gotoxy ((short)(lastt[1] * 2), (short)lastt[0]);
        printf ("  ");
        return;
    }
    void getin () {
        if (kbhit () != 0) {
            while (kbhit() != 0)
                input = getch ();
            switch (input) {
                case 'W':
                case 'w': {
                    if (way != DOWN)
                        way = UP;
                    break;
                }
                case 'S':
                case 's': {
                    if (way != UP)
                        way = DOWN;
                    break;
                }
                case 'A':
                case 'a':{
                    if (way != RIGHT)
                        way = LEFT;
                    break;
                }
                case 'D':
                case 'd':{
                    if (way != LEFT)
                        way = RIGHT;
                    break;
                }
            }
        }
        return;
    }
    void putfood () {
        if (empty) {
            bool flag = true;
            srand (time (NULL));
            while (flag) {
                food[0] = rand () % (X - 2) + 1;
                food[1] = rand () % (Y - 2) + 1;
                flag = false;
                for (unsigned int tc = 0; tc < len; tc++) {
                    if(snake[tc][0] == food[0] && snake[tc][1] == food[1])
                        flag = true;
                } 
            }
            empty = false;
            color (14);
            gotoxy ((short)(food[1] * 2), (short)food[0]);
            printf ("◆");
        }
        return;
    }
    void eatfood () {
        if (snake[0][0] == food[0] && snake[0][1] == food[1]) {
            empty = true;
            score++;
            if(wait >= MINTIME)
                wait -= 0.5;
            if(len < MAXLEN)
                len++;
        }
        return;
    }
    bool gameover () {
        bool over = false;
        if (snake[0][0] == 0 || snake[0][0] == X - 1 || snake[0][1] == 0 || snake[0][1] == Y - 1)
            over = true;
        for (unsigned int tc = 1; tc < len; tc++)
            if (snake[0][0] == snake[tc][0] && snake[0][1] == snake[tc][1])
                over = true;
        if (over == true) {
            system ("cls");
            while (kbhit() != 0)
                getch ();
            printf ("Game over!\n");
            printf ("Score:%d\n",score);
            printf ("Max score:%d\n",max_score);
            getch ();
            system ("cls");
            printf ("Save...\n");
            if (score > max_score) {
                std::fstream write;
                write.open ("score.txt",std::ios::out);
                write << score;
                write.close ();
                max_score = score;
            }
        }
        return over;
    }
    int start () {
        init ();
        drawmap ();
        Sleep (3000);
        while (true) {
            clt         ();
            drawsnake   ();
            putfood     ();
            eatfood     ();
            getin       ();
            move        ();
            if (gameover ())
                break;
            Sleep ((DWORD)(wait));
        }
        return 0;
    }
    #undef X
    #undef Y
    #undef MAXLEN
    #undef MINTIME
}

<'!'>



num
num
str
'> str
num
<'{'> num,begin,step
<"> num,begin,step
num,begin,step,+ str
num,begin,step,- num
<'/'>
str
str,color

command


str1,str2
str
Ctrl + A
Ctrl + B
Ctrl + D
Ctrl + E
Ctrl + F
Ctrl + L
Ctrl + O
Ctrl + R
Ctrl + S
Ctrl + T
Ctrl + U
CTRL + Enter
F1
F2
F3
F4
F5
F6

你可能感兴趣的:(编辑器,c++,c语言,python)

OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
jquery实现的jsonp掉java后台知了ing java jsonp jquery
什么是JSONP？先说说JSONP是怎么产生的：其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 2、
Struts2学习笔记 caoyong struts2
SSH : Spring + Struts2 + Hibernate 三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 分层原则:单向依赖，接口耦合 1、Struts2 = Struts + Webwork 2、搭建struts2开发环境 a>、到www.apac
SpringMVC学习之后台往前台传值方法满城风雨近重阳 springMVC
springMVC控制器往前台传值的方法有以下几种： 1.ModelAndView 通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参： ModelAndView mv=new ModelAndView(); mv.setViewName="success
WebService存在的必要性？一炮送你回车库 webservice
做Java的经常在选择Webservice框架上徘徊很久，Axis Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。当在不同的平台间传输数据时，就需要一个都能解析的数据格式。但是为什么要使用xml呢？不能使json或者其他通用数据
js年份下拉框 3213213333332132 java web ee
<div id="divValue">test...</div>测试 //年份 <select id="year"></select> <script type="text/javascript"> window.onload =
简单链式调用的实现技术归来朝歌方法调用链式反应编程思想
在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用这样的调用你可能在Ajax中，在页面中添加标签： $("<p>").append($("<span>").text(list[i].name)).appendTo("#result"); 也可能在HQ
JAVA调用.net 发布的webservice 接口 darkranger webservice
/** * @Title: callInvoke * @Description: TODO(调用接口公共方法) * @param @param url 地址 * @param @param method 方法 * @param @param pama 参数 * @param @return * @param @throws BusinessException
Javascript模糊查找 | 第一章循环不能不重视。 aijuans Way
最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： function search(){ var arr=new Array("my
狼和羊，该怎么抉择 atongyeye 工作
狼和羊，该怎么抉择在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
读取android系统的联系人拨号百合不是茶 android sqlite数据库内容提供者系统服务的使用
联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢关键代码: 1, 使用javabean操作存储读取到的数据 package com.example.bean; /** * * @author Admini
ORACLE自定义异常 bijian1013 数据库自定义异常
实例： CREATE OR REPLACE PROCEDURE test_Exception ( ParameterA IN varchar2, ParameterB IN varchar2, ErrorCode OUT varchar2 --返回值,错误编码 ) AS /*以下是一些变量的定义*/ V1 NUMBER; V2 nvarc
查看端号使用情况征客丶 windows
一、查看端口在windows命令行窗口下执行： >netstat -aon|findstr "8080" 显示结果： TCP 127.0.0.1:80 0.0.0.0:0 &
【Spark二十】运行Spark Streaming的NetworkWordCount实例 bit1129 wordcount
Spark Streaming简介 NetworkWordCount代码 /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with
Struts2 与 SpringMVC的比较 BlueSkator struts2 spring mvc
1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
Hibernate在更新时，是可以不用session的update方法的(转帖） BreakingBad Hibernate update
地址：http://blog.csdn.net/plpblue/article/details/9304459 public void synDevNameWithItil() {Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
读《研磨设计模式》-代码笔记-观察者模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; import java.util.Observable; import java.util.Observer; /** * “观
重置MySQL密码 chenhbc mysql 重置密码忘记密码
如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 1、关闭MySQL服务 2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL mysqld --skip-grant-tables 3、新开一个CMD窗口，进入MySQL mysql -uroot
再谈系统论，控制论和信息论 comsci 设计模式生物能源企业应用领域模型
再谈系统论，控制论和信息论偶然看
oracle moving window size与 AWR retention period关系 daizj oracle
转自： http://tomszrp.itpub.net/post/11835/494147 晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. SQL> select * from v$version; BANNER -------------------
Python版B树 dieslrae python
话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 首先是数据实体对象,很简单,只存放key,value class Entity(object): '''数据实体''' def __init__(self,key,value)
C语言冒泡排序 dcj3sjt126com 算法
代码示例： # include <stdio.h> //冒泡排序 void sort(int * a, int len) { int i, j, t; for (i=0; i<len-1; i++) { for (j=0; j<len-1-i; j++) { if (a[j] > a[j+1]) // >表示升序
自定义导航栏样式 dcj3sjt126com 自定义
-(void)setupAppAppearance { [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]]; [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
11.性能优化-优化-JVM参数总结 frank1234 jvm参数性能优化
1.堆 -Xms --初始堆大小 -Xmx --最大堆大小 -Xmn --新生代大小 -Xss --线程栈大小 -XX:PermSize --永久代初始大小 -XX:MaxPermSize --永久代最大值 -XX:SurvivorRatio --新生代和suvivor比例,默认为8 -XX:TargetSurvivorRatio --survivor可使用
nginx日志分割 for linux HarborChung nginx linux 脚本
nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限复制代码代码如下: chmo
Spring4新特性——泛型限定式依赖注入 jinnianshilongnian spring spring4 泛型式依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
centOS安装GCC和G++ liuxihope centos gcc
Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。按照这个思路，我想安装过程如下：安装gcc：yum install gcc 安装g++： yum install g++ 实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
第13章 Ajax进阶（上） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
How to determine BusinessObjects service pack and fix pack blueoxygen BO
http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/ The table below is helpful. Reference BOE XI 3.x 12.0.0. y BOE XI 3.0 12.0. x. y BO
Oracle里的自增字段设置 tomcat_oracle oracle
　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列 create table t ( id 　　　　 number generated by default as identity (start with 1 increment b
Spring Security（01）——初体验 yang_winnie spring Security
Spring Security（01）——初体验博客分类： spring Security Spring Security入门安全认证首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置