The C programming language (second edition,K&R) exercise（CHAPTER 3）

最新推荐文章于 2024-04-24 13:38:14 发布
最新推荐文章于 2024-04-24 13:38:14 发布
阅读量1k 收藏 10
点赞数 27
分类专栏： The C programming language 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoleiwe/article/details/137522820
版权

      E x c e r c i s e 3 − 1 Excercise\quad 3-1 Excercise3−1：输出结果如图1所示，这里故意让二分搜索算法去寻找一个在数组中不存在在的数，然后去看两种二分搜索算法分别所花费的时间的大小，为了使得所花费的时间更具有可分辨性，这里让搜索过程重复执行了 100000000 100000000 100000000次。

/* Solution by Paul Griffiths (mail@paulgriffiths.net) */

/*
  
  EX3_1.C
  =======

  Suggested solution to Exercise 3-1

*/

#include <stdio.h>
#include <time.h>

int binsearch(int x, int v[], int n);     /*  Original K&R function  */
int binsearch2(int x, int v[], int n);    /*  Our new function       */

#define MAX_ELEMENT 200000


/*  Outputs approximation of processor time required
    for our two binary search functions. We search for
    the element -1, to time the functions' worst case
    performance (i.e. element not found in test data)   */

int main(void) 
{
    int testdata[MAX_ELEMENT];
    int index;                  /*  Index of found element in test data  */
    int n = -1;                 /*  Element to search for  */
    int i;
    clock_t time_taken;

    /*  Initialize test data  */
    
    for ( i = 0; i < MAX_ELEMENT; ++i )
        testdata[i] = i;
    
    
    /*  Output approximation of time taken for 100000000 iterations of binsearch() */
    
    for ( i = 0, time_taken = clock(); i < 100000000; ++i ) 
	{
        index = binsearch(n, testdata, MAX_ELEMENT);
    }
    time_taken = clock() - time_taken;
    
    if ( index < 0 )
        printf("Element %d not found.\n", n);
    else
        printf("Element %d found at index %d.\n", n, index);
    
    printf("binsearch() took %lu clocks (%lu seconds)\n",
           (unsigned long) time_taken,
           (unsigned long) time_taken / CLOCKS_PER_SEC);
    
    
    /*  Output approximation of time taken for 100000000 iterations of binsearch2() */
    
    for ( i = 0, time_taken = clock(); i < 100000000; ++i ) 
	{
        index = binsearch2(n, testdata, MAX_ELEMENT);
    }
    time_taken = clock() - time_taken;
    
    if ( index < 0 )
        printf("Element %d not found.\n", n);
    else
        printf("Element %d found at index %d.\n", n, index);
    
    printf("binsearch2() took %lu clocks (%lu seconds)\n",
           (unsigned long) time_taken,
           (unsigned long) time_taken / CLOCKS_PER_SEC);
    
    return 0;
}


/* binsearch：find x in v[0] <= v[1] <= ... v[n-1] */

int binsearch(int x, int v[], int n) 
{
    int low, mid, high;
    
    low = 0;
    high = n - 1;
    while ( low <= high ) 
	{
        mid = (low+high) / 2;
        if ( x < v[mid] )
            high = mid - 1;
        else if ( x > v[mid] )
            low = mid + 1;
        else
            return mid;
    }
    return -1;
}

/* binsearch2：find x in v[0] <= v[1] <= ... v[n-1] */

int binsearch2(int x, int v[], int n) 
{
    int low, mid, high;
    
    low = 0;
    high = n - 1;
    mid = (low+high) / 2;	
    while (( low < high ) &&(x != v[mid]))
	{
        if ( x < v[mid] )
            high = mid - 1;
        else
            low = mid + 1;
        mid = (low+high) / 2;		
    }
    if ( x == v[mid] )
        return mid;
    else
        return -1;
}
　
图1.

      E x c e r c i s e 3 − 2 Excercise\quad 3-2 Excercise3−2：输出结果如图2所示

#include <stdio.h>

void escape(char s[], char t[]);  
void unescape(char s[], char t[]); 
int main(void) 
{
    char text1[100] = "\aHello,\n\tWorld! Mistakee\b was \"Extra 'e'\"!\n";
    char text2[100];
    char text3[100];    
    printf("Original string:\n%s\n", text1);
    
    escape(text2, text1);
    printf("Escaped string:\n%s\n", text2);
    
    unescape(text2, text3);
    printf("Unescaped string:\n%s\n", text3);
    
    return 0;
}


/*  Copies string t to string s, converting special
    characters into their appropriate escape sequences.
    The "complete set of escape sequences" found in
    K&R Chapter 2 is used, with the exception of:
    
    \? \' \ooo \xhh
    
    as these can be typed directly into the source code,
    (i.e. without using the escape sequences themselves)
    and translating them is therefore ambiguous.    */
void escape(char s[], char t[]) 
{
    int i=0;
    int j=0;
    while ( t[i]!='\0' ) 
	{
        switch (t[i])
		{
			case '\t':
			    s[j++]='\\';
			    s[j++]='t';			
			    break;
			case '\n':
			    s[j++]='\\';
			    s[j++]='n';				
			    break;	
			case '\a':
			    s[j++]='\\';
			    s[j++]='a';			
			    break;
			case '\b':
			    s[j++]='\\';
			    s[j++]='b';			
			    break;
			case '\f':
			    s[j++]='\\';
			    s[j++]='f';			
			    break;
			case '\r':
			    s[j++]='\\';
			    s[j++]='r';			
			    break;
			case '\v':
			    s[j++]='\\';
			    s[j++]='v';			
			    break;	
			case '\"':
			    s[j++]='\\';
			    s[j++]='\"';			
			    break;
			case '\\':
			    s[j++]='\\';
			    s[j++]='\\';			
			    break;								
			default:
			    s[j++]=t[i];			
			    break;			
		}
		i++;
    }
	s[j]='\0';
}

/*  Copies string s to string t, converting escape sequences
    into their appropriate special characters. See the comment
    for escape() for remarks regarding which escape sequences
    are translated. */
void unescape(char s[], char t[]) 
{
    int i=0;
    int j=0;
    while ( s[i]!='\0' ) 
	{
        switch (s[i])
		{
			case '\\':
                switch (s[++i])
		        {
		        	case 't':
		        	    t[j++]='\t';		
		        	    break;
		        	case 'n':
		        	    t[j++]='\n';			
		        	    break;	
		        	case 'a':
		        	    t[j++]='\a';		
		        	    break;
		        	case 'b':
		        	    t[j++]='\b';		
		        	    break;
		        	case 'f':
		        	    t[j++]='\f';		
		        	    break;
		        	case 'r':
		        	    t[j++]='\r';		
		        	    break;
		        	case 'v':
		        	    t[j++]='\v';		
		        	    break;
		        	case '\"':
		        	    t[j++]='\"';			
		        	    break;
		        	case '\\':
		        	    t[j++]='\\';		
		        	    break;
                    default:
                
                /*  We don't translate this escape
                    sequence, so just copy it verbatim  */                
                        t[j++] = '\\';
                        t[j++] = t[i];						
		        }			
			    break;								
			default:
			    t[j++]=s[i];			
			    break;			
		}
		++i;
    }
	t[j]='\0';
}
　
图2.

      E x c e r c i s e 3 − 3 Excercise\quad 3-3 Excercise3−3：输出结果如图3所示。

#include <stdio.h>

#define MAXIMUM 1000

void expand(char s1[], char s2[]);
int is_valid(char c);

int main()
{
    char s1[MAXIMUM] = "-A-C-E-I first a-z0-9 second -a-z third   9-2 fourth   6-6- end-";	
    char s2[MAXIMUM];
    printf("%s\n", s1);
    expand(s1, s2);
    printf("%s\n", s2);
    return 0;
}

void expand(char s1[], char s2[]) 
{
    char c, d;
    int i, j;
    i = j = 0;

    while ('\0' != (c = s1[i++])) 
	{
        if (is_valid(c) && '-' == s1[i]  && is_valid(s1[i + 1])) 
		{
            i++;
            d = s1[i];
            if (c > d) 
			{
                while (c > d) 
				{
                    s2[j++] = c--;
                }
            }
            else 
			{
                while (c < d) 
				{
                    s2[j++] = c++;
                }
            }
        }
        else 
		{
            s2[j++] = c;
        }
    }
    s2[j] = '\0';
}

int is_valid(char c)
{
    if(((c>='a') && (c<='z'))	|| ((c>='A') && (c<='Z'))	|| ((c>='0') && (c<='9')))
	{
		return 1;
	}
	else
	{
		return 0;
	}	
}
　
图3.

      E x c e r c i s e 3 − 4 Excercise\quad 3-4 Excercise3−4：下面我们首先来看一段代码以及输出，输出结果如图4所示。这里 i n t int int型变量能表示的数的最大范围是 [ − 2147483648 , 2147483647 ] [-2147483648,2147483647] [−2147483648,2147483647]，这里我们可以看到 i n t int int型可以表示的最大负数的绝对值要比 i n t int int型可以表示的最大正数的值大一（其它类型的有符号数的类型也是一样的），当我们在尝试使用书中的那个版本的 i t o a itoa itoa接口来将 i n t int int型可以表示的最大负数 − 2147483648 -2147483648 −2147483648转换为字符串的时候会出现问题。书中的那个版本的 i t o a itoa itoa接口会首先将要转换的负数变成正数，但是对于 i n t int int型，它可以表示的最大正数是 2147483647 2147483647 2147483647，因此从图4中我们可以看到 i n t u = − i ; int u=-i; intu=−i;操作之后 u u u的值还是 − 2147483648 -2147483648 −2147483648，因此书中的那个版本的 i t o a itoa itoa接口中的 d o w h i l e do\quad while dowhile循环只会运行一次且就算是这一次对个位数的转换也是错误的，这是因为这一次循环中 n % 10 n\%10 n%10操作的结果是 − 8 -8 −8，因此 n % 10 + ′ 0 ′ n\%10+'0' n%10+′0′操作的结果是 40 40 40（字符 ′ 0 ′ '0' ′0′的 A S C I I ASCII ASCII码值是48，字符 ′ ( ′ '(' ′(′的 A S C I I ASCII ASCII码值是40，），因此这里并没有得到我们所预期的字符 ′ 8 ′ '8' ′8′。为了能够成功实现对 i n t int int型可以表示的最大负数的转换，改进后的程序在判断 d o w h i l e do\quad while dowhile循环的执行的时候改为 w h i l e ( n / = 10 ) ; while ( n /= 10 ); while(n/=10);，而不是 w h i l e ( ( n / = 10 ) > 0 ) ; while( ( n /= 10 )>0); while((n/=10)>0);也就是不为0就可以继续执行循环，且改进后的程序在求余数之后做了绝对值的操作。

#include <stdio.h>
#include <limits.h>


int main(void)
{
	char c='\0';
	printf("sizeof(int)=%d\n",sizeof(int));
    printf("Signed int[%d to %d]\n", INT_MIN, INT_MAX);
    printf("Unsigned int[0 to %u]\n", UINT_MAX);
    int i=-2147483648;
    int u=-i;	
	printf("i=%d\n",i);	
	printf("u=%d\n",u);			
	c=(u%10)+'0';
	printf("c=%d\n",c);	
	printf("c=%c\n",c);		
	return 0;
}
　
图4. 
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>

void itoa_myself(int n, char s[]);
void reverse(char s[]);

int main(void) 
{
    char buffer[100];
    
    printf("INT_MIN: %d\n", INT_MIN);
    itoa_myself(INT_MIN, buffer);
    printf("Buffer : %s\n", buffer);
    
    return 0;
}

void itoa_myself(int n, char s[]) 
{
    int i, sign;
    sign = n;
    
    i = 0;
    do 
	{
        s[i++] = abs(n % 10) + '0';
    } while ( n /= 10 );
    if (sign < 0)
        s[i++] = '-';
    
    s[i] = '\0';
    reverse(s);
}

void reverse(char s[]) 
{
    int c, i, j;
    for ( i = 0, j = strlen(s)-1; i < j; i++, j--) 
	{
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

      E x c e r c i s e 3 − 5 Excercise\quad 3-5 Excercise3−5：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void itob(int n , char s[], int b);
void reverse(char s[]);

#define MAXIMUM 100

int main(){
    int b = 16;
    char s[MAXIMUM];
    itob(-2147483648,s,b);
    printf("Base %d = %s\n",b,s);
    return 0;
}

void itob(int n, char s[], int b)
{
    int i = 0;
	int negative=0;
	if(n<0)
	{
		negative=-1;			
	}
    if((b!=2) && (b!=8) && (b!=16)) 
	{		
	    printf("base error\n");	
	}		
    do
    {
        if (abs(n%b)>9)
            s[i++]= abs(n%b) +'A'-10;
        else
            s[i++] = abs(n%b) +'0';
    } while ((n/=b));
	if(negative==-1)
	{
		s[i++]='-';			
	}
    s[i] = '\0';	
    reverse(s);
}

void reverse (char s[])
{
    int i , j , c;
    for (i = 0, j = strlen(s)-1; i < j; i++,j--)
    c = s[i], s[i]=s[j], s[j]=c;
}

      E x c e r c i s e 3 − 6 Excercise\quad 3-6 Excercise3−6：

#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>

void itoa_myself(int n, char s[], int minmum);
void reverse(char s[]);

int main(void) 
{
    char buffer[100];
    
    printf("INT_MIN: %d\n", INT_MIN);
    itoa_myself(INT_MIN, buffer,25);
    printf("Buffer : %s\n", buffer);
    
    return 0;
}

void itoa_myself(int n, char s[], int minmum) 
{
    int i, sign;
    sign = n;
    
    i = 0;
    do 
	{
        s[i++] = abs(n % 10) + '0';
    } while ( n /= 10 );
    if (sign < 0)
        s[i++] = '-';
	while(i<minmum)
	{
        s[i++] = ' ';		
	}	
    s[i] = '\0';
    reverse(s);
}

void reverse(char s[]) 
{
    int c, i, j;
    for ( i = 0, j = strlen(s)-1; i < j; i++, j--) 
	{
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}
qqssss121dfd
关注
  • 27
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
"The C Programming Language", 2nd edition, Kernighan and Ritchie
dfreng的专栏
10-19 2457
目      录译者序序第1版序前言第1章   基本概念 1.1   入门 1.2   变量与算术表达式 1.3   for语句 1.4   符号常量 1.5   字符输入输出 1.5.1   文件复制 1.5.2   字符计数 1.5.3   行计数 1.5.4   单词计数 1.6   数组 1.7   函数 1.8   变元—按值调用 1.9   字符数组 1.10   外部变量与作用域 第
The_C_Programming_Language(K&R).pdf
02-27
Chapter 1 - A Tutorial Introduction Chapter 2 - Types, Operators and Expressions Chapter 3 - Control Flow Chapter 4 - Functions and Program Structure Chapter 5 - Pointers and Arrays ...
The C programming language (second edition,K&R) exercise（CHAPTER 4）
caoleiwe的博客
04-21 676
     Excercise4−1Excercise\quad 4-1Excercise4−1： #include <stdlib.h> #include <stdio.h> #include <string.h> int strindex(char s[],char t[]); int strrindex(char s[],char t[]); int main(void) { char s[100]="q
The C programming language (second edition,K&R) exercise（CHAPTER 2）
caoleiwe的博客
04-08 1211
的二进制表示的最右的比特值为1的比特位后面所有为0的比特位的值都变成1，因此总的来说操作。的二进制表示基本一样，除了二进制表示的最低位为0，那么此时操作。的二进制表示的最右的比特值为1的比特位的值变成0，同时将。的比特值为1的比特位清零，因此可以利用这个现象来统计。的比特值为1的比特位清零，其它位保持不变。的二进制表示的最低位肯定为1，那么此时。位清零，其它位保持不变。中比特位的值为1的比特位的个数。，那么它的二进制表示为。，那么它的二进制表示为。为奇数还是偶数，操作。
The C programming language (second edition,K&R) exercise（CHAPTER 1）
caoleiwe的博客
03-27 1381
函数的情况下要求可以打印出任何长度的输入行的长度以及尽可能多的文本。在书中的初始程序中当输入行的长度超过允许的最大长度时，返回的长度就是这个允许的最大长度，而不是当前行的实际长度，下面两个实现分别只修改。函数实现了当输入行的长度超过允许的最大长度时，返回的长度是当前行的实际长度。：对于这一题的具体要求我没有弄清楚,下面的代码实现是基于线面代码的原作者以及。我对该题的意图的理解是对于字符数较多的行，每隔特定。是为了处理处理的字符流的最前面就是一个或多个的。按键的作用，这里我们简单的用下面的程序演示一下。
The-C-Programming-Language:K＆R的C编程语言（第二版）中的练习答案
05-11
Brian W. Kernighan和Dennis M. Ritchie对C编程语言（第二版）的答案。 这些是K＆R的C编程语言（第二版）中练习的答案。 如果您发现错误或错误，请告诉我。 干杯!内容
The C Programming Language (K&R) 中文版
07-26
C语言
The C Programming Language Second Edition 徐宝文 李志 译
03-22
C语言教程知名图书 汉化版
Errata for The C Programming Language, Second Edition
05-08
Errata for The C Programming Language, Second Edition
linux驱动-CCF-1 provider 注册时钟
2401_83458819的博客
04-24 427
struct clk_hw_onecell_data onecell 填充到struct of_clk_provider *cp 中的data。struct clk_hw 组成 struct clk_hw_onecell_data onecell。b. 调用 of_clk_add_hw_provider 根据 进一步生成of_clk_provider ，并添加到全局列表。void *data;//对应 clk_hw_onecell_data（包含clk provider 注册的所有数组）
node-v9.6.0-x86.msi
04-29
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Python基于机器学习的分布式系统故障诊断系统源代码，分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别
04-29
基于技术手段（包括但不限于机器学习、深度学习等技术）对分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别，实现分布式系统故障运维的智能化，快速恢复故障的同时大大降低分布式系统运维工作的难度，减少运维对人力资源的消耗。在分布式系统中某个节点发生故障时，故障会沿着分布式系统的拓扑结构进行传播，造成自身节点及其邻接节点相关的KPI指标和发生大量日志异常
JavaScript前端开发的核心语言前端开发的核心语言
最新发布
04-29
javascript 当今互联网时代，JavaScript已经成为了前端开发的核心语言它是一种高级程序设计语言，通常用于网页的交互和动态效果的实现。JavaScript的灵活性以及广泛的使用使得它变得异常重要，能够为用户带来更好的用户体验。 JavaScript的特点之一是它的轻量级，它可以在网页中运行无需单独的编译或下载。这意味着网页可以更快地加载并且用户无需安装额外的软件才能运行网页上的JavaScript代码。此外，与HTML和CSS紧密结合，可以直接在HTML文档中嵌入，使得网页的开发变得非常便捷。 JavaScript具有动态性，它可以在浏览器中实时修改页面内容和样。它可以通过操作DOM（文档对象模型来动态地修改网页的结构和布局，并且可以根据用户的行为实时地响应各种事件，如点击、标悬停、滚动等。这使得开发者可以轻松地为网页添加交互性和动态效果，提供更好的用户体验。 JavaScript也是一种面向对象的语言。它支持对象、类、继承、多态等面向对象编程的概念，使得代码结构更加清晰和可维护。开发者可以创建自定义的对象和方法，对功能进行封装和复用，提高代码的可读性和可维护性。
四则运算自动生成程序安装包
04-29
四则运算自动生成程序安装包
基于Linux的私有文件服务器(网盘).zip
04-29
基于Linux的私有文件服务器(网盘)
源代码-access 管理 系统 API 文件.zip
04-29
源代码-access 管理 系统 API 文件.zip
海康机器人智能读码器工业协议操作手册V1.0.2.pdf
04-29
海康机器人智能读码器工业协议操作手册V1.0.2.pdf
256ssm-mysql-jsp 在线捐赠系统.zip（可运行源码+数据库文件+文档）
04-29
根据需求，确定系统采用JSP技术，JAVA作为编程语言，MySQL作为数据库。整个系统要操作方便、易于维护、灵活实用。主要实现了系统用户管理、注册用户管理、信息发布管理、医疗物品分类管理、项目信息管理、捐赠项目管理、志愿者申请管理、个人求助管理、个人捐赠统计、系统管理等功能。 前台用户模块包括： 1. 首页：网站打开的第一个页面，显示网站的最新信息。 2. 用户注册/登录、3. 新闻资讯、4. 暖心故事、5. 我要求助、6. 我要捐赠、7. 我们的项目、8. 志愿者中心：实现志愿者中心的列表显示、9. 系统简介、10. 在线留言、11. 用户后台 后台管理员模块包括： 1. 系统用户管理、2. 注册用户管理、3. 信息发布管理、4. 医疗物品分类管理、5. 项目信息管理、6. 捐赠项目管理、7. 志愿者申请管理、8. 个人求助管理：管理员可以设置个人求助审核状态，可以删除个人求助审核信息。 9. 个人捐赠统计：管理员可以查看个人捐赠统计信息。 10. 系统管理：管理员可以对留言板信息进行查看、回复或删除 关键词：医药捐赠系统；JSP;MySQL
the c programming language (2nd edition), by brian w. kernighan and dennis m
01-14
Ritchie，是一本经典的C语言编程教材。本书由C语言的创造者之一Dennis M. Ritchie与Brian W. Kernighan合著，于1978年首次出版。 《C语言程序设计》是一本被广泛推荐的C语言教材。它以简洁明了、易于理解的方式介绍了C语言的基础知识和编程技巧。书中内容详尽而系统，并通过丰富的示例和练习来帮助读者巩固所学知识。 这本书在C语言教学领域具有里程碑的意义。它为C语言的学习和应用奠定了坚实基础，并对后续编程语言的发展产生了深远影响。无论是初学者还是有一定编程经验的程序员，都可以从中受益。 在本书中，作者展示了C语言的核心概念和语法，包括变量、类型、运算符、控制流、函数和指针等。此外，本书还涵盖了如文件操作、预处理器和库函数等更高级的主题。 此外，本书还提供了一些重要的编程技巧和经验，如如何编写清晰、优雅的代码，如何进行调试和测试等。这些技巧对于成为一名出色的程序员非常重要。 总之，《C语言程序设计》是一本经典而实用的C语言教材。它为读者提供了扎实的基础知识和实用的编程技巧，适合于初学者和有一定编程经验的程序员。无论是学习编程基础还是进一步深入学习C语言，这本书都是非常值得推荐的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qqssss121dfd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值