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

已于 2024-04-10 17:35:23 修改
阅读量1.2k 收藏 22
点赞数 25
分类专栏： The C programming language 文章标签： c语言 r语言 开发语言
于 2024-04-08 11:33:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoleiwe/article/details/137155245
版权

      E x c e r c i s e 2 − 1 Excercise\quad 2-1 Excercise2−1：输出结果如图1和图2所示，这道练习题需要文章1和文章2的知识。

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


float getFloat(char sign, unsigned char exp, unsigned mantissa);
double getDouble(char sign, unsigned short exp, unsigned long long mantissa);

int main(void)
{
	printf("sizeof(char)=%d\n",sizeof(char));
    printf("Signed char[%d to %d]\n", (~(((unsigned char)~0) >> 1)), (unsigned char)(((unsigned char)~0 >> 1)));
    printf("Unsigned char[0 to %u]\n", ((unsigned char)~0));		
	printf("sizeof(short)=%d\n",sizeof(short));
    printf("Signed short[%d to %d]\n", (~(((unsigned short)~0) >> 1)), (unsigned short)(((unsigned short)~0 >> 1)));
    printf("Unsigned short[0 to %u]\n", (unsigned short)((unsigned short)~0));
	printf("sizeof(int)=%d\n",sizeof(int));
    printf("Signed int[%d to %d]\n", (unsigned int)(~(((unsigned int)~0) >> 1)), (unsigned int)(((unsigned int)~0 >> 1)));
    printf("Unsigned int[0 to %u]\n", (unsigned int)((unsigned int)~0));
	printf("sizeof(long)=%d\n",sizeof(long));
    printf("Signed long[%ld to %ld]\n",(unsigned long)(~(((unsigned long)~0) >> 1)), (unsigned long)(((unsigned long)~0 >> 1)));
    printf("Unsigned long[0 to %lu]\n",(unsigned long)((unsigned long)~0));
	printf("sizeof(long long)=%d\n",sizeof(long long));
    printf("Signed long long[%lld to %lld]\n", (unsigned long long)(~(((unsigned long long)~0) >> 1)), (unsigned long long)(((unsigned long long)~0 >> 1)));
    printf("Unsigned long long[0 to %llu]\n", (unsigned long long)((unsigned long long)~0));

	printf("---------------------------------------------------------------\n");
    printf("Signed char[%d to %d]\n", SCHAR_MIN, SCHAR_MAX);
    printf("Unsigned char[0 to %u]\n", UCHAR_MAX);		
	printf("---------------------------------------------------------------\n");
    printf("Signed short[%d to %d]\n", SHRT_MIN, SHRT_MAX);
    printf("Unsigned short[0 to %u]\n", USHRT_MAX);
	printf("---------------------------------------------------------------\n");
    printf("Signed int[%d to %d]\n", INT_MIN, INT_MAX);
    printf("Unsigned int[0 to %u]\n", UINT_MAX);
	printf("---------------------------------------------------------------\n");
    printf("Signed long[%ld to %ld]\n",LONG_MIN, LONG_MAX);
    printf("Unsigned long[0 to %lu]\n",ULONG_MAX);
	printf("---------------------------------------------------------------\n");
    printf("Signed long long[%lld to %lld]\n", LLONG_MIN, LLONG_MAX);
    printf("Unsigned long long[0 to %llu]\n", ULLONG_MAX);

	printf("---------------------------------------------------------------\n");

    printf("Positive Normalized Float[%g to %g]\n", getFloat(0, 0x01, 0x00000000), getFloat(0, 0xFE, 0x007FFFFF));
    printf("Negative Normalized Float[%g to %g]\n", getFloat(1, 0xFE, 0x007FFFFF), getFloat(1, 0x01, 0x00000000));

    printf("Positive De-Normalized Float[%g to %g]\n", getFloat(0, 0x00, 0x00000001), getFloat(0, 0x00, 0x007FFFFF));
    printf("Negative De-Normalized Float[%g to %g]\n", getFloat(1, 0x00, 0x007FFFFF), getFloat(1, 0x00, 0x00000001));

    printf("Positive De-Normalized Zero Float[%g]\n", getFloat(0, 0x00, 0x00000000));
    printf("Negative De-Normalized Zero Float[%g]\n", getFloat(1, 0x00, 0x00000000));
	
    printf("Positive Infinity Float[%g]\n", getFloat(0, 0xFF, 0x00000000));
    printf("Negative Infinity Float[%g]\n", getFloat(1, 0xFF, 0x00000000));	
	
    printf("Not A Number Float[%g]\n", getFloat(0, 0xFF, 0x00000010));		
    printf("Not A Number Float[%g]\n", getFloat(1, 0xFF, 0x00000001));		

    printf("Positive Normalized Double[%g to %g]\n", getDouble(0, 0x0001, 0x0000000000000000), getDouble(0, 0x07FE, 0x000FFFFFFFFFFFFF));
    printf("Negative Normalized Double[%g to %g]\n", getDouble(1, 0x07FE, 0x000FFFFFFFFFFFFF), getDouble(1, 0x0001, 0x0000000000000000));

    printf("Positive De-Normalized Double[%g to %g]\n", getDouble(0, 0x0000, 0x0000000000000001), getDouble(0, 0x0000, 0x000FFFFFFFFFFFFF));
    printf("Negative De-Normalized Double[%g to %g]\n", getDouble(1, 0x0000, 0x000FFFFFFFFFFFFF), getDouble(1, 0x0000, 0x0000000000000001));

    printf("Positive De-Normalized Zero Double[%g]\n", getDouble(0, 0x0000, 0x0000000000000000));
    printf("Negative De-Normalized Zero Double[%g]\n", getDouble(1, 0x0000, 0x0000000000000000));
	
    printf("Positive Infinity Double[%g]\n", getDouble(0, 0x07FF, 0x0000000000000000));
    printf("Negative Infinity Double[%g]\n", getDouble(1, 0x07FF, 0x0000000000000000));	
	
    printf("Not A Number Double[%g]\n", getDouble(0, 0x07FF, 0x0000000000000010));		
    printf("Not A Number Double[%g]\n", getDouble(1, 0x07FF, 0x0000000000000001));		
    return 0;
}

float getFloat(char sign, unsigned char exp, unsigned mantissa)
{
    unsigned f = ((unsigned)(((unsigned)(sign != 0))) << 31) | ((unsigned)(((unsigned)exp) << 23)) | ((unsigned)(mantissa & 0x007FFFFF));
    return *((float *)&f);
}

double getDouble(char sign, unsigned short exp, unsigned long long mantissa)
{
    unsigned long long d = ((unsigned long long)(((unsigned long long)(sign != 0)) << 63)) | ((unsigned long long)((unsigned long long)(exp & 0x07FF) << 52)) | ((unsigned long long)(mantissa & 0x000FFFFFFFFFFFFF));
    return *((double *)&d);
}
　
图1.
　
图2.

      E x c e r c i s e 2 − 2 Excercise\quad 2-2 Excercise2−2：

#include <stdio.h>

#define MAXLINE  (1000)

int getline(char s[], int lim);

int main()
{
    int len;    /* current line length */
    char line[MAXLINE];     /* current input line */

    while ((len = getline(line, MAXLINE)) > 0) 
	{
        printf("%s",line);
    }

    return 0;
}

/* getline: read a line s, return length */
int getline(char s[], int lim)
{
    int c, i;

    for (i = 0; i < lim-1; ++i)
	{
	    c = getchar();	
		if((c == '\n'))
		{
			break;
		}
		else if((c== EOF))
		{
			break;
		}		
		else
		{
            s[i] = c;			
		}
	}
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';

    return i;
}

      E x c e r c i s e 2 − 3 Excercise\quad 2-3 Excercise2−3：

#include <stdio.h>

#define MAXLINE  (1000)

int getline(char s[], int lim);
int htoi(char s[]);

int main()
{
	int result=0;
    int len;    /* current line length */
    char line[MAXLINE];     /* current input line */

    while ((len = getline(line, MAXLINE)) > 0) 
	{
        printf("%s\n",line);
		result=htoi(line);
        printf("result=%d\n",result);		
    }

    return 0;
}

int power(int ex)
{
    int i=0;
    int result=1;	
	while(i<ex)
	{
		result=result*16;	
        i=i+1;		
	}
    return result;
}

int htoi(char s[])
{
    int i=0;	
    int result=0;	
    int prefix=0;	
    int s_index=0;
	int e_index=0;
	
    while(s[i]!='\0')
	{
		if(((s[i]>='0')&&(s[i]<='9'))||((s[i]>='a')&&(s[i]<='f'))||((s[i]>='A')&&(s[i]<='F')))
		{
			
		}
		else
		{
			if(i==1)
			{
				if(s[0]=='0')
				{
				    if((s[1]=='x')||(s[1]=='X'))
				    {
				    	prefix=1;
				    	
				    }
					else
					{
					    printf("Hexadecimal string error\n");
                        return -1;						
					}
					
				}
				else
				{
					printf("Hexadecimal string error\n");
                    return -1;						
				}
			}
			else
			{
		        printf("Hexadecimal string error\n");
                return -1;
			}			
		}
	    i=i+1;			
	}	
    s_index=i;	
	if(s_index==0)
	{
		printf("Hexadecimal string error\n");
		return -1;
	}
	if(s_index==1)
	{
		if((s[i]>='0')&&(s[i]<='9'))
		{
		    return  ((int)(s[i]-'0'));	
		}		
		if((s[i]>='a')&&(s[i]<='f'))
		{
		    return  ((int)((s[i]-'a')+10));				
		}
		if((s[i]>='A')&&(s[i]<='F'))
		{
		    return  ((int)((s[i]-'A')+10));				
		}				
	}	
	if(s_index==2)
	{		
		if(prefix==1)
		{
		    printf("Hexadecimal string error\n");
		    return -1;	
		}
        else
		{
		    for(i=0;i<s_index;i++)
			{
		        if((s[s_index-1-i]>='0')&&(s[s_index-1-i]<='9'))
		        {
		            result=result +  ((int)(s[s_index-1-i]-'0')) *power(i);	
		        }		
		        if((s[s_index-1-i]>='a')&&(s[s_index-1-i]<='f'))
		        {
		            result=result +  ((int)((s[s_index-1-i]-'a')+10)) *power(i);										
		        }
		        if((s[s_index-1-i]>='A')&&(s[s_index-1-i]<='F'))
		        {
		            result=result +  ((int)((s[s_index-1-i]-'A')+10)) *power(i);									
		        }					
			}					
		}					
	}
	if(s_index>2)
	{		
		if(prefix==1)
		{
		    for(i=0;i<(s_index-2);i++)
			{
		        if((s[s_index-1-i]>='0')&&(s[s_index-1-i]<='9'))
		        {
		            result=result +  ((int)(s[s_index-1-i]-'0')) *power(i);	
		        }		
		        if((s[s_index-1-i]>='a')&&(s[s_index-1-i]<='f'))
		        {
		            result=result +  ((int)((s[s_index-1-i]-'a')+10)) *power(i);										
		        }
		        if((s[s_index-1-i]>='A')&&(s[s_index-1-i]<='F'))
		        {
		            result=result +  ((int)((s[s_index-1-i]-'A')+10)) *power(i);									
		        }					
			}					
		}	
        else
		{
		    for(i=0;i<s_index;i++)
			{
		        if((s[s_index-1-i]>='0')&&(s[s_index-1-i]<='9'))
		        {
		            result=result +  ((int)(s[s_index-1-i]-'0')) *power(i);	
		        }		
		        if((s[s_index-1-i]>='a')&&(s[s_index-1-i]<='f'))
		        {
		            result=result +  ((int)((s[s_index-1-i]-'a')+10)) *power(i);										
		        }
		        if((s[s_index-1-i]>='A')&&(s[s_index-1-i]<='F'))
		        {
		            result=result +  ((int)((s[s_index-1-i]-'A')+10)) *power(i);									
		        }					
			}					
		}					
	}

    return result;
}


/* getline: read a line s, return length */
int getline(char s[], int lim)
{
    int c, i;

    for (i = 0; i < lim-1; ++i)
	{
	    c = getchar();	
		if((c == '\n'))
		{
			break;
		}
		else if((c== EOF))
		{
			break;
		}		
		else
		{
            s[i] = c;			
		}
	}
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';

    return i;
}

      E x c e r c i s e 2 − 4 Excercise\quad 2-4 Excercise2−4：

#include <stdio.h>

#define MAXLINE  (1000)

int getline(char s[], int lim);
void squeeze(char s1[],char s2[]);

int main()
{
	int result=0;
    int len;    /* current line length */
    char line[MAXLINE];     /* current input line */

    while ((len = getline(line, MAXLINE)) > 0) 
	{
        printf("before:%s\n",line);
		squeeze(line,"aFEb");
        printf("after:%s\n",line);		
    }

    return 0;
}

int is_str_ch(char s[],char c)
{
    int i=0;
    char temp_c=0;	
    int result=0;	
	while((temp_c=s[i++])!='\0')
	{   
        if(temp_c==c)
		{
		    result=1;
            break;			
		}	
	}
    return result;
}


void squeeze(char s1[],char s2[])
{
    int i,j;
	for(i=j=0;s1[i]!='\0';i++)
	{			
	    if(!is_str_ch(s2,s1[i]))
        {
			s1[j++]=s1[i];		
		}				
	}
	s1[j]='\0';		
}


/* getline: read a line s, return length */
int getline(char s[], int lim)
{
    int c, i;

    for (i = 0; i < lim-1; ++i)
	{
	    c = getchar();	
		if((c == '\n'))
		{
			break;
		}
		else if((c== EOF))
		{
			break;
		}		
		else
		{
            s[i] = c;			
		}
	}
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';

    return i;
}

      E x c e r c i s e 2 − 5 Excercise\quad 2-5 Excercise2−5：

#include <stdio.h>

#define MAXLINE  (1000)

int getline(char s[], int lim);
int any(char s1[],char s2[]);

int main()
{
	int position=0;
    int len;    /* current line length */
    char line[MAXLINE];     /* current input line */

    while ((len = getline(line, MAXLINE)) > 0) 
	{
		position=any(line,"aFEb");
        printf("position=%d\n",position);		
    }

    return 0;
}


int any(char s1[],char s2[])
{
    int i,j;
	for(i=0;s1[i]!='\0';i++)
	{			
	    for(j=0;s2[j]!='\0';j++)
        {
			if(s1[i]==s2[j])
			{
				return i;				
			}				
		}				
	}
	return -1;		
}


/* getline: read a line s, return length */
int getline(char s[], int lim)
{
    int c, i;

    for (i = 0; i < lim-1; ++i)
	{
	    c = getchar();	
		if((c == '\n'))
		{
			break;
		}
		else if((c== EOF))
		{
			break;
		}		
		else
		{
            s[i] = c;			
		}
	}
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';

    return i;
}

      E x c e r c i s e 2 − 6 Excercise\quad 2-6 Excercise2−6：

#include <stdio.h>

unsigned setbits(unsigned x,int p,int n,unsigned y);

int main()
{
	unsigned x=0xFFFFFFDF;
	unsigned y=0xFFFFFFF2;
	unsigned p=0;
    p=setbits(x,5,2,y);
    printf("p=%08x\n",p);		

    return 0;
}


unsigned setbits(unsigned x,int p,int n,unsigned y)
{
    unsigned front=((~((unsigned)0))<<(p+1));
    unsigned back=~((~((unsigned)0))<<(p-n+1));
    unsigned all=front | back;	
	x=x & all;	
	y=(~((~0)<<n)) & y;
    y=y<<(p-n+1);
	x=x | y;
	return x;		
}

      E x c e r c i s e 2 − 7 Excercise\quad 2-7 Excercise2−7:

#include <stdio.h>

unsigned invert(unsigned x,int p,int n);

int main()
{
	unsigned x=0xFFFF55FF;
	unsigned inverted=0;
    inverted=invert(x,15,8);
    printf("inverted=%08x\n",inverted);		

    return 0;
}


unsigned invert(unsigned x,int p,int n)
{
	int i;
    unsigned temp1_x=x & (~((~((~((unsigned)0))<<n))<<(p-n+1)));
    unsigned temp2_x=0;	
    unsigned index=1<<p;
	for(i=0;i<n;i++)
	{
	    if(!(index & x))
		{
			temp2_x|=index;			
		}			
		index=index>>1;		
	}

	return (temp1_x) | (temp2_x);		
}

      E x c e r c i s e 2 − 8 Excercise\quad 2-8 Excercise2−8:

#include <stdio.h>

unsigned rightrot(unsigned x,int n);

int main()
{
	unsigned x=0xFFFFFF5A;
	unsigned rotated=0;
    rotated=rightrot(x,8);
    printf("rotated=%08x\n",rotated);		

    return 0;
}


unsigned rightrot(unsigned x,int n)
{
    unsigned temp1_x=x & (~((~((unsigned)0))<<n));
	temp1_x=temp1_x<<((sizeof(unsigned) * 8)-n);
    unsigned temp2_x=(x>>n) & ((~((unsigned)0)>>n));	

	return (temp1_x) | (temp2_x);		
}

      E x c e r c i s e 2 − 9 Excercise\quad 2-9 Excercise2−9:当 x x x为奇数的时候， x x x的二进制表示的最低位肯定为1，那么此时 x − 1 x-1 x−1的值二进制表示和 x x x的二进制表示基本一样，除了二进制表示的最低位为0，那么此时操作 x & = ( x − 1 ) x\&=(x-1) x&=(x−1)就会将 x x x的二进制表示的最低位清零，其它位保持不变。假设此时 x = 213 x=213 x=213，那么它的二进制表示为 11010101 11010101 11010101，此时 x − 1 x-1 x−1的值二进制表示为 11010100 11010100 11010100，那么此时操作 x & = ( x − 1 ) x\&=(x-1) x&=(x−1)之后 x x x的值为 11010100 11010100 11010100= x − 1 x-1 x−1。当 x x x为偶数的时候， x − 1 x-1 x−1会将 x x x的二进制表示的最右的比特值为1的比特位的值变成0，同时将 x x x的二进制表示的最右的比特值为1的比特位后面所有为0的比特位的值都变成1，因此总的来说操作 x & = ( x − 1 ) x\&=(x-1) x&=(x−1)会将 x x x的二进制表示的最右的比特值为1的比特位清零，其它位保持不变。假设此时 x = 208 x=208 x=208，那么它的二进制表示为 11010000 11010000 11010000，此时 x − 1 x-1 x−1的值二进制表示为 11001111 11001111 11001111，那么此时操作 x & = ( x − 1 ) x\&=(x-1) x&=(x−1)之后 x x x的值为 11000000 11000000 11000000。因此总结来说不论 x x x为奇数还是偶数，操作 x & = ( x − 1 ) x\&=(x-1) x&=(x−1)都会将 x x x的二进制表示的最右的比特值为1的比特位清零，因此可以利用这个现象来统计 x x x中比特位的值为1的比特位的个数。

#include <stdio.h>

int bitcount(unsigned x);

int main()
{
	unsigned x=0x84211234;
	unsigned num_of_1_bits=0;
    num_of_1_bits=bitcount(x);
    printf("num_of_1_bits=%d\n",num_of_1_bits);		

    return 0;
}


/* bitcount:  count 1 bits in x */
int bitcount(unsigned x)
{
    int b;

    for (b = 0; x != 0; x &= (x-1))
        b++;
    return b;
}

      E x c e r c i s e 2 − 10 Excercise\quad 2-10 Excercise2−10:

#include <stdio.h>

char lower(char c);

int main()
{
	char c='A';
    printf("lower(c)=%c\n",lower(c));		
    return 0;
}


/* lower:  convert c to lower case: ASCII only */
char lower(char c)
{
    return ((c>='A' && c<='Z') ? (c-'A'+'a'):c);
}
qqssss121dfd
关注
  • 25
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
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:K＆R的C编程语言（第二版）中的练习答案
05-11
Brian W. Kernighan和Dennis M. Ritchie对C编程语言（第二版）的答案。 这些是K＆R的C编程语言（第二版）中练习的答案。 如果您发现错误或错误，请告诉我。 干杯!内容
The C Programming Language Second Edition 徐宝文 李志 译
03-22
C语言教程知名图书 汉化版
The-C-Programming-Language-2nd-Edition:Brian W. Kernighan和Dennis M. Ritchie所著的“ The C Programming Language”（第2版）中的练习的源代码和我的解决方案，也称为K＆R-C language program source code
03-25
《 C程序设计语言》 K＆R示例代码，练习代码，以及重要笔记标注 ... Ritchie的书“ The C Programming Language”（第2版）中的练习的源代码和我的解决方案，也称为K＆R。 该存储库为中文版《 C程序设计语言》
字符函数&内存函数———C语言
2301_79109608的博客
08-21 959
原理：将num个字节的值从源指向的位置复制到目标指向的内存块。原型：void * memmove ( void * destination, const void * source, size_t num );原型：void * memcpy ( void * destination, const void * source, size_t num );原理：将ptr指向的内存块的前num个字节设置为指定的值(解释为unsigned char)destination的起始地址在src起始地址之后。
C语言——位运算
2201_75915488的博客
08-23 658
如果两个数据长度不同(例如long型和short型)，进行位运算时(如a & b,而a为long型,b为short型),系统会将二者按右端对齐。a<<n，可以看做:a * 2^n2. 如果移出的高位包含1，我们是不能使用以上计算方式的。对于左右操作数，只要相应二进制位数据相同，结果数据对应位数据为0，不同为1。对于左右操作数，只要相应二进制位数据有一个为1，结果数据对应为数据为1。对于左右操作数，只有相应二进制位数据都为1时，结果数据对应位数据为1。
R 语言学习教程，从入门到精通，R Excel 文件使用（18）
qq_45746668的博客
08-19 746
Excel 格式的文件主要是 xls 或 xlsx，这两种文件可以在 R 语言中导入 xlsx 库来实现直接的读取。 R 语言读写 Excel 文件需要安装扩展包，
基于R语言遥感随机森林建模与空间预测
weixin_48230888的博客
08-20 553
因此，遥感随机森林建模与空间预测的应用能够有效提升遥感数据分析的精度和可靠性，是许多研究者关注的热点。在R语言中，随机森林的实现与应用非常方便，R语言提供了多种包用于构建和优化随机森林模型。此外，R语言在数据可视化方面的优势使得用户能够直观地展示模型的结果和变量的重要性，进一步提高了分析的可解释性和应用价值。因此，R语言中的随机森林工具因其易用性、灵活性和强大的功能，成为遥感数据分析中不可或缺的工具。（2）R语言基础语法与数据结构，包括：程序包安装、加载、更新，数据读取与输出，ggplot2常规画图等。
pair 与 tie功能与用法-清晰教程
weixin_72391681的博客
08-21 865
对pair和tie做清晰 详细的教学分享
seq2seq编码器encoder和解码器decoder详解
Tunny_one
08-21 919
encoder和decoder详解
R 语言学习教程，从入门到精通，R XML 文件使用（19）
qq_45746668的博客
08-20 260
XML 指的是可扩展标记语言（eXtensible Markup Language），XML 被设计用来传输和存储数据。 R 语言读写 XML 文件需要安装扩展包，我们可以在 R 到控制台输入以下命令来安装
OpenAI API VBA function returns #Value! but MsgBox displays response
suiusoar
08-23 708
“OpenAI API VBA 函数返回 #Value!，但 MsgBox 显示响应”
我写的全部R包和函数，持续更新中
dege857的博客
08-19 487
最开始写了逻辑回归和线性回归的，后面又写了cox回归的。用于nhanes数据（复杂调查数据）的一键生存交互效应表（P for interaction）这个函数写了2套，相乘的模型。目前据我所知，目前尚未有专门的nhanes数据匹配的函数或者R包，应粉丝的要求，开发了svypm2函数，目前只能做2组分类的倾向评分匹配，3组分类的倾向评分匹配的还要等一等。应很多的粉丝的要求，编写了新版本的亚组交互函数（P for interaction），支持多个亚组参照比较，此函数还在进一步升级中。目前最新是2.0版本。
StarRocks 存算分离数据回收原理
kai_ding的专栏
08-21 856
StarRocks存算分离表中，垃圾回收是为了删除那些无用的历史版本数据，从而节约存储空间。考虑到对象存储按照存储容量收费，因此，节约存储空间对于降本增效尤为必要。用户手动执行了删除库、表、分区等命令，如执行了 drop table、drop database 以及 drop partition 等命令随着系统内 Compaction 任务不断进行，合并之前的数据文件可以被安全回收目前在 StarRocks 的存算分离表存储在对象存储上的文件类型包含如下几种：Segment 文件。
StarRocks 存算分离 Compaction 原理
kai_ding的专栏
08-21 946
StarRocks 中每次数据摄入都会生成一个新的数据版本，而查询时需要将所有版本数据进行合并才能获得一个正确的结果，如果历史数据版本太多，那么查询时需要读取的文件数也会很多，造成查询效率低下。因而 StarRocks 存在内部任务定期将历史数据版本进行整合，消除重复数据记录，我们称之为 Compaction。Compaction 是为了将不同版本的数据文件进行整合，合并成大文件的动作，减少系统中小文件数量，进而提升查询效率。Compaction 调度由 FE 发起，BE执行。
Spark MLlib 特征工程系列—特征转换MinMaxScaler
08-21 142
通过线性变换将特征值缩放到指定范围。它的主要目的是确保所有特征在相同的范围内，从而消除特征间因量级差异导致的影响。xscaledx−xminxmax−xmin×rmax−rminrminxscaled​xmax​−xmin​x−xmin​​×rmax​−rmin​rmin​xxx是原始特征值。xminxmin​和xmaxxmax​分别是特征在数据集中的最小值和最大值。rminrmin。
【0317】Postgres内核之VACUUM （FULL）通用 utility function invoker （12）
专注【PostgreSQL源码学习&研究】
08-23 272
1. 处理 utility functions
R 语言学习教程，从入门到精通，R 绘图饼图（23）
最新发布
qq_45746668的博客
08-24 393
条形图，也称为柱状图条形图，是一种以长方形的长度为变量的统计图表。 条形图可以是水平或垂直的，每个长方形可以有不同的颜色。
C语言经典教程：The C Programming Language (K&R) 中文版
"The C Programming Language (K&R) 中文版，高清 .pdf" 《The C Programming Language》（通常称为K&R）是由Brian W. Kernighan和Dennis M. Ritchie合著的经典C语言教程。这本书被誉为C语言学习者的必备参考，它...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qqssss121dfd

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

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

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

打赏作者

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

抵扣说明：

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

余额充值