pingwinowanie 1

Zad 1

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

# 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

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

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:

grep "pattern" file.txt
grep -i "pattern" file.txt
cat file.txt | grep "pattern"
ls -l | grep "pattern"

Zad 4

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

Zad 6

6.1
(Wersja dla archo-pochodnych (

pochodne))

for package in $(pacman -Qq); do
    if [ ! -d "/usr/share/doc/$package" ]; then
        echo "$package"
    fi
done

6.2

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

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)

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

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

Zad 7

7.1

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

7.2

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

7.3

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

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

7.5

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

Zad 9

Zad 10

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:

   ​​​​# 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

Jakieś rozwiązanie moje mam nadzieję, że git

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