Unit 1 - Practice Quiz

C identifiers must start with a letter (a-z, A-Z) or an underscore (_), followed by letters, digits, or underscores. They cannot be a keyword like int. 2nd_place is invalid because it starts with a digit. my-variable is invalid because it contains a hyphen.

The int data type is used to store integer values (whole numbers) without any decimal points. float and double are for decimal numbers, and char is for single characters.

The modulus operator (%) calculates the remainder of a division. When 9 is divided by 4, the remainder is 1.

The const keyword is used to declare a constant, which is a variable whose value cannot be modified after it is initialized.

The double equals sign (==) is the equality operator, used to compare two values. The single equals sign (=) is the assignment operator.

for is a keyword used for looping. While main is a standard function name, it is not a keyword. integer and array are not keywords in C.

The basic C character set includes letters (a-z, A-Z), digits (0-9), and several special characters like !, #, $, %, &, *, etc. Characters like € or ¥ are not part of the basic set.

The ++ operator is the increment operator. It increases the value of its operand by one. For example, x++ is equivalent to x = x + 1.

The char data type is specifically designed to store a single character. Note that C does not have a built-in string or bool data type.

A variable is an identifier for a memory location that holds data. The data stored in that location can be modified during the program's execution.

An expression is a combination of variables, constants, and operators that evaluates to a single value. x + 5 evaluates to 15. int y = 5 is a declaration statement, not just an expression.

The forward slash (/) is the division operator in C. For example, 10 / 2 results in 5.

The || operator is the logical OR operator. It returns true if at least one of its operands is true. && is logical AND, and ! is logical NOT.

The single ampersand (&) is the bitwise AND operator. It performs an AND operation on each pair of corresponding bits. && is the logical AND operator.

The single equals sign (=) is the assignment operator. It is used to assign the value on its right to the variable on its left.

Due to operator precedence, division (/) is performed before addition (+). So, 10 / 5 is calculated first (which is 2), and then 2 + 2 is calculated, resulting in 4.

The bitwise OR (|) compares each bit. 011 | 101 results in 111. The binary value 111 is equal to 7 in decimal.

while is a reserved keyword in C and cannot be used as an identifier (like a variable name). The other options are valid because they are not keywords and follow identifier naming rules.

The conditional operator (?:) is called the ternary operator because it is the only operator in C that takes three operands: a condition, a value for true, and a value for false.

The sizeof operator is a unary operator that returns the size, in bytes, of its operand. The operand can be a variable, a constant, or a data type.

Identifiers starting with an underscore are permitted in C. However, they are often used by compiler implementers and for standard library internals. To avoid potential name clashes, it's a common convention for application programmers to avoid starting their own identifiers with an underscore. 2_variables is invalid as it starts with a digit. my-variable is invalid due to the hyphen. auto is a keyword.

In C, floating-point literals without a suffix (like 3.14) are treated as type double by default. The sizeof operator returns the size of the data type in bytes. On most modern 64-bit systems, a double occupies 8 bytes. The format specifier %zu is the correct specifier for size_t, the type returned by sizeof.

According to the C99 standard and later, the result of the modulo operator (%) takes the sign of the dividend (the first operand). Here, the dividend is a which is -13. The calculation is -13 = 4 * (-3) - 1. Therefore, the remainder is -1.

The expression is evaluated left-to-right.

1. (a++ > 5): a (which is 5) is compared to 5. 5 > 5 is false. After the comparison, a is post-incremented to 6.
2. Since the left side of && is false, the right side (++b < 10) is not evaluated due to short-circuiting. So, b remains 0.
3. The result of the && expression is false. The expression becomes false || (c-- > 0).
4. Since the left side of || is false, the right side (c-- > 0) is evaluated. c (which is 10) is compared to 0. 10 > 0 is true. After the comparison, c is post-decremented to 9.
5. The overall result is true. The final values are a=6, b=0, and c=9.

x is 92 (01011100). x - 1 is 91 (01011011). The bitwise AND operation x & (x - 1) performs 01011100 & 01011011, which results in 01011000. This binary value is 88 in decimal. This specific operation is a well-known trick to clear (turn off) the least significant (rightmost) '1' bit in a number.

The conditional (ternary) operator has right-to-left associativity. The expression is evaluated as follows:

1. a > b (i.e., 10 > 20) is false.
2. The expression after the first colon : is evaluated: (b > c ? b : c).
3. b > c (i.e., 20 > 15) is true.
4. The result of this inner ternary expression is b, which is 20.
5. The value 20 is assigned to max.

Operator precedence dictates the order of operations. *, /, and % have higher precedence than + and -. They are evaluated from left to right.

1. 5 * 2 is 10.
2. 10 / 2 is 5.
3. 3 % 2 is 1.
4. The expression becomes 10 + 5 - 1.
5. 10 + 5 is 15.
6. 15 - 1 is 14.

This code attempts to modify a const-qualified variable. By casting away the const-ness of &value from const int* to int*, you bypass a compile-time check. However, the C standard states that attempting to modify an object defined with const through a non-const pointer results in undefined behavior. The compiler might place value in read-only memory, which could cause a crash, or the modification might appear to work, or it might be ignored entirely.

The binary representation of any even number always has its least significant bit (LSB) as 0. The binary representation of 1 is ...0001. Performing a bitwise AND (&) with 1 effectively isolates the LSB of n. If the result is 0, the LSB was 0, and the number is even. If the result is 1, the LSB was 1, and the number is odd.

The expression 5 / 2 involves two integers. Therefore, the compiler performs integer division, which truncates any fractional part. The result of 5 / 2 is 2. This integer result is then implicitly converted to a float (2.0) before being assigned to the result variable. To get 2.5, at least one of the operands would need to be a floating-point type, e.g., 5.0 / 2.

The C standard states that modifying a variable more than once between two sequence points results in undefined behavior. In the expression i++ == ++i, the variable i is modified twice (once by post-increment, once by pre-increment) without a sequence point in between. The compiler is free to evaluate the sides of == in any order, leading to unpredictable results. This code should be avoided.

This is another example of undefined behavior. The order of evaluation of the operands for the subtraction operator (-) is not specified. The compiler could evaluate (b = a + b) first, or (a = b) first. Furthermore, a is modified twice and b is modified and read multiple times without an intervening sequence point. This makes the final result unpredictable across different compilers and optimization levels.

The expression is evaluated from left to right. Because of 3.0, a floating-point promotion occurs.

1. 5 * 2 results in 10 (int).
2. 10 / 3.0: The integer 10 is promoted to a double 10.0. The result is 3.333... (double).
3. 3.333... * 6: The integer 6 is promoted to a double 6.0. The result is 20.0 (double).
4. Finally, double 20.0 is assigned to the int variable result. The fractional part is truncated, so 20 is stored and printed.

~0 creates an integer where all bits are set to 1. When cast to unsigned char, this becomes 11111111 in binary, which is 255. The expression is then 255 >> 4. Right shifting an unsigned number by 4 positions fills the vacated bits with 0s.
11111111 >> 4 results in 00001111.
In decimal, 00001111 is .

The C standard specifies a basic source character set which includes the 26 uppercase and 26 lowercase Latin letters, the 10 digits, the underscore, and various punctuation characters. The Euro symbol € is not in this set. While many modern compilers support extended character sets like UTF-8 in identifiers, relying on this feature makes the code non-portable and may fail on compilers that strictly adhere to the standard's basic character set.

This question tests understanding of the comma operator and operator precedence. The assignment operator (=) has higher precedence than the comma operator (,). Therefore, the statement is parsed as (k = i), j;. First, k = i is executed, assigning the value of i (which is 5) to k. The result of this assignment expression (5) is then discarded. After that, the expression j is evaluated and its result is also discarded. The final value of k is 5.

Unsigned integers in C follow the rules of modular arithmetic. When an unsigned integer is decremented from 0, it "wraps around" to the maximum possible value for that type. This maximum value is defined in the <limits.h> header as UINT_MAX. For a 32-bit unsigned int, this value would be .

You can read C declarations from right to left.

• int * const ptr;: ptr is a const pointer (*) to an int. This means the pointer ptr itself cannot be changed to point to another address, but the integer value it points to can be modified (e.g., *ptr = 10; is valid).
• const int * ptr;: ptr is a pointer (*) to an int that is const. This means the pointer ptr can be changed to point to another address, but the integer value it points to cannot be modified via this pointer (e.g., *ptr = 10; is invalid).

1. The if condition is a-- && --b.
2. a--: The current value of a (1) is used in the expression, which is considered true. After its use, a is decremented to 0.
3. Since the left side of && is true, the right side is evaluated.
4. --b: b is first decremented to 0. This new value (0) is used in the expression, which is considered false.
5. The overall condition true && false is false.
6. The else block is executed, printing "B".
7. The final printf prints the current values of a and b, which are 0 and 0 respectively. The final output is "B00".

In C, the result of a relational or logical operation is an integer: 1 for true and 0 for false.

1. (x < y): 5 < 10 is true, so this expression evaluates to 1.
2. (y > z): 10 > 5 is also true, so this expression evaluates to 1.
3. The statement becomes result = 1 != 1;.
4. 1 != 1 is false, which evaluates to 0.
5. Therefore, result is assigned the value 0.

The expression i++ * ++i modifies the variable i twice between two sequence points. The C standard does not define the order in which the operands of the * operator are evaluated, nor does it define when the side effects (the increments) take place relative to each other. Because a single object (i) is modified more than once without an intervening sequence point, the behavior is explicitly undefined.

This question tests the understanding of 'usual arithmetic conversions'. When an operation involves a signed and an unsigned integer, the signed integer is promoted to an unsigned integer. Here, b (-20) is converted to unsigned int. The two's complement representation of -20 (assuming 32-bit integers) is a very large positive number (e.g., 4294967276). When this large number is added to a (6), the result is an even larger number which is definitely greater than 5. Therefore, the condition a + b > 5 evaluates to true.

This question highlights the difference between right-shifting a signed and an unsigned integer.

1. x is -1. In 32-bit two's complement, this is represented as all 1s (0xFFFFFFFF). When a signed negative value is right-shifted, the result is implementation-defined, but on most modern systems, it performs an arithmetic shift, meaning the sign bit (the MSB, which is 1) is copied into the vacant bit positions. So, x >> 1 results in -1 again.
2. y is (unsigned int)x, which is 0xFFFFFFFF interpreted as an unsigned integer (4294967295). When an unsigned value is right-shifted, it's always a logical shift. A 0 is shifted into the most significant bit. 0xFFFFFFFF >> 1 becomes 0x7FFFFFFF, which is 2147483647 in decimal.

Let's retrace step 2:
y = z || (++x && --y);

• z is 0 (false).
• ++x runs. x becomes 1. This expression is true.
• The && must evaluate its right side. --y runs. y was 0, so it becomes -1. This expression is true.
• (true && true) is true (1).
• y = 0 || 1 results in y becoming 1.
• Final values: x is 1, y is 1.

Let's check the options.

The declaration const int * const ptr should be read from right to left:

• ptr: ptr is a...
• const ptr: constant pointer...
• * const ptr: to a...
• int * const ptr: integer...
• const int * const ptr: which is constant.

This means it's a constant pointer to a constant integer.

• Constant Pointer: The address stored in ptr cannot be changed. Therefore, ptr = &y; is illegal.
• Pointer to Constant Integer: The value at the address ptr points to cannot be changed through this pointer. Therefore, *ptr = 30; is illegal.
• The variable x itself is not constant, so modifying it directly via x = 30; is perfectly legal.

Prior to the C99 standard, the result of division and modulo with negative operands was implementation-defined. However, C99 and later standards specify the behavior:

1. Integer Division (/): The result truncates towards zero. -13 / 4 is -3.25, which truncates to -3.
2. Modulo Operator (%): The result is defined by the identity (a/b)*b + a%b == a. Using the division result from above: (-3) * 4 + res2 == -13. This simplifies to -12 + res2 == -13, which means res2 must be -1. An easier rule to remember for C99+ is that the sign of a % b is the same as the sign of a.

A positive power of two in binary representation has exactly one bit set to 1 (e.g., 8 is 1000). If you subtract 1 from such a number, you get a number where that bit becomes 0 and all lower bits become 1 (e.g., 7 is 0111).
When you perform a bitwise AND (&) between a power of two (x) and (x-1), the result is always zero, because there are no common set bits.

• Let's analyze the options:
  • A: Incorrect logic. For x=8, x+1=9. 1000 & 1001 is 1000 (8), not 0.
  • B: Incorrect logic. For x=8, x-1=7. 1000 | 0111 is 1111 (15), not -1.
  • C: x && !(x & (x - 1)). This is the correct logic. The x part handles the edge case where x is 0 (since 0 is not a positive power of two). The !(x & (x-1)) part checks the power-of-two property.

This question tests the parsing of nested conditional (ternary) operators. The conditional operator is right-associative. The expression is parsed as a ? b : (c ? b : a).

1. The condition a is evaluated. a is 0, which is false.
2. Therefore, the third part of the outer conditional operator is evaluated: (c ? b : a).
3. Inside this inner conditional, the condition c is evaluated. c is -1, which is non-zero and therefore true.
4. Therefore, the second part of the inner conditional, b, is the result of this sub-expression. The value of b is 1.
5. This result (1) is then assigned to the float variable result. The integer 1 is promoted to 1.0f.

A key feature of the sizeof operator is that its operand is not evaluated at runtime (except for Variable Length Arrays, which are not used here). The compiler determines the size of the type of the expression at compile time. The expression is x++. The type of this expression is int. Therefore, sizeof(x++) is equivalent to sizeof(int), which is 4 on the target system. Since the expression x++ is not evaluated, the value of x remains unchanged at 10.

The type of the result of the conditional operator (condition ? expr1 : expr2) is determined at compile time. It is the 'common type' to which both expr1 and expr2 can be converted. In this case, the types are double (d) and int (i). According to the usual arithmetic conversion rules, the common type is double. Therefore, the type of the entire expression (i ? d : i) is double, regardless of whether the condition i is true or false. The sizeof operator then returns the size of this resulting type, which is sizeof(double), or 8.

Keywords in C are reserved words that have special meaning to the compiler and cannot be used as identifiers (e.g., variable names, function names).

• Option A: goto is a keyword. It cannot be used as a variable name. This will cause a compilation error.
• Option B: while is a keyword, but it is being used as a member name within a struct. This is perfectly legal in C. The namespace for struct/union members is separate from the ordinary identifier namespace.
• Option C: case is a keyword, but here it is used as a label for a goto statement. This is also legal in C.
• Option D: auto is a keyword, but since C11, it is used for type inference. auto new_type var would be a syntax error, but the question is about using keywords as identifiers. A snippet like typedef int auto; would be an error. The given snippet D is tricky because auto's meaning changed. A simple int auto = 5; would fail. Option A is the most clear-cut and universally illegal example of using a keyword as an identifier.

The expression i + j attempts to add 2147483647 and 5. The result of this addition exceeds the maximum value that can be stored in a signed int. In C, signed integer overflow results in undefined behavior. This means the compiler is not required to produce any specific result. The program could crash, produce a seemingly random number (due to two's complement wraparound, which is common but not guaranteed), or behave in any other way. Therefore, the only correct answer according to the C standard is that the behavior is undefined.

This question tests knowledge of octal and hexadecimal escape sequences within character literals.

• \101: This is an octal escape sequence. The value is . In ASCII, 65 is the character 'A'.
• \x41: This is a hexadecimal escape sequence. The value is . In ASCII, this is also the character 'A'.
• The expression becomes 65 - 65, which evaluates to 0.

The expression a += a -= a *= a is parsed as a += (a -= (a *= a)). This single expression reads and modifies the variable a multiple times without an intervening sequence point. Specifically, the value of a is required for the additions/subtractions, but it is also modified by the assignments. This violates the rules of the C standard, leading to undefined behavior. While a specific compiler might produce a consistent result (e.g., by evaluating from right to left: a = 3*3=9; a = 9-9=0; a = 0+0=0), this behavior is not guaranteed by the language standard.

This question tests the left-to-right associativity of the less-than operator (<) and how boolean results are represented as integers.

1. The expression x < y < z is evaluated from left to right, so it is parsed as (x < y) < z.
2. The inner expression (x < y) is evaluated first. -1 < 2 is true.
3. In C, the result of a relational operator is an int with a value of 1 for true and 0 for false.
4. So, the expression becomes 1 < z.
5. The value of z is 0. The comparison is now 1 < 0, which is false.
6. The result of this final comparison is 0 (for false), which is assigned to result.

The expression ~n + 1 is the standard algorithm for finding the two's complement negation of a number n.

1. For result1 (unsigned):
   • x is 00000101 (5).
   • ~x is 11111010 (250).
   • ~x + 1 is 11111010 + 1 = 11111011.
   • As an unsigned char, 11111011 is . So result1 is 251.
2. For result2 (signed):
   • y is -5, which is 11111011.
   • ~y is 00000100 (4).
   • ~y + 1 is 00000100 + 1 = 00000101.
   • As a signed char, 00000101 is interpreted as 5. So result2 is 5.
     This shows that applying the negation algorithm to a negative number (y) yields its positive counterpart.

Revised Question:
c
unsigned char c = 1;
c = c << 7;
c = c + 1;
c = ~c;

Trace:

1. c is 1 (00000001).
2. c = c << 7;: 00000001 << 7 becomes 10000000. c is now 128.
3. c = c + 1;: 128 + 1 is 129. c is now 10000001.
4. c = ~c;: c is promoted to int. ~129 is calculated. Then truncated back to unsigned char. ~10000001 is 01111110. The value is .

Re-trace of unsigned char c = -1; c >>= 2; c = ~c;

1. c = (unsigned char)-1; -> c = 255 (11111111)
2. c >>= 2; -> c becomes 255 / 4 = 63 (00111111)
3. c = ~c; -> ~ operates on the promoted int value of 63. Let's assume 32-bit int.
   00000000 00000000 00000000 00111111 (63)
   11111111 11111111 11111111 11000000 (~63)
   When this is assigned back to unsigned char c, it is truncated to the lower 8 bits: 11000000.
   The value is .
   OK, the correct answer should be 192. My previous options were wrong. Let's fix that.
   New Options: A. 63, B. 192, C. -64, D. 191
   Correct: B. 192. Yes, this is correct now.

This question involves multiple data types and requires understanding both operator precedence/associativity and implicit type promotion (usual arithmetic conversions).

1. The expression is i * f / d. The * and / operators have the same precedence and are left-to-right associative. So, (i * f) is evaluated first.
2. *`(i f)**: Anintis multiplied by afloat. Theint`i (value 7) is promoted to float (7.0f). The result is 7.0f * 5.5f = 38.5f. The type of this result is float.
3. (result of step 2) / d: A float (38.5f) is divided by a double (d, value 2.0). The float is promoted to double. The result is 38.5 / 2.0 = 19.25. The type of this result is double.
4. int result = ...: The double value 19.25 is assigned to an int variable. This involves a conversion that truncates the fractional part. 19.25 becomes 19.
   Therefore, the final value of result is 19.

The C standard reserves certain categories of identifiers for use by the implementation (the compiler and standard library).

• Identifiers beginning with an underscore followed by an uppercase letter or another underscore (e.g., __FOO, _FOO) are reserved in all scopes.
• Identifiers beginning with a single underscore (e.g., _record_count) are reserved for use as identifiers with file scope.
  While a compiler might allow you to declare int _record_count; as a local variable without error, using it is bad practice because it could conflict with implementation-defined macros or variables, leading to unexpected behavior. The other options use naming conventions that are perfectly safe and not reserved by the standard.

This question demonstrates how bitwise operators can be used to perform addition. The expression is a representation of how a full adder works.

• i ^ j (XOR) calculates the sum of bits without considering the carry.
  • i = ...0101
  • j = ...1001
  • i ^ j = ...1100 (Decimal 12)
• i & j (AND) identifies the positions where a carry will be generated.
  • i = ...0101
  • j = ...1001
  • i & j = ...0001 (Decimal 1)
• (i & j) * 2 is equivalent to (i & j) << 1, which shifts the carry bits to the left, positioning them for the next addition.
  • 1 * 2 = 2 (Binary ...0010)
• Finally, k is the sum of the XOR result and the shifted carry bits.
  • k = 12 + 2 = 14.
    This is effectively simulating a binary addition: 5 + 9 = 14.