Convert To Shorthand Part 1

Question

This challenge has been divided into parts.
Your goal is to convert a sentence into a form of 'short-hand'

For Part 1 these are the rules

1. Take in 1 word
2. Remove all vowels(a,e,i,o,u), except the ones at the beginning and the end
3. If a letter is repeated more than once consecutively, reduce it to only one (e.g. Hello -> Hlo)
4. Create a function which converts the word into it's corresponding unicode characters based on above given rules, as given in the table

Letter	Corresponding Unicode Character
A	Λ
B	L
C	𐍉
D	Ꙅ
E	∟
F	⌽
G	T
H	|
I	⩗
J	)
K	<
L	(
M	ᨈ
N	ᑎ
O	┼
P	⊥
Q	⩁
R	\
S	⦵
T	_
U	⋃
V	⌵
W	⌵ (same as V)
X	X
Y	ɥ
Z	ᒣ

Test Cases

English Word	Substituted Word
A	Λ
Quick	⩁𐍉<
Brown	L\⌵ᑎ
Fox	⌽X
Jumps	)ᨈ⊥⦵
Over	┼⌵\
The	_|∟
Lazy	(ᒣɥ
Dog	ꙄT
Turtle	_\_(∟
Of	┼⌽
Terror	_\

As this is code-golf, shortest answer wins!

Part 2 has been posted here

Answer 1

Burlesque, 86 bytes

zzgn"aeiou"XX\\)**97?-"ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ"jsi

Try it online!

zz          # To lower case
gn          # Unique consecutives
"aeiou"XX   # Vowels as list
\\          # List diff
)**         # Map ord
97?-        # Conert to index into alphabet
"ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ" # SH as string
jsi         # Select indices from SH string

Answer 2

Retina 0.8.2, 99 bytes

T`L`l
\B[aeiou]\B

(.)\1+
$1
c
𐍉
T`l`Λ\L_Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵\_⋃⌵⌵Xɥᒣ

Try it online! Link includes test cases. Explanation:

T`L`l

Change everything to lower case.

\B[aeiou]\B

Remove all interior vowels.

(.)\1+
$1

Deduplicate consecutive letters.

c
𐍉

Convert c separately because T can only transliterate characters in the BMP.

T`l`Λ\L_Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵\_⋃⌵⌵Xɥᒣ

Transliterate the remaining letters.

Answer 3

Factor + grouping.extras, 178 bytes

[ >lower 1 cut 1 short cut* swap "aeiou"without glue [ ] group-by values [ members ] map-concat [ 97 mod "ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ"nth ] map ]

Try it online!

• >lower Convert to lowercase
• 1 cut 1 short cut* swap Slice the ends off the input (if possible -- that's what short is for) and bring the middle to the top of the stack.
• "aeiou"without glue Remove vowels and put the ends back on.
• [ ] group-by values [ members ] map-concat Consolidate consecutive letters.
• [ 97 mod "ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ"nth ] map Map letters to shorthand characters.

Answer 4

05AB1E, 76 bytes

lā¨Ć≠ÅÏžMм}ÔA•6Eˆ2O:¹VÑX©₃Œl±È“v¬BŒŠ>'µ‰‡S“úÁò›ØIÝZÚþв¬èôÏ&Áθ#›¤mн•Ž‚d·вç‡

Should have been 74 bytes without the {À, but apparently there's a bug in ÅÏ.. :/

Try it online or verify all test cases.

Explanation:

l          # Convert the (implicit) input-string to lowercase
 ā         # Push a list in the range [1,length] (without popping)
  ¨        # Remove the last item to make the range [1,length)
   Ć       # Enclose; append its own head, to have a trailing 1
    ≠      # Check which values are NOT 1
           # (we now have a list of 1s with leading/trailing 0 - e.g. [0,1,1,1,0])
     {À    # No-op bug-fix: sort the list, and rotate it once towards the left
     ÅÏ    # Apply to every truthy (==1) character in the string:
       žM  #  Push vowels-constant "aeoiu"
         м #  Remove those from the current character
      }Ô   # After the apply_on_truthy, connected uniquify the resulting string
A # Push the lowecase alphabet
 •6Eˆ2O:¹VÑX©₃Œl±È“v¬BŒŠ>'µ‰‡S“úÁò›ØIÝZÚþв¬èôÏ&Áθ#›¤mн•
          '# Push compressed integer 3279490039691721988310819230336479163628492048784374634744299180010706872685131111164709021133012715753321092552746940878765
   Ž‚d     # Push compressed integer 33189
      ·    # Double it to 66378
           # (compressing 66378 directly is a byte longer: •15Γ•)
       в   # Convert the large integer to base-66378 as list:
           #  [923,76,66377,42564,8735,9021,84,124,10839,41,60,40,6664,5198,9532,8869,10817,92,10677,95,8899,9013,9013,88,613,5283]
        ç  # Convert each integer to a character with that codepoint
         ‡ # Transliterate the lowercase alphabet to these characters
           # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •6Eˆ2O:¹VÑX©₃Œl±È“v¬BŒŠ>'µ‰‡S“úÁò›ØIÝZÚþв¬èôÏ&Áθ#›¤mн• is 3279490039691721988310819230336479163628492048784374634744299180010706872685131111164709021133012715753321092552746940878765; Ž‚d is 33189; •15Γ• is 66378 ; and •6Eˆ2O:¹VÑX©₃Œl±È“v¬BŒŠ>'µ‰‡S“úÁò›ØIÝZÚþв¬èôÏ&Áθ#›¤mн•Ž‚d·в is [923,76,66377,42564,8735,9021,84,124,10839,41,60,40,6664,5198,9532,8869,10817,92,10677,95,8899,9013,9013,88,613,5283].

Answer 5

Python 3.8 (pre-release), 151 bytes

lambda s:R(r"(.)\1+",r"\1",R("\B[AEIUO]\B","",s.upper())).translate(4*'ᑎ┼⊥⩁\⦵_⋃⌵⌵XɥᒣΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈ')
import re
R=re.sub

Try it online!

-2 thanks to @MarcMush. -1 thanks to @Steffan Test harness borrowed from @solid.py

Answer 6

Perl 5, 103 bytes

Pretty standard approach: lowercase the input, remove the inner vowels, remove duplicated chars and transliterate a-z to the required chars.

$_=lc;s/\B[aeiou]\B//g;s/(.)\1+/$1/g;y;a-z;ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ

Try it online!

Answer 7

Python 3, 180 bytes

lambda w:''.join('ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ'[ord(c)%97]for c in(w[0]+re.sub(r'(.)\1+|[aeiou]','',w[1:-1])+(w[-1],'')[len(w)<2]).lower())
import re

Try it online!

Answer 8

Julia 1.0, 138 bytes

~=replace
!s=(lowercase(s)~r"\B[aeiou]\B"=>"")~r"(.)\1*"=>x->["ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ"...][x[1]-'`']

Try it online!

Just found out that ~ has the same precedence than assignement (with right associativity so the parenthesis are needed), making it the only operator with lower precendence than =>

Answer 9

Vyxal, 80 bytes

ɽ:ẏḢṪṪ‡kvF¨MĠvhṅka»⟇†←¬ʁoĊ ∇"₄[ḃ0εẆḭ:₇°ḃτsf≈β→ƈḭ⅛Ṁǒṡ□ø꘍$↲„I₇⊍ǔ¹eṀHbṡ‛1L»»ƛ∨O»τCĿ

Try it Online!

Port of 05AB1E answer.

How?

ɽ:ẏḢṪṪ‡kvF¨MĠvhṅka»⟇†←¬ʁoĊ ∇"₄[ḃ0εẆḭ:₇°ḃτsf≈β→ƈḭ⅛Ṁǒṡ□ø꘍$↲„I₇⊍ǔ¹eṀHbṡ‛1L»»ƛ∨O»τCĿ
ɽ                                                                                 # Lowercase the (implicit) input
 :                                                                                # Duplicate
  ẏ                                                                               # Get length range [0, length)
   ḢṪṪ                                                                            # Remove the first item and the last two items
      ‡kvF                                                                        # Two element lambda: Remove all vowels from input to lambda
          ¨M                                                                      # Apply z (the lambda) for each element of x (the lowercased input)
                                                                                  #   only at the indices in y (the length range without the first and last two items)
            Ġ                                                                     # Group consecutive identical items
             vh                                                                   # Get the first item of each (this is removing consecutive duplicates)
               ṅ                                                                  # Join by nothing
                ka                                                                # Push the lowercase alphabet
                  »⟇†←¬ʁoĊ ∇"₄[ḃ0εẆḭ:₇°ḃτsf≈β→ƈḭ⅛Ṁǒṡ□ø꘍$↲„I₇⊍ǔ¹eṀHbṡ‛1L»          # Push huge compressed integer 3279490039691721988310819230336479163628492048784374634744299180010706872685131111164709021133012715753321092552746940878765
                                                                        »ƛ∨O»     # Push compressed integer 66378
                                                                             τ    # Convert the huge compressed integer to base-66378:
                                                                                  #  [923,76,66377,42564,8735,9021,84,124,10839,41,60,40,6664,5198,9532,8869,10817,92,10677,95,8899,9013,9013,88,613,5283]
                                                                              C   # Convert that list of codepoints to their corresponding characters
                                                                               ‡  # Transliterate the string made earlier from the lowercase alphabet to these characters

Answer 10

JavaScript (Node.js), 143 bytes

s=>s.replace(/\B[aeiou]\B|(.)(?=\1)|(.)/gi,(a,b,c)=>c?[..."_ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ"][Buffer(c)[0]%32]:'')

Try it online!

Answer 11

Ruby -pl, 103 bytes

gsub(/\B[aeiou]\B/,"").tr_s!"A-Za-z","ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\\\⦵_⋃⌵⌵Xɥᒣ"*2

Try it online!

Answer 12

Charcoal, 99 bytes

≔Φ↧θ¬∧∧κ⁻⊕κＬθ№aeiouιθ⭆Φθ¬∧κ⁼ι§θ⊖κyΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ⌕βι

Try it online! Link is to verbose version of code. Note that the deverbosifier thinks that the embedded string needs to be quoted (at a cost of three bytes) but I disagree. Explanation:

≔Φ↧θ¬∧∧κ⁻⊕κＬθ№aeiouιθ⭆Φθ

Lowercase the string and remove interior vowels.

¬∧κ⁼ι§θ⊖κyΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ⌕βι

Deduplicate consecutive letters and translate from lowercase letters to the desired symbols. Note that the symbols take up 3 or 4 bytes each (I'm relying on the deverbosifier calculation here, as it doesn't actually bother generating the appropriate byte sequences).

Answer 13

Haskell, 200 bytes

import Data.Char
import Data.List
c[h]=[h]
c(h:t)=h:[c|c<-init t,notElem c"AEIOU"]++[last t]
f=map((cycle"ᑎ┼⊥⩁\\⦵_⋃⌵⌵XɥᒣΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈ"!!).ord.head).group.c.map toUpper

Attempt This Online!

Answer 14

POSIX Issue ≤7 Shell + Utilities, 111 characters

tr a-z A-Z|sed 's/./&\
/;s/.$/\
&/'|tr A-Z 'ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ/'|sed 2s/[Λ∟⩗┼⋃ɥ]//g|tr -d \\n|tr -cs 0

Fun fact: since XPG3, tr is defined in terms of characters, and is defined exclusively for characters all the way until SUSv3, which renames -c to -C and adds byte-wise -c.
This is why in present-day POSIX we observe -c which renders the first set the complement of specified values and -C — characters, as well as stuff like [=equivalence classes=] which IIRC is only vaguely supported by the illumos gate? This is a wide-reaching standards blunder. The status of this in Issue 8 and later is unclear.

Not surprisingly, nothing supports this. All implementations behave as-if the data were in the POSIX (C) locale, i.e. they operate on bytes.

For something actual implementations accept, substitute the third line for

&/;y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\\⦵_⋃⌵⌵Xɥᒣ/'|sed 2s/[Λ∟⩗┼⋃ɥ]//g|tr -d \\n|tr -cs 0

this is what the transcript below uses to emulate the answer, but it's also obviously much longer.

$ for w in A Quick Brown Fox Jumps Over The Lazy Dog Turtle Of Terror; do echo $w | ./cg; echo; done
Λ
⩁𐍉<
L\⌵ᑎ
⌽X
)ᨈ⊥⦵
┼⌵\
_|∟
(ᒣɥ
ꙄT
_\_(∟
┼⌽
_\

Answer 15

Go, 289 bytes

import."strings"
func f(s string)(O string){o,S:="",ToUpper(s)
for i:=range S{r,L:=S[i:i+1],len(o)
if L>0&&o[L-1:L]==r{continue}
if!Contains("AEIOU",r)||i<1||i>len(s)-2{o+=r}}
for _,r:=range o{O+=string([]rune(`ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ`)[r-'A'])}
return}

Attempt This Online!

Golang, once again, doesn't have the luxury of regexp lookaheads, lookbehinds, and backreferences, forcing a "manual" implementation. If you can find a Golang-compatible regexp that solved this challenge, leave a comment.

A regexp-using solution using \B[AEIOU]\B is 10 bytes longer than this solution.

Explanation

// required import
import."strings"
func f(s string)(O string){
// setup
o,S:="",ToUpper(s)
// for each char...
for i:=range S{
// get the current char
r:=S[i:i+1]
// if it's a duplicate char, ignore
if len(o)>0&&o[len(o)-1:len(o)]==r{continue}
// if it's not a vowel, or it's a vowel not at the start/end of the string, add it in
if !Contains("AEIOU",r)||i<1||i>len(s)-2{o+=r}}
// translate to the unicode chars
for _,r:=range o{O+=string([]rune(`ΛL𐍉Ꙅ∟⌽T|⩗)<(ᨈᑎ┼⊥⩁\⦵_⋃⌵⌵Xɥᒣ`)[r-'A'])}
return}