# 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
```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
```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
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
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))
```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
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
## 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:
```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
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
Sign in with Wallet
Connect another wallet