Typ char w C#

char literaA = 'A';           // Literki w apostrofach!
char cyfra5 = '5';
char spacja = ' ';
char nowаLinia = '\n';
string tekst = "ABC";         // String w cudzysłowach!

Console.WriteLine($"Char: {literaA}");     // A
Console.WriteLine($"String: {tekst}");     // ABC

char literaA = 'A';
char polskieA = 'ą';
char emoji = '😀';
char chińskiZnak = '中';

Console.WriteLine($"A = {literaA} (kod: {(int)literaA})");        // A (kod: 65)
Console.WriteLine($"ą = {polskieA} (kod: {(int)polskieA})");      // ą (kod: 261)
Console.WriteLine($"😀 = {emoji} (kod: {(int)emoji})");          // 😀 (kod: 55357)
Console.WriteLine($"中 = {chińskiZnak} (kod: {(int)chińskiZnak})"); // 中 (kod: 20013)

// Bezpośrednie przypisanie znaku
char litera = 'X';
char cyfra = '7';
char znak = '@';

// Przez kod Unicode
char literaA1 = (char)65;      // 'A' (kod ASCII 65)
char literaA2 = '\u0041';      // 'A' (Unicode hex)
char polskieL = '\u0142';      // 'ł' (Unicode hex)

// Znaki specjalne (escape sequences)
char tab = '\t';               // Tabulator
char nowaLinia = '\n';         // Nowa linia
char backslash = '\\';         // Ukośnik wsteczny
char apostrof = '\'';          // Apostrof
char cudzysłów = '\"';         // Cudzysłów

Console.WriteLine($"Tab:|{tab}|");
Console.WriteLine($"Nowa linia:|{nowaLinia}|");
Console.WriteLine($"Backslash: {backslash}");
Console.WriteLine($"Apostrof: {apostrof}");
Console.WriteLine($"Cudzysłów: {cudzysłów}");

// char → int (kod Unicode)
char znak = 'B';
int kod = (int)znak;
Console.WriteLine($"'{znak}' ma kod: {kod}");  // 'B' ma kod: 66

// int → char
int kodLitery = 67;
char litera = (char)kodLitery;
Console.WriteLine($"Kod {kodLitery} to znak: '{litera}'");  // Kod 67 to znak: 'C'

// char → string
char pojedynczyZnak = 'D';
string stringZZnaku = pojedynczyZnak.ToString();
// lub
string stringZZnaku2 = $"{pojedynczyZnak}";
Console.WriteLine($"Char jako string: {stringZZnaku}");

// string → char (pierwszy znak)
string tekst = "Hello";
char pierwszyZnak = tekst[0];
Console.WriteLine($"Pierwszy znak z '{tekst}': '{pierwszyZnak}'");  // 'H'

char[] testowZnaki = {'A', 'a', '5', ' ', '@', '\t', 'ą', '.'};

foreach (char c in testowZnaki)
{
    Console.WriteLine($"\nZnak: '{c}' (kod: {(int)c})");
    Console.WriteLine($"  Litera: {char.IsLetter(c)}");
    Console.WriteLine($"  Cyfra: {char.IsDigit(c)}");
    Console.WriteLine($"  Biały znak: {char.IsWhiteSpace(c)}");
    Console.WriteLine($"  Wielka litera: {char.IsUpper(c)}");
    Console.WriteLine($"  Mała litera: {char.IsLower(c)}");
    Console.WriteLine($"  Litera lub cyfra: {char.IsLetterOrDigit(c)}");
    Console.WriteLine($"  Znak interpunkcyjny: {char.IsPunctuation(c)}");
    Console.WriteLine($"  Symbol: {char.IsSymbol(c)}");
    Console.WriteLine($"  Kontrolny: {char.IsControl(c)}");
}

char[] litery = {'A', 'b', 'Ć', 'ł', '5', '@'};

Console.WriteLine("Oryginał → Wielka → Mała");
Console.WriteLine("------------------------");

foreach (char c in litery)
{
    char wielka = char.ToUpper(c);
    char mała = char.ToLower(c);
    Console.WriteLine($"   '{c}'   →  '{wielka}'  →  '{mała}'");
}

static bool CzyPrawidłowyLogin(string login)
{
    // Login musi mieć 3-15 znaków i zawierać tylko litery, cyfry i _
    if (login.Length < 3 || login.Length > 15)
        return false;
    
    // Pierwszy znak musi być literą
    if (!char.IsLetter(login[0]))
        return false;
    
    // Sprawdzamy każdy znak
    foreach (char c in login)
    {
        if (!char.IsLetterOrDigit(c) && c != '_')
        {
            return false;
        }
    }
    
    return true;
}

// Testowanie
string[] loginy = {"user1", "123abc", "a", "very_long_username_too_long", "user@123", "User_123"};

foreach (string login in loginy)
{
    bool prawidłowy = CzyPrawidłowyLogin(login);
    Console.WriteLine($"Login '{login}': {(prawidłowy ? "✅ OK" : "❌ Błędny")}");
}

using System;

class GeneratorHasła
{
    static void Main()
    {
        Console.Write("Podaj długość hasła (8-50): ");
        if (int.TryParse(Console.ReadLine(), out int długość) && długość >= 8 && długość <= 50)
        {
            string hasło = GenerujHasło(długość);
            Console.WriteLine($"Wygenerowane hasło: {hasło}");
            AnalizujHasło(hasło);
        }
        else
        {
            Console.WriteLine("Nieprawidłowa długość!");
        }
    }
    
    static string GenerujHasło(int długość)
    {
        Random rand = new Random();
        char[] hasło = new char[długość];
        
        // Zestawy znaków
        string małeLitery = "abcdefghijklmnopqrstuvwxyz";
        string wielkieLitery = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        string cyfry = "0123456789";
        string znakiSpecjalne = "!@#$%^&*()_+-=[]{}|;:,.<>?";
        
        string wszystkieZnaki = małeLitery + wielkieLitery + cyfry + znakiSpecjalne;
        
        // Zapewniamy przynajmniej jeden znak z każdej grupy
        hasło[0] = małeLitery[rand.Next(małeLitery.Length)];
        hasło[1] = wielkieLitery[rand.Next(wielkieLitery.Length)];
        hasło[2] = cyfry[rand.Next(cyfry.Length)];
        hasło[3] = znakiSpecjalne[rand.Next(znakiSpecjalne.Length)];
        
        // Pozostałe znaki losowo
        for (int i = 4; i < długość; i++)
        {
            hasło[i] = wszystkieZnaki[rand.Next(wszystkieZnaki.Length)];
        }
        
        // Mieszamy hasło
        for (int i = 0; i < długość; i++)
        {
            int j = rand.Next(długość);
            (hasło[i], hasło[j]) = (hasło[j], hasło[i]); // Swap
        }
        
        return new string(hasło);
    }
    
    static void AnalizujHasło(string hasło)
    {
        int małeLitery = 0, wielkieLitery = 0, cyfry = 0, znakiSpecjalne = 0;
        
        foreach (char c in hasło)
        {
            if (char.IsLower(c))
                małeLitery++;
            else if (char.IsUpper(c))
                wielkieLitery++;
            else if (char.IsDigit(c))
                cyfry++;
            else
                znakiSpecjalne++;
        }
        
        Console.WriteLine("\n=== ANALIZA HASŁA ===");
        Console.WriteLine($"Długość: {hasło.Length}");
        Console.WriteLine($"Małe litery: {małeLitery}");
        Console.WriteLine($"Wielkie litery: {wielkieLitery}");
        Console.WriteLine($"Cyfry: {cyfry}");
        Console.WriteLine($"Znaki specjalne: {znakiSpecjalne}");
        
        // Ocena siły hasła
        int punkty = 0;
        if (małeLitery > 0) punkty++;
        if (wielkieLitery > 0) punkty++;
        if (cyfry > 0) punkty++;
        if (znakiSpecjalne > 0) punkty++;
        if (hasło.Length >= 12) punkty++;
        
        string siła = punkty switch
        {
            <= 2 => "Słabe",
            3 => "Średnie", 
            4 => "Silne",
            5 => "Bardzo silne",
            _ => "Nieznane"
        };
        
        Console.WriteLine($"Siła hasła: {siła} ({punkty}/5 punktów)");
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

class AnalizatorZnaków
{
    static void Main()
    {
        string nazwaPliku = "tekst_do_analizy.txt";
        
        // Tworzymy przykładowy plik z różnymi znakami
        if (!File.Exists(nazwaPliku))
        {
            string przykład = @"Programowanie w C# jest fascynujące!
Możemy analizować każdy znak w tekście.
WIELKIE litery, małe litery, cyfry 123, znaki specjalne @#$%
Polskie znaki: ąćęłńóśźż ĄĆĘŁŃÓŚŹŻ
Białe znaki: spacje, tabulatory	i nowe linie.";
            
            File.WriteAllText(nazwaPliku, przykład);
            Console.WriteLine($"Utworzono plik: {nazwaPliku}");
        }
        
        // Wczytujemy zawartość pliku
        string zawartość = File.ReadAllText(nazwaPliku);
        Console.WriteLine($"Analizowany tekst ({zawartość.Length} znaków):");
        Console.WriteLine($"{zawartość}\n");
        
        // Analizujemy znaki
        AnalizujZnaki(zawartość);
        
        // Zapisujemy raport
        ZapiszRaport(zawartość, "raport_znakow.txt");
    }
    
    static void AnalizujZnaki(string tekst)
    {
        // Słownik do liczenia wystąpień każdego znaku
        Dictionary<char, int> częstotliwość = new Dictionary<char, int>();
        
        // Liczniki kategorii znaków
        int litery = 0, cyfry = 0, białeZnaki = 0, interpunkcja = 0, 
            symbole = 0, kontrolne = 0, inne = 0;
        int wielkieLitery = 0, małeLitery = 0;
        int polskieZnaki = 0;
        
        // Analizujemy każdy znak
        foreach (char c in tekst)
        {
            // Liczenie wystąpień
            if (częstotliwość.ContainsKey(c))
                częstotliwość[c]++;
            else
                częstotliwość[c] = 1;
            
            // Klasyfikacja znaków
            if (char.IsLetter(c))
            {
                litery++;
                if (char.IsUpper(c))
                    wielkieLitery++;
                else if (char.IsLower(c))
                    małeLitery++;
                    
                // Sprawdzamy polskie znaki
                if ("ąćęłńóśźżĄĆĘŁŃÓŚŹŻ".Contains(c))
                    polskieZnaki++;
            }
            else if (char.IsDigit(c))
                cyfry++;
            else if (char.IsWhiteSpace(c))
                białeZnaki++;
            else if (char.IsPunctuation(c))
                interpunkcja++;
            else if (char.IsSymbol(c))
                symbole++;
            else if (char.IsControl(c))
                kontrolne++;
            else
                inne++;
        }
        
        // Wyświetlamy statystyki kategorii
        Console.WriteLine("=== STATYSTYKI KATEGORII ZNAKÓW ===");
        Console.WriteLine($"Wszystkich znaków: {tekst.Length}");
        Console.WriteLine($"Litery: {litery} (wielkie: {wielkieLitery}, małe: {małeLitery})");
        Console.WriteLine($"Polskie znaki diakrytyczne: {polskieZnaki}");
        Console.WriteLine($"Cyfry: {cyfry}");
        Console.WriteLine($"Białe znaki: {białeZnaki}");
        Console.WriteLine($"Znaki interpunkcyjne: {interpunkcja}");
        Console.WriteLine($"Symbole: {symbole}");
        Console.WriteLine($"Znaki kontrolne: {kontrolne}");
        Console.WriteLine($"Inne: {inne}");
        
        // Top 10 najczęściej występujących znaków
        Console.WriteLine("\n=== TOP 10 NAJCZĘSTSZYCH ZNAKÓW ===");
        var najczęstsze = częstotliwość
            .OrderByDescending(x => x.Value)
            .Take(10);
            
        int pozycja = 1;
        foreach (var para in najczęstsze)
        {
            char znak = para.Key;
            int liczba = para.Value;
            string nazwaZnaku = PobierzNazwęZnaku(znak);
            double procent = (double)liczba / tekst.Length * 100;
            
            Console.WriteLine($"{pozycja,2}. '{znak}' ({nazwaZnaku}) - {liczba} razy ({procent:F1}%)");
            pozycja++;
        }
        
        // Znaki występujące tylko raz
        var unikatowe = częstotliwość.Where(x => x.Value == 1).Count();
        Console.WriteLine($"\nZnaków występujących tylko raz: {unikatowe}");
    }
    
    static string PobierzNazwęZnaku(char znak)
    {
        return znak switch
        {
            ' ' => "spacja",
            '\t' => "tabulator",
            '\n' => "nowa linia",
            '\r' => "powrót karetki",
            _ when char.IsLetter(znak) => $"litera {(char.IsUpper(znak) ? "wielka" : "mała")}",
            _ when char.IsDigit(znak) => "cyfra",
            _ when char.IsPunctuation(znak) => "interpunkcja",
            _ when char.IsSymbol(znak) => "symbol",
            _ => "inny"
        };
    }
    
    static void ZapiszRaport(string tekst, string nazwaRaportu)
    {
        var raport = new List<string>();
        raport.Add("=== RAPORT ANALIZY ZNAKÓW ===");
        raport.Add($"Data: {DateTime.Now:dd.MM.yyyy HH:mm:ss}");
        raport.Add($"Analizowany tekst: {tekst.Length} znaków");
        raport.Add("");
        
        // Szczegółowa analiza każdego znaku (ASCII 32-126)
        raport.Add("=== ZNAKI ASCII (32-126) ===");
        for (int i = 32; i <= 126; i++)
        {
            char c = (char)i;
            int liczba = tekst.Count(x => x == c);
            if (liczba > 0)
            {
                raport.Add($"Kod {i,3}: '{c}' - {liczba,3} razy");
            }
        }
        
        File.WriteAllLines(nazwaRaportu, raport);
        Console.WriteLine($"\nRaport szczegółowy zapisano w: {nazwaRaportu}");
    }
}

// Znaki jako liczby - można na nich wykonywać operacje arytmetyczne
char a = 'A';
char b = (char)(a + 1);  // 'B'
char c = (char)(a + 25); // 'Z'

Console.WriteLine($"'{a}' + 1 = '{b}'");
Console.WriteLine($"'{a}' + 25 = '{c}'");

// Różnica między znakami
char x = 'X';
char y = 'A';
int różnica = x - y;  // 23 (X to 88. znak, A to 65.)
Console.WriteLine($"'{x}' - '{y}' = {różnica}");

// Przechodzenie przez alfabet
Console.WriteLine("Alfabet angielski:");
for (char litera = 'A'; litera <= 'Z'; litera++)
{
    Console.Write($"{litera} ");
}
Console.WriteLine();

// Konwersja char cyfry na int
char cyfrаZnak = '7';
int cyfrаLiczba1 = cyfrаZnak - '0';  // 7 (ASCII '7' = 55, '0' = 48, różnica = 7)
int cyfrаLiczba2 = char.GetNumericValue(cyfrаZnak);  // 7.0 (zwraca double)

Console.WriteLine($"Znak '{cyfrаZnak}' jako liczba: {cyfrаLiczba1}");

// Sprawdzanie czy char reprezentuje cyfrę i konwersja
static int CharNаCyfre(char c)
{
    if (char.IsDigit(c))
        return c - '0';
    else
        throw new ArgumentException($"'{c}' nie jest cyfrą!");
}

// Konwersja całego stringu cyfr na liczbę (ręcznie)
static int StringNаLiczbe(string cyfry)
{
    int wynik = 0;
    foreach (char c in cyfry)
    {
        if (!char.IsDigit(c))
            throw new ArgumentException($"'{c}' nie jest cyfrą!");
        
        wynik = wynik * 10 + (c - '0');
    }
    return wynik;
}

// ❌ BŁĄD
char znak = "A";     // Błąd kompilacji - to string, nie char!

// ✅ PRAWIDŁOWO
char znak = 'A';     // Char w apostrofach
string tekst = "A";  // String w cudzysłowach

char input = 'a';

// ❌ Niebezpieczne
if (input == 'A') { /* ... */ }

// ✅ Bezpieczne porównanie
if (char.ToUpper(input) == 'A') { /* ... */ }
// lub
if (char.ToLower(input) == 'a') { /* ... */ }

// ❌ Niebezpieczne - może rzucić wyjątek
int dużaLiczba = 70000;
char znak = (char)dużaLiczba;  // Może dać nieprzewidywalne rezultaty

// ✅ Bezpieczne sprawdzanie zakresu
if (dużaLiczba >= 0 && dużaLiczba <= 65535)
{
    char znak = (char)dużaLiczba;
}
else
{
    Console.WriteLine("Liczba poza zakresem char!");
}

// ❌ Błędne założenie - działa tylko dla angielskiego
char c = 'ą';
if (c >= 'a' && c <= 'z')  // false! ą ma kod 261, poza zakresem a-z
{
    Console.WriteLine("Mała litera");
}

// ✅ Prawidłowe sprawdzenie
if (char.IsLower(c))  // true - rozpoznaje polskie znaki
{
    Console.WriteLine("Mała litera");
}

static void PokazZakresy()
{
    Console.WriteLine("=== ZAKRESY UNICODE ===");
    
    // Cyfry (0-9)
    Console.WriteLine("Cyfry:");
    for (int i = 48; i <= 57; i++)
    {
        Console.Write($"{(char)i} ");
    }
    Console.WriteLine($" (kody {48}-{57})");
    
    // Wielkie litery angielskie (A-Z)
    Console.WriteLine("\nWielkie litery angielskie:");
    for (int i = 65; i <= 90; i++)
    {
        Console.Write($"{(char)i} ");
    }
    Console.WriteLine($" (kody {65}-{90})");
    
    // Małe litery angielskie (a-z)
    Console.WriteLine("\nMałe litery angielskie:");
    for (int i = 97; i <= 122; i++)
    {
        Console.Write($"{(char)i} ");
    }
    Console.WriteLine($" (kody {97}-{122})");
    
    // Podstawowe znaki interpunkcyjne
    Console.WriteLine("\nPodstawowe znaki specjalne:");
    int[] specialCodes = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
    foreach (int kod in specialCodes)
    {
        Console.Write($"'{(char)kod}' ");
    }
    Console.WriteLine();
    
    // Polskie znaki diakrytyczne
    Console.WriteLine("\nPolskie znaki diakrytyczne:");
    string polskie = "ąćęłńóśźż ĄĆĘŁŃÓŚŹŻ";
    foreach (char c in polskie)
    {
        if (c != ' ')
            Console.Write($"'{c}'({(int)c}) ");
    }
    Console.WriteLine();
}