De multe ori ne aflăm în situația în care căutăm un fișier pe disc: ex. doar ce am clonat un proiect de pe GitHub și vrem să inspectăm fișierele sursă pentru a putea compila și rula proiectul. Un alt exemplu poate fi că vrem să vedem cum arată fișierele de test existente în proiect; de multe ori, ințelegem mai bine proiectul doar prin simpla inspectare a testelor.

Există două utilitare care ne permit să căutăm în cadrul sistemului de fișiere: locate și find. In laboratorul anterior am discutat despre utilitarul locate, iar în laboratorul curent vom vorbi despre utilitarul find.

Utilitarul find îndeplinește același scop: căuta în fișierele de pe sistem. find este un utilitar mai complex decât locate. Acesta ne permite să căutăm fișiere după nume, permisiuni, tipul fișierelor, data ultimei modificări și multe altele. Inspectăm pagina de manual a utilitarului pentru a vedea cum îl putem folosi.

student@uso:~$ man find
 
SYNOPSIS
       find  [-H]  [-L]  [-P]  [-D  debugopts]  [-Olevel]  [starting-point...]
       [expression]

La o primă vedere, find poate părea complex și intimidant, dar lucrurile stau foarte simplu. Folosim find cu sintaxa find [starting-point] [expression], ca în exemplul de mai jos:

student@uso:~$ find . -name "*search*"
./C/searching
./C/searching/linear_search.c
./C/searching/other_binary_search.c
./C/searching/binary_search.c
./C/searching/modified_binary_search.c
./C/searching/jump_search.c
./C/searching/interpolation_search.c
./C/searching/fibonacci_search.c
./C/searching/ternary_search.c
./C/searching/pattern_searc h
./C/searching/pattern_search/naive_search.c
./C/searching/pattern_search/boyer_moore_search.c
./C/searching/pattern_search/rabin_karp_search.c
./C/data_structures/binary_trees/binary_search_tree.c

În exemplul de mai sus observă că am folosit ca starting-point . (căutarea pleacă din directorul curent), iar ca expression -name "*search*".

Utilitarul find folosește o expresie compusă pentru căutare. În exemplul anterior am folosit opțiunea -name PATTERN. Exact ca în cazul utilitarului locate, PATTERN poate folosi sintaxa globbing, așa cum am făcut în exemplul de mai sus "*search*".

Utilitarul find are o lungă listă de opțiuni pe care le putem folosi în expresii de căutare. Una din opțiunile mai cunoscute este -type care ne oferă posibilitatea de a căuta după tipul unui fișier:

student@uso:~$ find workspace/C -type f
workspace/C/leetcode/src/226.c
workspace/C/leetcode/src/700.c
workspace/C/leetcode/src/278.c
[...]

În exemplul de mai sus i-am transmis utilitarului find că vrem să căutăm în directorul ~/workspace/C toate fișierele text (regular file) -type f.

Exercițiu: Accesați pagina de manual a utilitarului find (man find) și căutați opțiunea -type. Căutați în directorul workspace/C după fiecare tip de fișier pentru care oferă suport opțiunea -type.

În cadrul unei căutări putem să combinăm opțiunile de căutare:

student@uso:~$ find workspace/C -type f -name "*search*"
workspace/C/searching/modified_binary_search.c
workspace/C/searching/ternary_search.c
workspace/C/searching/jump_search.c
workspace/C/searching/binary_search.c

În exemplul de mai sus căutăm toate fișierele text care conțin șirul search în nume.

Utilitarul find ne permite să executăm comenzi asupra rezultatelor căutării. Facem acest cu opțiunea -exec command {} ;. Atunci când folosim -exec, rezultatul căutării va înlocui șirul '{}' în textul comenzii; comanda de executat trebuie să se termine în caracterul ;.

Observăm exemplul de mai jos:

student@uso:~$ find workspace/C -type f -name "*search*" -exec ls -l {} \;
-rw-r--r-- 1 student student 3312 sep 17 19:20 workspace/C/searching/modified_binary_search.c
-rw-r--r-- 1 student student 1782 sep 17 19:20 workspace/C/searching/ternary_search.c
-rw-r--r-- 1 student student 1624 sep 17 19:20 workspace/C/searching/jump_search.c
-rw-r--r-- 1 student student 2799 sep 17 19:20 workspace/C/searching/binary_search.c
-rw-r--r-- 1 student student 867 sep 17 19:20 workspace/C/searching/other_binary_search.c

În exemplul de mai sus, argumetul opțiunii exec este ls -l {} \;. În cuvinte, pentru fiecare fișier text care conține șirul search vom afișa informații în format lung (ls -l {}). Observăm că -exec se încheie cu \;: este nevoie să escapăm caracterul ; pentru ca acesta să fie interpretat de către utilitarul find și nu de către terminalul în care rulăm, exact ca în cazul -name PATTERN.

În secțiunile ce urmează vom vedea cum ne folosim de opțiunea exec pentru a face recursiv search & replace în fișiere.

1. Folosind find căutați fișierele care conțin șirul bubble_sort în nume.
2. Folosind find căutați fișierele care conțin șirul quick_sort în nume.
3. Folosind find căutați fișierele care conțin șirul merge_sort în nume.
4. Folosind find căutați fișierele care conțin șirul sort în nume.

În secțiunea anterioară, Inspectarea sistemului de fișiere, am văzut cum căutăm fișiere în sistem cu ajutorul utilitarelor locate și find. Căutăm un fișier cu un scop: vrem să găsim fișierul README pentru informații despre compilarea proiectului, vrem să ne amintim un detaliu de implementare din cod, etc.

De cele mai multe ori acțiunea noastră se poate grupa în una din următoarele două categorii:

• Ne dorim să inspectăm rapid conținutul fișierelor pentru a ne da seama dacă am găsit informația căutată.
• Ne dorim să afișăm pe ecran conținutul fișierelor pentru a extrage și prelucra informații din acestea.

Pentru a vedea rapid conținutul unui fișier folosim utlitarul less.

Avem fișierul workspace/C/searching/binary_search.c. Vrem să ne facem rapid o idee despre cum arată implementarea algoritmului binary_search. Inspectăm conținutul fișierului workspace/C/searching/binary_search.c, folosind utilitarul less, ca în exemplul de mai jos:

student@uso:~$ less workspace/C/searching/binary_search.c
 
/**
 * @file
 * @brief Program to perform [binary
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * value in a given *sorted* array.
 * @authors [James McDermott](https://github.com/theycallmemac) - recursive
 * algorithm
 * @authors [Krishna Vedala](https://github.com/kvedala) - iterative algorithm
 */
#include <assert.h>
#include <stdio.h>
 
/** Recursive implementation
 * \param[in] arr array to search
 * \param l left index of search range
 * \param r right index of search range
 * \param x target value to search for
 * \returns location of x assuming array arr[l..r] is present
 * \returns -1 otherwise
 */
int binarysearch1(const int *arr, int l, int r, int x)
{
    if (r >= l)
    {
        int mid = l + (r - l) / 2;
 
        // If element is present at middle
        if (arr[mid] == x)
            return mid;
: 

Observăm că acum avem o sesiune interactivă în interiorul căreia putem explora fișierul.

În sesiunea interactivă căutăm după cuvântul cheie search. Pentru a porni căutarea apăsăm tasta /, introducem textul căutat (search) și apăsăm tasta Enter. Apăsăm tasta n pentru a merge la următoarea apariție a textului căutat; apăsăm n până când ajungem la implementarea funcției binarysearch2.

1. Analizați, folosind less, algoritmul de căutare din fișierul workspace/C/searching/linear_search.c. Ce implementare este mai eficientă: binary_search sau linear_search?
2. Analizați, folosind less, algoritmul de sortare quick_sort. Folosiți utilitarul find pentru a găsi fișierul sursă care conține implementarea.
3. Analizați, folosind less, algoritmul de sortare merge_sort. Folosiți utilitarul find pentru a găsi fișierul sursă care conține implementarea.
4. Căutați pe Google detalii despre cei doi algoritmi de sortare și încercați să vă răspundeți la întrebarea: Când folosim merge_sort și când folosim quick_sort?

Pentru a afișa pe ecran conținutul unui fișier folosim utlitarul cat. Rulăm comanda de mai jos, pentru a exemplifica:

student@uso:~$ cat workspace/C/searching/binary_search.c
/**
 * @file
 * @brief Program to perform [binary
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * value in a given *sorted* array.
 * @authors [James McDermott](https://github.com/theycallmemac) - recursive
 * algorithm
 * @authors [Krishna Vedala](https://github.com/kvedala) - iterative algorithm
 */
#include <assert.h>
#include <stdio.h>
 
[...]

Observăm că pentru un fișier cu un număr mare de linii, așa cum este binary_search.c, afișarea întregului conținut pe ecran devine un impediment în a putea înțelege și urmări conținutul. De aceea vă încurajăm să folosiți less în loc de cat pentru a inspecta un fișier: vă este mult mai ușor să vă plimbați în interiorul fișierului și puteți folosi funcția search pentru a căuta în fișier. De asemeni, folosind less vă păstrați consola curată și puteți urmări mai ușor ce comenzi ați dat anterior și care au fost rezultatele acestora.

Folosim comanda cat în combinație cu alte comenzi pentru a extrage sau filtra conținutul anumitor fișiere. Comanda cat primește ca argumente calea către unul sau mai multe fișiere și afișează pe ecran conținutul concatenat al acestora.

Un exemplu uzual este faptul că vrem să extragem informațiile despre starea memoriei sistemului din fișierul /proc/meminfo. Pentru aceasta rulăm comanda de mai jos:

student@uso:~$ cat /proc/meminfo | grep "Mem"
MemTotal:        2041248 kB
MemFree:          236092 kB
MemAvailable:     874420 kB

În exemplul de mai sus folosim cat pentru a oferi ca intrare conținutul fișierului /proc/meminfo utilitarului grep; cu utilitarul grep filtrăm conținutul după textul "Mem". Cu alte cuvinte, outputul comenzii cat /proc/meminfo, adică conținutul fișierului /proc/meminfo este textul pe care utilitarul grep îl prelucrează.

Exercițiu: Plecând de la exemplul de mai sus, extrageți din fișierul /proc/cpuinfo dimensiunea memoriei cache a procesorului vostru; filtrați conținutul după textul "cache".

Am văzut că utilitarul cat afișează întreg conținutul unui fișier. Există scenarii în care suntem interesați doar de începutul sau sfârșitul unui conținut. Pentru aceste cazuri putem folosi utilitarele:

• head - afișează primele 10 linii din conținut
• tail - afișează ultimele 10 linii din conținut

Așa cum am observat în capitolul despre procese, putem folosi utilitarul ps pentru a vedea care sunt procesele din sistem și ce resurse consumă acestea. Memoria sistemului este una dintre cele mai importante resurse; dacă sistemul nostru rămâne fără memorie disponibilă, tot sistemul este afectat: sistemul se va “mișca” mai greu, procesele se vor “mișca” mai greu sau pot chiar să își întrerupă activitatea. Știind acest lucru, suntem interesați să vedem care sunt primele zece procese care consumă cea mai multă memorie.

Folosim utilitarul ps pentru a afișa toate procesele din sistem:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=%mem
 
USER       UID   PID %MEM %CPU   RSS CMD
root         0     2  0.0  0.0     0 [kthreadd]
 
[...]
 
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7938 18.0  0.1 368304 /usr/bin/gnome-shell

Am folosit opțiunea -ouser,uid,pid,%mem,%cpu,rss,cmd pentru a selecta coloanele pe care să le afișeze ps.

Am folosit opțiunea --sort cu argumentul %mem pentru a sorta procesele după procentul de memorie folosită.

Observăm că avem procesele sortate crescător după coloana %MEM. Folosim utilitarul tail pentru a extrage din rezultatul ps cele mai consumatoare zece procese:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=%mem | tail
student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server
root         0  1074  2.2  0.0 45460 /usr/bin/containerd
student   1000  8274  2.3  0.0 48296 nautilus-desktop
root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7938 18.0  0.1 368248 /usr/bin/gnome-shell

În acest moment am găsit răspunsul căutat, dar avem două mici neajunsuri:

• Ne lipsește antetul, așa că nu știm ce informații avem pe coloane
• Procesele sunt sortate crescător, a.î. cel mai consumator este ultimul; vrem să fie sortate descrescător

Rezolvăm cele două probleme prin intermediul opțiunii --sort: dacă punem un - (minus) în fața argumentului după care sortăm, o să sortăm descrescător. Rulăm comanda:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | less
USER       UID   PID %MEM %CPU   RSS CMD
student   1000  7938 18.0  0.1 368248 /usr/bin/gnome-shell
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
 
[...]

Observăm că acum avem formatul dorit. Ne mai rămâne să extragem primele 11 linii din rezultatul comenzii de mai sus; 11 deoarece prima este linia antetului iar următoarele zece sunt procesele de interes. Pentru aceasta utilizăm comanda head cu opțiunea -11 ca în exemplul de mai jos:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11
USER       UID   PID %MEM %CPU   RSS CMD
student   1000  7938 18.0  0.1 367952 /usr/bin/gnome-shell
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
student   1000  8274  2.3  0.0 48296 nautilus-desktop
root         0  1074  2.2  0.0 45460 /usr/bin/containerd
student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server

1. Afișați primele zece procese sortate în funcție de memoria ocupată (Hint: RSS). Nu uitați să includeți antetul.
2. Afișați ultimele zece procese sortate în funcție de utilizarea procesorului (Hint: CPU). Nu uitați să includeți antetul.

Așa cum am văzut până în acest punct din carte, majoritatea comenzilor Linux afișează o gamă largă de informații pe care apoi utilizatorul (adică noi) le filtrează pentru a extrage ceea ce îl intresează. La începutul acestei secțiuni, dar și de-a lungul cărții, am folosit utilitarul grep ca să filtrăm rezultatul unei comenzi.

Comanda grep este una dintre cele mai folosite în linie de comandă. Sintaxa de folosire a grep este următoarea:

SYNOPSIS
       grep [OPTIONS] PATTERN [FILE...]

grep caută PATTERN în lista de fișiere primită ca argument și afișează liniile care conțin PATTERN-ul căutat. Atunci când nu primește nici un fișier, citește text de la tastatură (intrarea standard) și afișează liniile care conțin PATTERN-ul căutat.

Până acum noi am utilizat grep după modelul de mai jos:

student@uso:~$ cat workspace/C/searching/binary_search.c | grep search
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * \param[in] arr array to search
 * \param l left index of search range
 * \param r right index of search range
 * \param x target value to search for
int binarysearch1(const int *arr, int l, int r, int x)
 
[...]

În exemplul de mai sus, operatorul | trimite textul afișat de comanda cat către intrarea standard a comenzii grep. Vom discuta mai multe despre acesta în secțiunea improve_cli_improve_shell_oneliners.

Comanda următoare este echivalentă cu cea de mai sus:

student@uso:~$ grep search workspace/C/searching/binary_search.c
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * \param[in] arr array to search
 * \param l left index of search range
 * \param r right index of search range
 * \param x target value to search for
int binarysearch1(const int *arr, int l, int r, int x)
[...]

Observăm modul de folosire: grep PATTERN cale/către/fișier.

1. Căutați patternul “l” în fișierul binary_search.c, pentru a vedea unde este folosit parametrul left. Observați cât de multe rezultate irelevante ați găsit datorită faptului că am căutat doar caracterul l. Aici există o lecție de învățat. Numele variabilelor sunt foarte improtante: nu fac doar codul mai ușor de înțeles, dar ajută și căutarea. Folosiți patternul “param l” în încercarea de a restrânge căutarea.
2. Căutați patternul “arr” în fișierul binary_search.c.
3. Căutați patternul “binarysearch1” în fișierul binary_search.c pentru a vedea cum este apelată funcția de căutare.

Folosim opțiunea -n pentru a afișa și numărul liniei care conține patternul căutat:

student@uso:~$ grep -n search workspace/C/searching/binary_search.c
4: * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
14: * \param[in] arr array to search
15: * \param l left index of search range
16: * \param r right index of search range
17: * \param x target value to search for
21:int binarysearch1(const int *arr, int l, int r, int x)
[...]

Implicit, grep caută în mod case-sensitive patternul, așa cum putem observa din exemplul de mai jos:

student@uso:~$ grep Search workspace/C/searching/binary_search.c

Pentru a efectua căutarea textului în mod case-insesnsitive, folosim opțiunea -i, ca în exemplul de mai jos:

student@uso:~$ grep -i Search workspace/C/searching/binary_search.c
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * \param[in] arr array to search
 * \param l left index of search range
 * \param r right index of search range
 * \param x target value to search for
int binarysearch1(const int *arr, int l, int r, int x)
[...]

Pentru a afișa toate liniile, mai puțin pe cele care conțin pattern, folosim opțiunea -v, ca în exemplul de mai jos:

student@uso:~$ grep -v search workspace/C/searching/binary_search.c | less
/**
 * @file
 * @brief Program to perform [binary
 * value in a given *sorted* array.
 * @authors [James McDermott](https://github.com/theycallmemac) - recursive
 * algorithm
 * @authors [Krishna Vedala](https://github.com/kvedala) - iterative algorithm
 */
#include <assert.h>
#include <stdio.h>
[...]

În căutările noastre de până acum, ca și în exemplele de mai sus, am presupus că știm în ce fișiere se găsește informația căutată de noi. Acest lucru este adevărat pentru fișiere din sistem cu informații bine cunoscute, cum ar fi /proc/meminfo, dar atunci când lucrăm cu un proiect nou nu vom ști în ce fișiere să căutăm informația dorită. De exemplu, în cazul proiectului cu algoritmi implementați în C, noi am făcut presupunerea că vom găsi linii care conțin patternul search în fișierul workspace/C/searching/binary_search.c.

Atunci când nu știm în ce fișiere se află informația căutată putem să-i spunem lui grep să caute recursiv prin toată ierarhia de fișiere dintr-un anumit director. Pentru a efectua o căutare recursivă folosim opțiunea -r, ca în exemplul de mai jos:

student@uso:~$ grep -r search workspace/C/ | less
 
workspace/C/leetcode/src/700.c:struct TreeNode *searchBST(struct TreeNode *root, int val)
workspace/C/leetcode/src/700.c:        return searchBST(root->left, val);
workspace/C/leetcode/src/700.c:        return searchBST(root->right, val);
workspace/C/leetcode/src/35.c:int searchInsert(int *nums, int numsSize, int target)
workspace/C/leetcode/src/35.c:int searchInsert(int *nums, int numsSize, int target)
workspace/C/leetcode/src/35.c:        return searchInsert(nums, numsSize - 1, target);
workspace/C/leetcode/src/704.c:int search(int *nums, int numsSize, int target)
workspace/C/leetcode/src/704.c:/* Another solution: Using bsearch() */
workspace/C/leetcode/src/704.c:int search(int *nums, int numsSize, int target)
workspace/C/leetcode/src/704.c:    int *ret = bsearch(&target, nums, numsSize, sizeof(int), cmpint);
workspace/C/leetcode/README.md:|35|[Search Insert Position](https://leetcode.com/problems/search-insert-position/) | [C](./src/35.c)|Easy|
workspace/C/leetcode/README.md:|108|[Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | [C](./src/108.c)|Easy|
workspace/C/leetcode/README.md:|109|[Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/) | [C](./src/109.c)|Medium|
workspace/C/leetcode/README.md:|173|[Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/) | [C](./src/173.c)|Medium|
workspace/C/leetcode/README.md:|700|[Search in a Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/) | [C](./src/700.c)|Easy|
workspace/C/leetcode/README.md:|701|[Insert into a Binary Search Tree](https://leetcode.com/problems/insert-into-a-binary-search-tree/) | [C](./src/701.c)|Medium|
workspace/C/leetcode/README.md:|704|[Binary Search](https://leetcode.com/problems/binary-search/) | [C](./src/704.c)|Easy|
workspace/C/DIRECTORY.md:    * [Binary Search Tree](https://github.com/TheAlgorithms/C/blob/master/data_structures/binary_trees/binary_search_tree.c)
workspace/C/DIRECTORY.md:  * [Binary Search](https://github.com/TheAlgorithms/C/blob/master/searching/binary_search.c)
workspace/C/DIRECTORY.md:  * [Fibonacci Search](https://github.com/TheAlgorithms/C/blob/master/searching/fibonacci_search.c)

De cele mai multe ori vom folosi opțiunile -n, -i și -r în aceelași timp. În cazul nostru de până acum, aceasta se traduce în:

student@uso:~$ grep -nri search workspace/C/ | less
 
workspace/C/leetcode/src/700.c:10:struct TreeNode *searchBST(struct TreeNode *root, int val)
workspace/C/leetcode/src/700.c:21:        return searchBST(root->left, val);
workspace/C/leetcode/src/700.c:25:        return searchBST(root->right, val);
workspace/C/leetcode/src/35.c:1:int searchInsert(int *nums, int numsSize, int target)
workspace/C/leetcode/src/35.c:18:int searchInsert(int *nums, int numsSize, int target)
workspace/C/leetcode/src/35.c:27:        return searchInsert(nums, numsSize - 1, target);
workspace/C/leetcode/src/704.c:1:int search(int *nums, int numsSize, int target)
workspace/C/leetcode/src/704.c:23:/* Another solution: Using bsearch() */
workspace/C/leetcode/src/704.c:26:int search(int *nums, int numsSize, int target)
workspace/C/leetcode/src/704.c:28:    int *ret = bsearch(&target, nums, numsSize, sizeof(int), cmpint);
workspace/C/leetcode/README.md:26:|35|[Search Insert Position](https://leetcode.com/problems/search-insert-position/) | [C](./src/35.c)|Easy|
workspace/C/leetcode/README.md:35:|108|[Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | [C](./src/108.c)|Easy|
workspace/C/leetcode/README.md:36:|109|[Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/) | [C](./src/109.c)|Medium|
workspace/C/leetcode/README.md:47:|173|[Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/) | [C](./src/173.c)|Medium|
workspace/C/leetcode/README.md:78:|700|[Search in a Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/) | [C](./src/700.c)|Easy|
workspace/C/leetcode/README.md:79:|701|[Insert into a Binary Search Tree](https://leetcode.com/problems/insert-into-a-binary-search-tree/) | [C](./src/701.c)|Medium|
workspace/C/leetcode/README.md:80:|704|[Binary Search](https://leetcode.com/problems/binary-search/) | [C](./src/704.c)|Easy|
workspace/C/.github/pull_request_template.md:20:- [ ] Search previous suggestions before making a new one, as yours may be a duplicate.
workspace/C/DIRECTORY.md:31:    * [Binary Search Tree](https://github.com/TheAlgorithms/C/blob/master/data_structures/binary_trees/binary_search_tree.c)
workspace/C/DIRECTORY.md:338:## Searching
:

Astfel avem o căutare cât mai cuprinzătoare și putem folosi funcția de căutare în sesiunea interactivă less pentru a găsi linia și fișierul care ne interesează.

Din rezultatele căutărilor de mai sus observăm că grep caută patternul dat ca un subșir. Acest lucru se vede foarte ușor în rezultatul anterior:

student@uso:~$ grep -nri search workspace/C/ | less
 
workspace/C/leetcode/src/700.c:10:struct TreeNode *searchBST(struct TreeNode *root, int val)

Observăm că patternul search se regăsește în șirul *searchBST. Dacă dorim să căutăm cuvântul search folosim opțiunea -w (word) pentru a-i transmite utilitarului că patternul trebuie tratat ca un cuvânt, ca în exemplul de mai jos:

student@uso:~$ grep -nri -w "search" workspace/C/ | less
 
workspace/C/leetcode/src/704.c:1:int search(int *nums, int numsSize, int target)
workspace/C/leetcode/src/704.c:26:int search(int *nums, int numsSize, int target)
workspace/C/leetcode/README.md:26:|35|[Search Insert Position](https://leetcode.com/problems/search-insert-position/) | [C](./src/35.c)|Easy|
[...]

Observăm că acum rezultatele conțin doar cuvântul search.

1. Găsiți toate fișierele care includ headerul stdio.h.
2. Găsiți toate aparițiile patternului binarySearch.
3. Găsiți toate aparițiile patternului quickSort.

Atunci când rulăm o comandă aceasta își poate încheia execuția în două moduri: cu succes sau cu eșec. Atunci când își încheie execuția, orice proces întoarce un cod de eroare, care este un număr:

• Dacă numărul întors are valoarea 0, procesul și-a încheiat execuția cu succes.
• Dacă numărul întors are orice altă valoare, procesul și-a încheiat execuția cu eroare, iar codul întors poate fi folosit pentru a afla mai multe informații despre eroarea pe care a întors-o procesul. În pagina man a utilitarului ls este specificat:

  Exit status:
         0      if OK,
   
         1      if minor problems (e.g., cannot access subdirectory),
   
         2      if serious trouble (e.g., cannot access command-line argument).

Pentru a vedea codul cu care și-a încheiat execuția o comandă folosim sintaxa $?. Urmărim exemplul de mai jos:

student@uso:~$ ls Desktop/
todos.txt
student@uso:~$ echo $?
0
student@uso:~$ ls non-existent
ls: cannot access 'non-existent': No such file or directory
student@uso:~$ echo $?
2

Observăm că în cazul fișierului inexistet, comanda ls non-existent a întors valoarea 2, așa cum era specificat și în pagina de manual.

De multe ori vrem să executăm o succesiune de comenzi pentru a realiza o sarcină. De exemplu, atunci când vrem să instalăm o aplicație o rulăm trei comenzi:

• O să actualizăm indexul surselor de pachete folosind apt update
• O să instalăm pachetul care conține aplicația folosind apt install
• O să rulăm aplicația pentru a valida că instalarea a fost cu succes.

Preferăm să înlănțuim cele trei comenzi într-una singură pentru că astfel putem să pornim tot acest proces, să plecăm de la calculator, iar când ne întoarcem avem tot sistemul pregătit.

Pentru a înlănțui comenzi în terminalul bash avem trei operatori disponibili:

• Operatorul ; - este folosit pentru separarea comenzilor Urmăm exemplul de mai jos:

  student@uso:~$ mkdir demo; cd demo; touch Hello; ls
  Hello

  În exemplul de mai sus am creat directorul demo, am navigat în interiorul său, am creat fișierul Hello și am afișat conținutul directorului. Am făcut toate acestea înlănțuind comenzile mkdir, cd, touch și ls cu ajutorul operatorului ;.

  Operatorul ; este folosit pentru separarea comenzilor, dar nu ține cont dacă comenzile anterioare au fost executate cu succes sau nu. Urmăm exemplul de mai jos:

  student@uso:~$ mkdir operators/demo; cd operators/demo
  mkdir: cannot create directory ‘operators/demo’: No such file or directory
  -bash: cd: operators/demo: No such file or directory

  În exemplul de mai sus, comanda mkdir a eșuat deoarece nu a găsit directorul operators în care să creeze directorul demo. Cu toate acestea, operatorul ; doar separă comenzile între ele, așa că și comanda cd operators/demo a fost executată, și și aceasta a eșuat deoarece nu există calea operators/demo.

  Folosim operatorul ; pentru a înlănțui comenzi care sunt independente unele de altele, și deci execuția lor nu depinde de succesul unei comenzi precedente.

• Operatorul binar && (și logic) - execută a doua comandă doar dacă precedenta s-a executat cu succes. Exemplul anterior devine:

  student@uso:~$ mkdir operators/demo && cd operators/demo
  mkdir: cannot create directory ‘operators/demo’: No such file or directory

  Observăm că din moment ce comanda mkdir a eșuat, comanda cd nu a mai fost executată.

• Operatorul binar || (sau logic) - execută a doua comandă doar dacă prima s-a terminat cu eșec. Urmărim exemplul de mai jos:

  student@uso:~$ (ls -d operators || mkdir operators) && ls -d operators
  ls: cannot access 'operators': No such file or directory
  operators
  student@uso:~$ (ls -d operators || mkdir operators) && ls -d operators
  operators
  operators

  În exemplul de mai sus, prima comandă ls a eșuat, așa că a fost executată comanda mkdir și apoi a fost executată ultima comandă ls. La cea de-a doua rulare, a fost executată cu succes prima comandă ls, așa că comanda mkdir nu a mai fost executată, și apoi a fost executată ultima comandă ls.

Pentru a rezolva scenariul de la care am plecat inițial, putem rula:

sudo apt update && sudo apt install -y cowsay && cowsay "Howdy"

Comanda de mai sus va actualiza indexul pachetelor sursă, va instala pachetul cowsay și va rula comanda cowsay pentru a valida instalarea. O astfel de înlănțuire de comenzi este numită oneliner.

1. Scrieți un oneliner cu ajutorul căruia creați directorul ~/uso-lab/labs/05-cli/support/make-folder și apoi copiați conținutul directorului ~/uso-lab/labs/05-cli/support/redir în el.
2. Actualizați onelinerul anterior astfel încât după copiere să pornească compilarea proiectului folosind comanda make build.

Așa cum am descoperit în secțiunile și capitolele anterioare, în mediul Linux avem multe utilitare care rezolvă o nevoie specifică: ls afișează informații despre fișiere, ps despre procese, grep filtrează, etc. Toate acestea au la bază filozofia mediului Linux: “do one thing and do it well”. Ca întodeauna, frumusețea stă în simplitate: avem o suită de unelte la dispoziție, fiecare capabilă să rezolve rapid o sarcină dată; pentru a rezolva o problemă mai complexă trebuie doar să îmbinăm uneltele.

Operatorul | (pipe) ne ajută să facem acest lucru. Atunci când folosim operatorul | preluăm rezultatul comenzii din stânga operatorului și îl oferim ca intrare comenzii aflate în dreapta operatorului.

Am folosit de mai multe ori operatorul | până acum:

• Am afișat informații despre procesele din sistem și am filtrat după numele unui proces:

  student@uso:~$ ps -e | grep firefox
  14912 pts/0    00:00:19 firefox

• Am extras primele zece procese care consumă cel mai mare procent de memorie:

  student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11
  USER       UID   PID %MEM %CPU   RSS CMD
  student   1000  7938 18.0  0.1 367952 /usr/bin/gnome-shell
  student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
  student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
  root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
  student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
  student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
  root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
  student   1000  8274  2.3  0.0 48296 nautilus-desktop
  root         0  1074  2.2  0.0 45460 /usr/bin/containerd
  student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server

Ne amintim de fișierul /etc/passwd conține informații despre toți utilizatorii din sistem.

student@uso:~$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
(...)

În Linux există filtrul de text cut prin care putem extrage doar anumite informații dintr-un output. Să zicem că vrem să extragem doar numele utilizatorilor, fără informațiile legate de grupuri sau home directory.

student@uso:~/uso-lab$ cat /etc/passwd | cut -f1 -d":"
root
daemon
bin
(...)

Argumentul -f1 specifică faptul că vrem prima coloană, iar argumentul -d: specifică delimitatorul de coloane, în cazul nostru :.

1. Pornind de la comanda de mai sus, afișați numele utilizatorilor sortați alfabetic. (Hint: man sort)
2. Folosind utilitarul wc, obțineți numărul de utilizatori din sistem. (Hint: man wc)
3. Să afișeze cele mai consumatoare de memorie 10 procese din sistem. (Hint: folosiți | și tail)

Majoritatea utilitarelor pe care le folosim afișează rezultatele operațiilor pe care le aplică la ieșirea standard, adică pe ecran. În continuare vom aprofunda ceea ce am discutat despre redirectări în capitolul Lucrul cu Fișiere. Anterior am mai menționat și termenul de intrare standard; în această secțiune ne vom clarifica ce înseamnă, ce rol îndeplinesc și cum ne folosim de aceste cunoștințe.

Orice proces folosește implicit trei fluxuri (streams) de date:

• STDIN - fluxul de intrare standard, referit și ca “citit de la tastatură”. Spunem că un program care citește date de intrare din linie de comandă, deci așteaptă de la utilizator, citește de la intrarea standard; de aici și denumirea “citit de la tastatură”. Complementul citirii de la tastatură este citirea datelor dintr-un fișier.
• STDOUT - fluxul de ieșire standard, referit și ca “afișare pe ecran”. Spunem că un program afișează datele de ieșire pe ecran, adică scrie rezultatele procesărilor efectuate la ieșirea standard. Complementul afișării pe ecran este scrierea rezultatelor într-un fișier.
• STDERR - fluxul de ieșire standard al erorilor. Un program corect scris o să scrie erorile în fluxul de ieșire al erorilor. Acest lucru permite filtrarea erorilor.

În linie de comandă, atât STDOUT cât și STDERR vor apărea pe ecran. Datorită faptului că informațiile sunt scrise în două fluxuri distincte, utilizatorul are posibilitatea de a separa rezultatele de erori. Utilizatorul face aceasta folosind redirectări.

Cum spuneam mai sus, majoritatea programelor pe care le folosim vor afișa rezultatele pe ecran. Acest comportament este bun atunci când ne scriem onelinerul care ne extrage informațiile căutate, dar cel mai probabil o să vrem să salvăm rezultatul procesării într-un fișier.

Folosim operatorul > pentru a redirecta STDOUT sau STDERR într-un fișier. Pentru fiecare flux de date avem un număr, numit descriptor de fișier, asociat:

• STDIN are asociat descriptorul de fișier 0
• STDOUT are asociat descriptorul de fișier 1
• STDERR are asociat descriptorul de fișier 2

Pentru a redirecta ieșirea standard folosim sintaxa cmd 1> nume-fișier. Pentru a redirecta ieșirea standard a erorilor folosim sintaxa cmd 2> nume-fișier.

Urmăm exemplul de mai jos:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11
USER       UID   PID %MEM %CPU   RSS CMD
student   1000  7938 18.0  0.1 367952 /usr/bin/gnome-shell
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
student   1000  8274  2.3  0.0 48296 nautilus-desktop
root         0  1074  2.2  0.0 45460 /usr/bin/containerd
student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server
student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11 1> top10-consumers
student@uso:~$ less top10-consumers

Am scris, prin încercări succesive, onelinerul care ne afișează primele zece procese care consumă cea mai multă memorie. Apoi am folosit sintaxa 1> top10-consumers pentru a redirecta rezultatul în fișierul top10-consumers.

Urmăm exemplul de mai jos pentru a redirecta erorile:

student@uso:~$ ls D* F* > out 2> errs
student@uso:~$ cat out
Desktop:
todos.txt
 
Documents:
snippets.git
uni
uso.tar
 
Downloads:
courses.tar
uso.tar
student@uso:~$ cat errs
ls: cannot access 'F*': No such file or directory

Observăm că am folosit sintaxa 2> errs pentru a redirecta erorile în fișierul errs. Observăm că pentru a redirecta ieșirea standard putem omite descriptorul de fișier, așa cum am făcut cu > out.

Atunci când rulăm o comandă, redirectăm erorile într-un fișier pentru că vrem să verificăm că totul s-a executat cu succes. De cele mai multe ori suntem în rumătorul scenariu:

1. Urmează să executăm o comandă care durează mai mult timp și pentru care nu putem să ținem pasul, cu ochiul liber, cu fluxul de afișare a datelor pe ecran. Un exemplu este compilarea unui proiect mai mare.
2. O să pornim procesul și o să redirectăm STDOUT și STDERR în două fișiere, de ex. out și err.
3. În timpul cât rulează noi putem să facem altceva: ne ocupăm de altă sarcină, ne facem o cafea, etc.
4. La finalul execuției inspectăm fișierele out și err pentru a vedea dacă au existat erori și le rezolvăm.

Implicit, operatoru > șterge (trunchează) conținutul fișierului destinație. Dacă vrem să păstrăm conținutul fișierului și să adăugăm rezultatul redirectării în continuarea acestuia, folosim operatorul >>.

Rulați din nou exemplele de mai sus folosind operatorul >> în locul operatorului >. Folosiți less pentru a inspecta fișierele de ieșire și de erori.

Pe sistemele Linux găsim un număr de fișiere speciale pe care le putem folosim în diferite scopuri:

• Fișierul /dev/null este un fișier care ignoră orice este scris în el. Este echivalentul unei găuri negre în sistemul nostru. Cu ajutorul său, putem rescrie exemplul de mai sus în modul următor:

  student@uso:~$ firefox &> /dev/null &
  [1] 10349
  student@uso:~$ firefox > /dev/null 2>&1 &
  [2] 10595

  Acum orice va genera firefox va fi scris în /dev/null, care va consuma textul primit fără a ocupa spațiu pe disc.

• Fișierul /dev/zero este un generator de octeți. Acesta generează atâția octeți cu valoarea zero (0)¹⁾ cât îi sunt ceruți. Urmăm exemplul:

  student@uso:~$ cat /dev/zero | xxd
  00000000: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000010: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000020: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000030: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000040: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000050: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000060: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000070: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  00000080: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  [...]
  ^C

  Deoarece citim din generator, comanda cat va afișa o infinitate de octeți cu valoarea zero. Utilitarul xxd afișează în hexazecimal textul primit la STDIN. Trecem rezultatul lui cat prin xxd deoarece valoarea 0 nu este un caracter printabil. Cu alte cuvinte nu este un caracter obișnuit, ca cele de pe tastatură, deoarece nu are un echivalent grafic. Folosim Ctrl+c pentru a opri execția.

  Exercițiu: Rulați comanda cat /dev/zero pentru a înțelege nevoia utilitarului xxd din exemplul de mai sus.

  • Fișierul /dev/urandom este un alt generator de octeți.

  </blockquote></HTML>

  Acesta generează atâția octeți cu valoare random cât îi sunt ceruți.

  Exercițiu: Rulați comenzile din exemplul anterior, dar acum citiți din /dev/urandom.

Generatoarele de octeți sunt utile pentru a testa aplicațiile pe care le dezvoltăm. Majoritatea aplicațiilor pe care le vom scrie, ca și cele pe care le utilizăm, citesc și prelucrează informații. Testăm o aplicație pentru că vrem să verificăm că nu avem buguri. Pentru aceasta putem să folosim seturi de date de intrare cât mai variate și mai aleatoare, adică inputuri random. Folosim utilitarul dd pentru a genera un fișier de 100 MB cu octeți random, ca în exemplul de mai jos:

student@uso:~$ dd if=/dev/urandom of=rand-100mb count=100 bs=1M
100+0 records in
100+0 records out
104857600 bytes (105 MB, 100 MiB) copied, 1,11416 s, 94,1 MB/s
student@uso:~$ ls -lh rand-100mb
-rw-rw-r-- 1 student student 100M nov  8 17:49 rand-100mb

Am folosit următoarele opțiuni ale utilitarului dd:

• if - input file - calea către fișierul de unde citim
• of - output file - calea către fișierul unde scriem
• bs - block size - dimensiunea unui block citit din if
• count - block count - numărul de block-uri citite

Exercițiu: Creați un fișier numit rand-250mb folosind utilitarul dd.

1. Afișați primele zece procese sortate în funcție de memoria ocupată (Hint: RSS). Nu uitați să includeți antetul. Redirectați rezultatul în fișierul top10-rss-consumers. Modificați comanda astfel încât rezultatul redirectării să nu șteargă conținutul existent.
2. Afișați ultimele zece procese sortate în funcție de utilizarea procesorului (Hint: CPU). Nu uitați să includeți antetul. Redirectați rezultatul în fișierul top10-cpu-consumers. Modificați comanda astfel încât rezultatul redirectării să nu șteargă conținutul existent.

Note de subsol