C的笔记 | You

杨辉三角

数组要初始化
找规律

#include <stdio.h>
// 1
// 1 1
// 1 2 1
// 1 3 3 1
// 1 4 6 4 1

int main()
{
    int arr[10][10] = { 0 };
    int i = 0;
    int j = 0;
    for (i = 0; i <= 10; i++)
    {
        for (j = 0; j <= i; j++)
        {
            //第一列全1
            if (j == 0)
            {
                arr[i][j] = 1;
            }
            //对角线全1
            if (i == j)
            {
                arr[i][j] = 1;
            }
            if (i >= 2 && j >= 1)
            {
                arr[i][j] = arr[i -1][j - 1] + arr[i - 1][j];
            }
        }
    }
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j <= i; j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

杨辉三角.png

凶杀案

A：不是我

B：是C

C：是D

D：C在胡说

三个真话一个假话

#include <stdio.h>
int main()
{
    //假设法
    //1为真0为佳，竖着一组
    //A:0 1 1 1
    //B:0 0 1 0
    //C:0 0 0 1
    //D:1 1 1 0
    int killer = 0;
    for (killer = 'A'; killer <= 'D'; killer++)
    {
        if ((killer !='A') + (killer == 'C') + (killer == 'D') + (killer != 'D') == 3)
            {
                printf("凶手是%c", killer);
            }
    }
    return 0;
}

凶手是谁.png

趣味问题

燃香问题

有一根香材质不均匀，燃完一根需要1h，给你两根香，确认一个15min实践段。

将第一根香两端点燃，这样就确定了一个30min，同时将第一根香一段点燃
在第一根香燃烧完后，第二根香就剩30min了，这样再按照第一根香的方法就确定了15min

拆名次

A：B第二，我第三
B：我第二，E第四
C:我第一，D第二
D：C最后，我第三
E:我第四，A第一
每位选手都说对了一半

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    int e = 0;
    for (a = 1; a <= 5; a++)
    {
        for (b = 1; b <= 5; b++)
        {
            for (c = 1; c <= 5; c++)
            {
                for (d = 1; d <= 5; d++)
                {
                    for (e = 1; e <= 5; e++)
                    {
                        if (((b == 2) + (a == 3) == 1)
                        && ((b == 2) + (e == 4) == 1) 
                        && ((c == 1) + (d == 2) == 1) 
                        && ((c == 5) + (d == 3) == 1) 
                        && ((e == 4) + (a == 1) == 1)
                        )
                        {
                            if (a * b * c * d * e == 120)
                                printf("a=%d b=%d c=%d d=%d e=%d \n", a, b, c, d, e);
                        }
                    }
                }
            }
        }
    }
    return 0;
}

排名.png

二维数组列排序

#include <stdio.h>
int main(){
	int i, j, k, b[20][20];
	int m,n;
	scanf("%d %d", &m, &n);
	for(i = 0; i < m; i++)
		for(j = 0; j < n; j++)
			scanf("%d",  &b[i][j]);
	int temp = 0;
	for(i = 0; i < n; i++){
		for(j = 0; j < m; j++){
			for(k = 0; k < m - j - 1; k++){
				if(b[k][i] < b[k + 1][i]){
					temp = b[k][i];
					b[k][i] = b[k + 1][i];
					b[k + 1][i] = temp;
				} 
			}
		}
	}		
	for(i=0;i<m;i++){
			for(j=0;j<n;j++)
				printf("%d ", b[i][j]);
	printf("\n");
	}
	return 0;
			
}

3_7-指针

一级指针传参

#define _CRT_SECUTE_NO_WARNIG
#include <stdio.h>

void print(int* ptr, int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *(ptr + i));
    }
}
void test(char* p)
{

}
// 一级指针传参
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = arr;
    int sz = sizeof(arr) / sizeof(arr[0]);
    //p是一级指针
    print(p, sz);
    char* ch = 'w'; // 数组名是首地址
    char* p1 = &ch; //对于其它类型的变量需要取地址
    test(&ch);      //取地址完再存放到同类型的指针变量也行
    test(p1);
    return 0;
}

二级指传参

#define _CRT_SECUTE_NO_WARNIG
#include <stdio.h>

void test(int** p2)
{
    **p2 = 20;
}
int main()
{
    int a = 10;
    int* pa = &a;//pa一级指针
    int** ppa = &pa;//ppa是二级指针
    //把二级指针进行传参？
    test(ppa);
    test(&pa);//传一级指针变量的地址
    printf("%d\n", a);
    return 0;
}

函数指针

#define _CRT_SECUTE_NO_WARNIG
#include <stdio.h>

int Add(int x, int y)
{
    return x + y;
}
int main()
{
    int a = 10;
    int* pa = &a;
    
    char ch = 'w';
    char* pc = &ch;

    int arr[10] = { 0 };
    int (*parr)[10] = &arr;//取出数组的地址
    //parr 是指向数组的指针 - 存放的是数组的地址
    
    //函数指针-存放函数地址的指针
    //&函数名- 取到的是函数的地址
    //数组名 != &数组名 函数名 == &函数名
    //pf就是一个函数指针变量
    int (*pf)(int, int) = &Add;//
    
    //printf("%p\n", &Add);
    //printf("%p\n", Add);//结果一样
    return 0;
}

练习

void test(char* str)
{

}
int main()
{
    void (*pt)(char*) = &test;
    return 0;
}

使用

int Add(int x, int y)
{
    return x + y;
}
int main()
{
    int (*pf)(int, int) = &Add;//
    int ret = (*pf)(3, 5);
    printf("%d\n", ret);
    return 0;
}
//另外的写法
/*
int main()
{
    int (*pf)(int, int) = Add;//
    //int ret = (*pf)(3, 5);
    int ret = pf(3, 5);
    printf("%d\n", ret);
    return 0;
}
*/

阅读俩段代码

//代码1
(*(void (*)())0)();
//调用0地址的函数，该函数无参，发返回类型是void
//1.void (*)() 函数指针类型
//2. ((void (*)()0 对0进行强制类型转化，被解释为一个函数地址
//3.(*(void (*)())0)() 调用0地址处的函数
//代码2
void (*signal(int , void(*)(int)))(int);
//
//1. signal(int, void(*)(int)) + void(*)(int)
//2.signal和()先结合，说明signal是函数名
//3.signal函数的第一个参数类型是int，第二个参数的类型是函数指针
//该函数指针指向一个参数为int返回类型是void的函数
//4.signal函数的返回类型也是一个函数指针该函数指针指向一个参数为int，返回类型是void的函数
//5.signal是一个函数的声明

typedef void(*pfun_t)(int);//对void(*)(int)的函数指针型重命名为pfun_t
//typedef unsigned int uint;

pfun_t signal(int, pfun_t);

仿射密码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
void Affine() /* 仿射密码 */
{
    char c[100];
    int length, i = 0, ka = 0, kb = 0, tmp;
    system("cls");
    printf("********仿射密码********\n请输入最初的明文:");
    gets(c);
    length = strlen(c);
    printf("请输入秘钥（两数字）：");
    scanf("%d %d", &ka, &kb);
    getchar();
    while (gcd(ka,26) != 1)
    {
        printf("秘钥输入错误，请重新输入：");
        scanf("%d %d", &ka, &kb);
        getchar(); 
     } 
     for (i = 0; i < length; i++)
     {
        //大写字母 
        if (c[i] > 96 && c[i] < 123)
            c[i] = (ka * (c[i] - 97) + kb) % 26 + 97;
        //小写字母 
        else if (c[i] > 64 && c[i] < 91)
            c[i] = (ka * (c[i] - 65) + kb) % 26 + 65;   
     }
    printf("\n密文为：\n%s\n", c);
    //printf("********请安1~3选择：********\n");
    //printf("1.仿射加密\n2/仿射解密\n3.退出\n");
    
}
int gcd(int a, int b) /* 求最大公因数 */ 
{
    int k = 0;
    do
    {
        k = a % b;
        a = b;
        b = k;
    } while(k != 0);
    return a;
 } 
void exAffine() /* 仿射加密 */
{
    char c[100];
    int length, i = 0, ka = 0, kb = 0, tmp;
    system("cls");
    printf("********仿射密码*******\n请输入最初的密文：");
    gets(c);
    length = strlen(c);
    printf("请输入秘钥（两数字）：");
    scanf("%d %d", &ka, &kb);
    getchar();
    while (gcd(ka,26) != 1)
    {
        printf("秘钥输入错误，请重新输入：");
        scanf("%d %d", &ka, &kb);
        getchar(); 
     } 
     for (i = 0; i < length; i++)
     {
        //大写字母 
        if (c[i] > 64 && c[i] < 91)
        {
            tmp = Ni(ka, 26) * ((c[i] - 65) - kb);
            if (tmp < 0)
                c[i] = tmp % 26 + 26 + 65;
            else
                c[i] = tmp % 26 + 65;
         }
         //小写字母 
         if (c[i] > 96 && c[i] < 123)
         {
            tmp = Ni(ka, 26) * ((c[i] - 97) - kb);
            if (tmp < 0)
                c[i] = tmp % 26 + 26 + 97;
            else
                c[i] = tmp % 26 + 97;
         }
      } 
    printf("\n明文为：\n %s \n", c);
    //printf("********请安1~3选择：********\n");
    //printf("1.仿射加密\n2/仿射解密\n3.退出\n");
    
 } 
int Ni(int a, int b)
{
    int i = 0;
    while (a * (++i) % b != 1);
    return i;
}


int main()
{
    char i = '0';
    printf("********请按1~3选择：********\n");
    printf("1.仿射加密\n2/仿射解密\n3.退出\n");
    //scanf("%c", &i);
    //getchar();
    i = getch(); 
    while (i != '3')
    {
        if (i == '1')
            Affine();
        else if (i == '2')
            exAffine();
        
        printf("********请按1~3选择：********\n");
        printf("1.仿射加密\n2/仿射解密\n3.退出\n");
        i = getch();
    }
    return 0;
 }

汉诺塔

#include <stdio.h>

/* 俩层 
/*  三层 
1: A->C
2: A->B A->C B->C
3: A->C A->B C->B A->C B->A B->C A->C
*/
 
void move(char pos1, char pos2)
{
    printf("%c->%c ", pos1, pos2);
 } 
void Hanoi(int n, char pos1, char pos2, char pos3)
{
    if (n == 1)
    {
        move(pos1, pos3);   
    }
    else
    {
        Hanoi(n - 1, pos1, pos2, pos3);
        move(pos1, pos3);
        Hanoi(n - 1, pos2, pos1, pos3);
    }
}
/*
N:代表盘子个数
pos1:起始位置 
pos2:中转位置
pos3:目的位置
*/ 
int main()
{
    Hanoi(1, 'A', 'B', 'C');
    printf("\n");
    Hanoi(2, 'A', 'B', 'C');
    printf("\n");
    Hanoi(3, 'A', 'B', 'C');
    return 0;
}

3_10

#include <stdio.h>

int Add(int x, int y)
{
    return x + y;
 } 

int Sub(int x, int y)
{
    return x - y;
}

int Mul(int x, int y)
{
    return x * y;
}

int div(int x, int y)
{
    return (x / y);
}
 
void menu()
{
    printf("1.add\n");
    printf("2.sub\n");
    printf("3.mul\n");
    printf("4.div\n");
    printf("0.exit\n");
 } 
int main()
{
    int (*pf1)(int, int) = Add;
    int (*pf2)(int, int) = Sub;
    // pfArr[2] + int(*)(int, int)  
    int (*pfArr[2])(int, int) = {Add, Sub};
    //*pfArr 就是函数指针数组 
    
    //计算器-计算整型变量的加、减、乘、除。 
    int input = 0;
    do {
        menu();
        
        int x = 0;
        int y = 0;
        int ret = 0;
        printf("请选择：>");
        scanf("%d", &input);
        switch (input)
        {
            case 1:
                printf("请输入俩个操作数>:");
                scanf("%d %d", &x, &y);
                ret = Add(x, y);
                break;
            case 2:
                printf("请输入俩个操作数>:");
                scanf("%d %d", &x, &y);
                ret = Sub(x, y);
                break;
            case 3:
                printf("请输入俩个操作数>:");
                scanf("%d %d", &x, &y);
                ret = Mul(x, y);
                break;
            case 4:
                printf("请输入俩个操作数>:");
                scanf("%d %d", &x, &y);
                ret = div(x, y);
                break;
            case 0:
                printf("退出程序");
                input = 0;
                break;
            default:
                printf("选择错误，请重新选择");
                break; 
        }
        printf("ret = %d\n", ret);
    } while (input);
    return 0;
    
    
    
    return 0;
}

方法二

int main()
{

    //计算器-计算整型变量的加、减、乘、除。
    //a&b a^b a|b a>>b a<<b a>b 
    int input = 0;
    
    do {
        menu();
        int (*pfArr[5])(int, int) = {NULL, Add, Sub, Mul, div};
        int x = 0;
        int y = 0;
        int ret = 0;
        printf("请选择：>\n");
        scanf("%d", &input);
        if (input >= 1 && input <= 4)
        {
            printf("请输入2个操作数>:");
            scanf("%d %d", &x, &y); 
            ret = (pfArr[input])(x, y);
            printf("ret = %d\n", ret);
        }
        else if (input == 0)
        {
            printf("退出\n");
            break;
        }
        else
        {
            printf("选择错误\n");
        }   
    } while (input);
    return 0;
}

描述
KiKi写了一个输出“Hello world!”的程序，BoBo老师告诉他printf函数有返回值，你能帮他写个程序输出printf(“Hello world!”)的返回值吗？
输入描述：
无
输出描述：
包括两行：
第一行为“Hello world!”
第二行为printf(“Hello world!”)调用后的返回值。



#include <stdio.h>

//printf函数源码
//int __cdecl printf(const char * __restrict__ _Format,...);
int main() {
    int a = printf("Hello world!");
    printf("\n");
    printf("%d",  a);
    return 0;
}

BC15 大小写转换

#include<stdio.h>
int main() {
    int ch = 0;
    while ((ch = getchar()) != EOF) { 
    //EOF意为-1。本语句即只要输入项是字符即可打印
        getchar();
        putchar(ch + 32);
        printf("\n");
    }
    return 0;
}

指针进阶6

复习冒泡排序

#include <stdio.h>

void bubble_sort(int arr[], int sz)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < sz; i++){
        for(j = 0; j < sz - 1 - i; j++){
            if (arr[j] > arr[j + 1]){
                int tmp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = tmp;
            }
        }
        
    }   
    
}

void print(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main()
{
    int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz);
    print(arr, sz); 
    return 0;
 }

qsort();//快速排序

整型数据，字符串数据，结构体数据都可以排

#include <stdlib.h>
void qsort(void *base,//base 中存放的是待排序数据中第一个对象的地址 
                 size_t nitems, //num 是待排序数据的元素个数
                 size_t size, //size 排序中一个元素的大小 
                 int (*compar)(const void *, const void*) //指向函数的指针，用于确定排序的顺序（需要用户自定义一个比较函数） 
                 )

#include <stdio.h>
#include <stdlib.h>
//因为void不知道什么类型，所以要先强制转换类型，而qsort对比较函数只要求和0的关系
//所以直接return 差值即可 
int cmp_int(const void* e1, const void* e2)
{
    return *(int*)e1 - *(int*)e2;
 } 
void print(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
}
int main()
{
    int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, sz, sizeof(arr[0]), cmp_int);
    print(arr, sz); 
    return 0;
 }

qsort函数排序结构体

1.按年龄排序

#include <stdio.h>
#include <stdlib.h> 
struct Stu
{
    char name[20];
    int age;
}; 
int sort_by_age(const void* e1, const void* e2)
{
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void print(struct Stu s[], int sz)
{
    int i = 0;
    struct Stu *p;
    p = s;
    for (i = 0; i < sz; i++)
    {   
        printf("Stu%d\n",i);
        printf("name:%s\n", p->name);
        printf("age:%d\n", p->age);
        printf("\n");
        p++;
    }
}
void test2()
{
    //使用qsort排序结构体数据 
    struct Stu s[] = {
        {"zhangsan", 30},
        {"liso", 35},
        {"wangwu", 20}
    };
    int sz = sizeof(s) / sizeof(s[0]);
    //按年龄排序
    
    qsort(s, sz, sizeof(s[0]), sort_by_age);
    print(s, sz);
}
int main()
{
    
    test2();
        
    return 0;
 }

2.按名字排序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{
    char name[20];
    int age;
}; 
int sort_by_name(const void* e1, const void* e2)
{
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void print(struct Stu s[], int sz)
{
    int i = 0;
    struct Stu *p;
    p = s;
    for (i = 0; i < sz; i++)
    {   
        printf("Stu%d\n",i);
        printf("name:%s\n", p->name);
        printf("age:%d\n", p->age);
        printf("\n");
        p++;
    }
}
void test2()
{
    //使用qsort排序结构体数据 
    struct Stu s[] = {
        {"zhangsan", 30},
        {"liso", 35},
        {"wangwu", 20}
    };
    int sz = sizeof(s) / sizeof(s[0]);
    //按名字排序
    printf("突然想看下s中元素的大小%d\n",sizeof(s[0]));
    qsort(s, sz, sizeof(s[0]), sort_by_name);
    print(s, sz);
}
int main()
{
    
    test2();
        
    return 0;
 }

一个char 8bit=1byte 一个int 4byte 所以是24

3.突然想看下string.h中的strcmp源码

int __cdecl strcmp (
        const char * src,
        const char * dst
        )
{
        int ret = 0 ;

        while((ret = *(unsigned char *)src - *(unsigned char *)dst) == 0 && *dst)
                {
                ++src, ++dst;
                }

        return ((-ret) < 0) - (ret < 0); // (if positive) - (if negative) generates branchless code
}

看不懂，试着自己实现一个

int str_cmp(const char *str1, const char* str2)
{
    while (*str1 == *str2) {
        str1++;
        str2++;
    }
    int ret = *str1 - *str2;
    return ret; 
}
int main()
{
    char str1[] = "abcde";
    char str2[] = "bca";
    printf("%d",str_cmp(str1, str2));
    return 0;
}

模仿qsort实现冒泡排序

#include <stdio.h>
void Swap(char* buf1, char* buf2, int width)
{
    int i = 0;
    for (i = 0; i < width; i++)
    {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 =tmp;
        buf1++;
        buf2++;
    }
}
//模仿qsort实验一个冒泡排序的通用算法 
void bubble_sort(void* base,
                int sz,//元素个数 
                int width, //元素大小（几个字节） 
                int (*cmp)(const void* e1, const void* e2)
                )
{
    int i = 0;
    //sz个元素进行sz-1趟 
    for (i = 0; i < sz -1; i++)
    {
        //一趟排序 
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            //两个元素比较 
            //arr[j] arr[j+1]
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
            {
                //交换 
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
         } 
        
    }
}
int cmp_int(const void* e1, const void* e2)
{
    return *(int*)e1 - *(int*)e2;
}
void print_arr(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void test()
{
    int arr[] = { 1,3,5,6,7,8,2,4,0,9 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    print_arr(arr, sz);
}

int main()
{
    test();
    return 0;
}

折半排序

#include <stdio.h>
 
void CelerityRun(int left, int right, int array[]);

int main()
{
    int i;
    int a[10];
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &a[i]);
    }
    CelerityRun(0, 9, a);
    for(i = 0; i < 10; i++)
    {
        printf("%d\t", a[i]);
        if(i == 4)
            printf("\n");
    }
    return 0;
}

void CelerityRun(int left, int right, int array[])
{
    int i,j;
    int middle,iTemp;
    i = left;
    j = right;
    middle = array[(left+right) / 2]; //求中间值 
    do
    {
        while((array[i] < middle) && (i < right)) //从左找小于中间值的数 
            i++;
        while((array[j] > middle) && (j > left)) //从右找大于中间值的数 
            j--;
        if (i <= j)
        {
            iTemp = array[i];
            array[i] = array[j];
            array[j] = iTemp;
            i++;
            j--;
        }
    }while(i <= j);
    /* 递归左半边 */
    if (left < j)
        CelerityRun(left, j, array);
    /* 递归右半边 */ 
    if (right > i)
        CelerityRun(i, right, array);
}

二维数组

#include <stdio.h>

int main()
{
    int a[3][4];
    printf("%d\n", (int)sizeof(a));//48=3*4*sizeof(int) 
    printf("%d\n", (int)sizeof(a[0][0]));//4 - a[0][0]-是第一行第一个元素 
    printf("%d\n", (int)sizeof(a[0]));//16 第一行 4*4个int 
    printf("%d\n", (int)sizeof(a[0]+1));//4
                                         /*a[0]作为数组名并没有单独放在sizeof内部 
                                         *也没取地址，所以a[0]是第一行第一个算的地址 
                                         *a[0]+1，就是第一行第二个元素的地址 
                                         *
                                         */
    printf("%d\n", (int)sizeof(*(a[0]+1)));//*(a[0]+1)==a[0][1] int 4 byte 第一行第二个元素 
    printf("%d\n", (int)sizeof(a+1));//4/8  a是首元素地址，而二维数组数组名的首元素是第一行，
                                     //第一行的地址+1就是第二行的地址 
    printf("%d\n", (int)sizeof(*(a+1)));//16 对第二行解引用，有4个元素， 
    printf("%d\n", (int)sizeof(&a[0]+1));//4/8 第一行的地址+1就是第二行的地址 
    printf("%d\n", (int)sizeof(*(&a[0]+1)));//16 第二行解引用 
    printf("%d\n", (int)sizeof(*a));//16 首元素即第一行地址，再解引用 ，没有&没有单独放在sizeof内部 
    printf("%d\n", (int)sizeof(a[3]));//16 a[3]其实是第四行的数组名，（如果有的话）
                                      // 所以其实不存在，但是也能通过类型计算大小 

    return 0;
}

3+5
表达式

值属性 8
类型性 int
a[3属]的类型 - int [4]

#include <stdio.h>
int main()
{
    short s = 5;
    int a = 4;
    printf("%d\n", sizeof(s = a + 6));//2 由s决定 
    printf("%d\n", s);//5  sizeof内部的表达式不会计算,只看类型
    
    return 0;
 }

总结：数组名的意义

sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
除此之外所有的数组名都表示首元素的地址

PAT 答题卡

#include <stdio.h>
#include <string.h>
int Iswhat(char a[])
{
    int flag = 0;
    int len = strlen(a);
    int i = 0;
    for (i = 0; i < len; i++) {
        if (a[i] == ';'){
            flag = 1;
            break;
        }
        else if (a[i] == '/'){
            flag = 2;
            break;
        }
    }
    return flag;
 } 
 void init(char s[])
 {
    int i = 0;
    int len = strlen(s);
    for (i = 0; i < len; i++) {
        s[i] = '\0';
     }
 }
int main()
{
    int n ,m, x, y;
    int i = 0;
    int j = 0;
    char s[6] = { 0 };
    char a[90][90] = {};
    scanf("%d %d", &n, &m);
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            a[i][j] = '.';
    for (i = 0; i < m; i++) {
        init(s);
        scanf("%s", &s);
        if (Iswhat(s) == 0) {
            //printf("%s ", s);
            int len = strlen(s);
            printf("%d\n", len);
            if (len == 1) {
                x = 0;
                y = int(s[len - 1] - '0') - 1;
                 
            }
            else if (len == 2) {
                x = 0;
                y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
            }
            else if (len == 3) {
                x = int(s[len - 3] - '0');
                y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
            }
            else {
                x = int(s[len - 4] - '0') * 10 + int(s[len - 3] - '0');
                y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
            }
            //printf("%d %d\n", x, y);
            a[n - y][x - 1] = '#';
        }
        else if (Iswhat(s) == 1) {
            int len = strlen(s);
            if(len == 5) {
                x = int(s[len - 5] - '0') * 10 + int(s[len - 4] - '0');
                y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
            }
            else if(len == 3) {
                x = int(s[len - 3] - '0');
                y = int(s[len - 1] - '0');
            }
            else {
                int index = 0;
                int j = 0;
                for (j = 0; j < len; j++) {
                    if(s[j] == ';') {
                        index = j;
                    }
                } 
                if (index == 2) {
                    x = int(s[len - 4] - '0');
                    y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
                }
                else {
                    x = int(s[len - 4] - '0') * 10 + int(s[len - 3] - '0');
                    y = int(s[len - 1] - '0');
                }
            }
            a[n - y][x - 1] = '#';
        }
        else {
            int len = strlen(s);
            if(len == 5) {
                x = int(s[len - 5] - '0') * 10 + int(s[len - 4] - '0');
                y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
            }
            else if(len == 3) {
                x = int(s[len - 3] - '0');
                y = int(s[len - 1] - '0');
            }
            else {
                int index = 0;
                int j = 0;
                for (j = 0; j < len; j++) {
                    if(s[j] == '/') {
                        index = j;
                    }
                } 
                if (index == 2) {
                    x = int(s[len - 4] - '0');
                    y = int(s[len - 2] - '0') * 10 + int(s[len - 1] - '0');
                }
                else {
                    x = int(s[len - 4] - '0') * 10 + int(s[len - 3] - '0');
                    y = int(s[len - 1] - '0');
                }
            }
            a[n - y][x - 1] = '#';  
        }
    }
    for (i = 0; i < n; i++){
        for (j = 0; j < n; j++){
            printf("%c", a[i][j]);
        }
        printf("\n");
    }
    return 0;
 }