Tablice typu string i char w C# – https://school-it.pl/

Tablice typu `string`

Tablice typu string[] przechowują ciągi znaków, czyli teksty. Mogą być używane do przechowywania listy imion, słów, zdań itp.

Deklaracja i inicjalizacja tablicy `string`

Deklaracja:

string[] imiona;

Inicjalizacja z określeniem rozmiaru:

imiona = new string[3]; // Tablica może przechowywać 3 ciągi znaków

Deklaracja i inicjalizacja z wartościami początkowymi:

string[] imiona = new string[] {"Anna", "Jan", "Katarzyna"};

Lub prościej:

string[] imiona = {"Anna", "Jan", "Katarzyna"};

Zapisywanie danych do tablicy `string`

Przykład:

imiona[0] = "Piotr";
imiona[1] = "Marta";
imiona[2] = "Tomasz";

Użycie pętli do wprowadzania danych przez użytkownika:

for (int i = 0; i < imiona.Length; i++)
{
    Console.Write($"Podaj imię dla indeksu {i}: ");
    imiona[i] = Console.ReadLine();
}

Odczyt danych z tablicy `string`

Przykład:

for (int i = 0; i < imiona.Length; i++)
{
    Console.WriteLine($"Indeks {i}: {imiona[i]}");
}

Odczyt kontrolowany przez instrukcję `if`

Przykład: Wyświetlanie imion zaczynających się na literę 'A’:

for (int i = 0; i < imiona.Length; i++)
{
    if (imiona[i].StartsWith("A"))
    {
        Console.WriteLine(imiona[i]);
    }
}

`string.StartsWith(string value)`

Sprawdza, czy łańcuch znaków zaczyna się od określonego ciągu znaków.

Szukanie elementu w tablicy `string`

Przykład: Szukanie imienia „Marta” w tablicy:

string szukaneImie = "Marta";
bool znaleziono = false;

for (int i = 0; i < imiona.Length; i++)
{
    if (imiona[i] == szukaneImie)
    {
        znaleziono = true;
        Console.WriteLine($"Znaleziono imię {szukaneImie} na indeksie {i}.");
        break;
    }
}

if (!znaleziono)
{
    Console.WriteLine($"Imię {szukaneImie} nie zostało znalezione w tablicy.");
}

Tablice typu `char`

Tablice typu char[] przechowują pojedyncze znaki. Są przydatne, gdy chcemy pracować na poziomie pojedynczych liter lub symboli.

Deklaracja i inicjalizacja tablicy `char`

char[] litery;

Inicjalizacja z określeniem rozmiaru:

litery = new char[5]; // Tablica może przechowywać 5 znaków

Deklaracja i inicjalizacja z wartościami początkowymi:

char[] litery = new char[] {'a', 'e', 'i', 'o', 'u'};

Lub prościej:

char[] litery = {'a', 'e', 'i', 'o', 'u'};

Zapisywanie danych do tablicy `char`

Przykład:

litery[0] = 'X';
litery[1] = 'Y';
litery[2] = 'Z';

Użycie pętli do wprowadzania danych przez użytkownika:

for (int i = 0; i < litery.Length; i++)
{
    Console.Write($"Podaj znak dla indeksu {i}: ");
    litery[i] = Console.ReadKey().KeyChar;
    Console.WriteLine();
}

Odczyt danych z tablicy char
Przykład:

for (int i = 0; i < litery.Length; i++)
{
    Console.WriteLine($"Indeks {i}: {litery[i]}");
}

Przykład z tablicą `char[]`

Analiza znaków wprowadzonych przez użytkownika

using System;

class Program
{
    static void Main()
    {
        // Deklaracja i inicjalizacja tablicy
        char[] znaki = new char[5];

        // Wprowadzanie znaków przez użytkownika
        for (int i = 0; i < znaki.Length; i++)
        {
            Console.Write($"Podaj znak dla indeksu {i}: ");
            znaki[i] = Console.ReadKey().KeyChar;
            Console.WriteLine();
        }

        // Wyświetlanie wszystkich znaków
        Console.WriteLine("\nZawartość tablicy:");
        for (int i = 0; i < znaki.Length; i++)
        {
            Console.WriteLine($"Indeks {i}: '{znaki[i]}'");
        }

        // Wyświetlanie tylko cyfr
        Console.WriteLine("\nZnaki będące cyframi:");
        for (int i = 0; i < znaki.Length; i++)
        {
            if (char.IsDigit(znaki[i]))
            {
                Console.WriteLine($"Indeks {i}: '{znaki[i]}'");
            }
        }

        // Szukanie konkretnego znaku
        Console.Write("\nPodaj znak do wyszukania: ");
        char szukanyZnak = Console.ReadKey().KeyChar;
        Console.WriteLine();
        bool znaleziono = false;

        for (int i = 0; i < znaki.Length; i++)
        {
            if (znaki[i] == szukanyZnak)
            {
                znaleziono = true;
                Console.WriteLine($"Znaleziono znak '{szukanyZnak}' na indeksie {i}.");
                break;
            }
        }

        if (!znaleziono)
        {
            Console.WriteLine($"Znak '{szukanyZnak}' nie został znaleziony w tablicy.");
        }
    }
}

`char.IsDigit(char c)`

Sprawdza, czy podany znak jest cyfrą (0-9).

Dodatkowe informacje

Praca z tablicami znaków a łańcuchami znaków

Łańcuch znaków (string) jest sekwencją znaków, ale w C# jest to typ niezmienny (immutable).
Tablica znaków (char[]) pozwala na modyfikowanie poszczególnych znaków.

Konwersja string na char[]:

string tekst = "Hello";
char[] znaki = tekst.ToCharArray();

Konwersja char[] na string:

char[] litery = {'H', 'e', 'l', 'l', 'o'};
string tekst = new string(litery);

Przykład: Odwracanie tekstu

Odwracanie ciągu znaków za pomocą tablicy char[]:

string tekst = "Programowanie";
char[] znaki = tekst.ToCharArray();
Array.Reverse(znaki);
string odwróconyTekst = new string(znaki);

Console.WriteLine($"Oryginalny tekst: {tekst}");
Console.WriteLine($"Odwrócony tekst: {odwróconyTekst}");

`Array.Reverse<T>(T[] array)`

Odwraca kolejność elementów w tablicy.

Ćwiczenie: Zmiana wielkości liter z wykorzystaniem kodów ASCII

Napisz program, który zamienia wszystkie małe litery w tekście na duże i odwrotnie, wykorzystując operacje na kodach ASCII.

Implementacja

using System;

class Program
{
    static void Main()
    {
        Console.Write("Podaj tekst: ");
        string tekst = Console.ReadLine();
        string zmienionyTekst = "";

        foreach (char c in tekst)
        {
            if (char.IsUpper(c))
            {
                // Konwersja na małą literę
                char malaLitera = (char)(c + ('a' - 'A'));
                zmienionyTekst += malaLitera;
            }
            else if (char.IsLower(c))
            {
                // Konwersja na wielką literę
                char duzaLitera = (char)(c - ('a' - 'A'));
                zmienionyTekst += duzaLitera;
            }
            else
            {
                // Inne znaki pozostają bez zmian
                zmienionyTekst += c;
            }
        }

        Console.WriteLine($"Tekst po zamianie wielkości liter: {zmienionyTekst}");
    }
}

Wyjaśnienie kodu

char.IsUpper(c) i char.IsLower(c): Sprawdzają, czy znak jest odpowiednio wielką lub małą literą.
Operacje na kodach ASCII:
- ('a' - 'A'): Różnica między kodami ASCII małej i wielkiej litery (wynosi 32).
- Konwersja wielkiej litery na małą: Dodajemy różnicę do kodu znaku.
- Konwersja małej litery na wielką: Odejmujemy różnicę od kodu znaku.

Przykład działania

Tekst wejściowy: Hello World!
Tekst po zamianie: hELLO wORLD!

Praktyczny przykład: Szyfr ROT13

Szyfr ROT13 to prosty szyfr szyfrujący, który polega na przesunięciu każdej litery o 13 pozycji w alfabecie.

Implementacja szyfru ROT13

using System;

class Program
{
    static void Main()
    {
        Console.Write("Podaj tekst do zaszyfrowania: ");
        string tekst = Console.ReadLine();
        string zaszyfrowany = "";

        foreach (char c in tekst)
        {
            if (char.IsLetter(c))
            {
                char zaszyfrowanyZnak = SzyfrRot13(c);
                zaszyfrowany += zaszyfrowanyZnak;
            }
            else
            {
                zaszyfrowany += c;
            }
        }

        Console.WriteLine($"Zaszyfrowany tekst: {zaszyfrowany}");
    }

    static char SzyfrRot13(char znak)
    {
        if (char.IsUpper(znak))
        {
            return (char)(((znak - 'A' + 13) % 26) + 'A');
        }
        else
        {
            return (char)(((znak - 'a' + 13) % 26) + 'a');
        }
    }
}

Wyjaśnienie kodu

char.IsLetter(c): Sprawdza, czy znak c jest literą.
Funkcja SzyfrRot13(char znak): Implementuje szyfr ROT13 dla pojedynczego znaku.
- char.IsUpper(znak): Sprawdza, czy znak jest wielką literą.
- Operacje arytmetyczne na znakach:
  - znak - 'A': Oblicza pozycję znaku w alfabecie (0 dla 'A’, 1 dla 'B’, …, 25 dla 'Z’).
  - (znak - 'A' + 13) % 26: Przesuwa pozycję o 13 i zapewnia, że pozostaje w zakresie 0-25.
  - + 'A': Konwertuje z powrotem na kod ASCII znaku.

Przykład działania

Tekst wejściowy: Hello World
Tekst zaszyfrowany: Uryyb Jbeyq

Dekodowanie szyfru ROT13

Ponieważ ROT13 jest symetryczny (zastosowanie go dwa razy przywraca oryginalny tekst), możemy użyć tej samej funkcji do odszyfrowania.

Przykład

Console.Write("Podaj tekst do odszyfrowania: ");
string zaszyfrowanyTekst = Console.ReadLine();
string odszyfrowany = "";

foreach (char c in zaszyfrowanyTekst)
{
    if (char.IsLetter(c))
    {
        char odszyfrowanyZnak = SzyfrRot13(c);
        odszyfrowany += odszyfrowanyZnak;
    }
    else
    {
        odszyfrowany += c;
    }
}

Console.WriteLine($"Odszyfrowany tekst: {odszyfrowany}");

Ćwiczenia z tablicami `string` i `char`

Zliczanie liter w słowie:
- Napisz program, który wczytuje słowo od użytkownika i wyświetla, ile razy występuje w nim każda litera.
Filtrowanie słów według długości:
- Mając tablicę słów, wyświetl tylko te, które mają więcej niż 4 znaki.
Sprawdzanie palindromu:
- Napisz program, który sprawdza, czy wprowadzone słowo jest palindromem.
Szyfr Cezara:
- Zaszyfruj wprowadzony tekst, przesuwając każdą literę o 3 pozycje w prawo w alfabecie.

C#

C# WPF