---
# System prepended metadata

title: 'Ćwiczenia 1, grupa śr. 17-19, 22 lutego 2023'
tags: [pwit, ćwiczenia, ASK23]

---

# Ćwiczenia 1, grupa śr. 17-19, 22 lutego 2023

###### tags: `ASK23` `ćwiczenia` `pwit`


:::info

**Na dzisiejszych ćwiczeniach deklaracje nie obowiązują. Jednak od przyszłego razu tabelka do deklaracji będzie wyglądać tak:**

## Deklaracje

Gotowość rozwiązania zadania należy wyrazić poprzez postawienie X w odpowiedniej kolumnie! Jeśli pożądasz zreferować dane zadanie (co najwyżej jedno!) w trakcie dyskusji oznacz je znakiem ==X== na żółtym tle.

**UWAGA: Tabelkę wolno edytować tylko wtedy, gdy jest na zielonym tle!**


:::success
|                        | 1   | 2   | 3   | 4   | 5   | 6   | 7   | 8   |
| ----------------------:| --- | --- | --- | --- | --- | --- | --- | ---  
  Imię i Nazwisko        |     |     |     |     |     |     |     |     |
:::


:::



:::info
**Uwaga:** Po rozwiązaniu zadania należy zmienić kolor nagłówka na zielony.
:::




## Zadanie 1
:::success
Autor:	Maciej Styś
![](https://i.imgur.com/QH7PRcU.png)
:::



## Zadanie 2
:::danger
Autor:	Mikołaj Łabędzki
22 + 8 = 2A
73 + 2C = 9F
7F + 7F = FE
C2 + A4 = 166
:::

## Zadanie 3
:::success
Autor:	Kamila Goszcz
:::

- wyzeruj k-ty bit zmiennej x
```c
return x & ~(1 << k)
```
k=2
100_1_10
000001 -> 000100 // <<
000100 -> 111011 // ~
100010

- zapal k-ty bit zmiennej x
```c
return x | (1 << k)
```
- zaneguj k-ty bit zmiennej x
```c
return n ^ (1 << k)
```


b - bit

0 xor b = b
1 xor b = not b


## Zadanie 4
:::success
Autor:	Kamila Goszcz
:::

- $x * 2^y$
```c
return x << y
```
- $\lfloor x / 2^y \rfloor$
```c
return x >> y
```
x = 1001001
y = 3
w = 0001001

- $x\ mod\ 2^y$
```c
return (x << (32 - y)) >> (32 - y) // x jest zmienną typu uint32_t (stąd przesunięcie o 32)
    
```
W przykładzie liczby zapisane są na 7 bitach (będziemy przesuwać o 7)    


x = 1001001
y = 3
w = 0000001

x1 = 0010000
x2 = 0000001

Alternatywne rozwiązanie:
```c
return (x & ((1 << y) -1)) 
```

x = 1001001
y = 3
w = 0000001 -> 0001000  // (1 << y) 
    0001000 -> 0000111  // (1 << y) -1
x & 0000111 -> 1001001 & 0000111 -> 0000001 

- $\lceil x / 2^y \rceil$


Przykład 1:
x = 1001000
y = 3
wynik: 0001001

Przykład 2:
x = 1001001
y = 3
wynik: 0001010

```c
return (x + (1 << y) - 1) >> y; 
```
W naszych przykładach:
Przykład 1:

1001000 + (1 << 3) -> 1001000 + 0001000 -> 1010000
1010000 - 1 -> 1001111
1001111 >> y -> 1001111 >> 3 -> 0001001 

$\lceil 72 / 2^3 \rceil = 9$


Wniosek: jeśli $x / 2^y$ jest liczbą naturalną to $x + (1 << y) - 1$ ma te same bity co liczba $x$ na pozycjach od y wzwyż.

A co się dzieje, jeśli w liczbie x na pozycjach od $0$ do $y-1$ są jakieś zapalone bity?
Przykład 2:

1001001 + (1 << 3) -> 1001001 + 0001000 -> 1010001
1010001 - 1 -> 1010000
1010000 >> y -> 1010000 >> 3 -> 0001010 

$\lceil 73 / 2^3 \rceil = 10$






## Zadanie 5
:::danger
Autor:	
:::

Przykład:
przechowujemy liczby na 7 bitach. 

1 = 0000001 
~~-1 =1000001~~ źle, tak nie chcemy

dla każdej liczby x jest reprezentacja(x) + reprezentacja(-x) = 2^8

0000001 + 1111111 ->10000000 

Jak liczbę x przekształcić na -x:
(~x) + 1

~0000001 + 1 -> 1111110 + 1 = 1111111
~1111111 + 1 -> 0000000 + 1 = 0000001

```c
return (~x) + 1; 
```





## Zadanie 6
:::success
Autor:	 Kamila Goszcz
:::

```c
uint32_t mask = x & 0x000000FF
x = (x & 0xFFFFFF00) | (y & 0x000000FF)
y = (y & 0xFFFFFF00) | mask
```

## Zadanie 7
:::success
Autor: Kamila Goszcz
:::

```c
return (x & (x-1)) | ((~x & (x-1)) >> 31)
```
    alternatywnie, drugi dyzjunkt może wyglądać tak: (x -1) & Z, gdzie Z to liczba mająca 1 na najstarszym (skrajnie lewym) bicie, na pozostałych 0.

Pierwsza część sprawdza czy x jest potęgą 2 lub 0. Zauważmy, że potęgi dwójki mają dokładnie jedną 1 w swoim zapisie binarnym. 

`00100000 & 00011111 = 00000000`

Pozostałe liczby mają conajmniej dwie. Odjęcie 1 oznacza zredukowanie Tylko jednej z nich

`00100100 & 00100011 = 00100000`

Wyjątkiem będzie tutaj 0, wtedy mamy:

`00000000 & 11111111 = 00000000`

Druga część rozwiązania to wyłapanie tego przypadku. Tylko dla 0 zachodzi ~x = x-1

`11111111 & 11111111 >> 7 = 00000001`

dla potęgi 2:

`11011111 & 00011111 >> 7 = 00000000`

## Zadanie 8
:::success
Autor:	Kamila Goszcz
:::

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

```c=
return  ((x & 0x000000ff) << 24) |
        ((x & 0x0000ff00) << 8)  |
        ((x & 0x00ff0000) >> 8)  |
        ((x & 0xff000000) >> 24)
```

## Zadanie 9
:::danger
Autor:	Kamila Goszcz
:::

Standard ASCII przeznacza pierwsze 32 kody (0–31) na znaki sterujące. Nie są one przeznaczone do przenoszenia drukowalnych symboli, lecz do sterowania urządzeniem odbierającym dane.

- 0 w ASCII oznacza null , który oznacza bajt kończący ciąg znaków,
- 4 w ASCII oznacza end of transmission który oznacza koniec przepływu informacji
- 7 w ASCII oznacza bell character używany był do odtwarzania krótkiego dźwięku
- 10 w ASCII oznacza znak nowej linii
- 12 w ASCII oznacza page break co daje sygnał drukarce by kontynuować drukowanie od nowej strony 


## Zadanie 10
:::danger
Autor: można dodeklarować!
:::
