---
# System prepended metadata

title: pingwinowanie 1

---

# pingwinowanie 1

## Zad 1
![image](https://hackmd.io/_uploads/ByTBOTeaa.png)

> weź obrazy linuksa
> jakoś je sobie rozmieść w folderze
> napisz skrypt co odpala dla każdego z wersji cloc'a 
(cloc zlicza ile jest linii kodu oraz pliku w danym pliku tar.gz)
> wykorzystaj dane do zobrazowania tego w pythonie
> koniec
```bash=
# przykładowy do odpalenia cloc'a i zapisywaniu do jsona
# rm wyniki.txt
for folder in linux-*;
do   
    echo -n "$folder:" >> wyniki.txt
    cloc --json $folder/$folder.tar.gz | jq -c >> wyniki.txt
    echo $folder
done

```

## Zad 2
![image](https://hackmd.io/_uploads/rJVkO6eTa.png)
```bash=
alias ll='ls -lAFbhv --color=always'

gentmp() {
        date +"tmp-%Y%m%d%H%M%S"
}

genpwd() {
        echo $(tr -dc '3-9A-HJ-NP-Z' < /dev/urandom | head -c 32) 
}
```
#### ls -lAFbhv:
-l: Wyświetla szczegółowe informacje o plikach w formie listy.
-A: Wyświetla wszystkie pliki, pomijając katalog bieżący . i katalog nadrzędny ...
-F: Dodaje do nazw plików sufiksy wskazujące na rodzaj pliku (np. "/" dla katalogów).
-b: Wyświetla nieprzetworzone znaki niestandardowe w formie ucieczek odwrotnych.
-h: Używa czytelnych rozmiarów (np. KB, MB).
-v: Sortuje pliki alfabetycznie w sposób naturalny (np. 1, 2, 10, zamiast 1, 10, 2).
--color=always: Włącza kolorowanie wyników ls, nawet gdy wyjście nie jest przekierowane na terminal.

#### less -XER:
-X: Nie wyciera ekranu po wyjściu z pliku.
-E: Wyłącza wyświetlanie ostrzeżenia "END OF FILE" na dole ekranu.
-R: Umożliwia kolorowanie wyników ls przekierowanych do less.

## Zad 3
![image](https://hackmd.io/_uploads/SJ3l_aepT.png)

Podstawowe opcje programu grep:
-i, --ignore-case: Ignoruje wielkość liter podczas wyszukiwania.

-v, --invert-match: Wyświetla linie, które nie pasują do wzorca.

-r, --recursive: Wyszukuje rekursywnie w podkatalogach.

-n, --line-number: Wyświetla numery linii, w których występują dopasowania.

-l, --files-with-matches: Wyświetla tylko nazwy plików zawierających dopasowania, a nie same dopasowania.

-E, --extended-regexp: Używa rozszerzonych wyrażeń regularnych, co pozwala na skorzystanie z dodatkowych możliwości w wyrażeniach.

-w, --word-regexp: Dopasowuje tylko całe słowa, nie fragmenty słów.

-f, --file: wyszukuje patterny z pliku tekstowego

Przykłady:
```bash=
grep "pattern" file.txt
grep -i "pattern" file.txt
cat file.txt | grep "pattern"
ls -l | grep "pattern"
```
## Zad 4
![image](https://hackmd.io/_uploads/ryYJcpepT.png)

find - program wyszukiwania plików w systemie plików

Podstawowe opcje:

1. `-name pattern`: Wyszukuje pliki o określonym wzorze w nazwie.
   Przykład: `find . -name "*.txt"` 

2. ` -type type`: Określa typ szukanych obiektów (plik, katalog, dowiązanie symboliczne itp.).
   Przykład: `find . -type d` - znajduje wszystkie katalogi

3. `-size [+|-]size_unit`: Wyszukuje pliki o określonym rozmiarze.
   Przykład: `find . -size +1M` - znajduje pliki większe niż 1 megabajt 
   
4. `-exec command {} +`: Wykonuje określone polecenie dla każdego znalezionego pliku.
   Przykład: `find . -name "*.txt" -exec rm {} +` - usuwa wszystkie pliki z rozszerzeniem .txt

- `{}` oznacza aktualnie przetwarzany plik.
- `+` oznacza, że polecenie -exec będzie wykonywane dla grupy plików, które zostały znalezione, a nie dla każdego pliku osobno. Zamiast `+` można użyć `/` i wtedy przetwarza każdy plik osobno

5. `-mtime -n`: Wyszukuje pliki zmodyfikowane przed określoną liczbą dni.
   Przykład: `find . -mtime -7` - znajduje pliki zmodyfikowane w ciągu ostatnich 7 dni

6. `-maxdepth n`: Ogranicza wyszukiwanie do określonej głębokości katalogów.
   Przykład: `find . -maxdepth 2 -name "*.txt"` - znajduje pliki z rozszerzeniem .txt w bieżącym katalogu i jednym poziomie podkatalogów.

7. `-mindepth n`: Określa minimalną głębokość wyszukiwania.
   Przykład: `find . -mindepth 2 -name "*.txt"` - znajduje pliki z rozszerzeniem .txt w podkatalogach, z pominięciem bieżącego katalogu.

## Zad 5
![image](https://hackmd.io/_uploads/r1Gl5pepp.png)

## Zad 6
![image](https://hackmd.io/_uploads/HyMZcagTa.png)
![image](https://hackmd.io/_uploads/r1kM56xpa.png)
6.1 
(Wersja dla archo-pochodnych (![image](https://hackmd.io/_uploads/rkpEO1bTp.png) pochodne))
```bash=
for package in $(pacman -Qq); do
    if [ ! -d "/usr/share/doc/$package" ]; then
        echo "$package"
    fi
done

```

6.2
```bash=
for dir in /usr/share/doc/*; do
    [ -d "$dir" ] || continue  # Sprawdź, czy to katalog
    package_name=$(basename "$dir")
    if ! pacman -Qq | grep -qi "^$package_name$"; then
        owner=$(pacman -Qo "$dir" 2>/dev/null | awk '{print $5}' | head -n1)
        if [ -n "$owner" ]; then
            echo "$package_name: $owner"
        else
            echo "$package_name: unknown owner"
        fi
    fi
done
```

6.3
```bash=
for package in $(pacman -Qq); do
    if [ -d "/usr/share/doc/$package" ]; then
        if ! find "/usr/share/doc/$package/" -iname "changelog*" -print -quit | grep -q .; then
            echo "$package"
        fi
    fi
done
```

6.4 wtf? (nwm czy o to chodzi)
```bash=
for package in $(pacman -Qq); do
    if [ -d "/usr/share/doc/$package" ]; then
        find "/usr/share/doc/$package" -maxdepth 1 \( -iname "changelog*" -o -iname "ChangeLog*" \) -exec grep -qi 'Initial release' {} \; -print
    fi
done
```

6.5
```bash=
cat /usr/share/doc/bash/INTRO | grep -io bash | wc -l
#albo
grep -oi 'bash' /usr/share/doc/bash/INTRO | wc -l
```






## Zad 7
![image](https://hackmd.io/_uploads/Bk6M5TxTp.png)

7.1 
```bash
find / \
    -type f \
    -regextype posix-extended \
    -regex '.*\.so(\.[0-9]+)*$' \
    -print \
    2>/dev/null
```

7.2
```bash
find / \
    -type l \
    -exec file {} + \
    2>/dev/null \
| grep -E 'symbolic link to .*\.so(\.[0-9]+)*$' \
| awk -F: '{print $1}'
```

7.3
```bash
find / \
    -type f \
    -exec du -b {} + \
    2>/dev/null \
| grep -E '\.so(\.[0-9]+)*$' \
| awk 'BEGIN { count = 0; sum = 0 } { sum += $1; count++ } \
END { sum_gb = sum / (1024 * 1024 * 1024); \
avg_size = (sum / count) / (1024 * 1024); \
print "Liczba pasujących plików:", count; \
print "Sumaryczny rozmiar:", sum_gb, "GB"; \
print "Średni rozmiar:", avg_size, "MB" }'
```

7.4
```bash
find / \
    -type f \
    -regextype posix-extended \
    -regex '.*\.so(\.[0-9]+)*$' \
    -exec dirname {} + \
    2>/dev/null \
| sort -u
```

7.5
```bash
find / \
    -type l \
    -exec file {} + \
    2>/dev/null \
| grep -E 'symbolic link to .*\.so(\.[0-9]+)*$' \
| awk -F: '{print $1}' \
| awk -F/ '{$NF=""; OFS="/"; print}' \
| sort -u
```



## Zad 8
![image](https://hackmd.io/_uploads/HkqX96gaa.png)

## Zad 9
![image](https://hackmd.io/_uploads/SyHEqpxaa.png)

## Zad 10
![image](https://hackmd.io/_uploads/SyPHqTepa.png)

Sed (strumieniowy edytor) jest to narzędzie do przetwarzania tekstu w strumieniu. 
Krótkie omówienie głównych funkcji i opcji programu sed:

1. **Edycja strumieniowa**: Sed działa na strumieniach tekstu, czyli danych wejściowych podawanych na standardowe wejście. Może być stosowany do edycji plików tekstowych, ale także do przekształcania wyniku innych poleceń, takich jak `echo`, `cat`, czy `grep`.

2. **Wyrażenia regularne**: Sed obsługuje wyrażenia regularne, które pozwalają na wyszukiwanie i manipulację tekstem na podstawie wzorców. Można używać wyrażeń regularnych do wyszukiwania, zastępowania, usuwania oraz dodawania tekstu.

3. **Operacje na tekście**: Sed oferuje różne operacje, takie jak:
   - `s/pattern/replacement/`: Zastępuje wystąpienia wzorca `pattern` tekstem `replacement`.
   - `d`: Usuwa pasujące linie.
   - `p`: Drukuje pasujące linie.
   - `i`: Wstawia tekst przed wskazaną linią.
   - `a`: Wstawia tekst po wskazanej linii.
   - `c`: Zamienia wskazaną linię na nowy tekst.
   - `r`: Wstawia zawartość pliku na wskazanej linii.

    Przykłady:

    ```bash
    # Zastąp wsytąpienia "stare" na "nowe" w pliku
    sed 's/stare/nowe/' plik

    # Usuń liniw zawierająca "regex" z pilku
    sed '/regex/d' plik

    # Wstaw tekst "Kocham linuxa" przed drugą linią w pliku
    sed '2i\Kocham linuxa' plik
    
    # Zamien pierwszą linię na "Nowa linia" w pliku
    sed '1c\Nowa linia' plik
    
    # Wstaw zawartość pliku "naglowek.txt" na początku pliku
    sed '1r naglowek.txt' plik

    # Wstaw zawartość pliku "stopka.txt" na końcu pliku
    sed '$r stopka.txt' plik
    ```
    
4. **Modyfikacje tekstu**: Sed pozwala na modyfikowanie tekstu na podstawie wyrażeń regularnych oraz operacji, które można wykonywać na pasujących fragmentach tekstu.

5. **Przetwarzanie wieloliniowe**: Sed umożliwia przetwarzanie tekstu w kontekście wielu linii, co pozwala na bardziej zaawansowane operacje, takie jak łączenie, dzielenie lub przemieszczanie linii.

6. **Opcje**: Sed oferuje różne opcje, które pozwalają na dostosowanie jego zachowania, na przykład 
     - -n do wyłączenia automatycznego drukowania wyników, 
     - -i do modyfikacji pliku na miejscu, 
     - -e do wykonywania wielu operacji
     - oraz wiele innych.


## Zad 11
![image](https://hackmd.io/_uploads/SyU896l6p.png)
Jakieś rozwiązanie moje mam nadzieję, że git
```bash
display() {
    input_string="$1"
    colored_string=$(echo "$input_string" | 
    sed -E 's/(R)/\o033[91m&\o033[0m/g' | 
    sed -E 's/(G)/\o033[92m&\o033[0m/g' | 
    sed -E 's/(B)/\o033[94m&\o033[0m/g')
    echo "$colored_string"
}

find_first_pattern() {
    word=$1
    best_pos=${#word}
    first_pattern=""
    
    for pattern in "GR" "BR" "RB" "BG" "GB" "RG"; do
        if echo "$curr_state" | grep -q "$pattern"; then
            pos=$(echo "$curr_state" | grep -b -o "$pattern" | head -n 1 | cut -d: -f1)
            pos=$((pos + 0))
            if [ "$best_pos" -gt "$pos"  ]; then
                best_pos="$pos"
                first_pattern=$pattern
            fi
        fi
    done

    if [ "$first_pattern" == "" ]; then
        for pattern in "GG" "BB" "RR"; do
            if echo "$curr_state" | grep -q "$pattern"; then
                first_pattern=$pattern
            fi
        done
    fi
    echo "$first_pattern"
}

find_opposite() {
    pair=$1
    opposite=""
    case "$pair" in
        "RG") opposite="BB" ;;
        "GR") opposite="BB" ;;
        "RB") opposite="GG" ;;
        "BR") opposite="GG" ;;
        "GB") opposite="RR" ;;
        "BG") opposite="RR" ;;
        "BB") opposite="BB" ;;
        "GG") opposite="GG" ;;
        "RR") opposite="RR" ;;
        *) echo "Unknown pair" ;;
    esac

    echo "$opposite"
}

curr_state="$1"
display $curr_state

while true; do
    first_pattern=$(find_first_pattern "$curr_state")
    # echo "FIRST " $first_pattern
    opposite=$(find_opposite "$first_pattern")
    # echo "OPPOSITE " $opposite
    new_state=$(echo "$curr_state" | sed "s/${first_pattern}/${opposite}/")
    if [ $curr_state != $new_state ]; then
        display "$new_state"
        curr_state="$new_state"
    else
        break
    fi
done
```

I jakieś krótkie omówienie, chyba najbardziej tricky linijek

### grep -q "$pattern"
odpowiada czy istnieje dany pattern w zapytaniu, można sprawdzić np.

```
echo "RGBBRG" | grep -q "BG"
echo $?  -> zwróci 1 bo nie ma

echo "RGBBRG" | grep -q "GB"
echo $? -> zwróci 0 bo jest :>>
```
### echo "\$curr_state" | grep -b -o "\$pattern" | head -n 1 | cut -d: -f1)
To może weźmy po kolei

#### grep -b dokleja bajty czyli np
```echo "RGBBRG" | grep -b RG```  doklei 0:RGBBRG

ale teraz łącząc z -o które wypisuje tylko interesujący nas output dostaniemy
```echo "RGBBRG" | grep -b -o BR```
3:BR

bo ten pattern zaczyna się przy 3 pozycji więc kox

#### head -n 1 | cut -d: -f1

No dalej mamy head -n 1, to raczej nie wymaga wyjaśnienia, ale jeśli jest wiele patternów to wypisujemy tylko 1 z nich
I teraz wchodzi cut -d: -f1
W skrócie działa jak split pythonowy czyli splitujemy po znaku który mamy po -d, w naszym przypadku :
-f1 precyzuje, że chcemy pierwszy element po tym splicie czyli dla formatu x:pattern -> dostaniemy x, gdzie x to miejsce, gdzie się zaczyna pattern
