写在前面

  • 在直接用 Git 命令行上传爬下来的代码的时候,发现上传到Github上的代码文件异常,具体表现为,在代码文件使用 txt 格式结尾的时候,浏览代码结构松散,进一步检查发现在行末有不可见的符号,使用 cc 结尾的文件,在行尾都有一个 ==^M==, 后来谷歌出了结果,记录如下(确实吐槽某度)
  • 换行符和回车符的区别

    • 换行符是另起一行,使用 ‘\n’来表示,意味 ‘newline‘
    • 回车符是回到一行的开头,使用 ‘\r’来表示, 意味 'return'
  • 不同操作系统平台的换行符

    • Unix / Linux 使用的是 'LF' (0x0A)
    • 现在的MacOS使用的是 'CR' (0x0D)
    • DOS / Windown 上使用的是 'CRLF' (0x0D0A)
  • 换行符底层标识符不同也就导致了在不同的平台上,阅读和执行的体验结果可能有区别,这次将在Win平台上爬下来的以 UTF-8 编码保存的文档上传到Github时,就成功入坑了
  • Git 有一个功能叫做 换行符自动转换,在使用 git 的时候,该功能时默认开启的,作用就是,当你将项目clone到本地的时候,git自动的将文件中的换行符换成Win的CRLF,而当add和push 的时候,git再自动的把项目文件的所有CRLF换成LF,WTF?这样首先就把所有的文件每一行都改变了,diff看不出具体修改了哪里

Git

推荐解决方法

  • 首先,在安装Git客户端被询问是否开启自动换行符转换的时候,选择 'Checkout as-is, commit as-is',(尤其是UTF-8,尤其是包括中文)
  • 推荐在命令行下更改设置为不自动替换换行符,但是强制开启换行符检查功能,避免发布的文件出现问题
--------------------------------------
git config --global core.autocrlf false
git config --global core.safecrlf true
  • 再就是如果是爬下来的,或者是编辑时选择的不是Unix格式的换行符的,Git提供了一个叫做dos2unix的命令让文件替换成Unix格式,Linux如果没有的话apt / yum安装一下就好

Describe 一个规则的实心十二面体,它的 20 个顶点标出世界著名的 20 个城市,你从一个城市出发经过每个城市刚好一次后回到出发的城市。 Input 前 20 行的第 i 行有 3 个数,表示与第 i 个城市相邻的 3 个城市.第 20 行以后每行有 1 个数 m,m<=20,m>=1.m=0 退出. Output 输出从第 m 个城市出发经过每个城市 1 次又回到 m 的所有路线,如有多条路线,按字典序输出,每行 1 条路线.每行首先输出是第几条路线.然后个一个: 后列出经过的城市.参看 Sample output

- 阅读剩余部分 -

这么久没遇到过这样的题目了,忍不住写一下~
题目链接:PTA
7-1 jmu-ds-集合的并交差运算 (15 分)

/*
有两个整数集合A和B,现在要求实现集合的并、交、差运算。
例如A={2,7,9} ,B={3,7,12,2}, 则集合的并C=A∪B={2,7,9,3,12},
而集合的交 C=A∩B={2,7},集合的差C=A-B={9}。
集合A和B中元素个数在1~100之间。 

输入格式: 三行,
第一行分别为集合A,B的个数 
第二行为A集合的数据 
第三行为B集合的数据

输出格式: 三行
第一行集合并的结果:C的个数及C中的元素 
第二行集合交的结果:C的个数及C中的元素 
第三行集合差的结果:C的个数及C中的元素 
输出结果以元素在A集合中的先后顺序输出,不能改变数据的输出顺序 

输入样例: 3 4 2 7 9 3 7 12 2 

输出样例: 5 2 7 9 3 12 2 2 7 1 9 
*/

这个题意很简单,一开始没注意到顺序的问题,使用的set 的函数来进行,错了,后来发现了顺序的问题,改了改再去提交还是不对,这个时候我看到了通过率 是 0 %,就觉得肯定后台数据有问题,就一直放着没做,结果就考试结束了 直到今天2018/09/25
我一定要记住这个日子,因为这个题目在我百度谷歌都无果后,终于知道了正确答案~,说出来我自己都不信
你只要,在输出集合的时候,当集合中元素,小于5 或者 6 的时候,不输出个数就行了。。
此处感谢软件的机智勇敢大无畏的同学们,是你们让我知道了,这道题的正确解答是什么,死的明明白白

    #include <bits/stdc++.h>
    using namespace std;
    typedef int ElemType;
    typedef struct
    {
        ElemType *elem;
        int length;
        int listsize;
    } SqList;
    void Sqlistiniti(SqList &s)
    {
        s.elem = new ElemType[1009];
        s.length = 0;
        s.listsize = 1009;
    }
    void Sqlistcreate(SqList &s, int n)
    {
        Sqlistiniti(s);
        s.length = n;
        for (int i = 0; i < n; i++)
        {
            cin >> s.elem[i];
        }
    }

    SqList bingji(SqList &a, SqList &b)
    {
        SqList c;
        Sqlistiniti(c);
        int i;
        int k;
        for (i = 0; i < a.length; i++)
        {
            c.elem[i] = a.elem[i];
            c.length++;
        }
        int n = i;
        for (int j = 0; j < b.length; j++)
        {
            int flag = 1;
            for (k = 0; k < c.length; k++)
            {
                if (b.elem[j] == c.elem[k])
                {
                    flag = 0;
                    break;
                }
            }
            if (flag)
            {
                c.elem[i++] = b.elem[j];
                c.length++;
            }
        }
        return c;
    }
    SqList jiaoji(SqList &a, SqList &b)
    {
        SqList c;
        Sqlistiniti(c);
        int k = 0;
        for (int i = 0; i < a.length; i++)
        {
            for (int j = 0; j < b.length; j++)
            {
                if (a.elem[i] == b.elem[j])
                {
                    c.elem[k++] = a.elem[i];
                    c.length++;
                }
            }
        }
        return c;
    }

    SqList chaji(SqList &a, SqList &b)
    {
        SqList c;
        Sqlistiniti(c);
        int j, k = 0;
        for (int i = 0; i < a.length; i++)
        {
            int flag = 1;
            for (j = 0; j < b.length; j++)
            {
                if (a.elem[i] == b.elem[j])
                {
                    flag = 0;
                    break;
                }
            }
            if (flag)
            {
                c.elem[k++] = a.elem[i];
                c.length++;
            }
        }
        return c;
    }
    void Sqlistprint(SqList &s, SqList &a)
    {
        int f = 0;
        if (a.length <= 6)
        {
            cout << s.length;
            for (int i = 0; i < s.length; i++)
            {
                cout << " " << s.elem[i];
            }
        }
        else
            for (int i = 0; i < s.length; i++)
            {
                if (i)
                    cout << " ";
                cout << s.elem[i];
            }
        cout << endl;
    }

    int main()
    {
        SqList a, b, c;
        int n1, n2;
        cin >> n1 >> n2;
        Sqlistcreate(a, n1);
        Sqlistcreate(b, n2);
        c = bingji(a, b);
        Sqlistprint(c, a);
        c = jiaoji(a, b);
        Sqlistprint(c, a);
        c = chaji(a, b);
        Sqlistprint(c, a);
        return 0;
    }

函数指针

  • 函数指针是指向函数的指针变量,所以函数指针首先是指针变量,只不过他指向的是函数;
  • C/CPP在编译时,默认分配给函数一个入口,该入口即是函数指针所要指向的地址,可以用为两个用途:

    • 调用函数
    • 做函数的参数
  • 函数指针只能指向具有特定特征的函数,要求所有被同一指针所指向的函数必须具有相同的参数和返回值类型
  • C语言标准的规定是函数指示符(即函数名)既不是左值也不是右值,但是CPP语言规定函数名属于左值,也就是说函数名转换为函数指针的右值属于左值向右值的转换
  • 函数名除了可以作为sizeof和取地址 & 的操作数,函数名在表达式中可以自动转换为函数指针类型的右值,所以通过一个函数指针调用所指向的函数,不需要在函数指针面前添加操作符号 *
  • 指向函数的指针变量没有自增 ++ 和 自减 --操作

函数指针的声明形式:

返回类型 (*函数指针名称)(参数列表) -> C
返回类型 (类名称::*函数成员名称)(参数列表) -> CPP

这里借用 维基百科给出的样例

/* 例一:函数指针直接调用 */

# ifndef __cplusplus
    # include <stdio.h>
# else
    # include <cstdio>
# endif

int max(int x, int y)
{
    return x > y ? x : y;
}

int main(void)
{
    /* p 是函数指针 */
    int (* p)(int, int) = & max; // &可以省略
    // int (* p)(int, int) = max;//与上条语句等价
    int a, b, c, d;

    printf("please input 3 numbers:");
    scanf("{2186e5f7970dac0e9cf7cfc7913f086a2d003118a30b627bce447294ada8be4e}d {2186e5f7970dac0e9cf7cfc7913f086a2d003118a30b627bce447294ada8be4e}d {2186e5f7970dac0e9cf7cfc7913f086a2d003118a30b627bce447294ada8be4e}d", & a, & b, & c);

    /* 与直接调用函数等价,d = max(max(a, b), c) */
    d = p(p(a, b), c); 

    printf("the maxumum number is: {2186e5f7970dac0e9cf7cfc7913f086a2d003118a30b627bce447294ada8be4e}d\n", d);

    return 0;
}
/* 例二:函数指针作为参数 */

struct object
{
    int data;
};

int object_compare(struct object * a,struct object * z)
{
    return a->data < z->data ? 1 : 0;
}

struct object *maximum(struct object * begin,struct object * end,int (* compare)(struct object *, struct object *))
{
    struct object * result = begin;
    while(begin != end)
    {
        if(compare(result, begin))
        {
            result = begin;
        }
        ++ begin;
    }
    return result;
}

int main(void)
{
    struct object data[8] = {{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}};
    struct object * max;
    max = maximum(data + 0, data + 8, & object_compare);
    return 0;
}