1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/*
* 编译环境：vs2022
* 题目简介：输出字符串大写形式
* 时间：2022/3/22
* 分析：有两种方案：
*		1.将标准输入复制到标准输出中，然后在转换大写，
*			但是，它只能在使用ASCII码的机器上运行
*		2.使用tolower函数
* 总结：
* 改进：
* 作者：人工智障plus
*/

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<ctype.h>
/*
* 将标准输入复制到标准输出中，将所有大写字母转换为小写字母。
* 如果参数并非大写字母，tolower 函数将不修改，直接返回它的值
*/

/*
* 方法2：
int main(int argc, char *argv[])
{
	int ch;

	while( (ch = getchar()) != EOF )
	{
		putchar( tolower( ch ) );
	}
	
	return 0;
}
*
*/

// 方法1：
int main(int argc, char *argv[])
{
	int ch;
	while( (ch = getchar() ) != EOF)
	{
		if( ch >= 'A' && ch <= 'Z' )
			ch += 'a' - 'A';
		putchar( ch );
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/*
* 编译环境：vs2022
* 题目简介：加密字母
* 时间：2022/3/22
* 分析：字符实际上是较小的整形值，
*		加密实际上是改变这个整型值
* 总结：
* 改进：
* 作者：人工智障plus
*/

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<ctype.h>

int main(int argc, char *argv[])
{
	int ch;
	
	while( (ch = getchar()) != EOF )
	{
		//加密
		if( ('a'<=ch)&&(ch<='m') )
		{
			putchar(ch+13);
		}
		if( ('m'<ch)&&(ch<='z') )
		{
			putchar(ch-'m'+'a');
		}

		if( ('A'<=ch)&&(ch<='M') )
		{
			putchar(ch+13);
		}
		
		if( ('M'<ch)&&(ch<='Z') )
		{
			putchar(ch-'M'+'A');
		}
	}
	
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

/*
* 编译环境：vs2022
* 题目简介：变换二进制
* 时间：2022/3/22
* 分析：可以设立一个临时值，保存左移位的值
*		然后将右移位的值放在原变量中，然后把它们相加
* 总结：通过移位和+，来变换它的前后值
* 改进：打印二进制
* 作者：人工智障plus
*/

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>

unsigned int reverse_bits( unsigned int value );
void print_bits(unsigned int value);

int main(int argc, char *argv[])
{
	unsigned int value = 25;
	value=reverse_bits(value);
	printf("%u\n",value);
	print_bits(value);
	return 0;
}

unsigned int reverse_bits( unsigned int value )
{
	unsigned int answer;
	unsigned int i;

	answer = 0;
	/*
	* 只要i不是0就继续进行。这就使得循环与机器的字长无关，
	* 从而避免了可移植性问题
	*/
	for( i = 1; i != 0; i <<= 1)
	{
		/*
		* 把旧的answer左移1位，位下一个位留下空间
		* 如果value的最后一位是1，answer就与1进行OR操作
		* 然后将value右移至下一位
		*/
		answer = answer << 1;
		if( value & 1 )
			answer = answer | 1;
		value = value >> 1;
	}
	return answer;
}

//将value二进制形式打印出来
void print_bits(unsigned int value)
{
	int len = sizeof(unsigned int) * 8;
	int idx;
	int bit;
 
	for(idx = 1; idx <= len; idx++){
		//从左往右，通过位偏移后，和1取与运算，打印bit位的值
		bit = 1 & (value >> (len - idx));
 
		printf("%d", bit);
		//四位一空，方便阅读
		if(idx % 4 == 0){
			printf(" ");
		}
	}
	printf("\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

/*
* 编译环境：vs2022
* 题目简介：位数组
* 时间：2022/3/23
* 分析：
* 总结：字符'1','0'无法打印，所以是方框
* 改进：
* 作者：人工智障plus
*/

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>

void set_bit( char bit_array[], unsigned bit_number );
void clear_bit( char bit_array[], unsigned bit_number );
void assign_bit( char bit_array[], unsigned bit_number, int value );
int test_bit( char bit_array[], unsigned bit_number );

int main(int argc, char *argv[])
{
	char array[10]={"000000000"};
	set_bit(array,0);
	set_bit(array,1);
	printf("%s\n",array);
	clear_bit(array,0);
	printf("%s\n",array);
	assign_bit(array,2,1);
	printf("%s\n",array);



	return 0;
}


void set_bit( char bit_array[], unsigned bit_number )
{
	bit_array[bit_number] = 1;
}

void clear_bit( char bit_array[], unsigned bit_number )
{
	bit_array[bit_number] = 0;
}

void assign_bit( char bit_array[], unsigned bit_number, int value )
{
	if(value == 0) 
		bit_array[bit_number] = 0;
	else
		bit_array[bit_number] = 1;
}

int test_bit( char bit_array[], unsigned bit_number )
{
	if(bit_array[bit_number] != 0)
		return 1;
	else
		return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

/*
* 编译环境：vs2022
* 题目简介：指定位储存
* 时间：2022/3/23
* 分析：见提示
* 总结：用或运算来置一创建掩码。
* 改进：
* 作者：人工智障plus
*/

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>

int store_bit_field(int original_value, int value_to_store, unsigned starting_bit, unsigned ending_bit);

int main(int argc, char *argv[])
{
	int result;
	result = store_bit_field(0xffff, 0x123, 13, 9);
	printf("0x%0x\n", result);

	return 0;
}

int store_bit_field(int original_value, int value_to_store, unsigned starting_bit, unsigned ending_bit)
{
	int mask = 0;
	int tmp = 0;
	//制作对应的起始位置掩码
	for(int idx = starting_bit; idx >= ending_bit; idx--)
	{
		tmp = 1<< idx;
		mask |= tmp;
	}

	//通过掩码将original_value 对应的范围内置0
	original_value &= ~mask;
	//将value_to_store对齐起始和结束位置
	value_to_store  <<= ending_bit;
	//value_to_store中将超出范围的部分置0
	value_to_store &= mask;
	//将值和original_value取或保存值
	original_value |= value_to_store;

	return original_value;
}