What's my middle name?

Question

Note: The winning answer will be selected on 4/12/17 the current winner is Jolf, 1 byte.

I'm surprised that we haven't had a what's my middle name challenge on this site yet. I did alot of searching but found nothing. If this is a dup, please flag it as such.

Your challenge

Parse a string that looks like Jo Jean Smith and return Jean.

Test cases

Input: Samantha Vee Hills
Output: Vee

Input: Bob Dillinger
Output: (empty string or newline)

Input: John Jacob Jingleheimer Schmidt
Output: Jacob Jingleheimer

Input: Jose Mario Carasco-Williams
Output: Mario

Input: James Alfred Van Allen
Output: Alfred Van 

(That last one is incorrect technically, but fixing that would be too hard.)

Notes:

• Names will always have at least 2 space-separated parts, with unlimited middle names between them or can be a list/array of strings.
• Names may contain the alphabet (case-insensitive) and - (0x2d)
• You may output a trailing newline.
• You may require input to have a trailing newline.
• Input from STDIN, a function parameter, or command-line argument is allowed, but hard-coding it in is not allowed.
• Standard loopholes forbidden.
• Output may be function return value, STDOUT, STDERR, etc.
• Trailing spaces/newlines/tabs in the output are allowed.
• Any questions? Comment below!

This is code-golf, so the shortest anwser in bytes wins!

Answer 1

Matlab, 81, 79, 78, 55 Bytes

function x=a(s)
s=strsplit(s);x=strjoin(s(2:end-1));end

Takes in an input string, s, is split (by the default delimiter, whitespace char) into a cell array, from which the middle element is accessed. Then the middle elements are concatenated, or an empty string is returned.

Edit: thanks to Luis Mendo for saving 3 bytes!

Edit 2: Better solution from Ankit!

Answer 2

C, 42 bytes

f(char**b){for(;b[2];printf("%s ",*++b));}

The parameter is a NULL terminated array of pointers to char.

See it work here.

The command line arguments may also be used with the same function.

C, 51 bytes

main(a,b)char**b;{for(;b[3];printf("%s ",b++[2]));}

A full program. Input is done through command line arguments.

See it work here.

C, 54 bytes

f(char**b){*strrchr(*b=strchr(*b,32),32)=0;*b+=!!**b;}

The parameter is an in/out parameter.

See it work here.

Answer 3

Clojure, 43 bytes:

#(drop 1(butlast(read-string(str"("%")"))))

Here we read string as an edn data, then choosing its center.

Or for stdout, 57 bytes:

#(apply pr-str(drop 1(butlast(read-string(str"("%")")))))

You can also check it here.

Answer 4

Powershell, 32 bytes

''+($args|sls ' .+ '|% m*)|% t*m

Test script:

$f = {
''+($args|sls ' .+ '|% m*)|% t*m
}

@(
    ,("Samantha Vee Hills"    ,"Vee")
    ,("Bob Dillinger"    ,"")
    ,("John Jacob Jingleheimer Schmidt"    ,"Jacob Jingleheimer")
    ,("Jose Mario Carasco-Williams"    ,"Mario")
    ,("James Alfred Van Allen"    ,"Alfred Van")
) | % {
    $name,$expected = $_
    $result = &$f $name
    "$($result-eq$expected): $expected"
}

Output:

True: Vee
True:
True: Jacob Jingleheimer
True: Mario
True: Alfred Van

Answer 5

Brainfuck, 98 bytes

>+[,>++++[<-------->-]<]>++++[<++++++++>-]<[>,]++++[<-------->-]<[[-]++++[<-------->-]<]<[<]>>[.>]

Explanation

>+[,>++++[<-------->-]<] Skip input until first space

>++++[<++++++++>-]< Store a Space char incase there is no middle name
[>,] Store input to a char array

++++[<-------->-]<[[-]++++[<-------->-]<] Goto the last space and zero the last space

<[<] Goto the start of the char array
>>[.>] Print the char array

Answer 6

AWK, 9 bytes

NF--,$1=a

Try it online!

NF--,     - Cut out the last argument (also eval's to "true")
     $1=a - Blank out the first argument

Since there's always at least 2 input fields NF--1 is always truthy, so the code prints $0.

In case the leading space isn't allowed (the question was asked in the comments under the initial posting but there was no response), then this is the shortest I've come up with.

AWK, 15 bytes

NF-=sub($1FS,a)

Try it online!

    sub($1FS,a)  - Remove the first field, plus space from the input
NF-=             - Decrement "NF" by one (the return from "sub")

Answer 7

Factor, 17 16 bytes

[ rest 1 head* ]

(-1 byte as 1 head* is 1 byte shorter than but-last.)

Explanation:

It's a quotation (anonymous function) that takes a sequence of strings as input and leaves a sequence of strings as output.

• rest Take all elements of a sequence but the first.
• 1 head* Take all elements of a sequence but the last.

Answer 8

Fig, \$2\log_{256}(96)\approx\$ 1.646 bytes

pq

Try it online!

pq
 q # Remove the tail
p  # Remove the head

Answer 9

Python 2, 42 19 16 Bytes

lambda n:n[1:-1]

Try it online! Thanks to @Kritixi Lithos for saving 23 bytes! Thanks @math_junkie for saving 3 more bytes. For input, put each part of the name as a string within a list like so:

["Samantha", "Vee", "Hills"]

And yes, the OP has approved a list to be a valid input.

Explanation

lambda n:n[1:-1]    # Returns only the middle elements... pretty literal here

Answer 10

C++, 91 bytes

#import<list>
#import<string>
void f(std::list<std::string>&n){n.pop_front();n.pop_back();}

Takes input as a reference to a list of strings and modifies the list directly.

Try it online!

Answer 11

APL (Dyalog), 8 6 bytes

¯1↓1↓⊢

Try it online!

This is a tacit train.

Explanation

When ↓ is a dyad, it returns all but the first/last n elements of its vector argument.

   1↓                  ⍝ Remove the first element in the 
     ⊢                 ⍝ right argument
¯1↓                    ⍝ and remove the last element

Answer 12

Bash, 31 19 bytes

echo ${@:2:$[$#-2]}

Try it online!

Breakdown:

Prints parameter expansion from second to second last element.

Edit

Removed commented code from breakdown section, since it's now just one line long.

-12 bytes thanks to Neil

Answer 13

CJam, 6 bytes

{1>W<}

Anonymous block that expects an array of strings on the stack, and leaves an array of strings after.

Try it online!

Explanation

1>    e# Slice the array after the first element
  W<  e# Slice the array before the last element

Answer 14

REXX, 42 bytes

arg a
say delword(delword(a,words(a)),1,1)

Answer 15

Ruby, 13 bytes

->s{s[1..-2]}

The author confirmed in comments that the input and output can be arrays.

Answer 16

Japt, 3 bytes

ůJ

Try it or run all test cases

Answer 17

C (gcc), 144 139 91 86 bytes

y,z;char*f(char*s){for(y=0;*++s-32;);for(;s[y];y++)z=s[y]-32?z:y;z[s]=0;return!!*s+s;}

Try it online!

-48 bytes by learning C over the past year and a half since I first posted this

-7 bytes from Jonathan Frech

A function that takes in a char* and outputs a char* corresponding to the (character after the) first space in the string, but also edits the string so that it's last space is replaced with \0.

Note: this function will segfault if given a string without a space in it.

Full program:

y;z;char*f(char*s){y=0;while(*++s-32);while(s[y]){z=s[y]-32?z:y;y++;}s[z]=0;return s+!!*s;}
int main(int argc, char *argv[]){
	for (int i = 1; i < argc; ++i)
		printf("%s\n",f(argv[i]));
}

Un-golfed:

char *middle(char* name) {
	int index = 0, lastspace;
	while(name[0] != ' ') // move name pointer forward to the first space
		++name;
	while(name[index] != '\0') { // find the index in the (new) string of the last space
		if (name[index] == ' ') lastspace = index;
		index++;
	}
	name[lastspace] = '\0'; // Terminate the string at the last space
	if (name[0] == '\0') return name; // If the last space was the first space, return the empty string
	else return name + 1; // Else, return the new string
}

Try it online!

Answer 18

Perl 5 + -p040, 13 bytes

$_ x=$.>1&/ /

Try it online!

Explanation

With -p, input is implicitly stored in $_, the 040 flag makes space the line terminator which means the code is called for each word/name in the input. x= is the in-place string repetition operator which modifies the string in place (e.g. $_="abc";$_ x=3;# "abcabcabc") and the condition is $.>1 ($. is set to the current 'line' number, although since space is our line end character this is word/name number) &ed with / / (if $_ m//atches , which it will for all but the last word/name). Because of -p the result (the string repeated zero or one times depending on the conditional) is implicitly printed.

Answer 19

GolfScript, 6 bytes

~(;);`

Try it online!

Input is taken in the form of ["name""name""name"]. Input string is converted to an array, then the first and last elements are separated and discarded, and the result is formatted and outputted.

Answer 20

Pip -s, 8 bytes

@<@>Ya^s

Try it online!

-1 from DLosc.

Answer 21

Dash, 24 bytes

g=\ ${*#* };echo ${g% *}

Try it online!

Input via args.

Also handles the unmentioned case of a single name being provided, returning nothing.

While this feels not that clever compared to the posted bash answer, that answer doesn’t work in Dash and this is the best I could muster within its restrictions.

Answer 22

Vyxal S, 2 bytes

ḢṪ

Try it Online!

Removes head and tail of list. S flag joins by spaces.

Answer 23

K (ngn/k), 25 24 bytes

{" "/*(1;-1+#t)_t:" "\x}

Try it online!

Down 1 byte by using assignment in expressions

Does the same thing as the APL answer.

Explanation:

{" "/*(1;-1+#t)_t:" "\x}    Main function. Takes x as input
                  " "\x     Split x by whitespace
                t:          Assign to variable t
      (       )_            Then delete the following elements in t:
       1;                   The first element, followed by
            #t              The length of t
         -1+                - 1
                            Delete returns back the string as an array, so we need to
     *                      Get the first element of the array
 " "/                       And joined each element in the sub-array by whitespace
                            This is to handle cases like "James Alfred Van Allen",
                            where the result after delete will be ["Alfred", "Van"]

Answer 24

Ruby -p, 20 bytes

Basically identical to Yelp’s sed answer and others.

gsub /^\S+ |\S+$/,""

Attempt This Online!

Answer 25

Go, 106 bytes

import."strings"
func f(s string)(o string){l:=Split(s," ")
if k:=len(l);k>2{o=Join(l[1:k-1]," ")}
return}

Attempt This Online!

Answer 26

Thunno 2 Ṡ, 2 bytes

ḣṫ

Attempt This Online!

ḣ   # head remove
 ṫ  # tail remove
    # Ṡ flag joins by spaces

Answer 27

Batch, 70 bytes

@set s=.
:l
@if not "%3"=="" set s=%s% %2&shift&goto l
@echo(%s:~2%

The loop concatenates arguments starting with the second, shifting them until the third argument is empty. This results in a leading space, so to remove that I prepend with a . so that I can slice the string (slicing an empty string produces an erroneous result in Batch). If a trailing space on output is acceptable, then for 66 bytes:

@set s=
:l
@if not "%3"=="" set s=%s%%2 &shift&goto l
@echo(%s%

Answer 28

Ruby, 33 bytes

->s{$><<s.split[1..-2].join(' ')}

Answer 29

TI-Basic (TI-84 Plus CE), 131 bytes

Prompt Str0
inString(Str0," →A
length(Str0)–A→L
sub(Str0,A,L→Str0
" →Str2
For(B,1,L
sub(Str0,B,1)+Str2→Str2
End
inString(Str2," →A
L-A→L
sub(Str2,A,L→Str2
" →Str0
For(B,1,L
sub(Str2,B,1)+Str0→Str0
End
Disp Str0

Explanation:

Prompt Str0              # 4 bytes, input user string
inString(Str0," →A       # 10 bytes, store the index of the first space in A
length(Str0)–A→L         # 10 bytes, store the length of the string (after removing the first A characters) in L
sub(Str0,A,L→Str0        # 12 bytes, remove first A-1 and last characters of Str0
" →Str2                  # 6 bytes, temporary string to reverse Str0
For(B,1,L                # 7 bytes, reverse Str0 into Str2
sub(Str0,B,1)+Str2→Str2  # 16 bytes
End                      # 2 bytes
inString(Str2," →A       # 10 bytes, store the index of the first space in A
L-A→L                    # 6 bytes, get new length
sub(Str2,A,L→Str2        # 12 bytesremove first A-1 and last characters of Str2
" →Str0                  # 6 bytes, temporary string to reverse Str2
For(B,1,L                # 7 bytes, reverse Str2 into Str0
sub(Str2,B,1)+Str0→Str0  # 16 bytes
End                      # 2 bytes
Disp Str0                # 3 bytes, display final string with (2 trailing spaces)

Answer 30

Python 3, 28 bytes

print(input().split()[1:-1])

Try it online!