O zi bună, dragi cititori ai blogului nostru! Pe site-ul nostru, am atins deja subiectul matricelor și acesta a fost un exemplu despre cum se face . A existat, de asemenea, un articol despre cum au fost folosite și matricele pentru a rezolva această problemă. Și astăzi vom vorbi despre cum se sortează o matrice multidimensională. Asadar, haideti sa începem.
Să luăm o matrice „bunuri” de următoarea formă:

200, "manufacture" => "TOO Tselina"); $bunuri = matrice("preț" => 400, "producție" => "IP Devyatkin"); $bunuri = matrice("preț" => 800, "producție" => "JSC Agrarnik"); $bunuri = matrice("preț" => 790, "producție" => "ZAO Krasny Vostok"); ?>

Trebuie să sortați această matrice după cheie. Pentru a face acest lucru, folosim funcția „ksort”:

xsort($bunuri); print_r($marfa); ?>

Ca rezultat, obținem o matrice sortată după cheie:

Array ( => Array ( => 400 => IP Devyatkin) => Array ( => 200 => Tselina LLP) => Array ( => 800 => JSC Agrarnik) => Array ( => 790 => CJSC Krasny Vostok ))

După cum puteți vedea, cheile sunt în ordine crescătoare de la 45 la 89. Acum trebuie să sortăm matricea după valoarea tastei „preț”. Pentru a face acest lucru, vom folosi funcția „uasort” și vom scrie o funcție personalizată. „sort_p” pentru el:

sort_p($a, $b) ( returnează strcmp($a[„prețul”], $b[„prețul”]); ) uasort($ bunuri, "sort_p"); print_r($marfa); ?>

Ca rezultat, obținem o matrice sortată după cheia „preț”:

Matrice ( => Matrice ( => 200 => Tselina LLP) => Array ( => 400 => IP Devyatkin) => Array ( => 790 => ZAO Krasny Vostok) => Array ( => 800 => JSC Agrarnik))

După cum puteți vedea, valorile tastei „preț” sunt în ordine crescătoare de la 200 la 800. Pentru a modifica valorile tastei „preț” în ordine inversă, în ordine descrescătoare, schimbăm parametrii de funcția „strcmp” din funcția definită de utilizator „sort_p”:

b[„preț”], $ A["Preț"]); ) uasort($bunuri, "sort_p"); print_r($marfa); ?>

Obtinem urmatorul rezultat:

Matrice ( => Matrice ( => 800 => JSC Agrarnik) => Matrice ( => 790 => ZAO Krasny Vostok) => Array ( => 400 => IP Devyatkin) => Array ( => 200 => Tselina LLP))

După cum puteți vedea, acum valorile cheii „preț” sunt în ordine descrescătoare de la 800 la 200. Acum trebuie să sortăm matricea după valoarea celor două chei „producție” și „preț”, pentru aceasta va scrie o funcție personalizată „sort_pm”:

sort_pm($a, $b) ( $r1 = strcmp($a["producție"], $b["producție"]$a["preț"], $b["preț"]) : $r1; ) uasort ($bunuri, "sort_pm"); print_r($marfa); ?>

Acum sortarea are loc după valorile celor două chei în ordine crescătoare, prioritatea este cheia „producție”.

Matrice ( => Matrice ( => 800 => JSC Agrarnik) => Array ( => 790 => CJSC Krasny Vostok) => Array ( => 400 => IP Devyatkin) => Array ( => 200 => Tselina LLP))

Dacă preferați valorile tastei „preț”, atunci schimbați parametrii funcțiilor „strcmp” și scrieți funcția „sort_pm” după cum urmează:

$a[„preț”], $b[„preț”]); return ($r1 == 0) ? strcmp(): $r1; ) uasort($bunuri, "sort_pm"); print_r($marfa); ?>

Adică, parametrii funcțiilor „strcmp” au fost modificați. Acum vor fi prioritizate valorile tastei „preț”, ceea ce înseamnă că sortarea va fi efectuată în primul rând de către aceștia, apoi valorile cheii „producție” vor fi sortate. Să explicăm cu următorul exemplu:

200, "manufacture" => "TOO Tselina"); $bunuri = matrice("preț" => 400, "producție" => "IP Devyatkin"); $bunuri = matrice("preț" => 400, "producție" => "Vacanță AO");$bunuri = matrice("preț" => 800, "producție" => "JSC Agrarnik"); $bunuri = matrice("preț" => 790, "producție" => "ZAO Krasny Vostok"); funcția sort_pm($a, $b) ( $r1 = strcmp( $a[„preț”], $b[„preț”]); return ($r1 == 0) ? strcmp( $a[„producție”], $b[„producție”]): $r1; ) uasort($bunuri, "sort_pm"); print_r($marfa); ?>

Sortare matrice este procesul de distribuire a tuturor elementelor într-o anumită ordine. Foarte des, acest lucru este util. De exemplu, în căsuța dvs. de e-mail, e-mailurile sunt afișate în funcție de ora la care au fost primite; scrisorile noi sunt considerate mai relevante decât cele pe care le-ați primit cu o jumătate de oră, o oră, două sau o zi în urmă; când accesați lista de contacte, numele sunt de obicei în ordine alfabetică, deoarece este mai ușor să găsiți ceva în acest fel. Toate aceste cazuri implică sortarea datelor înainte de a le scoate efectiv.

Cum funcționează sortarea?

Sortarea datelor poate face căutarea într-o matrice mai eficientă, nu numai pentru oameni, ci și pentru computere. De exemplu, luați în considerare cazul în care trebuie să știm dacă un anumit nume apare într-o listă de nume. Pentru a afla, trebuie să verificăm fiecare element al matricei cu valoarea noastră. Căutarea într-o matrice cu multe elemente poate fi prea ineficientă (costisitoare).

Cu toate acestea, să presupunem că matricea noastră de nume este sortată alfabetic. Apoi căutarea noastră începe cu prima literă a valorii noastre și se termină cu următoarea literă din alfabet. În acest caz, dacă am ajuns la această literă și nu am găsit numele, atunci știm sigur că nu se află în restul matricei, deoarece am parcurs deja scrisoarea noastră în ordine alfabetică!

Nu este un secret pentru nimeni că există algoritmi de căutare mai buni în matricele sortate. Folosind un algoritm simplu, putem căuta un anumit element într-o matrice sortată care conține 1.000.000 de elemente folosind doar 20 de comparații! Dezavantajul, desigur, este că sortarea unei matrice cu un număr atât de mare de elemente este relativ costisitoare și cu siguranță nu se face pentru o singură interogare de căutare.

În unele cazuri, sortarea unei matrice face căutarea inutilă. De exemplu, căutăm cel mai bun punctaj al unui student la un test. Dacă matricea nu este sortată, atunci va trebui să trecem prin fiecare element al matricei pentru a găsi cel mai mare scor. Dacă matricea este sortată, atunci cel mai mare scor va fi fie în prima poziție, fie în ultima (în funcție de metoda de sortare a matricei: ordine crescătoare sau descrescătoare), deci nu trebuie să căutăm deloc!

Sortarea se face de obicei prin recompararea perechilor de elemente ale matricei și înlocuirea valorilor dacă acestea îndeplinesc anumite criterii. Ordinea în care aceste elemente sunt comparate depinde de algoritmul de sortare utilizat. Criteriile constau în modul în care va fi sortată matricea (de exemplu, în ordine crescătoare sau în ordine descrescătoare).

Pentru a schimba două elemente, putem folosi funcția std::swap() din biblioteca standard C++, care este definită în algoritm. În C++11, std::swap() a fost mutat în fișierul antet al utilitarului:

#include #include int main() ( int a = 3; int b = 5; std::cout<< "Before swap: a = " << a << ", b = " << b << "\n"; std::swap(a, b); // меняем местами значения переменных a и b std::cout << "After swap: a = " << a << ", b = " << b << "\n"; }

Rezultatul rulării programului de mai sus este:

Înainte de schimbare: a = 3, b = 5
După schimbare: a = 5, b = 3

După operația de înlocuire, valorile variabilelor a și b sunt schimbate.

Sortarea tablourilor după metoda de selecție

Există multe moduri de a sorta matrice. Tipul de matrice de selecție este poate cel mai ușor de înțeles, deși unul dintre cele mai lente.

Pentru sortarea unui tablou prin metoda de selecție de la cel mai mic la cel mai mare element se efectuează următorii pași:

Începând de la elementul de la indicele 0, căutăm în matrice cea mai mică valoare.

Valoarea găsită este schimbată cu un element nul.

Repetați pașii #1 și #2 pentru următorul index din matrice.

Cu alte cuvinte, căutăm cel mai mic element din matrice și îl mutăm în prima poziție. Apoi căutăm al doilea cel mai mic element și îl mutăm pe locul doi după primul cel mai mic element. Acest proces continuă până când matricea rămâne fără elemente nesortate.

Iată un exemplu despre cum funcționează acest algoritm într-o matrice cu 5 elemente:

{ 30, 50, 20, 10, 40 }

În primul rând, căutăm cel mai mic element, începând cu indicele 0:

{ 30, 50, 20, 10 , 40 }

Apoi schimbați cel mai mic element cu elementul de la indicele 0:

{ 10 , 50, 20, 30 , 40 }

Acum că primul element al matricei este sortat, îl ignorăm. Căutăm următorul element cel mai mic, dar pornind de la indicele 1:

{ 10 , 50, 20 , 30, 40 }

Și schimbați-l cu elementul de la indexul 1:

{ 10 , 20 , 50 , 30, 40 }

Acum putem ignora primele două elemente. Căutând următorul element cel mai mic, începând cu indicele 2:

{ 10 , 20 , 50, 30 , 40 }

Și schimbați-l cu elementul de la indexul 2:

{ 10 , 20 , 30 , 50 , 40 }

Căutând următorul cel mai mic element, începând cu indicele 3:

{ 10 , 20 , 30 , 50, 40 }

Și schimbați-l cu elementul de la indexul 3:

{ 10 , 20 , 30 , 40 , 50 }

Căutând următorul cel mai mic element, începând cu indicele 4:

{ 10 , 20 , 30 , 40 , 50 }

Și îl schimbăm cu elementul de la indicele 4 (se efectuează auto-înlocuirea, adică nu facem nimic):

{ 10 , 20 , 30 , 40 50 }

{ 10, 20, 30, 40, 50 }

Rețineți că ultima comparație va fi întotdeauna o singură comparație (adică auto-înlocuire), care este o operație suplimentară, astfel încât să putem opri sortarea înainte de ultimul element al matricei.

Sortarea matricelor după metoda de selecție în C++

Iată cum este implementat acest algoritm în C++:

#include #include // pentru std::swap. În C++11 utilizați antetul int main() ( const int lungime = 5; int array = ( 30, 50, 20, 10, 40 ); // Buclă prin fiecare element al matricei // (cu excepția ultimului, acesta va fi deja sortat după când ajungem acolo) pentru (int startIndex = 0; startIndex< length - 1; ++startIndex) { // В переменной smallestIndex хранится индекс наименьшего значения, которое мы нашли в этой итерации // Начинаем с того, что наименьший элемент в этой итерации - это первый элемент (индекс 0) int smallestIndex = startIndex; // Затем ищем элемент поменьше в остальной части массива for (int currentIndex = startIndex + 1; currentIndex < length; ++currentIndex) { // Если мы нашли элемент, который меньше нашего наименьшего элемента, if (array < array) // то запоминаем его smallestIndex = currentIndex; } // smallestIndex теперь наименьший элемент // Меняем местами наше начальное наименьшее число с тем, которое мы обнаружили std::swap(array, array); } // Теперь, когда весь массив отсортирован - выводим его на экран for (int index = 0; index < length; ++index) std::cout << array << " "; return 0; }

Cea mai confuză parte a acestui algoritm se află în interiorul unei alte bucle (așa-numita buclă imbricată). Bucla exterioară (startIndex) iterează prin elemente unul câte unul (la rândul său). În fiecare iterație a buclei exterioare, bucla interioară (currentIndex) este folosită pentru a găsi cel mai mic element dintre elementele rămase în matrice (începând de la startIndex + 1). smallestIndex ține evidența indexului celui mai mic element găsit de bucla interioară. Apoi smallestIndex este schimbat din startIndex . Și, în sfârșit, bucla exterioară (startIndex) trece acest element și procesul se repetă.

Cheie: Dacă întâmpinați dificultăți în a înțelege cum funcționează programul de mai sus, încercați să îl notați pe o bucată de hârtie. Scrieți elementele inițiale (nesortate) ale matricei pe orizontală într-un rând în partea de sus a foii de lucru. Desenați săgeți care indică elementele startIndex , currentIndex și smallestIndex în acest moment. Derulați manual programul și redesenați săgețile pe măsură ce indicii se modifică. După fiecare iterație a buclei exterioare, trageți o nouă linie care arată starea curentă a matricei (locația elementelor sale).

Sortarea textului se realizează folosind același algoritm. Doar schimbați tipul matricei de la -a la și inițializați-l cu valorile corespunzătoare.

std::sort()

Deoarece operația de sortare a matricei este foarte comună, biblioteca standard C++ oferă o funcție de sortare încorporată - std::sort(). Acesta se află în fișierul antet algoritm și este numit după cum urmează:

#include #include // pentru std::sort int main() (const int lungime = 5; int array = ( 30, 50, 20, 10, 40); std::sort(array, array+length); pentru (int i= 0 i< length; ++i) std::cout << array[i] << " "; return 0; }

Test

Sarcina numărul 1

Scrieți pe o bucată de hârtie cum să sortați următoarea matrice folosind metoda de selecție (cum am făcut mai sus):

{30, 60, 20, 50, 40, 10}

Raspunsul 1

30 60 20 50 40 10
10 60 20 50 40 30
10 20 60 50 40 30
10 20 30 50 40 60
10 20 30 40 50 60
10 20 30 40 50 60 (auto-înlocuire)
10 20 30 40 50 60 (auto-înlocuire)

Sarcina numărul 2

Rescrieți codul în subtitlul „C++ Selection Sorting of Arrays”, astfel încât sortarea să se facă în ordine descrescătoare (de la cel mai mare la cel mai mic). Deși poate părea complicat la prima vedere, este de fapt foarte simplu.

Răspunsul #2

Doar schimba:

Dacă (matrice< array)

Dacă (matrice > matrice)

De asemenea, smallestIndex ar trebui redenumit în cel mai mareIndex:

#include #include // pentru std::swap. În C++11 utilizați antetul int main() (const int lungime= 5; int array = ( 30, 50, 20, 10, 40); // Buclă prin fiecare element de matrice, cu excepția ultimului pentru (int startIndex = 0; startIndex< length - 1; ++startIndex) { // largestIndex - это индекс наибольшего элемента, который мы обнаружили до сих пор int largestIndex = startIndex; // Перебираем каждый элемент массива начиная со startIndex + 1 for (int currentIndex = startIndex + 1; currentIndex < length; ++currentIndex) { // Если текущий элемент больше нашего наибольшего элемента, if (array >array) // atunci acesta este noul cel mai mare element din această iterație. ) // Schimbați numărul nostru de început cu cel mai mare element găsit std::swap(array, array); ) pentru (int index = 0; index< length; ++index) std::cout << array << " "; return 0; }

Sarcina numărul 3

Această sarcină este deja puțin mai dificilă.

O altă metodă simplă de sortare a elementelor este "sortare cu bule"(sau mai mult "sortare cu bule"). Linia de jos este să comparați o pereche de valori care sunt în apropiere, iar dacă criteriile specificate sunt îndeplinite, valorile din această pereche sunt schimbate. Și astfel elementele „bulbează” până la sfârșitul matricei. Deși există mai multe moduri de a optimiza sortarea cu bule, vom rămâne cu versiunea neoptimizată pentru această provocare, deoarece este mai simplă.

Cu o versiune neoptimizată de sortare cu bule, se parcurg următorii pași sortarea unui tablou de la cea mai mică la cea mai mare valoare:

Elementul de matrice de la indicele 0 este comparat cu elementul de matrice de la indicele 1. Dacă elementul de la indicele 0 este mai mare decât elementul de la indicele 1, atunci valorile sunt schimbate.

Apoi trecem la următoarea pereche de valori: elementul de la indexul 1 și elementul de la indexul 2 și așa mai departe până ajungem la sfârșitul matricei.

Repetați pasul #1 și pasul #2 până când întreaga matrice este sortată.

Scrieți un program care sortează cu bule următoarea matrice conform regulilor de mai sus:

const int lungime(9); int matrice = ( 7, 5, 6, 4, 9, 8, 2, 1, 3 );

La sfârșitul programului, scoateți elementele sortate ale matricei.

Cheie: Dacă putem sorta doar un element pe iterație, atunci aceasta înseamnă că va trebui să repetăm ​​bucla de câte ori există numere în matricea noastră (lungimea sa) pentru a ne asigura că întreaga matrice este sortată.

Răspunsul #3

#include #include // pentru std::swap. În C++11 utilizați antetul int main() (const int length(9); int matrice = (7, 5, 6, 4, 9, 8, 2, 1, 3); for (int iterație = 0; iterație< length-1; ++iteration) { // Перебираем каждый элемент массива до последнего элемента (не включительно) // Последний элемент не имеет пары для сравнения for (int currentIndex = 0; currentIndex < length - 1; ++currentIndex) { // Если текущий элемент больше элемента после него, то меняем их местами if (array >matrice) std::swap(matrice, matrice); ) ) // Afișează matricea sortată pe ecran pentru (index int = 0; index< length; ++index) std::cout << array << " "; return 0; }

Sarcina numărul 4

Implementați următoarele două soluții de optimizare pentru algoritmul de sortare cu bule pe care l-ați scris în sarcina anterioară:

Rețineți că de fiecare dată când se efectuează sortarea cu bule, cea mai mare valoare din matrice „bulează” până la sfârșit. După prima iterație, ultimul element al matricei este deja sortat. După a doua iterație, penultimul element al matricei este sortat și așa mai departe. Cu fiecare nouă iterație, nu trebuie să verificăm din nou elementele care au fost deja sortate. Modificați-vă bucla pentru a nu verifica din nou elementele care au fost deja sortate.

Instruire

Există mai multe moduri de a sorta o matrice. Cel mai simplu pentru algoritmizare este sortarea „bubble”, dar este și una dintre cele mai lente. Esența acestei metode este de a trece succesiv prin matricea de date și de a compara fiecare pereche de elemente. Dacă elementul copil este mai mic decât cel anterior, pozițiile sunt schimbate. Apoi algoritmul începe de la capăt. Un exemplu de sortare a codului în limbaj C:

int masa;
intel_min=10;

pentru (int i=0; ii; j--)
dacă (mai puțin(masă [j], masă ))
swap(masa [j], masa );
}

Unul dintre algoritmii optimi pentru sortarea unui tablou în ordine crescătoare este ordonarea inserției. Esența algoritmului este de a forma o secvență dată între un grup de elemente (în ordine crescătoare). Un handler special într-o buclă verifică matricea pentru ordine. Pentru a sorta în ordine crescătoare, este specificată următoarea condiție. Dacă următorul element este mai mic decât precedentul, acesta este scos din locul său și plasat în cel care corespunde valorii sale. Un exemplu de cod al programului pentru sortarea în ordine crescătoare în limbajul C:

int Kol = 40;
intmass, k;

pentru (int i = 1, j=0; i(
k = masa [i]; // variabilă auxiliară pentru stocarea elementului de matrice
j = i - 1;
în timp ce(k(
masa = masa[j];
j--;
dacă (jmass = k;
}
}

O altă metodă de sortare frecvent utilizată este algoritmul de sortare prin căutarea elementului minim sau maxim dintr-o matrice. La sortarea în ordine crescătoare, în momentul primei treceri prin matrice, elementul acestuia cu cea mai mică valoare este găsit și plasat la începutul matricei. În locul lui se instalează elementul care ocupa anterior prima poziție. După o analiză suplimentară a matricei, locul ocupat este exclus. Următorul element minim este căutat, plasat pe locul doi și așa mai departe, până când întregul tablou este sortat. Cod pentru sortare prin găsirea elementului minim al listei:

intmass, bb;
int Kol = 30, min, pos;

pentru (int i = 0; i(
min = masa[i];
pos = i;
pentru (int j=0; j (
dacă (masa [j] (
min = masa[j];
pos = j;
}
bb = masa[i];
masa[i] = masa;
masa = bb;
}
}

Modul în care sunt ordonate elementele matricei depinde de instrumentele pe care le aveți la dispoziție. Următoarele sunt câteva opțiuni pentru a comanda matrice unidimensionale folosind cel mai comun limbaj de programare pe partea de server, PHP. Nu este necesar să se creeze funcții pentru iterarea elementelor de matrice, compararea acestora și atribuirea de noi valori atunci când se utilizează acest limbaj - toate acestea se realizează prin funcții încorporate.

Instruire

Utilizați funcția sort() dacă trebuie să sortați datele într-o matrice în ordine crescătoare. De exemplu: $valori = matrice (58, 15, 2.41, 26, 30);
sort($values);Ca urmare a aplicației, locația datelor în matrice se va schimba - va deveni astfel: (2.41, 15, 26, 30, 58). Dacă semnalul SORT_STRING este adăugat la apelul funcției, atunci funcția va considera datele matricei ca șiruri de caractere și le va alinia cu . Deoarece caracterul variabilei șir „2.41” este situat mai departe în alfabet decât primul caracter al variabilei șir „15”, după aplicarea funcției sort($values, SORT_STRING), variabilele se vor alinia diferit: (15, 2,41, 26, 30, 58).

Utilizați funcția rsort() dacă trebuie să sortați matricea în ordinea descrescătoare a valorilor sale. Această funcție diferă de cea descrisă în primul pas doar în ordinea de sortare.

Utilizați funcția asort() atunci când doriți să sortați în ordine crescătoare valorile unui tablou numit (asociativ) fără a modifica mapările originale dintre index și valoarea fiecărui element de matrice. De exemplu: $valori = matrice ("unu" => 58, "două" => 15, "trei" => 2.41, "patru" => 26, "cinci" => 30);
asort($values); Ca urmare, ordinea elementelor matricei va fi: ("trei" => 2.41, "două" => 15, "patru" => 26, "cinci" => 30, "unu " => 58 ). În caz contrar, această funcție nu diferă de funcția de sortare descrisă în primul pas. Pentru a sorta în mod similar elementele în ordine descrescătoare, utilizați funcția arsort().

Când lucrați pe multe site-uri, problema sortării datelor matricei în ordine alfabetică este adesea întâlnită. Mulți oameni scriu tablouri suplimentare pentru aceasta, compară tabele mari și sortează fiecare nume... Această opțiune nu este cea mai bună, deși o vom lua în considerare și noi. În acest articol, aș dori să vă ofer cea mai simplă și mai scurtă cale, care, dacă citiți cu atenție manualele, o găsiți în documentație.

Matrice alfabetică PHP

Cod PHP

setlocale(LC_ALL, „Russian_Russia.1251”); // setați localitatea pentru literele rusești

// un exemplu de matrice în care cuvintele NU sunt în ordine
$example=array("jar","Boris","vedere","profil","vânător","Fyodor","soție","voce");

Natcasesort($exemplu, SORT_LOCALE_STRING); // sortați matricea NU ține cont de majuscule și minuscule
// PENTRU diferențierea majusculelor, folosiți sort în loc de natcasesort

// afișează rezultatul
foreach ($exemplu ca $key => $valoare)(
echo „$valoare”(!LANG:; // afișează numai cuvinte, fără index
}
?>

Demonstrație Descărcați surse
Puteți vedea cum funcționează scriptul în demo. Dacă doriți, puteți descărca și arhiva cu fișierul.

Dacă serverul dvs. nu este pe Windows, atunci va trebui să instalați alte localități sau mai multe simultan:

(LC_ALL, „ru_RU.CP1251”, „rus_RUS.CP1251”, „Russian_Russia.1251”);
// Imprimă ru_RU.CP1251 pentru FreeBSD
// Afișează rus_RUS.CP1251 pentru Linux
// Rezultă Russian_Russia.1251 pentru Windows

Voi trece înaintea uneia dintre întrebări cu un răspuns - localitatea pentru Ucraina în PHP arată astfel:

// Setați localurile pentru Windows

// Codificare Windows-1251
setlocale(LC_ALL, „Russian_Russia.1251”);

// Codificare KOI8-R
setlocale(LC_ALL, „Russian_Russia.20866”);

// Codificare UTF-8 (utilizați cu grijă)
setlocale(LC_ALL, „Russian_Russia.65001”);
?>

A doua modalitate de a alfabetiza o matrice PHP

Cod PHP

=> a
=> b
=> in
=> g
=> q
=> e
=> yo
=> w
=> h
=> și
=> th
=> la
=> l
=> m
=> n
=> despre
=> n
=> p
=> cu
=> t
=> y
=> f
=> x
=> c
=> h
=> w
=> u
=> b
=> s
=> b
=> e
=> da
=> i
Și repetă peste prima literă a celei de-a doua matrice.
Prima literă a oricărui element al matricei se calculează după cum urmează:

Cod PHP

$city="Moscova"; // de exemplu element cu index 1

$prima_litera = mb_substr($oraș,0,1,"UTF-8"); // obține litera „M”
Deoarece lucrăm cu litere rusești (codare pe mai mulți octeți), este mai bine să folosim funcția mb_substr, iar la final este mai bine să specificați codificarea exactă a datelor variabilei sau matricei, în cazul nostru UTF-8.

Vă mulțumim pentru atenție! Sper că informațiile au fost de ajutor. Dacă aveți întrebări, atunci scrieți în comentarii.