using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Text.RegularExpressions;

​

class Program

{

    // Türkçe karakterleri eşleyen harita

    private static readonly Dictionary<char, char> TurkishCharMap = new Dictionary<char, char>

    {

        { 'ı', 'I' }, { 'i', 'I' }, { 'İ', 'I' }, { 'I', 'I' },

        { 'ğ', 'G' }, { 'g', 'G' }, { 'Ğ', 'G' }, { 'G', 'G' },

        { 'ü', 'U' }, { 'u', 'U' }, { 'Ü', 'U' }, { 'U', 'U' },

        { 'ş', 'S' }, { 's', 'S' }, { 'Ş', 'S' }, { 'S', 'S' },

        { 'ö', 'O' }, { 'o', 'O' }, { 'Ö', 'O' }, { 'O', 'O' },

        { 'ç', 'C' }, { 'c', 'C' }, { 'Ç', 'C' }, { 'C', 'C' }

    };

​

    // Türkiye’deki tüm iller listesi (orijinal haliyle)

    private static readonly string[] TurkishCities = {

        "Adana", "Adıyaman", "Afyonkarahisar", "Ağrı", "Aksaray", "Amasya", "Ankara", "Antalya", "Ardahan",

        "Artvin", "Aydın", "Balıkesir", "Bartın", "Batman", "Bayburt", "Bilecik", "Bingöl", "Bitlis",

        "Bolu", "Burdur", "Bursa", "Çanakkale", "Çankırı", "Çorum", "Denizli", "Diyarbakır", "Düzce",

        "Edirne", "Elazığ", "Erzincan", "Erzurum", "Eskişehir", "Gaziantep", "Giresun", "Gümüşhane",

        "Hakkari", "Hatay", "Iğdır", "Isparta", "İstanbul", "İzmir", "Kahramanmaraş", "Karabük", "Karaman",

        "Kars", "Kastamonu", "Kayseri", "Kilis", "Kırıkkale", "Kırklareli", "Kırşehir", "Kocaeli",

        "Konya", "Kütahya", "Malatya", "Manisa", "Mardin", "Mersin", "Muğla", "Muş", "Nevşehir",

        "Niğde", "Ordu", "Osmaniye", "Rize", "Sakarya", "Samsun", "Şanlıurfa", "Siirt", "Sinop",

        "Şırnak", "Sivas", "Tekirdağ", "Tokat", "Trabzon", "Tunceli", "Uşak", "Van", "Yalova",

        "Yozgat", "Zonguldak"

    };

​

    // Normalize edilmiş iller listesi (bir kere hesaplanıp saklanıyor)

    private static readonly Dictionary<string, string> NormalizedCities = TurkishCities

         .GroupBy(city => city.NormalizeTurkishToAscii(), StringComparer.OrdinalIgnoreCase)

                .ToDictionary(

                    group => group.Key,

                    group => group.First(),

                    StringComparer.OrdinalIgnoreCase

                );

​

    static void Main()

    {

       string[] inputs = { "Aydinnnnnnnnnnnnnnnnnnnnnnnnnnnnn", "mula","ıSTANBUL 123", "istan!", "Bur @", "Ank 456", "İzmir#", "Konya 789", "Ist an bul", "ıSTANBUL", "ISTANBUL",

                "istanbul", "İstanBUL", "istan", " ıstan", "Bur", "Ank", "İzmir", "Konya", "ığdır", "İGDır", "İĞDIR" };

​

            const double SIMILARITY_THRESHOLD = 0.65; // %65 benzerlik eşiği

​

            foreach (var input in inputs)

            {

                var isMatch = NormalizedCities.TryMatchWithSimilarity(input, SIMILARITY_THRESHOLD, out var city);

                if (isMatch)

                {

                    Console.WriteLine($"{input} => {city} (Normalized: {city.NormalizeTurkishToAscii()})");

                }

                else

                {

                    Console.WriteLine($"{input} => no match found (similarity < {SIMILARITY_THRESHOLD:P0})");

                }

            }

    }

}

​

​

public static partial class StringExtensions

{

    private static readonly Dictionary<char, char> TurkishCharMap = new()

{

    { 'ı', 'I' }, { 'i', 'I' }, { 'İ', 'I' }, { 'I', 'I' },

    { 'ğ', 'G' }, { 'g', 'G' }, { 'Ğ', 'G' }, { 'G', 'G' },

    { 'ü', 'U' }, { 'u', 'U' }, { 'Ü', 'U' }, { 'U', 'U' },

    { 'ş', 'S' }, { 's', 'S' }, { 'Ş', 'S' }, { 'S', 'S' },

    { 'ö', 'O' }, { 'o', 'O' }, { 'Ö', 'O' }, { 'O', 'O' },

    { 'ç', 'C' }, { 'c', 'C' }, { 'Ç', 'C' }, { 'C', 'C' }

};

    public static string NormalizeTurkishToAscii(this string input)

    {

        if (string.IsNullOrWhiteSpace(input))

            return input;

​

        var cleanedInput = Regex.Replace(input, "[^a-zA-ZğüşıöçĞÜŞİÖÇ]","");

​

        if (string.IsNullOrWhiteSpace(cleanedInput))

            return input;

​

        var normalized = new StringBuilder(cleanedInput.Length);

        foreach (var c in cleanedInput)

        {

            normalized.Append(TurkishCharMap.TryGetValue(c, out var value) ? value : char.ToUpperInvariant(c));

        }

        return normalized.ToString();

    }

​

    public static bool TryMatch<T>(this Dictionary<string, T> normalizedCities, string input, out T? value)

    {

        value = default;

        var normalizedInput = NormalizeTurkishToAscii(input);

        if (string.IsNullOrWhiteSpace(normalizedInput))

            return false;

​

        // Önce tam eşleşme kontrolü yapalım

        foreach (var pair in normalizedCities)

        {

            if (string.Equals(pair.Key, normalizedInput, StringComparison.OrdinalIgnoreCase))

            {

                value = pair.Value;

                return true;

            }

        }

​

        // Tam eşleşme bulunamadıysa, StartsWith kontrolü yapalım

        T matchedValue = default;

        var hasMatch = false;

        foreach (var pair in normalizedCities)

        {

            if (pair.Key.StartsWith(normalizedInput, StringComparison.OrdinalIgnoreCase))

            {

                if (hasMatch) // İkinci eşleşme bulundu

                    return false;

​

                matchedValue = pair.Value;

                hasMatch = true;

            }

        }

​

        if (hasMatch)

        {

            value = matchedValue;

            return true;

        }

​

        return false;

    }

​

​

    private static string LimitRepeatingChars(string input, int maxRepeat = 3)

    {

        if (string.IsNullOrEmpty(input) || maxRepeat < 1)

            return input;

​

        var result = new StringBuilder();

        char lastChar = input[0];

        int repeatCount = 1;

        result.Append(lastChar);

​

        for (int i = 1; i < input.Length; i++)

        {

            if (input[i] == lastChar)

            {

                repeatCount++;

                if (repeatCount <= maxRepeat)

                    result.Append(input[i]);

            }

            else

            {

                lastChar = input[i];

                repeatCount = 1;

                result.Append(input[i]);

            }

        }

​

        return result.ToString();

    }

​

    public static bool TryMatchWithSimilarity<T>(this Dictionary<string, T> normalizedCities, string input, double similarityThreshold, out T? value)

    {

        value = default;

        var normalizedInput = NormalizeTurkishToAscii(input);

        if (string.IsNullOrWhiteSpace(normalizedInput))

            return false;

​

        // Tekrar eden karakterleri sınırla

        normalizedInput = LimitRepeatingChars(normalizedInput);

​

        // Önce normal TryMatch'i deneyelim

        if (TryMatch(normalizedCities, input, out value))

            return true;

​

        // Normal eşleşme bulunamadıysa, benzerlik araması yapalım

        var bestMatch = normalizedCities

            .Select(pair => new

            {

                City = pair.Value,

                Similarity = CalculateSimilarity(pair.Key, normalizedInput)

            })

            .OrderByDescending(x => x.Similarity)

            .FirstOrDefault();

​

        if (bestMatch != null && bestMatch.Similarity >= similarityThreshold)

        {

            value = bestMatch.City;

            return true;

        }

​

        return false;

    }

​

    private static double CalculateSimilarity(string source, string target)

    {

        if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(target)) return 0;

        if (source == target) return 1;

​

        int distance = LevenshteinDistance(source, target);

        int maxLength = Math.Max(source.Length, target.Length);

        return 1 - ((double)distance / maxLength);

    }

​

    private static int LevenshteinDistance(string source, string target)

    {

        var matrix = new int[source.Length + 1, target.Length + 1];

​

        // İlk satır ve sütunu doldur

        for (int i = 0; i <= source.Length; i++)

            matrix[i, 0] = i;

        for (int j = 0; j <= target.Length; j++)

            matrix[0, j] = j;

​

        // Matrisin geri kalanını doldur

        for (int i = 1; i <= source.Length; i++)

        {

            for (int j = 1; j <= target.Length; j++)

            {

                int cost = (source[i - 1] == target[j - 1]) ? 0 : 1;

​

                matrix[i, j] = Math.Min(

                    Math.Min(matrix[i - 1, j] + 1, matrix[i, j - 1] + 1),

                    matrix[i - 1, j - 1] + cost

                );

            }

        }

​

        return matrix[source.Length, target.Length];

    }

}

​