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!

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:

Python 3, 37 bytes

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

Try it online!

-1 thanks to @xnor

JavaScript, 32 31 bytes

-1 thanks to @Arnauld

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

Try it online!

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!

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

Dyalog APL, 21 chars

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

Same logic as this Jelly answer. This answer feels too long...

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!

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

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!

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

Scratch, 69 bytes

Run it here

(The executing script does not need to be counted. Look inside and find the custom block for the code)

define(x say(join[a](letter<[aeiouAEIOU]contains(letter(1)of(x))>of[n 

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 

TI-Basic, 43 bytes

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

Ouput is stored in Ans.

R, 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 

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" 

Java (JDK), 39 bytes

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

Try it online!

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) 

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!

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" 

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' 

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.

JavaScript (ES6), 37 bytes

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

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.

jq, 33 bytes

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

Try it online!

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.

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| 

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 

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