यूनिकोड वर्णों से विशिष्ट अंक (ń ǹ ñ ñ ņ marks marks marks marks marks marks marks (() निकालें

Question 1

मैं एक एल्गोरिथ्म को देख रहा हूं, जो कि डिक्ट्रिटिक्स ( टिल्ड , राउंडफ्लेक्स , कैरेट , ओम्लूट , कैरन ) और उनके "सरल" चरित्र वाले पात्रों के बीच मैप कर सकता है ।

उदाहरण के लिए:

ń  ǹ  ň  ñ  ṅ  ņ  ṇ  ṋ  ṉ  ̈  ɲ  ƞ ᶇ ɳ ȵ  --> n
á --> a
ä --> a
ấ --> a
ṏ --> o

आदि।

मैं जावा में ऐसा करना चाहता हूं, हालांकि मुझे संदेह है कि यह कुछ यूनिकोड-वाई होना चाहिए और किसी भी भाषा में आसानी से उचित होना चाहिए।
उद्देश्य: आसानी से शब्दों के लिए खोज करने के लिए अनुमति देने के साथ। उदाहरण के लिए, यदि मेरे पास टेनिस खिलाड़ियों का एक डेटाबेस है, और Björn_Borg दर्ज किया गया है, तो मैं Bjorn_Borg भी रखूंगा ताकि मुझे यह पता चल सके कि कोई Bjorn में प्रवेश करता है और Björn नहीं।

Question 2

मैंने हाल ही में जावा में यह किया है:

public static final Pattern DIACRITICS_AND_FRIENDS
    = Pattern.compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");

private static String stripDiacritics(String str) {
    str = Normalizer.normalize(str, Normalizer.Form.NFD);
    str = DIACRITICS_AND_FRIENDS.matcher(str).replaceAll("");
    return str;
}

यह आपके द्वारा निर्दिष्ट के अनुसार होगा:

stripDiacritics("Björn")  = Bjorn

लेकिन यह उदाहरण के लिए Białystok पर विफल हो जाएगा, क्योंकि łचरित्र विशिष्ट नहीं है।

यदि आप एक पूर्ण विकसित स्ट्रिंग सरलीकरण करना चाहते हैं, तो आपको कुछ और विशेष वर्णों के लिए एक दूसरे क्लीनअप राउंड की आवश्यकता होगी, जो कि डायक्रिटिक्स नहीं हैं। क्या यह नक्शा है, मैंने सबसे आम विशेष पात्रों को शामिल किया है जो हमारे ग्राहक नामों में दिखाई देते हैं। यह पूरी सूची नहीं है, लेकिन यह आपको यह विचार देगा कि इसे कैसे बढ़ाया जाए। अचल संग्रह गूगल-संग्रह से सिर्फ एक सरल वर्ग है।

public class StringSimplifier {
    public static final char DEFAULT_REPLACE_CHAR = '-';
    public static final String DEFAULT_REPLACE = String.valueOf(DEFAULT_REPLACE_CHAR);
    private static final ImmutableMap<String, String> NONDIACRITICS = ImmutableMap.<String, String>builder()

        //Remove crap strings with no sematics
        .put(".", "")
        .put("\"", "")
        .put("'", "")

        //Keep relevant characters as seperation
        .put(" ", DEFAULT_REPLACE)
        .put("]", DEFAULT_REPLACE)
        .put("[", DEFAULT_REPLACE)
        .put(")", DEFAULT_REPLACE)
        .put("(", DEFAULT_REPLACE)
        .put("=", DEFAULT_REPLACE)
        .put("!", DEFAULT_REPLACE)
        .put("/", DEFAULT_REPLACE)
        .put("\\", DEFAULT_REPLACE)
        .put("&", DEFAULT_REPLACE)
        .put(",", DEFAULT_REPLACE)
        .put("?", DEFAULT_REPLACE)
        .put("°", DEFAULT_REPLACE) //Remove ?? is diacritic?
        .put("|", DEFAULT_REPLACE)
        .put("<", DEFAULT_REPLACE)
        .put(">", DEFAULT_REPLACE)
        .put(";", DEFAULT_REPLACE)
        .put(":", DEFAULT_REPLACE)
        .put("_", DEFAULT_REPLACE)
        .put("#", DEFAULT_REPLACE)
        .put("~", DEFAULT_REPLACE)
        .put("+", DEFAULT_REPLACE)
        .put("*", DEFAULT_REPLACE)

        //Replace non-diacritics as their equivalent characters
        .put("\u0141", "l") // BiaLystock
        .put("\u0142", "l") // Bialystock
        .put("ß", "ss")
        .put("æ", "ae")
        .put("ø", "o")
        .put("©", "c")
        .put("\u00D0", "d") // All Ð ð from http://de.wikipedia.org/wiki/%C3%90
        .put("\u00F0", "d")
        .put("\u0110", "d")
        .put("\u0111", "d")
        .put("\u0189", "d")
        .put("\u0256", "d")
        .put("\u00DE", "th") // thorn Þ
        .put("\u00FE", "th") // thorn þ
        .build();


    public static String simplifiedString(String orig) {
        String str = orig;
        if (str == null) {
            return null;
        }
        str = stripDiacritics(str);
        str = stripNonDiacritics(str);
        if (str.length() == 0) {
            // Ugly special case to work around non-existing empty strings
            // in Oracle. Store original crapstring as simplified.
            // It would return an empty string if Oracle could store it.
            return orig;
        }
        return str.toLowerCase();
    }

    private static String stripNonDiacritics(String orig) {
        StringBuffer ret = new StringBuffer();
        String lastchar = null;
        for (int i = 0; i < orig.length(); i++) {
            String source = orig.substring(i, i + 1);
            String replace = NONDIACRITICS.get(source);
            String toReplace = replace == null ? String.valueOf(source) : replace;
            if (DEFAULT_REPLACE.equals(lastchar) && DEFAULT_REPLACE.equals(toReplace)) {
                toReplace = "";
            } else {
                lastchar = toReplace;
            }
            ret.append(toReplace);
        }
        if (ret.length() > 0 && DEFAULT_REPLACE_CHAR == ret.charAt(ret.length() - 1)) {
            ret.deleteCharAt(ret.length() - 1);
        }
        return ret.toString();
    }

    /*
    Special regular expression character ranges relevant for simplification -> see http://docstore.mik.ua/orelly/perl/prog3/ch05_04.htm
    InCombiningDiacriticalMarks: special marks that are part of "normal" ä, ö, î etc..
        IsSk: Symbol, Modifier see http://www.fileformat.info/info/unicode/category/Sk/list.htm
        IsLm: Letter, Modifier see http://www.fileformat.info/info/unicode/category/Lm/list.htm
     */
    public static final Pattern DIACRITICS_AND_FRIENDS
        = Pattern.compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");


    private static String stripDiacritics(String str) {
        str = Normalizer.normalize(str, Normalizer.Form.NFD);
        str = DIACRITICS_AND_FRIENDS.matcher(str).replaceAll("");
        return str;
    }
}

Question 3

कोर java.text पैकेज को इस उपयोग के मामले को संबोधित करने के लिए डिज़ाइन किया गया था (डायक्रिटिक्स, केस, आदि के बारे में देखभाल के बिना तार मिलान)।

वर्णों में अंतर Collatorपर सॉर्ट करने के लिए कॉन्फ़िगर करें PRIMARY। इसके साथ, CollationKeyप्रत्येक स्ट्रिंग के लिए बनाएं । यदि आपका सभी कोड जावा में है, तो आप CollationKeyसीधे उपयोग कर सकते हैं । यदि आपको किसी डेटाबेस या अन्य प्रकार के सूचकांक में कुंजियों को संग्रहीत करने की आवश्यकता है, तो आप इसे बाइट सरणी में बदल सकते हैं ।

ये वर्ग यूनिकोड मानक केस फोल्डिंग डेटा का उपयोग यह निर्धारित करने के लिए करते हैं कि कौन से अक्षर समान हैं, और विभिन्न अपघटन रणनीतियों का समर्थन करते हैं ।

Collator c = Collator.getInstance();
c.setStrength(Collator.PRIMARY);
Map<CollationKey, String> dictionary = new TreeMap<CollationKey, String>();
dictionary.put(c.getCollationKey("Björn"), "Björn");
...
CollationKey query = c.getCollationKey("bjorn");
System.out.println(dictionary.get(query)); // --> "Björn"

ध्यान दें कि कोलाटर स्थानीय-विशिष्ट हैं। ऐसा इसलिए है क्योंकि "वर्णमाला क्रम" स्थानों के बीच भिन्न होता है (और समय के साथ भी, जैसा कि स्पेनिश के साथ हुआ है)। Collatorवर्ग इन नियमों के सभी ट्रैक और तिथि करने के लिए उन्हें रखने के लिए होने से आप राहत मिलती है।

Question 4

यह अपाचे कॉमन्स लैंग का हिस्सा है । 3.1।

org.apache.commons.lang3.StringUtils.stripAccents("Añ");

रिटर्न An

Question 5

आप इस्तेमाल कर सकते हैं Normalizer वर्ग से java.text:

System.out.println(new String(Normalizer.normalize("ń ǹ ň ñ ṅ ņ ṇ ṋ", Normalizer.Form.NFKD).getBytes("ascii"), "ascii"));

लेकिन अभी भी कुछ काम करना बाकी है, क्योंकि जावा असंगत यूनिकोड वर्णों के साथ अजीब चीजें बनाता है (यह उन्हें अनदेखा नहीं करता है, और यह एक अपवाद नहीं फेंकता है)। लेकिन मुझे लगता है कि आप इसे एक शुरुआती बिंदु के रूप में इस्तेमाल कर सकते हैं।

Question 6

एक मसौदा रिपोर्ट हैयूनिकोड वेबसाइट पर चरित्र तह पर जिसमें बहुत अधिक प्रासंगिक सामग्री है। विशेष रूप से धारा 4.1 देखें। "फोल्डिंग एल्गोरिथ्म"।

यहाँ एक चर्चा और कार्यान्वयन है पेर्ल का उपयोग करते हुए डिसरिटिक मार्कर हटाने की है।

ये मौजूदा SO प्रश्न संबंधित हैं:

Question 7

कृपया ध्यान दें कि इन सभी चिह्नों में से कुछ "सामान्य" चरित्र पर सिर्फ "निशान" नहीं हैं, जिन्हें आप अर्थ को बदले बिना हटा सकते हैं।

स्वीडिश में, å ä और ö सही और उचित प्रथम श्रेणी के चरित्र हैं, कुछ अन्य चरित्र के "संस्करण" नहीं। वे सभी अन्य वर्णों से अलग ध्वनि करते हैं, वे अलग-अलग तरह के होते हैं, और वे शब्दों को अर्थ बदल देते हैं ("mätt" और "मैट" दो अलग-अलग शब्द हैं)।

Question 8

यूनिकोड में विशिष्ट डायट्रिक वर्ण होते हैं (जो मिश्रित वर्ण होते हैं) और एक स्ट्रिंग को परिवर्तित किया जा सकता है ताकि चरित्र और डायटिक्स अलग हो जाएं। उसके बाद, आप बस स्ट्रिंग से डायट जिलों को हटा सकते हैं और आप मूल रूप से कर रहे हैं।

सामान्यीकरण, डीकंपोज़िशन और समतुल्यता के बारे में अधिक जानकारी के लिए, यूनिकोड मानक को देखें यूनिकोड होम पेज पर देखें ।

हालांकि, आप वास्तव में इसे कैसे प्राप्त कर सकते हैं यह फ्रेमवर्क / ओएस / ... पर निर्भर करता है। यदि आप .NET का उपयोग कर रहे हैं, तो आप System.Text.NormalizationForm गणन को स्वीकार करते हुए String.Normalize विधि का उपयोग कर सकते हैं ।

Question 9

सबसे आसान तरीका (मेरे लिए) बस एक विरल मानचित्रण सरणी बनाए रखना होगा जो बस आपके यूनिकोड कोड बिंदुओं को डिस्प्ले स्ट्रिंग्स में बदलता है।

जैसे कि:

start    = 0x00C0
size     = 23
mappings = {
    "A","A","A","A","A","A","AE","C",
    "E","E","E","E","I","I","I", "I",
    "D","N","O","O","O","O","O"
}
start    = 0x00D8
size     = 6
mappings = {
    "O","U","U","U","U","Y"
}
start    = 0x00E0
size     = 23
mappings = {
    "a","a","a","a","a","a","ae","c",
    "e","e","e","e","i","i","i", "i",
    "d","n","o","o","o","o","o"
}
start    = 0x00F8
size     = 6
mappings = {
    "o","u","u","u","u","y"
}
: : :

एक विरल सरणी का उपयोग आपको यूनिकोड तालिका के व्यापक रूप से स्थानिक वर्गों में भी कुशलता से प्रतिस्थापन का प्रतिनिधित्व करने की अनुमति देगा। स्ट्रिंग प्रतिस्थापन आपके मनोदशाओं को बदलने के लिए मनमाने ढंग से अनुक्रमों की अनुमति देगा (जैसे कि æअंगूर बनना ae)।

यह एक भाषा-अज्ञेयवादी उत्तर है, इसलिए, यदि आपके पास एक विशिष्ट भाषा है, तो बेहतर तरीके होंगे (हालांकि वे सभी संभवत: इस तरह से सबसे कम स्तर पर नीचे आ जाएंगे)।

Question 10

कुछ विचार करने के लिए: यदि आप प्रत्येक शब्द का एक "अनुवाद" प्राप्त करने का प्रयास करते हैं, तो आप कुछ संभावित विकल्पों को याद कर सकते हैं।

उदाहरण के लिए, जर्मन में, "एस-सेट" की जगह, कुछ लोग "बी" का उपयोग कर सकते हैं, जबकि अन्य "एसएस" का उपयोग कर सकते हैं। या, "o" या "oe" के साथ एक umlauted o की जगह। आदर्श रूप से आपके पास कोई भी समाधान, मुझे लगता है कि दोनों को शामिल करना चाहिए।

Question 11

Windows और .NET में, मैं सिर्फ स्ट्रिंग एन्कोडिंग का उपयोग करके परिवर्तित करता हूं। इस तरह मैं मैनुअल मैपिंग और कोडिंग से बचता हूं।

स्ट्रिंग एन्कोडिंग के साथ खेलने का प्रयास करें।

Question 12

जर्मन के मामले में यह उमलाट्स (ä, ö, ü) से विकृति विज्ञान को दूर नहीं करना चाहता था। इसके बजाय उन्हें दो अक्षर संयोजन (ae, oe, ue) द्वारा प्रतिस्थापित किया जाता है। उदाहरण के लिए, Björn को Bjoern (ब्योर्न नहीं) के रूप में लिखा जाना चाहिए ताकि सही उच्चारण हो सके।

इसके लिए मेरे पास हार्डकोडेड मैपिंग होगी, जहां आप प्रत्येक विशेष वर्ण समूह के लिए व्यक्तिगत रूप से प्रतिस्थापन नियम को परिभाषित कर सकते हैं।

Question 13

भविष्य के संदर्भ के लिए, यहां C # एक्सटेंशन पद्धति है जो लहजे को हटाती है।

public static class StringExtensions
{
    public static string RemoveDiacritics(this string str)
    {
        return new string(
            str.Normalize(NormalizationForm.FormD)
                .Where(c => CharUnicodeInfo.GetUnicodeCategory(c) != 
                            UnicodeCategory.NonSpacingMark)
                .ToArray());
    }
}
static void Main()
{
    var input = "ŃŅŇ ÀÁÂÃÄÅ ŢŤţť Ĥĥ àáâãäå ńņň";
    var output = input.RemoveDiacritics();
    Debug.Assert(output == "NNN AAAAAA TTtt Hh aaaaaa nnn");
}