代码编辑器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)

【Python】一文详细介绍 py格式文件高斯小哥 Python基础【高质量合集】python 新手入门学习
【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
python抓包与解包_Python—网络抓包与解包（pcap、dpkt） weixin_39691055 python抓包与解包
pcap安装[root@localhost~]#pipinstallpypcap抓包与解包#-*-coding:utf-8-*-importpcap,dpktimportre,threading,requests__black_ip=['103.224.249.123','203.66.1.212']#抓包：param1eth_name网卡名，如：eth0,eth3。param2p_type日志捕
打印出1-100的奇数。（C语言）王多鱼001 C语言 c语言算法数据结构
代码：#includeintmain(){for(inti=1;i<101;i++){if(i%2==1){printf("%d,",i);}}return0;}
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
llama.cpp 编译安装@Ubuntu skywalk8163 项目实践人工智能 llama ubuntu linux 人工智能
在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
python 推导式(派生、衍生) sanduo112 人工智能 python windows 开发语言
python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
数据挖掘|数据预处理|基于Python的数据标准化方法皖山文武数据挖掘数据建模与分析 python 数据挖掘开发语言
基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
c++中如何判断变量的数据类型，并输出 xnrbjy c++开发语言
C++中如果想要判断变量的数据类型，可以使用typeid运算符。该运算符返回一个std::type_info类型的对象，可以使用name()方法获取其名称从而确定变量的类型，例如：#include#includeusingnamespacestd;intmain(){inta=123;floatb=3.14;boolc=true;chard='A';stringe="HelloWorld";cou
C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
CSV指南：Python程序获取大型CSV文件行数孤独打铁匠Julian 笔记经验分享 python
本指南提供了几种使用Python来获取大型CSV文件行数的方法，并解释了每种方法的适用场景。方法1:使用csv.reader处理复杂CSV文件当你的CSV文件中包含多行字段（即某些字段的值中包含换行符）时，使用csv.reader是一个可靠的选择，因为它能够正确处理这些复杂情况。这个方法适用于大多数大小的CSV文件，但是对于非常大的文件，读取整个文件可能会占用较多的时间和内存。对于极大的文件，考虑
谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Python python chrome drivers
ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
大创项目推荐深度学习 opencv python 公式识别(图像识别机器视觉) laafeer python
文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
python转码 Desamond python 开发语言
转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现）宇宙之一粟不归路之Python #IT面试题收集与总结数据结构与算法算法数据结构排序算法 python java
文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
27.Python从入门到精通—Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为以山河作礼。 #Python基础入门—详解版 python java 服务器
27.从入门到精通：Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理在Python中，异常处理是一种处理程序在执行期间可能遇到的错误的方法。当Python解释器遇到错误时，它会引发异常。异常是一种Python对象，它包含有关错误的信息，例如错误类型和错误位置。为了处理异常，您可以使用try-except语句。在
python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
C++ pdf 打印插入图片灿烂李 java 前端服务器
一：使用PODOFO给PDF插入图片：#includeintmain(){PoDoFo::PdfMemDocumentpdfDocument;PoDoFo::PdfPage*page;PoDoFo::PdfImageimage;PoDoFo::PdfVecObjects*vec_objects;PoDoFo::PdfRectrect;//打开PDF文档pdfDocument.loadFromFil
Python | Redis工具类 -拟墨画扇- Python redis 数据库缓存 python
一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
Python dict字符串转json对象，小数精度丢失问题朝如青丝暮成雪 json python
一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
Linux学习系列之vim编辑器（一） llibertyll linux 学习
vi编辑器的操作模式输入模式—aio等—>命令模式<—：键—末行模式从输入/末行模式切换到命令模式都是需要按ESC键注:a光标后输入，i光标前输入，o直接向下加一行输入，O向上加一行输入在vi编辑器中光标的移动（命令行模式下）键组合（命令）光标的移动$光标移动到当前行的结尾0（零）光标移动到当前行的开始GG光标移动到最后一行gg光标移动到第一行在命令行模式下删除与复制的操作键组合（命令）含义dd删
C语言pthread互斥锁(mutex)和可重入锁(递归锁recursive)的演示嫦娥妹妹等等我开发语言 c语言
实验理论参考:1一旦共享资源被互斥锁锁定,则其余线程想访问共享资源必须等待，直到锁被释放2使用normal属性的互斥锁,一旦发生重入逻辑,则阻塞,成为死锁需要将属性改为recursive成为可重入的,递归的代码功能:1命令行传参1model=1演示异步未上锁之乱序演示count在数据竞态（RaceCondition）下的错误值2命令行传参2model=2演示使用互斥锁后线程的执行顺序演示count
C语言演示多线程编程条件下自旋锁和屏障的使用嫦娥妹妹等等我开发语言 c语言开源
主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
Python+Requests模拟发送GET请求爱学习的执念自动化测试软件测试技术分享 python 开发语言
模拟发送GET请求前置条件：导入requests库一、发送不带参数的get请求代码如下：以百度首页为例importrequests#发送get请求response=requests.get(url="http://www.baidu.com")print(response.content.decode("utf-8"))#以utf-8的编码输出内容二、发送带参数的get请求发送带参数的get请求有
Python极速入门：五分钟开启实战之旅！知白守黑V Python 编程语言系统运维 python 编程语言 python开发 python学习 python入门 python数据分析
1.Python基础语法和结构：了解Python的基本语法，包括变量、数据类型、运算符、注释等。控制流：掌握条件语句（if-elif-else）、循环（for和while）及其控制（break和continue）。函数：学习如何定义和使用函数，包括参数传递、返回值、作用域和闭包。模块和包：理解如何导入和使用模块，以及如何创建和使用自己的包。2.数据处理列表、元组和集合：学习这些序列类型的操作和方法
Python Flask 使用数据库安果移不动 python flask 开发语言
pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy
PaperWeekly sapienst Papers PaperwithCode General ML
1.Python软件包解决DL在未见过的数据分布下性能差的问题：（1）神经网络和损失分离的模块化设计（2）强大便捷的基准测试能力（3）易于使用但难以修改（4）github:https://github.com/marrlab/domainlabTrainer和Models之间是什么关系Trainer和Models是DomainLab中的两个核心概念。Trainer是一个用于指导数据流向模型并计算S
Unity3D 制作MMORPG 3D地图编辑器详解 Thomas_YXQ 3d 编辑器 Unity3D 游戏开发 unity 开发语言
前言在MMORPG游戏中，地图编辑器是一个非常重要的工具，可以帮助开发者快速创建复杂的游戏地图。本文将详细介绍如何使用Unity3D制作一个简单的MMORPG3D地图编辑器。对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！创建地图编辑器界面首先，我们需要创建一个新的Unity项目，并在场景中创建一个空的GameObject作为地图编辑器的主要控制器。然后，我们可以使用
生日蜡烛（C语言） blue and ACM c语言 java 算法
某君从某年开始每年都举办一次生日party，每次吹与年龄相同的蜡烛。现在他共吹了236根蜡烛。请问，他从多少岁开始过生日party的？答案：26#includeintmain(){intage=0;inttotal=0;for(inti=10;i<100;i++){for(intj=i;j<100;j++){total+=j;if(total==236){age=i;break;}}total=0
使用Python读取Excel文件并计算平均分嘻嘻爱编码 Python从入门到放弃 python excel 开发语言
在这篇博客中，我们将探讨如何使用Python的pandas库来读取Excel文件，并计算其中数据的平均分。pandas是一个强大的数据分析工具，它允许我们以简单直观的方式处理表格数据。安装必要的库在开始之前，确保你的环境中安装了pandas和openpyxl库。可以使用以下命令进行安装：pipinstallpandasopenpyxl读取Excel文件首先，我们需要读取Excel文件。假设我们有一
python项目练习——7.网站访问日志分析器 F—— python项目练习 python 信息可视化数据分析数据挖掘开发语言学习
项目功能分析：这个项目可以读取网站的访问日志文件，统计访问量、独立访客数、访问来源等信息，并以图表或表格的形式展示出来。这个项目涉及到文件操作、数据处理、数据可视化等方面的技术。示例代码：importrefromcollectionsimportCounterimportmatplotlib.pyplotaspltdefparse_log_file(log_file):#读取日志文件内容witho
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的配置