爱心代码咯----还缺女朋友吗？

Python

火柴人发射爱心

import turtle as t
#画人的脑袋和躯干
t.speed(0)
t.penup()
t.goto(-100,100)
t.pendown()
t.pensize(3)
t.circle(50)
t.right(90)
t.forward(100)
t.right(45)
t.forward(70)
t.backward(70)
t.left(90)
t.forward(70)

#画人的小手
t.penup()
t.goto(-100,60)
t.pendown()
t.left(45)
t.forward(50)
t.right(45)
t.forward(45)
t.backward(45)
t.left(90)
t.forward(45)

#左眼
t.penup()
t.goto(-120,160)
t.pendown()
t.color('black')
t.begin_fill()
t.circle(5)
t.end_fill()

#右眼
t.penup()
t.goto(-80,160)
t.pendown()
t.color('black')
t.begin_fill()
t.circle(5)
t.end_fill()

#嘴
t.penup()
t.goto(-120,125)
t.pendown()
t.right(85)
t.circle(30,90)

#画心
t.penup()
t.goto(90,95)
t.pendown()
t.left(20)
t.color("red")
t.begin_fill()
t.circle(-35,210)
t.forward(65)
t.right(80)
t.forward(65)
t.circle(-35,210)
t.end_fill()
t.hideturtle()
t.done()

 流星雨

import turtle as tu
import random as ra

import math

tu.setup(1.0, 1.0)
tu.screensize(1.0, 1.0)    #设置画布大小
tu.bgcolor('black')        #设置画布颜色
t = tu.Pen()
t.ht()                     #隐藏画笔
colors = ['skyblue','white','cyan','aqua']   #流星的颜色列表

class Star():    #流星类

    def __init__(self):
        self.r = ra.randint(50,100)  
        self.t = ra.randint(1,3)
        self.x = ra.randint(-2000,1000)   #流星的横坐标
        self.y = ra.randint(0,500)        #流星的纵坐标
        self.speed = ra.randint(5,10)     #流星移动速度
        self.color = ra.choice(colors)    #流星的颜色
        self.outline = 1                  #流星的大小

    def star(self):                #画流星函数
        t.pensize(self.outline)    #流星的大小
        t.penup()                  #提笔
        t.goto(self.x,self.y)      #随机位置
        t.pendown()                #落笔
        t.color(self.color)        
        t.begin_fill()
        t.fillcolor(self.color)
        t.setheading(-30)
        t.right(self.t)
        t.forward(self.r)
        t.left(self.t)
        t.circle(self.r*math.sin(math.radians(self.t)),180)
        t.left(self.t)
        t.forward(self.r)
        t.end_fill()   

    def move(self):                   #流星移动函数
        if self.y >= -500:            #当流星还在画布中时
            self.y -= self.speed      #设置上下移动速度
            self.x += 2*self.speed    #设置左右移动速度
        else:                     
            self.r = ra.randint(50,100)
            self.t = ra.randint(1,3)
            self.x = ra.randint(-2000,1000)
            self.y = 500
            self.speed = ra.randint(5,10)
            self.color = ra.choice(colors)
            self.outline = 1

Stars = []            #用列表保存所有流星

for i in range(100):     
    Stars.append(Star())      

while True:           #开始绘制
    tu.tracer(0)
    t.clear()
    for i in range(100):    #80个流星
        Stars[i].move()
        Stars[i].star()
    tu.update()

tu.mainloop()

 跳动的爱心

import random

from math import sin, cos, pi, log

from tkinter import *

CANVAS_WIDTH = 640  # 宽

CANVAS_HEIGHT = 480  # 高

CANVAS_CENTER_X = CANVAS_WIDTH / 2

CANVAS_CENTER_Y = CANVAS_HEIGHT / 2

IMAGE_ENLARGE = 11  # 放大比例

HEART_COLOR = "#ff1943"


def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):
    """
    “爱心函数生成器”
    :param shrink_ratio: 放大比例
    :param t: 参数
    :return: 坐标
    """

    # 基础函数

    x = 16 * (sin(t) ** 3)

    y = -(13 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(4 * t))

    # 放大

    x *= shrink_ratio

    y *= shrink_ratio

    # 移到画布中央

    x += CANVAS_CENTER_X

    y += CANVAS_CENTER_Y

    return int(x), int(y)


def scatter_inside(x, y, beta=0.15):
    """
    随机内部扩散
    :param x: 原x
    :param y: 原y
    :param beta: 强度
    :return: 新坐标
    """

    ratio_x = - beta * log(random.random())

    ratio_y = - beta * log(random.random())

    dx = ratio_x * (x - CANVAS_CENTER_X)

    dy = ratio_y * (y - CANVAS_CENTER_Y)

    return x - dx, y - dy


def shrink(x, y, ratio):
    """
    抖动
    :param x: 原x
    :param y: 原y
    :param ratio: 比例
    :return: 新坐标
    """

    force = -1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.6)

    dx = ratio * force * (x - CANVAS_CENTER_X)

    dy = ratio * force * (y - CANVAS_CENTER_Y)

    return x - dx, y - dy


def curve(p):
    """
    自定义曲线函数，调整跳动周期
    :param p: 参数
    :return: 正弦
    """

    return 2 * (2 * sin(4 * p)) / (2 * pi)


class Heart:
    """
    爱心类
    """

    def __init__(self, generate_frame=20):

        self._points = set()  # 原始爱心坐标集合

        self._edge_diffusion_points = set()  # 边缘扩散效果点坐标集合

        self._center_diffusion_points = set()  # 中心扩散效果点坐标集合

        self.all_points = {}  # 每帧动态点坐标

        self.build(2000)

        self.random_halo = 1000

        self.generate_frame = generate_frame

        for frame in range(generate_frame):
            self.calc(frame)

    def build(self, number):

        # 爱心

        for _ in range(number):
            t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口

            x, y = heart_function(t)

            self._points.add((x, y))

        # 爱心内扩散

        for _x, _y in list(self._points):

            for _ in range(3):
                x, y = scatter_inside(_x, _y, 0.05)

                self._edge_diffusion_points.add((x, y))

        # 爱心内再次扩散

        point_list = list(self._points)

        for _ in range(4000):
            x, y = random.choice(point_list)

            x, y = scatter_inside(x, y, 0.17)

            self._center_diffusion_points.add((x, y))

    @staticmethod
    def calc_position(x, y, ratio):

        # 调整缩放比例

        force = 1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.520)  # 魔法参数

        dx = ratio * force * (x - CANVAS_CENTER_X) + random.randint(-1, 1)

        dy = ratio * force * (y - CANVAS_CENTER_Y) + random.randint(-1, 1)

        return x - dx, y - dy

    def calc(self, generate_frame):

        ratio = 10 * curve(generate_frame / 10 * pi)  # 圆滑的周期的缩放比例

        halo_radius = int(4 + 6 * (1 + curve(generate_frame / 10 * pi)))

        halo_number = int(3000 + 4000 * abs(curve(generate_frame / 10 * pi) ** 2))

        all_points = []

        # 光环

        heart_halo_point = set()  # 光环的点坐标集合

        for _ in range(halo_number):

            t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口

            x, y = heart_function(t, shrink_ratio=11.6)  # 魔法参数

            x, y = shrink(x, y, halo_radius)

            if (x, y) not in heart_halo_point:
                # 处理新的点

                heart_halo_point.add((x, y))

                x += random.randint(-14, 14)

                y += random.randint(-14, 14)

                size = random.choice((1, 2, 2))

                all_points.append((x, y, size))

        # 轮廓

        for x, y in self._points:
            x, y = self.calc_position(x, y, ratio)

            size = random.randint(1, 3)

            all_points.append((x, y, size))

        # 内容

        for x, y in self._edge_diffusion_points:
            x, y = self.calc_position(x, y, ratio)

            size = random.randint(1, 2)

            all_points.append((x, y, size))

        for x, y in self._center_diffusion_points:
            x, y = self.calc_position(x, y, ratio)

            size = random.randint(1, 2)

            all_points.append((x, y, size))

        self.all_points[generate_frame] = all_points

    def render(self, render_canvas, render_frame):

        for x, y, size in self.all_points[render_frame % self.generate_frame]:
            render_canvas.create_rectangle(x, y, x + size, y + size, width=0, fill=HEART_COLOR)


def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):
    render_canvas.delete('all')

    render_heart.render(render_canvas, render_frame)

    main.after(160, draw, main, render_canvas, render_heart, render_frame + 1)


if __name__ == '__main__':
    root = Tk()  # 一个Tk

    canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)

    canvas.pack()

    heart = Heart()  # 心

    draw(root, canvas, heart)

    root.mainloop()

 全屏跳动爱心

import random
from math import sin, cos, pi, log
from tkinter import *
import ctypes

user32 = ctypes.windll.user32
CANVAS_WIDTH = user32.GetSystemMetrics(0)  # 画布的宽
CANVAS_HEIGHT = user32.GetSystemMetrics(1)  # 画布的高
CANVAS_CENTER_X = CANVAS_WIDTH / 2  # 画布中心的X轴坐标
CANVAS_CENTER_Y = CANVAS_HEIGHT / 2  # 画布中心的Y轴坐标
IMAGE_ENLARGE = 11  # 放大比例
HEART_COLOR = "#ff2121"  # 心的颜色，这个是中国红


def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):
    """
    “爱心函数生成器”
    :param shrink_ratio: 放大比例
    :param t: 参数
    :return: 坐标
    """
    # 基础函数
    x = 16 * (sin(t) ** 3)
    y = -(13 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(4 * t))

    # 放大
    x *= shrink_ratio
    y *= shrink_ratio

    # 移到画布中央
    x += CANVAS_CENTER_X
    y += CANVAS_CENTER_Y

    return int(x), int(y)


def scatter_inside(x, y, beta=0.15):
    """
    随机内部扩散
    :param x: 原x
    :param y: 原y
    :param beta: 强度
    :return: 新坐标
    """
    ratio_x = - beta * log(random.random())
    ratio_y = - beta * log(random.random())

    dx = ratio_x * (x - CANVAS_CENTER_X)
    dy = ratio_y * (y - CANVAS_CENTER_Y)

    return x - dx, y - dy


def shrink(x, y, ratio):
    """
    抖动
    :param x: 原x
    :param y: 原y
    :param ratio: 比例
    :return: 新坐标
    """
    force = -1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.6)  # 这个参数...
    dx = ratio * force * (x - CANVAS_CENTER_X)
    dy = ratio * force * (y - CANVAS_CENTER_Y)
    return x - dx, y - dy


def curve(p):
    """
    自定义曲线函数，调整跳动周期
    :param p: 参数
    :return: 正弦
    """
    # 可以尝试换其他的动态函数，达到更有力量的效果（贝塞尔？）
    return 2 * (2 * sin(4 * p)) / (2 * pi)


class Heart:
    """
    爱心类
    """

    def __init__(self, generate_frame=20):
        self._points = set()  # 原始爱心坐标集合
        self._edge_diffusion_points = set()  # 边缘扩散效果点坐标集合
        self._center_diffusion_points = set()  # 中心扩散效果点坐标集合
        self.all_points = {}  # 每帧动态点坐标
        self.build(2000)

        self.random_halo = 1000

        self.generate_frame = generate_frame
        for frame in range(generate_frame):
            self.calc(frame)

    def build(self, number):
        # 爱心
        for _ in range(number):
            t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口
            x, y = heart_function(t)
            self._points.add((x, y))

        # 爱心内扩散
        for _x, _y in list(self._points):
            for _ in range(3):
                x, y = scatter_inside(_x, _y, 0.05)
                self._edge_diffusion_points.add((x, y))

        # 爱心内再次扩散
        point_list = list(self._points)
        for _ in range(4000):
            x, y = random.choice(point_list)
            x, y = scatter_inside(x, y, 0.17)
            self._center_diffusion_points.add((x, y))

    @staticmethod
    def calc_position(x, y, ratio):
        # 调整缩放比例
        force = 1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.520)  # 魔法参数

        dx = ratio * force * (x - CANVAS_CENTER_X) + random.randint(-1, 1)
        dy = ratio * force * (y - CANVAS_CENTER_Y) + random.randint(-1, 1)

        return x - dx, y - dy

    def calc(self, generate_frame):
        ratio = 10 * curve(generate_frame / 10 * pi)  # 圆滑的周期的缩放比例

        halo_radius = int(4 + 6 * (1 + curve(generate_frame / 10 * pi)))
        halo_number = int(3000 + 4000 * abs(curve(generate_frame / 10 * pi) ** 2))

        all_points = []

        # 光环
        heart_halo_point = set()  # 光环的点坐标集合
        for _ in range(halo_number):
            t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口
            x, y = heart_function(t, shrink_ratio=11.6)  # 魔法参数
            x, y = shrink(x, y, halo_radius)
            if (x, y) not in heart_halo_point:
                # 处理新的点
                heart_halo_point.add((x, y))
                x += random.randint(-14, 14)
                y += random.randint(-14, 14)
                size = random.choice((1, 2, 2))
                all_points.append((x, y, size))

        # 轮廓
        for x, y in self._points:
            x, y = self.calc_position(x, y, ratio)
            size = random.randint(1, 3)
            all_points.append((x, y, size))

        # 内容
        for x, y in self._edge_diffusion_points:
            x, y = self.calc_position(x, y, ratio)
            size = random.randint(1, 2)
            all_points.append((x, y, size))

        for x, y in self._center_diffusion_points:
            x, y = self.calc_position(x, y, ratio)
            size = random.randint(1, 2)
            all_points.append((x, y, size))

        self.all_points[generate_frame] = all_points

    def render(self, render_canvas, render_frame):
        for x, y, size in self.all_points[render_frame % self.generate_frame]:
            render_canvas.create_rectangle(x, y, x + size, y + size, width=0, fill=HEART_COLOR)


def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):
    render_canvas.delete('all')
    render_heart.render(render_canvas, render_frame)
    main.after(160, draw, main, render_canvas, render_heart, render_frame + 1)


if __name__ == '__main__':
    root = Tk()  # 一个Tk
    root.attributes('-fullscreen', True)  # 全屏
    root.attributes('-alpha', 0.9)  # 透明度
    canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)
    canvas.pack()
    heart = Heart()  # 心
    draw(root, canvas, heart)  # 开始画画~
    root.mainloop()

 C语言

爱心代码

#include<stdio.h>
#include<Windows.h>

int main()
{
    float x, y, a;
    for (y = 1.5; y > -1.5; y -= 0.1)
    {
        for (x = -1.5; x < 1.5; x += 0.05)
        {
            a = x * x + y * y - 1;
            putchar(a * a * a - x * x * y * y * y <= 0.0 ? '*' : ' ');
        }
        system("color 0c");
        putchar('\n');
    }
    return 0;
}

 爱心代码---循环版本

#include<stdio.h>
#include<Windows.h>

int main()
{
    float x, y, a;
    char color;
    while (1)
    {
        for (y = 1.5; y > -1.5; y -= 0.1)
        {
            for (x = -1.5; x < 1.5; x += 0.05)
            {
                a = x * x + y * y - 1;
                putchar(a * a * a - x * x * y * y * y <= 0.0 ? '*' : ' ');
            }
            system("color 0c");
            putchar('\n');
        }
    }
    return 0;
}

 跳动的心

#include <stdio.h>
#include <math.h>
#include <windows.h>
#include <tchar.h>

float f(float x, float y, float z) {
    float a = x * x + 9.0f / 4.0f * y * y + z * z - 1;
    return a * a * a - x * x * z * z * z - 9.0f / 80.0f * y * y * z * z * z;
}

float h(float x, float z) {
    for (float y = 1.0f; y >= 0.0f; y -= 0.001f)
        if (f(x, y, z) <= 0.0f)
            return y;
    return 0.0f;
}

int main() {
    HANDLE o = GetStdHandle(STD_OUTPUT_HANDLE);
    _TCHAR buffer[25][80] = { _T(' ') };
    _TCHAR ramp[] = _T(".:-=+*#%@");

    for (float t = 0.0f;; t += 0.1f) {
        int sy = 0;
        float s = sinf(t);
        float a = s * s * s * s * 0.2f;
        for (float z = 1.3f; z > -1.2f; z -= 0.1f) {
            _TCHAR* p = &buffer[sy++][0];
            float tz = z * (1.2f - a);
            for (float x = -1.5f; x < 1.5f; x += 0.05f) {
                float tx = x * (1.2f + a);
                float v = f(tx, 0.0f, tz);
                if (v <= 0.0f) {
                    float y0 = h(tx, tz);
                    float ny = 0.01f;
                    float nx = h(tx + ny, tz) - y0;
                    float nz = h(tx, tz + ny) - y0;
                    float nd = 1.0f / sqrtf(nx * nx + ny * ny + nz * nz);
                    float d = (nx + ny - nz) * nd * 0.5f + 0.5f;
                    *p++ = ramp[(int)(d * 5.0f)];
                }
                else
                    *p++ = ' ';
            }
        }

        for (sy = 0; sy < 25; sy++) {
            COORD coord = { 0, sy };
            SetConsoleCursorPosition(o, coord);
            WriteConsole(o, buffer[sy], 79, NULL, 0);
        }
        Sleep(33);
    }
}

 love组成的爱心

#include <stdio.h>

int main()

{
    int i, j, k, n = 0, x = 0, y = 50;

    //爱心的头部没有规律，所以直接打印
    printf("\n\n\n\n\n");
    printf("         lovelove                   lovelove\n");
    printf("       lovelovelove               lovelovelove\n");
    printf("     lovelovelovelove           lovelovelovelove\n");
    printf("   lovelovelovelovelove       lovelovelovelovelove\n");
    printf("  lovelovelovelovelovelo     lovelovelovelovelovelo\n");
    printf(" lovelovelovelovelovelove   lovelovelovelovelovelov\n");
    for (i = 0; i < 2; i++)
    {
        printf("lovelovelovelovelovelovelovelovelovelovelovelovelove\n");

    }

    for (i = 0; i < 5; i++)    //爱心的中间部分的上部分
    {
        y = 50;
        y = y - i * 2;
        n++;
        for (k = 0; k < n; k++)    //在每一行的起始位置先打印空格
        {
            printf(" ");
        }
        while (1)     //空格后面打印love，但是要注意love即使没打印完，也要换行
        {
            if (x < y)
            {
                printf("l");
                y--;
            }
            else
                break;
            if (x < y)
            {
                printf("o");
                y--;
            }
            else
                break; if (x < y)
            {
                printf("v");
                y--;
            }
                else
                break; if (x < y)
            {
                printf("e");
                y--;
            }
                else
                break;
        }
        printf("\n");
    }


    //最下面的部分，具体内容同上，没和上一部分放一起是因为从这行开始多两个空格
    for (i = 0, n = 3; i < 10; i++)
    {
        y = 37;
        y = y - i * 4;
        n++;
        for (k = 0; k < n; k++)
        {
            printf("  ");
        }
        while (1)
        {
            if (x < y)
            {
                printf("l");
                y--;
            }
            else
                break;
            if (x < y)
            {
                printf("o");
                y--;
            }
            else
                break; if (x < y)
            {
                printf("v");
                y--;
            }
                else
                break; if (x < y)
            {
                printf("e");
                y--;
            }
                else
                break;
        }
        printf("\n");
    }

    printf("\n\n\n\n\n\n\n\n\n\n\n\n");
    return 0;
}

 指向爱心

#include<stdio.h>
#define V 4//设置心形放大倍数
#define list (4*V+3)//列数
#define row (3*V+3)//行数
void FindMainPoint(char line[row][list]);
void Connect(int r1, int r2, int l1, int l2, char line[row][list]);//r行l列
void Print(char line[row][list]);
void Finger(char point[17][20]);
int main(void)
{
    char line[row][list];
    char point[17][20];
    FindMainPoint(line);
    Print(line);
    printf("\n\n");
    Finger(point);
    return 0;
}

//找到关键点
void FindMainPoint(char line[row][list])
{
    int list_mid = (list + 1) / 2 - 1;

    int list_left = (list + 1) / 4 - 1;

    int list_left_right = list_left + 1;

    int list_right = list_mid + list_left + 1;

    int list_right_left = list_right - 1;

    int row_above = 1 - 1;

    int row_mid = row / 3 - 1;

    int row_mid_below = row_mid + 1;

    int row_below = row - 1;

    line[row_above][list_left] = '*';//(4,1)
    line[row_above][list_left_right] = '*';//(5,1)
    line[row_above][list_right] = '*';//(12,1)
    line[row_above][list_right_left] = '*';//(11,1)

    line[row_mid][0] = '*';//(1,4)
    line[row_mid][list_mid] = '*';//(8,4)
    line[row_mid][list - 1] = '*';//(15,4)

    line[row_mid_below][0] = '*';//(1,5)
    line[row_mid_below][list - 1] = '*';//(15,5)

    line[row_below][list_mid] = '*';//(8,12)

    Connect(row_mid, row_above, 0, list_left, line);//(1,4)&&(4,1)
    Connect(row_above, row_mid, list_left_right, list_mid, line);//(5,1)&&(8,4)
    Connect(row_mid, row_above, list_mid, list_right_left, line);//(8,4)&&(11,1)
    Connect(row_above, row_mid, list_right, list - 1, line);//(12,1)&&(15,4)
    Connect(row_mid_below, row_below, 0, list_mid, line);//(1,5)&&(8,12)
    Connect(row_below, row_mid_below, list_mid, list - 1, line);//(8,12)&&(15,5)
    return;
}

//连接关键点
void Connect(int r1, int r2, int l1, int l2, char line[row][list])
{
    int i, j;
    if (r1 > r2)
    {
        for (i = r1, j = l1; i >= r2; i--, j++)
        {
            line[i][j] = '*';
        }
    }
    else
    {
        for (i = r1, j = l1; i <= r2; i++, j++)
        {
            line[i][j] = '*';
        }
    }
    return;
}

//打印爱心
void Print(char line[row][list])
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        printf("\t\t\t\t\t\t");//将图形尽量居中，改变大小后，自行修改
        for (j = 0; j < list; j++)
        {
            if (line[i][j] != '*')
            {
                printf(" ");
            }
            else

                printf("*");
        }
        printf("\n");
    }
}

//打印手指
void Finger(char point[17][20])
{
    int i, j;
    for (i = 0, j = 5; j <= 6; j++)
        point[i][j] = '*';//
    for (j = 4, i = 1; i <= 8; i++)
        point[i][j] = '*';//
    for (j = 7, i = 1; i <= 6; i++)
        point[i][j] = '*';//
    for (i = 4, j = 8; j <= 10; j++)
        point[i][j] = '*';//
    for (j = 11, i = 5; i <= 6; i++)
        point[i][j] = '*';//
    for (i = 5, j = 12; j <= 14; j++)
        point[i][j] = '*';//
    for (j = 15, i = 6; i <= 7; i++)
        point[i][j] = '*';//
    for (i = 6, j = 15; j <= 18; j++)
        point[i][j] = '*';
    for (j = 19, i = 7; i <= 11; i++)
        point[i][j] = '*';//
    for (j = 18, i = 12; i <= 13; i++)
        point[i][j] = '*';//
    for (j = 17, i = 14; i <= 15; i++)
        point[i][j] = '*';//
    for (i = 16, j = 6; j <= 16; j++)
        point[i][j] = '*';//
    for (i = 14, j = 7; j <= 15; j++)
        point[i][j] = '*';
    for (j = 7; j <= 15; j += 4)//
        for (i = 10; i <= 12; i++)
            point[i][j] = '*';
    for (j = 5, i = 14; i <= 15; i++)
        point[i][j] = '*';//
    for (j = 2, i = 10; i <= 11; i++)
        point[i][j] = '*';//
    for (j = 0, i = 7; i <= 8; i++)
        point[i][j] = '*';//
    for (i = 6, j = 1; j <= 2; j++)
        point[i][j] = '*';
    point[7][3] = '*';
    point[9][1] = '*';
    point[12][3] = '*';
    point[13][4] = '*';
    for (i = 0; i < 17; i++)
    {
        printf("\t\t\t\t\t\t  ");//将图形尽量居中，改变大小后，自行修改
        for (j = 0; j < 20; j++)
        {
            if (point[i][j] != '*')
            {
                printf(" ");
            }
            else

                printf("*");
        }
        printf("\n");
    }
}