कोरियाई दो-सेट कीबोर्ड और क्वर्टी कीबोर्ड के बीच कनवर्ट करें


14

परिचय

यह कुछ हद तक DVORAK कीबोर्ड लेआउट जैसा है , लेकिन बहुत कठिन है।

पहले कोरियाई कीबोर्ड के बारे में बात करते हैं। जैसा कि आप विकिपीडिया में देख सकते हैं , कोरियाई और अंग्रेजी कुंजी सेटों के बीच बदलने के लिए एक कोर / Eng कुंजी है।

कोरियाई कभी-कभी गलत लिखते हैं: वे कोरियाई में क्वेर्टी कीबोर्ड या अंग्रेजी में दो-सेट कीबोर्ड पर लिखने का प्रयास करते हैं।

तो, यहां समस्या यह है: यदि दो-सेट कीबोर्ड में टाइप किए गए कोरियाई वर्ण दिए गए हैं, तो इसे qwerk कीबोर्ड में टाइप किए गए वर्णमाला वर्णों में बदलें। यदि Qwerty में टाइप किए गए वर्णमाला वर्ण दिए गए हैं, तो इसे दो-सेट कीबोर्ड में बदल दें।

दो-सेट कीबोर्ड

यहाँ दो-सेट कीबोर्ड लेआउट है:

ㅂㅈㄷㄱㅅㅛㅕㅑㅐㅔ
 ㅁㄴㅇㄹㅎㅗㅓㅏㅣ
  ㅋㅌㅊㅍㅠㅜㅡ

और शिफ्ट की के साथ:

ㅃㅉㄸㄲㅆㅛㅕㅑㅒㅖ

सिर्फ शीर्ष पंक्ति बदलती है जबकि अन्य नहीं।

कोरियाई वर्ण के बारे में

यदि यह यहाँ समाप्त होता है, तो यह आसान हो सकता है, लेकिन नहीं। जब आप टाइप करें

dkssud, tprP!

आउटपुट इस तरह से नहीं दिखाया गया है:

ㅇㅏㄴㄴㅕㅇ, ㅅㅔㄱㅖ!

लेकिन इस तरह से:

안녕, 세계!(means Hello, World!)

और यह चीजों को बहुत कठिन बना देता है।

कोरियाई वर्ण तीन भागों में अलग हो जाते हैं: 'चोसोंग (व्यंजन)', 'जुंगसॉन्ग (स्वर)', और 'जोंगसेओंग (शब्दांश के अंत में व्यंजन: रिक्त हो सकता है)', और आपको इसे अलग करना होगा।

सौभाग्य से, ऐसा करने का एक तरीका है।

कैसे अलग करें?

19 चोसॉन्ग, 21 जुंगसेओंग, और 28 जोंगसेओंग (रिक्त के साथ) हैं, और 0xAC00 '00' है, जो कोरियाई पात्रों का पहला चरित्र है। इसका उपयोग करके, हम कोरियाई वर्णों को तीन भागों में अलग कर सकते हैं। यहां दो-सेट कीबोर्ड में प्रत्येक की स्थिति और उसका क्रम दिया गया है।

चुना आदेश:

ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ
r R s e E f a q Q t T d w W c z x v g

jungseong आदेश:

ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ
k o i O j p u P h hk ho hl y n nj np nl b m ml l

जोंगसेग आदेश:

()ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ
()r R rt s sw sg e f fr fa fq ft fx fv fg a q qt t T d w c z x v g

आइए कहना (unicode value of some character) - 0xAC00है Korean_code, और चोज़ियांग, जंगसिओंग के सूचकांक, Jongseong है Cho, Jung, Jong

फिर, Korean_codeहै(Cho * 21 * 28) + Jung * 28 + Jong

यहाँ जावास्क्रिप्ट कोड है जो आपकी सुविधा के लिए , इस कोरियाई वेबसाइट से कोरियाई चरित्र को अलग करता है ।

var rCho = [ "ㄱ", "ㄲ", "ㄴ", "ㄷ", "ㄸ", "ㄹ", "ㅁ", "ㅂ", "ㅃ", "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅉ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ" ];
var rJung =[ "ㅏ", "ㅐ", "ㅑ", "ㅒ", "ㅓ", "ㅔ", "ㅕ", "ㅖ", "ㅗ", "ㅘ", "ㅙ", "ㅚ", "ㅛ", "ㅜ", "ㅝ", "ㅞ", "ㅟ", "ㅠ", "ㅡ", "ㅢ", "ㅣ" ];
var rJong = [ "", "ㄱ", "ㄲ", "ㄳ", "ㄴ", "ㄵ", "ㄶ", "ㄷ", "ㄹ", "ㄺ", "ㄻ", "ㄼ", "ㄽ", "ㄾ","ㄿ", "ㅀ", "ㅁ", "ㅂ", "ㅄ", "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ" ];
var cho, jung, jong;
var sTest = "탱";
var nTmp = sTest.charCodeAt(0) - 0xAC00;
jong = nTmp % 28; // Jeongseong
jung = ((nTmp - jong) / 28 ) % 21 // Jungseong
cho = ( ( (nTmp - jong) / 28 ) - jung ) / 21 // Choseong

alert("Choseong:" + rCho[cho] + "\n" + "Jungseong:" + rJung[jung] + "\n" + "Jongseong:" + rJong[jong]);

जब इकट्ठे हुए

  1. ध्यान दें कि , , , , , , अन्य jungseongs का एक संयोजन है।
ㅗ+ㅏ=ㅘ, ㅗ+ㅐ=ㅙ, ㅗ+ㅣ=ㅚ, ㅜ+ㅓ=ㅝ, ㅜ+ㅔ=ㅞ, ㅜ+ㅣ=ㅟ, ㅡ+ㅣ=ㅢ
  1. चोसांग आवश्यक है। इसका मतलब है, अगर frkदिया गया है, जो है ㄹㄱㅏ, तो यह दो तरह से बदल सकता है: ㄺㅏऔर ㄹ가। फिर, आपको इसे एक ऐसे तरीके में बदलना होगा जो चुना गया है। यदि jjjrjrदिया गया है, जो कि ㅓㅓㅓㄱㅓㄱअग्रणी है , तो ऐसा कुछ भी नहीं है जिसे चुना जा सके, लेकिन चौथा है जिसे चुना जा सकता है, इसलिए इसे बदल दिया जाता है ㅓㅓㅓ걱

एक और उदाहरण: 세계( tprP)। इसे 섹ㅖ( (ㅅㅔㄱ)(ㅖ)) में बदला जा सकता है , लेकिन क्योंकि चुना जाना आवश्यक है, इसे 세계( (ㅅㅔ)(ㄱㅖ)) में बदल दिया गया है

उदाहरण

इनपुट 1

안녕하세요

आउटपुट 1

dkssudgktpdy

इनपुट २

input 2

आउटपुट 2

ㅑㅞㅕㅅ 2

इनपुट 3

힘ㄴㄴ

आउटपुट 3

glass

इनपुट 4

아희(Aheui) is esolang which you can program with pure Korean characters.

आउटपुट 4

dkgml(모뎌ㅑ) ㅑㄴ ㄷ내ㅣ뭏 조ㅑ초 ㅛㅐㅕ ㅊ무 ㅔ갷ㄱ므 쟈소 ㅔㅕㄱㄷ ㅏㅐㄱㄷ무 촘ㄱㅁㅊㅅㄷㄱㄴ.

इनपुट 5

dkssud, tprP!

आउटपुट 5

안녕, 세계!

इनपुट 6

ㅗ디ㅣㅐ, 째깅! Hello, World!

आउटपुट 6

hello, World! ㅗ디ㅣㅐ, 째깅!

सबसे छोटा कोड जीतता है। (बाइट्स में)

आपकी सुविधा के लिए नया नियम

आप उन पात्रों को खारिज कर सकते हैं जैसे Aदो-सेट कीबोर्ड में इसका समकक्ष नहीं है। इतना Aheuiकरने के लिए Aㅗ뎌ㅑठीक है। लेकिन, अगर आप बदल Aheuiजाते हैं 모뎌ㅑ, तो आप -5 अंक प्राप्त कर सकते हैं, इसलिए आप 5 बाइट कमा सकते हैं।

आप दो jungseongs (जैसे ) को अलग कर सकते हैं ㅗ+ㅏ। की तरह rhkकरने के लिए 고ㅏ, या howकरने के लिए ㅗㅐㅈ। लेकिन अगर आप (जैसे कि यह गठबंधन rhkकरने के लिए या howकरने के लिए ㅙㅈ), तो आपको अतिरिक्त -5 अंक अर्जित कर सकते हैं।


में जंगसिओंग आदेश पत्र की धारा एक लापता है। मैं 21 कोरियाई प्रतीकों को देखता हूं, लेकिन केवल 20 अक्षर (-पीयर) है। EDIT: कोरियाई प्रतीक के लिए एक परीक्षण के lबाद लापता होने लगता है । ml
केविन क्रूज़सेन

@ केविनक्रूजसेन ने संपादित किया। ㅣ के लिए एल।
लेगेनडुस्ट

1
कभी-कभी एक से अधिक व्याख्याएं हो सकती हैं। उदाहरण के लिए, के fjfauरूप में व्याख्या की जा सकती है 럶ㅕया 럴며। हम इसका समाधान कैसे करेंगे?
निक केनेडी

1
@LegenDUST खैर, मैं एक भी शब्द कोरियाई नहीं पढ़ सकता, इसलिए मुझे आपके स्पष्टीकरण के साथ जाना होगा। ; पी tprPपरीक्षण के मामले में 5 के रूप में: यह में बदल जाता है ㅅㅔㄱㅖ, जहां एक चुना है, एक जंगला है और एक जंगल है। तो क्या इसे 섷ㅖ(जैसे समूहीकृत (ㅅㅔㄱ)(ㅖ)) के बजाय 세계(समूहबद्ध ) में तब्दील नहीं किया जाना चाहिए (ㅅㅔ)(ㄱㅖ)? पहले की टिप्पणी में आप कहते हैं कि यह टाइप करके व्याख्या है, इसलिए मैं इसे ㅅㅔㄱबदलने की उम्मीद करूंगा । या कोरियाई टाइपिंग बाएं से दाएं की बजाय दाएं से बाएं ओर है?
केविन क्रूज़सेन

1
Unicode.org से @KevinCruijssen पीडीएफ फाइल । AC00 ( ) से D7AF ( ) तक।
लेगेनडुस्ट

जवाबों:


6

जेली , 296 264 बाइट्स

Ẏœṣjƭƒ
“ȮdȥŒ~ṙ7Ṗ:4Ȧịعʂ ="÷Ƥi-ẓdµ£f§ñỌ¥ẋaḣc~Ṡd1ÄḅQ¥_æ>VÑʠ|⁵Ċ³(Ė8ịẋs|Ṇdɼ⁼:Œẓİ,ḃṙɠX’ṃØẠs2ḟ€”A
“|zƒẉ“®6ẎẈ3°Ɠ“⁸)Ƙ¿’ḃ2’T€ị¢
¢ĖẈṪ$ÞṚƊ€
3£OŻ€3¦ŒpFḟ0Ɗ€J+“Ḥœ’,ƲyO2£OJ+⁽.[,Ʋ¤y¹ỌŒḊ?€µ¢ṖŒpZF€’ḋ588,28+“Ḥþ’Ʋ0;,ʋ/ṚƲ€ñṣ0ḊḢ+®Ṫ¤Ɗ;ṫ®$Ɗ¹Ḋ;⁶Ṫ⁼ṁ@¥¥Ƈ@¢ṪẈṪ‘;Ʋ€¤ḢƲ©?€ṭḢƲF2£żJ+⁽.[Ɗ$ẈṪ$ÞṚ¤ñỌ

इसे ऑनलाइन आज़माएं!

एक पूर्ण कार्यक्रम जो एक स्ट्रिंग को अपने तर्क के रूप में लेता है और एक स्ट्रिंग लौटाता है (जो स्पष्ट रूप से मुद्रित होता है)। यह तीन पास में काम करता है: पहले यह सभी कोरियाई वर्णों को लैटिन अक्षरों के लिए कोड बिंदुओं की सूची में परिवर्तित करता है। फिर यह यौगिक कोरियाई वर्णों की पहचान और निर्माण करता है। अंत में, यह किसी भी शेष आवारा लैटिन अक्षरों को कोरियाई समकक्ष के रूप में बदल देता है। ध्यान दें कि अन्य अक्षर और लैटिन अक्षर जो युक्ति में प्रकट नहीं होते हैं (जैसे A) अकेले रह गए हैं।

यदि कल्पना से बाहर के बड़े अक्षरों के निचले मामले में रूपांतरण की आवश्यकता है, तो यह अतिरिक्त 10 बाइट्स की लागत पर किया जा सकता है ।

व्याख्या

हेल्पर लिंक 1 : तर्कों और x के साथ डियाडिक लिंक। x खोज के जोड़े की सूची है और उप-कलाकारों की जगह ले सकता है। y में प्रत्येक खोज सब लिस्ट को इसी बदले हुए सबलिस्ट के साथ बदल दिया जाएगा

Ẏ      | Tighten (reduce to a single list of alternating search and replace sublists)
     ƒ | Reduce using y as starting argument and the following link:
    ƭ  | - Alternate between using the following two links:
 œṣ    |   - Split at sublist
   j   |   - Join using sublist

हेल्पर लिंक 2 : लैटिन वर्णों / वर्ण युग्मों की सूची उस क्रम में जो कोरियाई वर्णों के यूनिकोड क्रम से मेल खाती है

“Ȯ..X’          | Base 250 integer 912...
      ṃØẠ       | Base decompress into Latin letters (A..Za..z)
         s2     | Split into twos
           ḟ€”A | Filter out A from each (used as filler for the single characters)

हेल्पर लिंक 3 : चोसोंग, जुंगसॉन्ग और जोंगसेग के लिए उपयोग किए जाने वाले लैटिन पात्रों की सूची

“|...¿’        | List of base 250 integers, [1960852478, 2251799815782398, 2143287262]
       ḃ2      | Convert to bijective base 2
         ’     | Decrease by 1
          T€   | List of indices of true values for each list
            ị¢ | Index into helper link 2

हेल्पर लिंक 4 : लैटिन वर्णों की उपरोक्त सूची की गणना की गई और लंबाई के घटते क्रम में क्रमबद्ध किया गया

¢         | Helper link 3 as a nilad
       Ɗ€ | For each list, the following three links as a monad
 Ė        | - Enumerate (i.e. prepend a sequential index starting at 1 to each member of the list)
    $Þ    | - Sort using, as a key, the following two links as a monad
  Ẉ       |   - Lengths of lists
   Ṫ      |   - Tail (this will be the length of the original character or characters)
      Ṛ   | - Reverse

मुख्य लिंक : मोनाद जो एक जेली स्ट्रिंग को अपने तर्क के रूप में लेता है और अनुवादित जेली स्ट्रिंग लौटाता है

खंड 1 : संबंधित लैटिन वर्णों के यूनिकोड कोडपॉइंट्स के लिए एम्पीयरिक ब्लॉक कन्वर्ट करें

खंड 1.1 : ब्लॉक बनाने के लिए आवश्यक लैटिन चरित्र (नों) की सूची प्राप्त करें

3£      | Helper link 3 as a nilad (lists of Latin characters used for Choseong, Jungseong and Jongseong)
  O     | Convert to Unicode code points
   Ż€3¦ | Prepend a zero to the third list (Jongseong)

धारा 1.2 : इन अक्षरों के सभी संयोजनों को बनाएं (19 × 21 × 28 = 11,172 समुचित शाब्दिक क्रम में संयोजन)

Œp      | Cartesian product
     Ɗ€ | For each combination:
  F     | - Flatten
   ḟ0   | - Filter zero (i.e. combinations with an empty Jonseong)

धारा 1.3 : लैटिन अक्षरों की इसी सूची के साथ ब्लॉक के यूनिकोड कोड बिंदुओं को जोड़ी, और इनपुट स्ट्रिंग में morphemic ब्लॉकों का अनुवाद करने के लिए इनका उपयोग करें

       Ʋ   | Following as a monad
J          | - Sequence from 1..11172
 +“Ḥœ’     | - Add 44031
      ,    | - Pair with the blocks themelves
        y  | Translate the following using this pair of lists
         O | - The input string converted to Unicode code points

धारा 2 : आउटपुट में व्यक्तिगत कोरियाई वर्णों को अनुभाग 1 से लैटिन समकक्ष के कोड बिंदुओं में परिवर्तित करें

          ¤  | Following as a nilad
2£           | Helper link 2 (list of Latin characters/character pairs in the order that corresponds to the Unicode order of the Korean characters)
  O          | Convert to Unicode code points
         Ʋ   | Following as a monad:
   J         | - Sequence along these (from 1..51)
    +⁽.[     | - Add 12592
        ,    | - Pair with list of Latin characters
           y | Translate the output from section 1 using this mapping

धारा 3 : धारा 2 से आउटपुट में अनियंत्रित वर्णों को साफ करें (काम करता है क्योंकि कोरियाई से अनुवादित कुछ भी अब एक सबलिस्ट में होगा और इसलिए गहराई 1 है)

  ŒḊ?€  | For each member of list if the depth is 1:
¹       | - Keep as is
 Ọ      | Else: convert back from Unicode code points to characters
      µ | Start a new monadic chain using the output from this section as its argument

धारा 4 : लैटिन वर्णों के मध्ययुगीन ब्लॉक को कोरियाई में रूपांतरित करें

धारा 4.1 : चोसांग और जुंगसॉन्ग के सभी संभावित संयोजनों को प्राप्त करें

¢    | Helper link 4 (lists of Latin characters enumerated and sorted in decreasing order of length)
 Ṗ   | Discard last list (Jongseong)
  Œp | Cartesian product

धारा ४.२ : बेस मोर्फ़ेमिक ब्लॉक के लिए यूनिकोड कोड बिंदु के साथ प्रत्येक संयोजन को लेबल करें (यानी बिना जोंगसेग के)

                       Ʋ€ | For each Choseong/Jungseong combination
Z                         | - Transpose, so that we now have e.g. [[1,1],["r","k"]]
 F€                       | - Flatten each, joining the strings together
                    ʋ/    | - Reduce using the following as a dyad (effectively using the numbers as left argument and string of Latin characters as right)
                Ʋ         |   - Following links as a monad
   ’                      |     - Decrease by 1
    ḋ588,28               |     - Dot product with 21×28,28
           +“Ḥþ’          |     - Add 44032
                 0;       |     - Prepend zero; used for splitting in section 4.3 before each morphemic block (Ż won’t work because on a single integer it produces a range)
                   ,      |     - Pair with the string of Latin characters
                      Ṛ   |   - Reverse (so we now have e.g. ["rk", 44032]

धारा 4.3 : बेस मोरपॉजिक ब्लॉक के यूनिकोड कोड बिंदुओं के साथ धारा 3 से आउटपुट में लैटिन वर्णों के इन तारों को बदलें

ñ   | Call helper link 1 (effectively search and replace)
 ṣ0 | Split at the zeros introduced in section 4.2

खंड 4.4: यह पहचानें कि क्या प्रत्येक जंतुविषयक ब्लॉक के हिस्से के रूप में जोंगसेग है

                                        Ʋ | Following as a monad:
Ḋ                                         | - Remove the first sublist (which won’t contain a morphemic block; note this will be restored later)
                                     €    | - For each of the other lists Z returned by the split in section 4.3 (i.e. each will have a morphemic block at the beginning):
                                  Ʋ©?     |   - If the following is true (capturing its value in the register in the process) 
             Ḋ                            |     - Remove first item (i.e. the Unicode code point for the base morphemic block introduced in section 4.3)
              ;⁶                          |     - Append a space (avoids ending up with an empty list if there is nothing after the morphemic block code point)
                                          |       (Output from the above will be referred to as X below)
                                ¤         |       * Following as a nilad (call this Y):
                        ¢                 |         * Helper link 4
                         Ṫ                |         * Jongseong
                              Ʋ€          |         * For each Jongseong Latin list:
                          Ẉ               |           * Lengths of lists
                           Ṫ              |           * Tail (i.e. length of Latin character string)
                            ‘             |           * Increase by 1
                             ;            |           * Prepend this (e.g. [1, 1, "r"]
                     ¥Ƈ@                  |     - Filter Y using X from above and the following criteria
                Ṫ                         |       - Tail (i.e. the Latin characters for the relevant Jongseong
                 ⁼ṁ@¥                     |       - is equal to the beginning of X trimmed to match the relevant Jongseong (or extended but this doesn’t matter since no Jongseong are a double letter)
                                  Ḣ       |       - First matching Jongseong (which since they’re sorted by descending size order will prefer the longer one if there is a matching shorter one)
           Ɗ                              | - Then: do the following as a monad (note this is now using the list Z mentioned much earlier):
      Ɗ                                   |   - Following as a monad
 Ḣ                                        |     - Head (the Unicode code point of the base morphemic block)
  +®Ṫ¤                                    |     - Add the tail of the register (the position of the matched Jongsepng in the list of Jongseong)
       ;                                  |   - Concatenate to:
        ṫ®$                               |     - The rest of the list after removing the Latin characters representing the Jongseong
            ¹                             | - Else: leave the list untouched (no matching Jongseong)
                                       ṭ  | - Prepend:
                                        Ḣ |   - The first sublist from the split that was removed at the beginning of this subsection

धारा 5 : शेष लैटिन अक्षर जो कोरियाई लोगों से मेल खाते हैं, लेकिन एक मोर्फेमेक ब्लॉक का हिस्सा नहीं हैं

F                   | Flatten
                ¤   | Following as a nilad
 2£                 | - Helper link 2 (Latin characters/pairs of characters in Unicode order of corresponding Korean character)
          $         | - Following as a monad
   ż     Ɗ          |   - zip with following as a monad
    J               |     - Sequence along helper link 2 (1..51)
     +⁽.[           |     - Add 12592
             $Þ     | - Sort using following as key
           Ẉ        |   - Lengths of lists
            Ṫ       |   - Tail (i.e. length of Latin string)
               Ṛ    | - Reverse
                 ñ  | Call helper link 1 (search Latin character strings and replace with Korean code points)
                  Ọ | Finally, convert all Unicode code points back to characters and implicitly output

1
आउटपुट गलत है: जब मैंने डाला , तो मैंने छोड़ दिया cor, लेकिन यह दिया cBor। और यह नहीं बदलता cहै canमें रूपांतरित होना पड़ा ㅊ무, लेकिन यह रूपांतरित हो गया c무। और मैंने बड़े पात्रों को भी छोड़ दिया, जो कल्पना में प्रकट नहीं होते हैं, लेकिन यह ठीक हो सकता है।
लेगेनडुस्ट

@LegenDUST सी समस्या तय हो गई है। मैंने Aएकल पात्रों के दूसरे चरित्र के लिए एक प्लेसहोल्डर के रूप में इस्तेमाल किया , और किसी कारण के बाद cएक के रूप में बाहर आ रहा था B। अन्य पत्रों के निचले मामले में रूपांतरण किया जा सकता है, लेकिन पहले से ही एक कठिन चुनौती के लिए एक अनावश्यक जटिलता की तरह लगता है।
निक केनेडी

मैं समझता हूं कि यह कठिन है। इसलिए मैंने नया नियम जोड़ा: यदि आप डिकैपिटलाइज़ करते हैं, तो आप 5 बाइट कमा सकते हैं। लेकिन यह ठीक है।
लेगेनडुस्ट

3

जावास्क्रिप्ट (Node.js) , 587 582 575 569 557 554 550 549 बाइट्स

TFW आपको लगता है कि पता नहीं था string.charCodeAt() == string.charCodeAt(0)

s=>s.replace(eval(`/[ㄱ-힣]|${M="(h[kol]?|n[jpl]?|ml?|[bi-puyOP])"}|([${S="rRseEfaqQtTdwWczxvg"}])(${M}((s[wg]|f[raqtxvg]|qt|[${S}])(?!${M}))?)?/g`,L="r,R,rt,s,sw,sg,e,E,f,fr,fa,fq,ft,fx,fv,fg,a,q,Q,qt,t,T,d,w,W,c,z,x,v,g,k,o,i,O,j,p,u,P,h,hk,ho,hl,y,n,nj,np,nl,n,m,ml,l".split`,`,l=L.filter(x=>!/[EQW]/.test(x)),I="indexOf"),(a,E,A,B,C,D)=>a<"~"?E?X(E):A&&C?F(43193+S[I](A)*588+L[I](C)*28+l[I](D)):X(A)+X(C)+X(D):(b=a.charCodeAt()-44032)<0?L[b+31439]||a:S[b/588|0]+L[30+b/28%21|0]+["",...l][b%28],F=String.fromCharCode,X=n=>n?F(L[I](n)+12593):"")

इसे ऑनलाइन आज़माएं!

547 यदि वर्णमाला और कोरियाई जैमोस के बाहर के वर्णों को अनदेखा किया जा सकता है।

ठीक है, मैंने इसे लिखने के लिए बहुत समय तक संघर्ष किया, लेकिन यह काम करना चाहिए। कोई भी कोरियाई jamo / शब्दांश का उपयोग नहीं किया जाता है क्योंकि वे बहुत महंगे हैं (प्रति उपयोग 3 बाइट्स)। बाइट को बचाने के लिए नियमित अभिव्यक्ति में उपयोग किया जाता है।

s=>                                                    // Main Function:
 s.replace(                                            //  Replace all convertible strings:
  eval(
   `/                                                  //   Matching this regex:
    [ㄱ-힣]                                             //   ($0) All Korean jamos and syllables
    |${M="(h[kol]?|n[jpl]?|ml?|[bi-puyOP])"}           //   ($1) Isolated jungseong codes
    |([${S="rRseEfaqQtTdwWczxvg"}])                    //   ($2) Choseong codes (also acts as lookup)
     (                                                 //   ($3) Jungseong and jongseong codes:
      ${M}                                             //   ($4)  Jungseong codes
      (                                                //   ($5)  Jongseong codes:
       (                                               //   ($6)
        s[wg]|f[raqtxvg]|qt                            //          Diagraphs unique to jongseongs
        |[${S}]                                        //          Or jamos usable as choseongs
       ) 
       (?!${M})                                        //         Not linked to the next jungseong
      )?                                               //        Optional to match codes w/o jongseong
     )?                                                //       Optional to match choseong-only codes
   /g`,                                                //   Match all
   L="(...LOOKUP TABLE...)".split`,`,                  //   Lookup table of codes in jamo order
   l=L.filter(x=>!/[EQW]/.test(x)),                    //   Jongseong lookup - only first half is used
   I="indexOf"                                         //   [String|Array].prototype.indexOf
  ),
  (a,E,A,B,C,D)=>                                      //   Using this function:
   a<"~"?                                              //    If the match is code (alphabets):
    E?                                                 //     If isolated jungseongs code:
     X(E)                                              //      Return corresponding jamo
    :A&&C?                                             //     Else if complete syllable code:
     F(43193+S[I](A)*588+L[I](C)*28+l[I](D))           //      Return the corresponding syllable
    :X(A)+X(C)+X(D)                                    //     Else return corresponding jamos joined
   :(b=a.charCodeAt()-44032)<0?                        //    Else if not syllable:
    L[b+31439]||a                                      //     Return code if jamo (if not, ignore)
   :S[b/588|0]+L[30+b/28%21|0]+["",...l][b%28],        //    Else return code for the syllable
  F=String.fromCharCode,                               //   String.fromCharCode
  X=n=>                                                //   Helper function to convert code to jamo
   n?                                                  //    If not undefined:
    F(L[I](n)+12593)                                   //     Return the corresponding jamo
   :""                                                 //    Else return empty string
 )

2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 405 401 400 बाइट्स

c=CharacterRange
p=StringReplace
q=StringReverse
r=Reverse
t=Thread
j=Join
a=j[alphabet@"Korean",4520~c~4546]
x=j[#,r/@#]&@t[a->Characters@"rRseEfaqQtTdwWczxvgkoiOjpuPh"~j~StringSplit@"hk ho hl y n nj np nl b m ml l r R rt s sw sg e f fr fa fq ft fx fv fg a q qt t T d w c z x v g"]
y=t[""<>r@#&/@Tuples@TakeList[Insert[a,"",41]~p~x~p~x,{19,21,28}]->44032~c~55203]
f=q@p[q@#,#2]&
g=f[#,r/@y]~p~x~f~y&

इसे ऑनलाइन आज़माएं!

थोड़ा अनगढ़

मैथेमेटिका में इसे परीक्षण करने के लिए बस के alphabetसाथ बदलें Alphabet; हालाँकि, TIO वोल्फ्राम क्लाउड का समर्थन नहीं करता है इसलिए मैंने Alphabet["Korean"]हेडर में परिभाषित किया।

हम पहले हंगुल वर्णमाला के सभी हंगुल सिलेबल्स का निरूपण करते हैं, फिर लैटिन और हंगुल वर्णों की अदला-बदली करते हैं, फिर सिलेबल्स का पुनर्मूल्यांकन करते हैं।


1
आपके TIO के बजाय टेस्ट केस input 2परिणाम । एक ही समाधान में होता है हालांकि मैं पर काम कर रहा था, दोनों के बाद से और जंगसिओंग कर रहे हैं, और मैं छाप केवल चोज़ियांग + जंगसिओंग + jongseong या चोज़ियांग + जंगसिओंग + खाली संयुक्त किया जाएगा तहत किया गया। मैंने ओपी से सत्यापन के लिए पूछा कि क्यों बन गया । ㅑㅜㅔㅕㅅ 2ㅑㅞㅕㅅ 2ㅜㅔ
केविन क्रूज़सेन

@ केविनक्रूजसेन ㅞ (एनपी) अपने आप में एक जुंगसॉंग है
निक केनेडी

1
यह दो वर्ण व्यंजन या स्वर के लिए ठीक से काम नहीं करता है। उदाहरण के लिए fnpfaएक एकल चरित्र होना चाहिए लेकिन इसके बजाय समाप्त होता है루ㅔㄹㅁ
निक केनेडी

प्रगति में ठीक करें। यह बहुत अधिक खर्च नहीं करना चाहिए।
lirtosiast

2

जावा 19, 1133 1126 1133 बाइट्स

s->{String r="",k="ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ",K[]=k.split(" "),a="r R s e E f a q Q t T d w W c z x v g k o i O j p u P h hk ho hl y n nj np nl b m ml l r R rt s sw sg e f fr fa fq ft fx fv fg a q qt t T d w c z x v g";var A=java.util.Arrays.asList(a.split(" "));k=k.replace(" ","");int i,z,y,x=44032;for(var c:s.toCharArray())if(c>=x&c<55204){z=(i=c-x)%28;y=(i=(i-z)/28)%21;s=s.replace(c+r,r+K[0].charAt((i-y)/21)+K[1].charAt(y)+(z>0?K[2].charAt(z-1):r));}for(var c:s.split(r))r+=c.charAt(0)<33?c:(i=k.indexOf(c))<0?(i=A.indexOf(c))<0?c:k.charAt(i):A.get(i);for(i=r.length()-1;i-->0;r=z>0?r.substring(0,i)+(char)(K[0].indexOf(r.charAt(i))*588+K[1].indexOf(r.charAt(i+1))*28+((z=K[2].indexOf(r.charAt(i+2)))<0?0:z+1)+x)+r.substring(z<0?i+2:i+3):r)for(z=y=2;y-->0;)z&=K[y].contains(r.charAt(i+y)+"")?2:0;for(var p:"ㅗㅏㅘㅗㅐㅙㅗㅣㅚㅜㅓㅝㅜㅔㅞㅜㅣㅟㅡㅣㅢ".split("(?<=\\G...)"))r=r.replace(p.substring(0,2),p.substring(2));return r;}

-5 बोनस से अधिक की लागत के ASDFGHJKLZXCVBNMबाद से अपरिवर्तित पूंजी अक्षरों के साथ आउटपुट .toLowerCase()

+7 बाइट्स यूनिकोड मान 20,000 से ऊपर के गैर-कोरियाई वर्णों के लिए बग-फिक्स के रूप में (धन्यवाद @NickKennedy के लिए धन्यवाद )।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

s->{                         // Method with String as both parameter and return-type
  String r="",               //  Result-String, starting empty
         k="ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ",
                             //  String containing the Korean characters
         K[]=k.split(" "),   //  Array containing the three character-categories
         a="r R s e E f a q Q t T d w W c z x v g k o i O j p u P h hk ho hl y n nj np nl b m ml l r R rt s sw sg e f fr fa fq ft fx fv fg a q qt t T d w c z x v g"; 
                             //  String containing the English characters
  var A=java.util.Arrays.asList(a.split(" "));
                             //  List containing the English character-groups
  k=k.replace(" ","");       //  Remove the spaces from the Korean String
  int i,z,y,                 //  Temp integers
      x=44032;               //  Integer for 0xAC00
  for(var c:s.toCharArray()) //  Loop over the characters of the input:
    if(c>=x&c<55204){        //   If the unicode value is in the range [44032,55203]
                             //   (so a Korean combination character):
      z=(i=c-x)%28;          //    Set `i` to this unicode value - 0xAC00,
                             //    And then `z` to `i` modulo-28
      y=(i=(i-z)/28)%21;     //    Then set `i` to `i`-`z` integer divided by 28
                             //    And then `y` to `i` modulo-21
      s=s.replace(c+r,       //    Replace the current non-Korean character with:
        r+K[0].charAt((i-y)/21)
                             //     The corresponding choseong
         +K[1].charAt(y)     //     Appended with jungseong
         +(z>0?K[2].charAt(z-1):r));}
                             //     Appended with jongseong if necessary
  for(var c:s.split(r))      //  Then loop over the characters of the modified String:
    r+=                      //   Append to the result-String:
       c.charAt(0)<33?       //    If the character is a space:
        c                    //     Simply append that space
       :(i=k.indexOf(c))<0?  //    Else-if the character is NOT a Korean character:
         (i=A.indexOf(c))<0? //     If the character is NOT in the English group List:
          c                  //      Simply append that character
         :                   //     Else:
          k.charAt(i)        //      Append the corresponding Korean character
       :                     //    Else:
        A.get(i);            //     Append the corresponding letter
  for(i=r.length()-1;i-->0   //  Then loop `i` in the range (result-length - 2, 0]:
      ;                      //    After every iteration:
       r=z>0?                //     If a group of Korean characters can be merged:
          r.substring(0,i)   //      Leave the leading part of the result unchanged
          +(char)(K[0].indexOf(r.charAt(i))
                             //      Get the index of the first Korean character,
                   *588      //      multiplied by 588
                  +K[1].indexOf(r.charAt(i+1))
                             //      Get the index of the second Korean character,
                   *28       //      multiplied by 28
                  +((z=K[2].indexOf(r.charAt(i+2)))
                             //      Get the index of the third character
                    <0?      //      And if it's a Korean character in the third group:
                      0:z+1) //       Add that index + 1
                  +x         //      And add 0xAC00
                 )           //      Then convert that integer to a character
          +r.substring(z<0?i+2:i+3) 
                             //      Leave the trailing part of the result unchanged as well
         :                   //     Else (these characters cannot be merged)
          r)                 //      Leave the result the same
     for(z=y=2;              //   Reset `z` to 2
         y-->0;)             //   Inner loop `y` in the range (2, 0]:
       z&=                   //    Bitwise-AND `z` with:
         K[y].contains(      //     If the `y`'th Korean group contains
           r.charAt(i+y)+"")?//     the (`i`+`y`)'th character of the result
          2                  //      Bitwise-AND `z` with 2
         :                   //     Else:
          0;                 //      Bitwise-AND `z` with 0
                             //   (If `z` is still 2 after this inner loop, it means
                             //    Korean characters can be merged)
  for(var p:"ㅗㅏㅘㅗㅐㅙㅗㅣㅚㅜㅓㅝㅜㅔㅞㅜㅣㅟㅡㅣㅢ".split("(?<=\\G...)"))
                             //  Loop over these Korean character per chunk of 3:
    r=r.replace(p.substring(0,2),
                             //   Replace the first 2 characters in this chunk
         p.substring(2));    //   With the third one in the result-String
  return r;}                 //  And finally return the result-String

1
वे 44032 से 55203 तक के हैं। आपको पहले ही प्रारंभ स्थान कोडित मिल गया है। अंत बस है44032 + 19×21×28 - 1
निक केनेडी

अब अच्छी तरह से काम करता है। सोचा था कि मैं तुम्हें पहले ही उखाड़ फेंकेगा, लेकिन यहाँ नहीं, इसलिए तुम जाओ!
निक केनेडी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.