Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
I have a string like this:
s = "helloworldandhellocodegolf"
I want to make every consonant after a vowel uppercase.
Desired output:
heLloWoRldaNdheLloCoDeGoLf
As you can see, l gets uppercased because it's right after the vowel e etc..
If there are repeated vowels, like:
s = "aabeekad"
Desired output:
s = "aaBeeKaD"
This is code-golf, so shortest code in bytes wins.
The consonants are all alphabet characters except for aeiou.
Expects and returns a string.
s=>Buffer(s).map(c=>c^s&~(s=68174912>>c)&32)+''
The constant \$68174912\$ (which I've already used here) is a bitmask describing the positions of the vowels:
00000100000100000100010001000000
v v v v v
zyxwvutsrqponmlkjihgfedcba`_^]\[
s => // s = input string
Buffer(s) // turn it into a buffer
.map(c => // for each ASCII code c:
c ^ // toggle the case if
s & // the previous letter was a vowel
~( // and the current letter is a consonant
s = // save in s the new state obtained by
68174912 // right-shifting the bit-mask
>> c // by c positions (mod 32)
) & 32 // isolate the case bit
) + '' // end of map(), coerce back to a string
Expects and returns an array of ASCII codes.
a=>a.map(p=c=>c^p&~(p=68174912>>c)&32)
A full program that takes input from STDIN, and outputs to STDOUT.
c;main(d){for(;read(0,&c,1);)putchar(c^d-(d='Xz'%c>0)&32);}
I use the same formula to check for vowels as in this other task. Here, (d='Xz'%c>0) sets d equal to \$ 0 \$ if the current letter c is a vowel, and \$ 1 \$ otherwise. c should be uppercased if and only if the current d is \$ 1 \$, and the previous d is \$ 0 \$. To apply the uppercasing, c is XOR'ed with \$ 32 \$, but only when the conditions are met. Below is a table to visualize what is happening:
| prev_d | d | prev_d - d | & 32 | ^ c |
-+--------+---+------------+------+------+-
| 0 | 0 | 0 | 0 | c |
| 0 | 1 | -1 | 32 | 32^c |
| 1 | 0 | 1 | 0 | c |
| 1 | 1 | 0 | 0 | c |
read(0,&c,1) only work when int is little endian?
\$\endgroup\$
Dec 17, 2022 at 10:42
~(c=getchar()) works at the cost of a byte.
\$\endgroup\$
Dec 17, 2022 at 22:42
36865%x>14 is the same length as 'Xz'%c>0. Unfortunately I couldn't find a way to compress 36865, or any of the other numbers you found.
\$\endgroup\$
x=>x.replace(/(?<=[aeiou])[^aeiou]/g,x=>x.toUpperCase())
-p, s/[aeiou]\K[^aeiou]/\U$&/g
-3 bytes thanks to Sisyphus
-1 byte thanks to Jo King
\zp⁽AḊ⁽ǐẆṅḢ
This is a terrible way to do it but it works.
\zp⁽AḊ⁽ǐẆṅḢ
\zp # Prepend "z" so that there is a leading consonant
⁽AḊ # Adjacent-group by is-vowel
⁽ǐẆ # Title-case every second item, starting on the first item
ṅḢ # Join by nothing and remove the leading "z"
`° ß`$‡ǐNøṙ
An alternate 11 byter that uses regex
See this golfing tip of mine that explains why the string "° ß" is "[aeiou] [bcdfghjklmnpqrstvwxyz]"
`° ß`$‡ǐNøṙ
`° ß` # The string `[aeiou] [bcdfghjklmnpqrstvwxyz]`
$ # Make the stack input, ^
‡ǐN # Push a function that title cases a string and then swapscase.
# This is because regex matches will be vowel-consonant, and title case makes the vowel uppercase, consonant lowercase, swapcase inverts that for the desired result
øṙ # Apply that function to regex matches in the input
import(."regexp";."strings")
func f(s string)string{return MustCompile(`[aeiou][^aeiou]`).ReplaceAllStringFunc(s,func(x string)string{return x[:1]+ToUpper(x[1:])})}
No (?<=), non-capturing groups only work with Find(All)String(Submatch) which leads to a longer solution, so this mess is what I've had to come with.
d=0
for c in input():print(end=[c,c.upper()][d>(d:=c in"aeiou")])
Complete program. Thanks to @Neil and @Steffan for making this more concise. Try it online!
lambda x:re.sub("(?<=[aeiou])[^aeiou]",lambda a:a[0].upper(),x)
import re
Function solution. Try it online!
aRXV.XC;@_.UC_@1
-5 bytes thanks to @DLosc
Regex solution, ported from @Steffan's regex, with some pip builtin regex patterns used to save bytes
{Iy>YaNVWUC:aa}Ma
-4 bytes thanks to @DLosc
Non-regex alternative
"aeiou"0>ir[sp<l~!' **lf-ol~>]
This isn't even close to the smallest, but the way it works is probably very different from other languages, so I thought it was worth posting.
It uses two stacks, one with a list of vowels, and one with the STDIN string. Each character on the STDIN stack is copied to the vowel stack and the code search to see if there's a match. That "am I a vowel" result is combined with a "was the last char as vowel" result that lives on the stack to decide whether or not to capitalize the current character before printing it.
"aeiou" - push "is a vowel" comparison data on stack
0 - push "0" as "was last char a vowel" starter val
>i - switch to new stack, read STDIN onto it
r - reverse stack
[ ] - for each input char/codepoint
sp<l - stash the char, delete, switch stacks and restore
~! - search for the char in "aeiou", negate result
' - push " " (32), the "capitalize" codepoint offset
* - multiple to clear if not this IS a vowel
* - multiple against "was previous char vowel?" result
l - reload the current char/codepoint
f- - flip stack and subtract to capitalize if needed
o - output current char
l~ - reload char, search against vowels
> - switch back to the STDIN stack
:s/[aeiou]\+\zs./\u&/g<cr>
:s/ # Search and replace...
[aeiou]\+ # A string of one or more vowels
\zs # (start the match here)
. # Any character
# (because of greedy matching, this will always be the first consonant)
/ # Replace with
\u # Make uppercase
& # The matched string (after \zs)
/g<cr> # Replace all occurrences
T`aeioul`aeiouL`[aeiou]+.
Try it online! Explanation: Transliterates vowels to themselves and other lowercase letters to uppercase letters, but only the letter after a run of vowels. (This is so that a double vowel doesn't confuse the transliteration.)
Alternative, also 25 bytes:
rT`aeioul`aeiouL`[aeiou].
Try it online! Explanation: The r makes it match the pattern from right to left solving the double vowel problem.
Both programs work in Retina 1 but 8 bytes can be saved because the aeiou can be replaced by v in the transliteration patterns.
f(s,[d=0])=>String.fromCharCodes([for(s in s.runes)s^d&~(d=68174912>>s%32)&32]);
Extra test-cases:
| Input | Output |
|---|---|
| loremipsumdolorsitamet | loReMiPsuMdoLoRsiTaMeT |
| namauctoranteelementumarculaciniaaceuismodestiaculis | naMauCtoRaNteeLeMeNtuMaRcuLaCiNiaaCeuiSmoDeStiaCuLiS |
Thanks to @steffan who cut down to 80 bytes (!) by porting @arnauld answer.
f(s,[v,i=0])=>s.split('').map((e)=>i++<1||!(v='aeiou'.contains)(s[i-2])||v(e)?e:e.toUpperCase()).join();
\$\endgroup\$
f(s,[d=0])=>s.split('').map((e)=>d>(d='aeiou'.contains(e)?1:0)?e.toUpperCase():e).join();
\$\endgroup\$
f(s,[d=0])=>String.fromCharCodes([for(s in s.runes)s^d&~(d=68174912>>s%32)&32]);
\$\endgroup\$
d;f(*s){for(d=1;*s;)*s++^=d-(d='Xz'%*s>0)&32;}
dingledooper's answer as a function.
⭆θ⎇№⌕Ａ⭆θ№aeiouλ10⊖κ↥ιι
Try it online! Link is to verbose version of code. Explanation: Maps each letter to its vowel-ness as a binary flag, then searches for the substring 10 in the result, the second character of which is where the consonants that needs to be uppercased are.
θ Input string
⭆ Map over letters and join
№ Count of
κ Current index
⊖ Decremented
θ In input string
⭆ Map over letters and join
№ Count of
λ Inner letter in
aeiou Literal string `aeiou`
⌕Ａ Find all matches of
10 Literal string `10`
⎇ If found then
ι Current consonant
↥ Uppercased
ι Else current letter
Implicitly print
s/[aeiou][^aeiou]/\U\l&/g
It makes the whole match uppercase and then it turns first letter to lowercase. This is 5 bytes shorter than s/([aeiou])([^aeiou])/\1\u\2/g solution and it also doesn't require -E flag.
'zì.γžMså}2Å€™}J¦
Port of Steffan's Vyxal answer
'zì.γžMså}2Å€™}J¦ # Implicit input TOP OF THE STACK:
'zì # Prepend a 'z' "zhelloworldandhellocodegolf"
.γ } # Group by
žM # The string of vowels 'aeiou'
så # Contains the letter ["zh", "e", "ll", "o", "w", "o", "rld", "a", "ndh", "e", "ll", "o", "c", "o", "d", "e", "g", "o", "lf"]
2Å€ } # Every second item:
™ # Convert to title case ["Zh", "e", "Ll", "o", "W", "o", "Rld", "a", "Ndh", "e", "Ll", "o", "C", "o", "D", "e", "G", "o", "Lf"]
J # Join everything 'ZheLloWoRldaNdheLloCoDeGoLf'
¦ # And remove the leading 'z' 'heLloWoRldaNdheLloCoDeGoLf'
š can be ì so the input will remain a string. Then you can change .å to å and remove the first J for -2. In addition, 05AB1E has an every b'th builtin (Å€), so ā<ÈÅÏ™} can be 2Å€™} for another -2. 17 bytes
\$\endgroup\$
Dec 27, 2022 at 10:48
Œue€ØḄ<ƝŻTƲ¦
A monadic Link that accepts a list of lowercase characters and yields a list of characters.
Œue€ØḄ<ƝŻTƲ¦ - Link: list of lowercase characters, S
¦ - sparse application (to S)...
Ʋ - ...to indices: last four links as a monad - f(S):
ØḄ - lowercase consonants
€ - for each (character in S):
e - exists in? -> 1 if a consonant else 0
Ɲ - for neighbours:
< - less than? -> 1 if [0,1] else 0
Ż - prepend a zero
T - truthy indices -> indices of consonants directly after a vowel
Œu - ...action: convert to uppercase
--extendedglob, 52 bytes<<<${1//(#m)[aeiou][^aeiou]/$MATCH[1]${(U)MATCH[2]}}
lambda x:"".join(b.upper()if a in"aeiou"and b not in"aeiou"else b for a,b in zip(" "+x,x))
Would be 71 bytes if didn't have to deal with repetitive vowels, still got 90 bytes though. Try it online!
S) each occurrence (globally, :g) in the input string of one or more vowels (<[aeiou]>+) followed by any character (.) by the matched text ($/) converted to uppercase (.uc). Or rather it would do that if not for the capture marker (<() which causes the matched text to include only the single character following the vowels, so that's the only character that gets replaced with its uppercase version. The opening capture marker <( can be paired with a closing marker )>, but it's unnecessary here since the matched text extends to the end of the string.
\$\endgroup\$
sm?*Z!=Z}d"aeiou"r1
sm?*Z!=Z}d"aeiou"r1ddQ # implicitly add ddQ to the end
# implicitly assign Q = eval(input())
s # sum of
m Q # map lambda d over Q
? # ternary if (
*Z! # Z and not
=Z}d"aeiou" # assign Z to d being a vowel):
r1d # d capitalized
d # else: d
->(s){v="aeiou";s.chars.map.with_index{v.include?(s[_2-1])&&!v.include?(_1)?(_1.upcase):_1}.join}
