Convert between Korean two-set keyboard and qwerty keyboard
Jelly, 296 264 bytes
Ẏœṣ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+⁽.[Ɗ$ẈṪ$ÞṚ¤ñỌ
Try it online!
A full program that takes a string as its argument and returns a string (which is implicitly printed). This works in three passes: first it converts all Korean characters to lists of code points for the Latin letters. Then it identifies and builds the compound Korean characters. Finally, it turns any remaining stray Latin letters to the Korean equivalent. Note that other characters and Latin letters that don’t appear in the spec (e.g. A) are left alone.
If conversion to lower case of capital letters outside spec is needed, this can be done at a cost of an additional 10 bytes.
Explanation
Helper link 1: dyadic link with arguments x and y. x is a list of pairs of search and replace sublists. y will have each search sublist replaced with the corresponding replace sublist
Ẏ | 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
Helper link 2: List of Latin characters/character pairs in the order that corresponds to the Unicode order of the Korean characters
“Ȯ..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)
Helper link 3: Lists of Latin characters used for Choseong, Jungseong and Jongseong
“|...¿’ | 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
Helper link 4: Above lists of Latin characters enumerated and sorted in decreasing order of length
¢ | 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
Main link: Monad that takes a Jelly string as its argument and returns the translated Jelly string
Section 1: Convert morphemic blocks to the Unicode codepoints of the corresponding Latin characters
Section 1.1: Get the list of Latin character(s) needed to make the blocks
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)
Section 1.2: Create all combinations of these letters (19×21×28 = 11,172 combinations in the appropriate lexical order)
Œp | Cartesian product
Ɗ€ | For each combination:
F | - Flatten
ḟ0 | - Filter zero (i.e. combinations with an empty Jonseong)
Section 1.3: Pair the Unicode code points of the blocks with the corresponding list of Latin characters, and use these to translate the morphemic blocks in the input string
Ʋ | 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
Section 2: Convert the individual Korean characters in the output from section 1 to the code points of the Latin equivalent
¤ | 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
Section 3: Tidy up untranslated characters in the output from section 2 (works because anything translated from Korean will now be in a sublist and so have depth 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
Section 4: Convert morphemic blocks of Latin characters into Korean
Section 4.1: Get all possible combinations of Choseong and Jungseong
¢ | Helper link 4 (lists of Latin characters enumerated and sorted in decreasing order of length)
Ṗ | Discard last list (Jongseong)
Œp | Cartesian product
Section 4.2: Label each combination with the Unicode code point for the base morphemic block (i.e. with no Jongseong)
Ʋ€ | 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]
Section 4.3: Replace these strings of Latin characters in the output from section 3 with the Unicode code points of the base morphemic block
ñ | Call helper link 1 (effectively search and replace)
ṣ0 | Split at the zeros introduced in section 4.2
Section 4.4: Identify whether there is a Jongseong as part of each morphemic block
Ʋ | 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
Section 5: Handle remaining Latin characters that match Korean ones but are not part of a morphemuc block
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
JavaScript (Node.js), 587 582 575 569 557 554 550 549 bytes
tfw you didn't know that 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):"")
Try it online!
547 if characters outside alphabets and korean jamos can be ignored.
Okay I struggled for so long to write this, but this should work. No Korean jamo/syllable is used because they are too expensive (3 bytes per use). Used in the regular expression to save bytes.
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
)
Wolfram Language (Mathematica), 405 401 400 bytes
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&
Try it online!
Slightly ungolfed
To test this in Mathematica just replace alphabet with Alphabet; however, TIO doesn't support the Wolfram Cloud so I defined Alphabet["Korean"] in the header.
We first decompose all Hangul syllables to the Hangul alphabet, then swap Latin and Hangul characters, then recompose the syllables.