---
# System prepended metadata

title: CAOS - Lecture 1

---

# CAOS - Lecture 1

# Opgave 2 - Problem 2.1 (p. 73) (bemærk løsning i bogen indeholder fejl: i delopgave a) skal "B" cifferet oversættes til 1011 Svaret på delopgave b) 1010 1110 0100 1001 = AE49
![](https://i.imgur.com/QeazaB0.png)

Perform the following number conversions:
A. 0x25B9D2 to binary
    - 001001011011100111010010

B. binary 1010111001001001 to hexadecimal
- 0xAE49

C. 0xA8B3D to binary
- 10101000101100111101

D. binary (00)1100100010110110010110 to hexadecimal
- (Man deler den op i 4. Da den ikke går op så tilføjer vi det antal 0 foran der mangler. I dette tilfælde 00)
- 0x322D96
# Opgave 3 - Problem 2.3 (p. 74) (særlig vigtig)
Q: A single byte can be represented by 2 hexadecimal digits. Fill in the missing entries in the following table, giving the decimal, binary, and hexadecimal valuesof different byte patterns: ![](https://i.imgur.com/6Bn2AJp.png)

![](https://i.imgur.com/JWICWz4.png)
![](https://i.imgur.com/0jTjEKG.png)

A: 


| Dec | Binary | Hex |
| -------- | -------- | -------- |
| 0     | 0000 0000     | 0x00     |
| 158     | 1001 1110    | 0x9E    |
| 76     |   0100 1100 |  0x4C  |
| 145     |  1001 0001  | 0x91     |
| 174     | 1010 1110     | 0xAE     |
| 60     | 0011 1100     | 0x3C     |
| 241     | 1111 0001     | 0xF1     |



# Opgave 4 - Problem 2.7 (p. 85)
What would be printed as a result of the following call to show_bytes?
const char *m = "mnopqr";
show_bytes((byte_pointer) m, strlen(m));
Note that letters ‘a’ through ‘z’ have ASCII codes 0x61 through 0x7A.
m = 0x6D
n = 0x6E
o = 0x6F
p = 0x70
q = 0x71
r = 0x72
    - The printed reult is: 0110 1101 0110 1110 0110 1111 0111 0000 0111 0001 0111 0010

# Opgave 5 - Problem 2.10 (p. 90)
As an application of the property that a ^ a = 0 for any bit vector a, consider the
following program:

1     void inplace_swap(int *x, int *y) {
2         *y = *x ^ *y; /* Step 1 */
3         *x = *x ^ *y; /* Step 2 */
4         *y = *x ^ *y; /* Step 3 */
5     }


As the name implies, we claim that the effect of this procedure is to swap the values stored at the locations denoted by pointer variables x and y. Note that unlike the usual technique for swapping two values, we do not need a third location to temporarily store one value while we are moving the other. There is no performance advantage to this way of swapping; it is merely an **intellectual amusement**. Starting with values a and b in the locations pointed to by x and y, respectively, fill in the table that follows, giving the values stored at the two locations after each step of the procedure. Use the properties of ^ to show that the desired effect is achieved. Recall that every element is its own additive inverse (that is, a ^ a = 0).
![](https://i.imgur.com/4UnbpgL.png)

![](https://i.imgur.com/vmb5wxp.png)


| Step |     \*x |       \*y |
| -------- | -------- | -------- |
| Initially     | a     | b     |
| Step 1     | a      | a ^ b     |
| Step 2     | a\^(a\^b)=(a\^a)\^b = b     | a ^ b     |
| Step 3    | b     | b\^(a\^b) = (b\^b)\^a = a     |





# Opgave 6 - Problem 2.12 (p. 91)
Write C expressions, in terms of variable x, for the following values. Your code should work for any word size w ≥ 8. For reference, we show the result of evaluating the expressions for x = 0x87654321, with w = 32.

![](https://i.imgur.com/Q6YL9rJ.png)
![](https://i.imgur.com/0upimDj.png)

A. The least significant byte of x, with all other bits set to 0. [0x00000021]
- x & 0xFF

B. All but the least significant byte of x complemented, with the least significant byte left unchanged. [0x789ABC21]
- x ^ 0xFFFFFF00
- x ^~ 0xFF

C. The least significant byte set to all ones, and all other bytes of x left unchanged. [0x876543FF]
- x | 0xFF

# Opgave 7 - Problem 2.14 (p. 93)
Suppose that a and b have byte values 0x55 and 0x46, respectively. Fill in the following table indicating the byte values of the different C expressions
![](https://i.imgur.com/mVaBqrI.png)
0x55 = 0101 0101
0x46 = 0100 0110

1. 0100 0100 = 0x44
2. 0101 0111 = 0x57
3. 1011 1011 = 0xBB
4. 0001 0001 = 0x11 men den skal give 0x0
5. 1 = 0x01
6. 1 = 0x01
7. 0 = 0x00
8. 1 = 0x01

# Opgave 9 - C-pointer Refresher;
## 1. Write a function printArray with parameter type long array, that prints its elements as a long integer value and a long hexidecimal value respectively (using %ld respectively %lx as placeholders in printf, and use it to print a sample array "a" containing 20 elements each initialized with the value from 10+i (where i  is the index). Ie 10,11,...,29
```c
#define LEN 20
long myArray[LEN];
void printArray(long arr[]){
   for(int i =0;i<LEN;i++) 
     printf("Index %d:\t  %lu\t %lx\n", i, arr[i],arr[i]);

}

printArray(myArray);
```

## 2. Make a pointer x to the 4th element (index 3), and print out its address (use %p). Also print out the address of 'a'. Are the addresses what you expect?
```c
//create a pointerx  to index 3
  long * x = &myArray[3]; //note "address of" operator
  printf("Array starts at address %p, element 3 at %p\n", myArray, x);
```

## 3. Print the value pointed by x by dereferencing x
```c
//create a pointerx  to index 3
  long * x = &myArray[3]; //note "address of" operator
  printf("Array starts at address %p, element 3 is %ld\n", myArray, *x);
```

## 4. Write a function swap (taking to long pointers as argument) that swaps the appointed values. Apply it to swap the array elements with indexes 0 and 5.  print the Array
```c
void swap (long * e1, long * e2){
  long tmp1=*e1;
  long tmp2=*e2;
  *e2=tmp1;
  *e1=tmp2;
}
 swap(&myArray[0], &myArray[5]);
```
## 5. Print the hex value of the expression "long y=*(x+9)"

## 6. What does it print if you set y=*(x+100)

## 7. What happens if you set y=*(x+100000);?