title: English An or A?

text:
# Question
Title: English An or A?
Given a string consisting of only upper and lower case letters, output `an` if it begins with a vowel, and `a` if not. For the purposes of this challenge, we'll ignore normal grammar rules, and use a very basic rule instead: if the input begins with a vowel (any of `AEIOUaeiou`), then output `an`. Otherwise, output `a`.

Your program should be case insensitive (`computer` and `CoMpUtER` are the same). This is , so the shortest code in bytes wins

## Test cases

```
airplane: an
water: a
snake: a
hybrid: a
igloo: an
WATER: a
IglOO: an
HoUr: a
unIverSe: an
youTH: a

```

Note that for the last 3, they contradict typical grammar rules, in favour of our simplified rule, and that `y` is not counted as a vowel

# Answer
# Japt v2.0a0 `-mg`, ~~9~~ 8 bytes

Takes input as an array of characters.

```
è\v îÍia

```

Try it

```
è\v çÍia     :Implicit map of each element in input array
è            :Count the occurrences of
 \v          :  RegEx /[aeiou]/gi
    ç        :Repeat that many times
     Í       :  "n"
      ia     :Prepend "a"
             :Implicit output of first element

```

The `Í` is Japt's shortcut for `n2<space>` (Mainly intended for converting binary strings to decimal) The space close the `ç` method and the `n` and the `2` are passed to it as individual arguments but as `ç` only expects one argument the `2` is ignored.
> 6 votes

# Answer
# C (gcc), 44 bytes

```
f(int*s){printf("a%.*s",2130466>>*s&1,"n");}

```

Try it online!

### Commented

```
f(int *s) {     // *s = input string
  printf(       // print ...
    "a%.*s",    //   the letter 'a' followed by a string with
                //   a dynamic length
    2130466     //   using the bitmask of vowels:
                //     1000001000001000100010
                //     ^     ^     ^   ^   ^
                //     utsrqponmlkjihgfedcba_
    >> *s & 1,  //   output 1 character if the first character
                //   is a vowel, or zero otherwise
                //   (assumes that the shift is modulo 32,
                //   which is guaranteed on Intel and may be
                //   true on ARM as well)
    "n"         //   where the string to be printed is "n"
  );            //
}               //

```

---

# C (clang), 39 bytes

This version was suggested by Johan du Toit.

```
f(*s){write(1,"an",(2130466>>*s&1)+1);}

```

Try it online!

---

# C (clang), 36 bytes

This one was suggested by dingledooper.

```
f(*s){puts(2130466>>*s&1?"an":"a");}

```

Try it online!
> 13 votes

# Answer
# Factor \+ `english`, 15 bytes

```
[ >lower a/an ]

```

Almost a builtin. For whatever reason, `a/an` doesn't handle capital letters properly so we need to make it lowercase first. Luckily it's simplistic enough that it doesn't return the correct article for 'universe.'

Doesn't work on TIO because the `english` vocabulary postdates build 1525 (the one TIO uses), so have a picture:
> 8 votes

# Answer
# Python 3, 37 bytes

```
lambda x:'a'+'n'*(x[0]in'aeiouAEIOU')

```

Try it online!

-1 thanks to @xnor
> 6 votes

# Answer
# JavaScript, ~~32~~ 31 bytes

*-1 thanks to @Arnauld*

```
s=>/^[aeiou]/i.test(s)?"an":"a"

```

Try it online!
> 4 votes

# Answer
# Vyxal `r`, 11 9 bytes

```
hk∨c›‛anẎ

```

Try it Online!

```
hk∨c›‛anẎ
h          - First character of input
 k∨       - All vowels ("aeiouAEIOU")
    c      - A in B? ("h" in "k∨"?)
     ›     - Increment
      `an  - Two-byte string literal "an"
         Ẏ - Slice until B (A[0:B])

```

9 bytes thanks to @Aaron Miller
> 4 votes

# Answer
# jq, 36 bytes

```
1?*(test("^[aeiou]";"i")//"a")//"an"

```

Try it online!

Some longer alternatives:

```
"an"[:match("^[aeiou]?";"i").length+1]

```

Try it online!

```
.[:1]|1?*(inside("aeiouAEIOU")//"a")//"an"

```

Try it online!

```
"a"+sub("^([^aeiou](?<x>))?.*";.x//"n";"i")

```

Try it online!
> 4 votes

# Answer
# Dyalog APL, 21 chars

```
'an'↑⍨1+'aeiou'∊⍨⊃∘⎕c

```

Same logic as this Jelly answer. This answer feels too long...
> 4 votes

# Answer
# PowerShell Core, 33 bytes

```
"a"+"n"*("$args"-match"^[AEIOU]")

```

Try it online!

Or 36 bytes without regex

```
"a"+"n"*($args[0]-in("AEIOU"|% t*y))

```

Try it online!
> 3 votes

# Answer
# PHP, ~~36~~ 34 bytes

```
fn($s)=>stripos(_aeiou,$s[0])?an:a

```

Try it online!

Straightforward PHP code. Ignoring accented vowels of course, the `_` is ignored, it is only there so that the index in the string is truthy

EDIT: saved 2 bytes thanks to YetiCGN's suggestions
> 3 votes

# Answer
# JavaScript, ~~91~~ 73 bytes

-18 from @emanresuA

```
a=(s)=>{return 'a'+('AEIOU'.includes(s.charAt(0).toUpperCase())?"n":"");}

```

## Explanation

```
a=                        declares variable
(s)=>{                    ES6 Arrow Function
return 'a'+               return statement
('AEIOU'.includes(        check if in string 'AEIOU'
s.charAt(0)               first letter of string
.toUpperCase())           case insensitivity
?                         ternary operator
"n"                       if true, add 'n'  (an)
:"");                     else, add nothing (a)
}                         finish function

```

Try it Online!

Old TIO link

first time here so let me know if I missed something
> 3 votes

# Answer
# Jelly, 9 bytes

```
ḢeØc‘⁾anḣ

```

Try it online!

The footer simply extracts the test case from the `:` separated string

## How it works

```
ḢeØc‘⁾anḣ - Main link. Takes a string S on the left
Ḣ          - Extract the first character of S
  Øc       - Yield vowels; "AEIOUaeiou"
 e         - Is the first character in that string? Yield 1 if so, else 0
    ‘      - Increment, yielding 2 for vowel-starting strings, 1 otherwise
      ⁾anḣ - Take that many characters of the string ⁾an

```
> 2 votes

# Answer
# Perl 5 `-p`, ~~28~~ 20 bytes

*27 bytes for the actual code; +1 byte for -E to get **say***

*-8 bytes by golfing further*

```
$_=/^[aeiou]/i?an:a

```

Try it online!
> 2 votes

# Answer
# Zsh `--continue-on-error`, 25 bytes

```
>$1:l
s=n<[aeiou]*
<<<a$s

```

Attempt This Online!

When `[aeiou]*` fails to match (i.e., the word begins with a consonant), Zsh would normally exit with a "fatal" error. The aptly named option `CONTINUE_ON_ERROR` overrides this, and simply skips the assignment line `s=n` instead.
> 2 votes

# Answer
# TI-Basic, 43 bytes

```
Input Str1
"a
If inString("AEIOUaeiou",sub(Str1,1,1
"an

```

Ouput is stored in `Ans`.
> 2 votes

# Answer
# , 47 bytes

```
function(s)"if"(grepl("^[aeiou]",s,T),"an","a")

```

Try it online!

Other solutions:

```
function(s)c("a","an")[1+grepl("^[aeiou]",s,T)]   # 47 bytes
function(s)paste0("a","n"[grepl("^[aeiou]",s,T)]) # 49 bytes

```
> 2 votes

# Answer
# Nim, 61 bytes

```
proc a(i:string):string=
 if i[0]in "aeiouAEIOU":"an"else:"a"

```

Try it online!

Simple explanation + ungolfed code:

```
# Define function
proc a(i: string): string =
 # If the first character of 'i' is in "aeiouAEIOU",
 # Then it is a "an"
 if i[0] in "aeiouAEIOU":
  return "an"
 # Else, return "a"
 else:
  return "a"

```
> 2 votes

# Answer
# Java (JDK), 39 bytes

```
s->s.matches("(?i)^[aeiou].*")?"an":"a"

```

Try it online!
> 2 votes

# Answer
# Haskell, ~~80~~ ~~76~~ ~~74~~ ~~64~~ ~~40~~ 35 bytes

*-24 thanks to @Franky*
*-5 thanks to @ovs*

```
a(x:_)='a':['n'|elem x"aeiouAEIOU"]

```

Try it online!
> 2 votes

# Answer
# 05AB1E, ~~12~~ 11 bytes

```
„anžMIнlå>∍

```

Try it online or verify all test cases.

**Explanation:**

```
„an          # Push "an"
   žM        # Push builtin constant "aeiou"
     I       # Push the input-string
      н      # Pop and leave just its first character
       l     # Convert it to lowercase
        å    # Check if this lowercase first letter is in the vowels-string
         >   # Increase it by 1
          ∍  # Shorten the "an" to this length
             # (after which the result is output implicitly)

```
> 2 votes

# Answer
# F#, 61 bytes

```
let a(i:string)=if"aeiouAEIOU".Contains(i.[0])then"an"else"a"

```

Try it online!

Alternative 66 bytes solution:

```
let a(i:string)=if"aeiouAEIOU".Contains(i.Chars(0))then"an"else"a"

```

Try it online!

Check if the input's first character is in `aeiouAEIOU` or not (`if"aeiouAEIOU".Contains(i.Chars(0))`), if true, return "an" (`then"an"`), else, return "a" (`else"a"`)

Ungolfed version:

```
let anOrA (inpt : string) =
 if "aeiouAEIOU".Contains(inpt.Chars(0)) then "an" else "a"

```
> 2 votes

# Answer
# Vim, 20 bytes

```
lD:s/[aeiou]\c/an
ra

```

Try it online!

Explanation:

```
lD                 # Keep only the first character
  :s/[aeiou]\c/an  # Replace any of AEIOUaeiou with 'an'
ra                 # Replace the first character with 'a'

```
> 2 votes

# Answer
# C (clang), 34 bytes

```
f(*s){puts("a\00an"+('A\04D'>>*s&2));}
```

Try it online!

Partial based on dingledooper's answer.

`\00` and `\04` should be replaced by raw bytes instead of using escaped character sequences.
> 2 votes

# Answer
## Python, ~~42~~ 37 bytes

```
lambda s:'a'+'n'*(2130466>>s[0]%32&1)

```

Uses the same logic as this C answer, but I have to take `%32` because python bit shifts aren't modulo 32.

Note that I take advantage of order of operations by using `%32` and `&1` (which is `%2`) to avoid needing parentheses.

(-5): Removed the `ord()` by taking a bytestring (`bytes`) instead of a `str`.
> 2 votes

# Answer
# JavaScript (ES6), 37 bytes

```
s=>'a'+(/[aeiou]/i.test(s[0])?"n":"")

```
> 2 votes

# Answer
# jq, 33 bytes

```
(match("^[aeiou]";"i")|"an")//"a"

```

Try it online!
> 2 votes

# Answer
# CLC-INTERCAL, 144 bytes.

In ISO-8859-1:

```
DO,1<-#99DOWRITEIN,1DO;1<-#2DO;1SUB#1<-#52DO;1SUB#2<-#360(1)DO.1<-',1SUB#3'~#31(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬xDO;1SUB#2<-#0DOCOMEFROM.1DOREADOUT;1

```

## Usage

* Stdin and stdout, both of each as a line.
    + No trailing LF for output.

## Copy and paste the following Bash script to test online on shinh's server!

```
printf %s "$(cat<<'x'
DO,1<-#99DOWRITEIN,1DO;1<-#2DO;1SUB#1<-#52DO;1SUB#2<-#360(1)DO.1<-',1SUB#3'~#31(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬xDO;1SUB#2<-#0DOCOMEFROM.1DOREADOUT;1
x
)" | iconv -f UTF-8 -t LATIN1 >x.i
wc -c x.i
sick x.i
while IFS=: read x _; do
echo $x
./x.io <<<$x
echo
done<<'x'
airplane: an
water: a
snake: a
hybrid: a
igloo: an
WATER: a
IglOO: an
HoUr: a
unIverSe: an
youTH: a
x

```

## How it works

The idea was just to make "an" on the variable `;1` and then erase "n" unless vowel. I used Baudot character set for input.
> 2 votes

# Answer
# International Phonetic Esoteric Language, 40 bytes

```
0h"aeiouAEIOU"dʔdpʌɔ|a|"an"ɔ|e||a|"a"|e|

```

Expects a string, leaves the string and a `"a"` or `"an"`.

### Ungolfed:

```
               (s -- a/an)
0h             (first char)
"aeiouAEIOU"dʔ (is c a vowel?)
dp             (discard vowels)
ʌɔ|a|          (if c is not a vowel, go to |a|)
|an|"an"ɔ|end| (when c is a vowel)
|a|"a"         (when c is not a vowel)
|end|

```
> 2 votes

# Answer
# GAIA, 32 bytes

```
{(⟨₵v&!!⟩⟨₵V&!!⟩v}⟨“a”p⟩⟨“an”p⟩?

```

Try it online!

Probably could be shortened, especially on the second section.

Explanation:

```
( -takes first letter of the input

₵v& - is member (&) of string aeiou (₵v) -> returns the contained letter if member, empty if not.

₵V& - is member (&) of string AEIOU (₵V) -> returns the contained letter if member, empty if not.

!! - if the passed value is empty returns 0, otherwise 1

v - is logical or

{(⟨₵v&!!⟩⟨₵V&!!⟩v} - so this checks if the first letter is member of either lower or upper case vowels

⟨“a”p⟩⟨“an”p⟩? - this checks for the value passed by the first section, if true executes the first member, if false the second.

p -prints a string

```
> 2 votes

# Answer
# K (ngn/k), 21 bytes

**Solution:**

```
{$`an`a@^"aeiou"?*_x}

```

Try it online!

**Explanation:**

```
{                   } / function taking implicit x argument
                  _x  / convert x to lowercase
                 *    / take first
         "aeiou"?     / find right in left
        ^             / null?
  `an`a@              / index into 2-item list (`a;`an)
 $                    / convert to string

```
> 2 votes

# Answer
# Perl 5 \+ `-pl`, 19 bytes

```
$_=a.n x/^[aeiou]/i

```

Try it online!

---

# Perl 5 \+ `-lpF/^([aeiou]).*$/i`, 11 bytes

Using `-F` and the resulting `$#F` can save a bunch of bytes.

```
$_=a.n x$#F

```

Try it online!
> 1 votes

# Answer
# Ly, 35 bytes

```
"aeiou">ir'aL' *+s<l~s<'al['nf!]p&o

```

Try it online!

Takes advantage of the constraints on the input, meaning we can assume it's only upper or lower case letters....

```
"aeiou"                             - Push codepoints for the vowels on the stack
       >i                           - Switch to clean stack, read input
         r                          - Reverse stack (first char/codepoint to top)
          'aL                       - Is it uppercase?
             ' *                    - Push "32" and multiple w/ test results
                +                   - Add to the codepoint (maps it to lowercase)
                 s<                 - Save the resulting codepoint, switch stacks
                   l~               - Load the char/codepoint, search on stack
                     s<             - Save boolean result, switch to clean stack
                       'a           - Push "a" on the stack
                         l[  f!]p   - if/then "true" if a vowel
                           'n       - Push "n" on the stack
                                 &o - Print the stack

```
> 1 votes

# Answer
# Kotlin, 39 bytes

```
{if(it[0]in "AEIOUaeiou")"an" else "a"}

```

Try it online!
> 1 votes

# Answer
# Charcoal, 13 bytes

```
a¿№aeiou↧§Ｓ⁰n

```

Try it online! Link is to verbose version of code. Explanation:

```
a

```

Always output an `a`.

```
¿№aeiou↧§Ｓ⁰

```

If the lowercased first letter of the input can be found in the string `aeiou`, then ...

```
n

```

... output an `n`.
> 1 votes

# Answer
# Retina 0.8.2, 23 bytes

```
i`([aeiou])?\w+
a$#1$*n

```

Try it online! Link includes test cases. Explanation: The first letter of the word is case-insensitively checked for a vowel and the word replaced with `a` plus an `n` if the first letter was a vowel.
> 1 votes

# Answer
# Lexurgy, 89 bytes

Typical Lexurgy pattern: Match some text, place a marker, delete everything past and including the marker.

```
a:
*=>an|/$ _ {a,e,i,o,u,A,E,I,O,U}
else:
*=>a|/$ _
b propagate:
[]=>*/| _
c:
|=>*

```

## Alternative, 52 bytes

```
a:
*=>a\ /$ _
n:
\ =>n\ /$ a _ {a,e,i,o,u,A,E,I,O,U}

```

Returns the input string with `a`  or `an`  prepended.
> 1 votes

# Answer
# Go, ~~102~~ 96 bytes

```
import."regexp"
func f(s[]byte)string{l:="a";if a,_:=Match("(?i)^[aeiou]",s);a{l+="n"};return l}

```

Attempt This Online!

Regex matching for beginning vowel, case insensitive.

* -6 by @The Thonnu
> 1 votes

# Answer
# Stax, 9 bytes

```
ü╟(sGö╥"▼

```

Run and debug it

### Approach

1. Get first character of input
2. Is it a consonant? Result is an integer
3. Right-trim that many characters from `"an"`.
> 1 votes

# Answer
# Pushy, 22 bytes

```
@O`AEIOUaeiou`vK=u13*q

```

Try it online!

I think this one is quite slick!

```
                         \ Input is on the INPUT stack
@                        \ Reverse the input (so first letter is on top of stack)
 O                       \ Go to the OUTPUT stack
  `AEIOUaeiou`           \ Push all vowels
              v          \ Bring the first letter to this stack
               K=        \ Pop and check equality in place, replacing each vowel with
                         \ 0 or 1 accordingly.
                 u       \ Remove duplicates from the stack and sort ascendingly.
                         \        If first letter was a vowel: we now have [0,1]
                         \        Otherwise: we have [0].
                  13*    \ Multiply all stack elements by 13.
                         \        If first letter was a vowel: we now have [0,13]
                         \        Otherwise: we have [0].
                     q   \ Interpret the stack as lowercase alphabet, indexing mod 26.
                         \ Print the result.

```
> 1 votes

# Answer
# Scala, 45 bytes

```
s=>if(s.matches("(?i)^[aeiou].*"))"an"else"a"

```

Try it online!
> 1 votes

# Answer
# Lua, 44 bytes

```
print((...):find'^[aieouAEIOU]'and'an'or'a')

```

Try it online!
> 1 votes

# Answer
# Logically, ~~373~~ ~~358~~ 348 Bytes

```
@e:2i:o:b;XOR(2i)(b)NOT(b)(o)
@E:4a,4b:o:4t;AND(4t)(o)e(a0,b0)(t0)e(a1,b1)(t1)e(a2,b2)(t2)e(a3,b3)(t3)
@A:4i,4a,4b,4c,4d,4e:o:5t;OR(5t)(o)E(4i,4a)(t0)E(4i,4b)(t1)E(4i,4c)(t2)E(4i,4d)(t3)E(4i,4e)(t4)
@M b:8t,_,j,k;WRITE(h,h,l,l,l,l,h,h,l)()READ(h)(_,8t)A(t4,t3,t2,t1,l,l,l,l,l,l,h,l,l,h,l,l,l,h,h,h,h,l,h)(j)AND(j,t0)(k)WRITE(k,l,h,h,h,l,h,h,l)()

```

## Ungolfed

```
@Equals
i: 4a, 4b;
o: o;
b: 4t;
AND(4t)(o)
XOR(a0,b0,1)(t0)
XOR(a1,b1,1)(t1)
XOR(a2,b2,1)(t2)
XOR(a3,b3,1)(t3)

@EqualsAny
i: 4i, 4a,4b,4c,4d,4e
o: o;
b: 5t;
OR(5t)(o)
Equals(4i,4a)(t0)
Equals(4i,4b)(t1)
Equals(4i,4c)(t2)
Equals(4i,4d)(t3)
Equals(4i,4e)(t4)

@Main
b:8t,_,j,k;
WRITE(h,h,l,l,l,l,h,h,l)()
READ(h)(_,8t)
EqualsAny(t4,t3,t2,t1,
        l,l,l,l,
        l,l,h,l,
        l,h,l,l,
        l,h,h,h,
        h,l,h,l)(j)
AND(j,t0)(k)
WRITE(k,l,h,h,h,l,h,h,l)()

```

First, Writes an `'a'` to STDOUT. Simultaniously it reads a byte from STDIN.

The byte is then tested as a vowel by first confirming:

* The 2^1 through 2^4 bits are one of the following: `0000`, `0100`, `0010`, `1110`, `0101`, which is checked via a big "EqualsAny" gate.
* The 2^0 bit is high through a seperate And gate
* The 2^5 bit is ignored, as that controls for case.
* Bits 2^6 and Bits 2^7 are ignores as we are garunteed a letter

When the result is pulled high, an `'n'` is sent to STDOUT. Otherwise, the chip terminates.
> 1 votes

# Answer
# Thunno 2, 7 bytes

```
ṃh⁺`anɱ

```

Try it online!

#### Explanation

```
ṃh⁺`anɱ  # Implicit input
ṃh       # Is the first letter a vowel?
  ⁺      # Increment (0|1) -> (1|2)
   `anɱ  # Take the first characters from "an"
         # Implicit output

```
> 1 votes

# Answer
# Vyxal, 54 bitsv1, 6.75 bytes

```
hA›‛anẎ

```

Try it Online!

Independently discovered.

## Explained

```
hA›‛anẎ
hA       # Is the first letter a vowel?
  ›      # Increment the boolean
   ‛anẎ  # And get "an"[0:that]

```

Created with the help of Luminespire.
> 0 votes

# Answer
# CLC-INTERCAL, 126 bytes, CAPITAL OUTPUT

```
(1000)DO$@1SUB#1<-#3DO$@1SUB#2<-#12(1)DO.1<-2@1SUB#3(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬xDO$@1SUB#2<-#0DOCOMEFROM.1~#31DOFINISHLECTURE

```

## Usage

Now `1@1` (which is usually `$@1`) is *tail* output; one of `A` or `AN` shall be written. `2@1` is tail input.

## Example

```
DOSTUDY#1AT(1000)INCLASS@1
DOENSLAVE@1TO,1
DOENROL,9TOLEARN#1
DO,9<-#2   DONOTE output
DO,1<-#99  DONOTE input
DOCOMEFROM#99
(33)DOWRITEIN,1
DO,9LEARNS#1
(99)DOREADOUT,9
DONEXTFROM#33
DO.1<-,1SUB#1
DORESUME'.1~.1'~#1

(1000)DO$@1SUB#1<-#3
DO$@1SUB#2<-#12
(1)DO.1<-2@1SUB#3
(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬x
DO$@1SUB#2<-#0
DOCOMEFROM.1~#31
DOFINISHLECTURE

```

# CLC-INTERCAL, 131 bytes

First ever lecture answer. Lecturified user100411's answer

```
(1000)DO$@1SUB#1<-#52DO$@1SUB#2<-#360(1)DO.1<-'$$@1SUB#3'~#31(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬xDO$@1SUB#2<-#0DOCOMEFROM.1DOFINISHLECTURE

```

## Usage

`$@1` is hybrid output to have a string of either "a" or "an" which must be predimensioned. `$$@1` is tail input to have English word.

## How it works

Using Baudot code for input.

```
(1000)DO$@1SUB#1<-#52
DO$@1SUB#2<-#360              DONOTE $@1 is "an"
(1)DO.1<-'$$@1SUB#3'~#31      DONOTE these five labels represent vowels
(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬x DONOTE
DO$@1SUB#2<-#0                DONOTE $@1 is "a"
DOCOMEFROM.1                  DONOTE come from those five labels
DOFINISHLECTURE

```

## Example

```
~ $ cat > a.i
DOSTUDY#1AT(1000)INCLASS@1
DOENSLAVE;1TO,1
DOENROL;1TOLEARN#1
DO;1<-#2
DO,1<-#99
DO,2<-#1
DOCOMEFROM#99
(33)DOWRITEIN,1
DO;1LEARNS#1
(99)DOREADOUT;1+,2
DONEXTFROM#33
DO.1<-,1SUB#1
DORESUME'.1~.1'~#1

(1000)DO$@1SUB#1<-#52
DO$@1SUB#2<-#360
(1)DO.1<-'$$@1SUB#3'~#31
(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬x
DO$@1SUB#2<-#0
DOCOMEFROM.1
DOFINISHLECTURE
~ $ sick -lRun a.i
Ant
an
ant
an
bat
a
Bat
a
E
an
e
an
i
an
I
an
o
an
O
an
u
an
U
an
P
a
Q
a
[EOF actually]
*621 Pointless RESUME

```
> 0 votes

# Answer
# Uiua, 25 bytes

```
("a"|"an")∊:"aeiouAEIOU"⊢

```

Test pad
> 0 votes

---
Tags: code-golf, string, natural-language, alphabet
---