关于C语言的一道习题!

Posted 2023-04-27

原题如下:
将"China"译成密码.加密规则:用原来的字母后面的第4个字母代替原来的字母.(提示:设5个字符型变量,存放5个字符,经运算使各ASCII码增4,再输出)

我连题意都没看明白~晕!
只能用基本语句编写
不可以用复合语句和控制语句!
"for"不行!!!!
另外能不能再说仔细点这题到底是什么意思,尤其是提示里面的!

就是说让你设五个个字符型变量,int a,b,c,d,e;存放5个字符,a='C';
b='h';
c='i';
d='n';
e='a';
经运算使各ASCII码增4，每个字符加四
a='C'+4;
b='h'+4;
c='i'+4;
d='n'+4;
e='a'+4;
你可以查ASCII码表，C语言书的最后一页一般都有吧
ASCII码表

Decimal Octal Hex Binary Value
------- ----- --- ------ -----
000 000 000 00000000 NUL (Null char.)
001 001 001 00000001 SOH (Start of Header)
002 002 002 00000010 STX (Start of Text)
003 003 003 00000011 ETX (End of Text)
004 004 004 00000100 EOT (End of Transmission)
005 005 005 00000101 ENQ (Enquiry)
006 006 006 00000110 ACK (Acknowledgment)
007 007 007 00000111 BEL (Bell)
008 010 008 00001000 BS (Backspace)
009 011 009 00001001 HT (Horizontal Tab)
010 012 00A 00001010 LF (Line Feed)
011 013 00B 00001011 VT (Vertical Tab)
012 014 00C 00001100 FF (Form Feed)
013 015 00D 00001101 CR (Carriage Return)
014 016 00E 00001110 SO (Shift Out)
015 017 00F 00001111 SI (Shift In)
016 020 010 00010000 DLE (Data Link Escape)
017 021 011 00010001 DC1 (XON) (Device Control 1)
018 022 012 00010010 DC2 (Device Control 2)
019 023 013 00010011 DC3 (XOFF)(Device Control 3)
020 024 014 00010100 DC4 (Device Control 4)
021 025 015 00010101 NAK (Negative Acknowledgement)
022 026 016 00010110 SYN (Synchronous Idle)
023 027 017 00010111 ETB (End of Trans. Block)
024 030 018 00011000 CAN (Cancel)
025 031 019 00011001 EM (End of Medium)
026 032 01A 00011010 SUB (Substitute)
027 033 01B 00011011 ESC (Escape)
028 034 01C 00011100 FS (File Separator)
029 035 01D 00011101 GS (Group Separator)
030 036 01E 00011110 RS (Request to Send)(Record Separator)
031 037 01F 00011111 US (Unit Separator)
032 040 020 00100000 SP (Space)
033 041 021 00100001 ! (exclamation mark)
034 042 022 00100010 " (double quote)
035 043 023 00100011 # (number sign)
036 044 024 00100100 $ (dollar sign)
037 045 025 00100101 % (percent)
038 046 026 00100110 & (ampersand)
039 047 027 00100111 ' (single quote)
040 050 028 00101000 ( (left/opening parenthesis)
041 051 029 00101001 ) (right/closing parenthesis)
042 052 02A 00101010 * (asterisk)
043 053 02B 00101011 + (plus)
044 054 02C 00101100 , (comma)
045 055 02D 00101101 - (minus or dash)
046 056 02E 00101110 . (dot)
047 057 02F 00101111 / (forward slash)
048 060 030 00110000 0
049 061 031 00110001 1
050 062 032 00110010 2
051 063 033 00110011 3
052 064 034 00110100 4
053 065 035 00110101 5
054 066 036 00110110 6
055 067 037 00110111 7
056 070 038 00111000 8
057 071 039 00111001 9
058 072 03A 00111010 : (colon)
059 073 03B 00111011 ; (semi-colon)
060 074 03C 00111100 < (less than)
061 075 03D 00111101 = (equal sign)
062 076 03E 00111110 > (greater than)
063 077 03F 00111111 ? (question mark)
064 100 040 01000000 @ (AT symbol)
065 101 041 01000001 A
066 102 042 01000010 B
067 103 043 01000011 C
068 104 044 01000100 D
069 105 045 01000101 E
070 106 046 01000110 F
071 107 047 01000111 G
072 110 048 01001000 H
073 111 049 01001001 I
074 112 04A 01001010 J
075 113 04B 01001011 K
076 114 04C 01001100 L
077 115 04D 01001101 M
078 116 04E 01001110 N
079 117 04F 01001111 O
080 120 050 01010000 P
081 121 051 01010001 Q
082 122 052 01010010 R
083 123 053 01010011 S
084 124 054 01010100 T
085 125 055 01010101 U
086 126 056 01010110 V
087 127 057 01010111 W
088 130 058 01011000 X
089 131 059 01011001 Y
090 132 05A 01011010 Z
091 133 05B 01011011 [ (left/opening bracket)
092 134 05C 01011100 \ (back slash)
093 135 05D 01011101 ] (right/closing bracket)
094 136 05E 01011110 ^ (caret/cirumflex)
095 137 05F 01011111 _ (underscore)
096 140 060 01100000 `
097 141 061 01100001 a
098 142 062 01100010 b
099 143 063 01100011 c
100 144 064 01100100 d
101 145 065 01100101 e
102 146 066 01100110 f
103 147 067 01100111 g
104 150 068 01101000 h
105 151 069 01101001 i
106 152 06A 01101010 j
107 153 06B 01101011 k
108 154 06C 01101100 l
109 155 06D 01101101 m
110 156 06E 01101110 n
111 157 06F 01101111 o
112 160 070 01110000 p
113 161 071 01110001 q
114 162 072 01110010 r
115 163 073 01110011 s
116 164 074 01110100 t
117 165 075 01110101 u
118 166 076 01110110 v
119 167 077 01110111 w
120 170 078 01111000 x
121 171 079 01111001 y
122 172 07A 01111010 z
123 173 07B 01111011 (left/opening brace)
124 174 07C 01111100 | (vertical bar)
125 175 07D 01111101 (right/closing brace)
126 176 07E 01111110 ~ (tilde)
127 177 07F 01111111 DEL (delete)

前32个控制字符的详细解释:

NUL (null)
SOH (start of heading)
STX (start of text)
ETX (end of text)
EOT (end of transmission) - Not the same as ETB
ENQ (enquiry)
ACK (acknowledge)
BEL (bell) - Caused teletype machines to ring a bell. Causes a beep
in many common terminals and terminal emulation programs.
BS (backspace) - Moves the cursor (or print head) move backwards (left)
one space.
TAB (horizontal tab) - Moves the cursor (or print head) right to the next
tab stop. The spacing of tab stops is dependent
on the output device, but is often either 8 or 10.
LF (NL line feed, new line) - Moves the cursor (or print head) to a new
line. On Unix systems, moves to a new line
AND all the way to the left.
VT (vertical tab)
FF (form feed) - Advances paper to the top of the next page (if the
output device is a printer).
CR (carriage return) - Moves the cursor all the way to the left, but does
not advance to the next line.
SO (shift out) - Switches output device to alternate character set.
SI (shift in) - Switches output device back to default character set.
DLE (data link escape)
DC1 (device control 1)
DC2 (device control 2)
DC3 (device control 3)
DC4 (device control 4)
NAK (negative acknowledge)
SYN (synchronous idle)
ETB (end of transmission block) - Not the same as EOT
CAN (cancel)
EM (end of medium)
SUB (substitute)
ESC (escape)
FS (file separator)
GS (group separator)
RS (record separator)
US (unit separator)

参考资料：feiyingrsm

参考技术A 提示已经说得很明显了

提示:设5个字符型变量,存放5个字符,经运算使各ASCII码增4,再输出本回答被提问者采纳 参考技术B // C板
#include <stdio.h>
int main( )
char ch1 = 'C';
char ch2 = 'h';
char ch3 = 'i';
char ch4 = 'n';
char ch5 = 'a';
ch1 = int(ch1) + 4;
ch2 = int(ch2) + 4;
ch3 = int(ch3) + 4;
ch4 = int(ch4) + 4;
ch5 = int(ch5) + 4;
printf("%c%c%c%c%c",ch1,ch2,ch3,ch4,ch5);


// C++板
#include <iostream>
using std::cout;
int main( )
char ch1 = 'C';
char ch2 = 'h';
char ch3 = 'i';
char ch4 = 'n';
char ch5 = 'a';
ch1 = static_cast<int>(ch1) + 4;
ch2 = static_cast<int>(ch2) + 4;
ch3 = static_cast<int>(ch3) + 4;
ch4 = static_cast<int>(ch4) + 4;
ch5 = static_cast<int>(ch5) + 4;
cout << ch1 << ch2 << ch3 << ch4 << ch5;


PS：按“题意”所作，不能使用for我郁闷。 参考技术C char str[5] = "China";

for ( i = 0 ; i < 5 ; i ++ )
str[ i ] += 4;
printf( "%c",str[i] );


没编译过，随便写的。 参考技术D char a[5]='c','h','i','n','a';
for (int i=0;i<5;i++)
a[i]+=4;
for(int i=0;i<5;i++)
printf("%c",a[i]);

计算机操作系统关于PV操作的一道题

有三个并发进程A,B和C，共享一个缓冲器F，F中每次只能存放一个数。进程A每次产生一个随机数R，将其存入F中，若存放到F中的数是5的倍数，则由进程B将其取出并打印，否则由进程C将被5除后的余数打印出来，为防止数的丢失和重复取同一个数，现用PV操作进行管理，请写出利用记录型信号量描述此问题的算法。

//算法描述语言使用基于C语言的伪代码
//算法思想：根据楼主的要求“为防止数的丢失和重复取同一个数”可以看出，进程A、进程B、进程C三者之间应该是互斥的关系。那么问题所限定的使用信号量的方式来管理的潜藏意思，就是要利用PV

原语实现并发进程在资源争夺中有效互斥。
//而具体实现的目标是“防止数的丢失”和“重复取同一个数”。由于本人不才，只讨论单任务系统下的状况。
//“数的丢失”的情况主要是进程A产生了随即变量给F后，但在进程B或者进程C处理之前又获得处理机的使用权而覆盖了之前那个未被处理过的F中的数——进程A连续获得处理机的使用权，而进程B、进

程C无法获得处理机使用权；
//“重复取同一个数”的情况则与“数的丢失”刚好相反：进程B或者进程C处理已经处理过F中的数了，但由于进程B或者进程C又再获得了处理机使用权因而F中的同一个数又被处理了一次——处理机的

使用权一直在进程B或者进程C两者手上，而进程A无法获得处理机使用权。
//因此，只要让进程A、进程B、进程C都懂得“适时弃权”的话，那么上述的要求就自然达到。
//不才本人的想法是这样的：进程A、进程B、进程C可以视为两类进程：负责生成随机数的生成进程（进程A属此类），负责处理F的处理进程（进程B、进程C属此类）。在要求下的工作流程则应该是：生

成进程→处理进程→生成进程→处理进程→……因此，我的做法便是在在进程外另外开辟一个标志位来表示上一个处理过F的进程类型——如果下一个进入临界区的进程检查标志位后，发现上次处理F的

是同类型进程，那么它就自动放弃这次处理机使用权，进入就绪队列。

//缓冲器F由于每次只能接受一段代码的使用，各进程在使用F时互斥。因此F是临界区。
//设F的信号量名为resource，初始值为0。
//再设一用于标志上一次操作F的是否为A的标示位（也是临界区）wasA：当wasA为1时，表示上次操作F的是A；当wasA为0时，表示上次操作F的不是A，而是B或者C。其信号量名为lastOper，初始值为0。

//……其他与本算法无重要关系的代码……

//进程A的算法描述
void processA(usrStruct &F)
//尝试进入临界区F
P(resource);
//尝试进入临界区wasA
P(lastOper);
//上次F的处理不是由进程A操作的吧？
if( wasA == 0 )
//上次F的处理不是由进程A操作的
//那么，生成随机数并赋值给F
//然后，修改wasA，提示下个获得临界区F的进程，它所读到的F是由进程A处理的
wasA = ~wasA;
//上次F的处理是由进程A操作的话，为了防止F中变量的丢失（没有经由进程B或进程C的操作就被新的值覆盖了），放弃处理。
//离开临界区wasA
V(lastOper);
//离开临界区wasA
V(resource);


//进程B的算法描述
void processB(usrStruct &F)
//尝试进入临界区F
P(resource);
//尝试进入临界区wasA
P(lastOper);
//上次F的处理是由进程A操作的吧？
if( wasA == 1 )
//上次F的处理是进程A操作的
//那么，F是5的倍数吧？
if( F%5 == 0 )
//打印F值
//然后，修改wasA，提醒下个获得临界区F的进程，它所读到的F不是由进程A处理的
wasA = ~wasA;
//F不是5的倍数的话，那么这个F不应该由本进程B处理，放弃处理
//上次F的处理不是由进程A操作的话，那么该值已经被别的进程处理过，为了防止重复取同一个数（进程B和进程C没有等进程A生成新的随机数给F就一再地处理同一个F），放弃处理。
//离开临界区wasA
V(lastOper);
//离开临界区wasA
V(resource);


//进程C的算法描述
void processC(usrStruct &F)
//尝试进入临界区F
P(resource);
//尝试进入临界区wasA
P(lastOper);
//上次F的处理是由进程A操作的吧？
if( wasA == 1 )
//上次F的处理是进程A操作的
//那么，F不是5的倍数吧？
if( F%5 != 0 )
//打印F%5的值
//然后，修改wasA，提醒下个获得临界区F的进程，它所读到的F不是由进程A处理的
wasA = ~wasA;
//F不是5的倍数的话，那么这个F不应该由本进程B处理，放弃处理
//上次F的处理不是由进程A操作的话，那么该值已经被别的进程处理过，为了防止重复取同一个数（进程B和进程C没有等进程A生成新的随机数给F就一再地处理同一个F），放弃处理。
//离开临界区wasA
V(lastOper);
//离开临界区wasA
V(resource);


////////////////////////////////////////////////////////////
//希望能够帮到你。 参考技术A Idn`y