注意：获奖答案将在17年4月12日选定，当前获奖者为Jolf，1个字节。

令我感到惊讶的是，我们在此站点上还没有遇到我的中间名挑战。我做了很多搜索，但一无所获。如果这是一个重复项，请照此标记。

你的挑战

解析一个看起来像的字符串Jo Jean Smith并返回Jean。

测试用例

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 

（从技术上讲，最后一个是不正确的，但是要解决这个问题太难了。）

笔记：

• 名称将始终至少包含2个以空格分隔的部分，中间没有无限的中间名，或者可以是字符串列表/字符串数组。
• 名称可能包含字母（不区分大小写）和-（0x2d）
• 您可以输出尾随换行符。
• 您可能需要输入才能包含尾随换行符。
• 允许从STDIN，函数参数或命令行参数输入，但不允许对其进行硬编码。
• 禁止使用标准漏洞。
• 输出可能是函数返回值，STDOUT，STDERR等。
• 输出中允许尾随空格/换行符/制表符。
• 任何问题？在下面发表评论！

这是代码高尔夫球，因此最短的字节为准！

Jolf，1个字节

€

获取输入的内部。在这里尝试！

欧姆，2个字节（CP437）

接受并返回字符串列表。

()

说明：

()   Main wire, arguments: a

(    Remove the first element of a
 )   ...and then the last element of that
     Implicit output

Vim，6个 5字节

dW$BD

在线尝试！

（带有尾随空格的输出）

由于Vim与V反向兼容，因此我包括了V的TIO链接。

说明

dW                      " Delete up to the next word (removes the first name)
$                       " Go to the end of the line
B                       " Go back one word
D                       " Delete it

Python，24字节

lambda n:n.split()[1:-1]

尝试在线输入字符串！

输入格式：字符串

Python 2，16个字节

lambda n:n[1:-1]

尝试在线列表输入！

输入格式：清单

Brain-Flak，133字节

{{}((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}}{}{({}<>)<>}<>{{}((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}}{}{({}<>)<>}<>

在线尝试！

132个字节的代码，外加1个字节的-c标志（允许ASCII输入和输出）。

不幸的是，它包含许多重复的代码，但实际上很难重用。我稍后再研究。这是一个解释：

#While True
{
    #Pop
    {}

    #Not equals 32
    ((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}

#Endwhile
}

#Pop the 0
{}

#Reverse Stack
{({}<>)<>}<>

#While True
{
    #Pop
    {}

    #Not equals 32
    ((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}

#Endwhile
}

#Pop the 0
{}

#Reverse Stack
{({}<>)<>}<>

05AB1E，2个字节

¦¨

在线尝试！

如果不允许输出中间名列表，则将其更改。

Haskell中，23，17 9个字节

init.tail

获取并返回字符串列表。在线尝试！

删除第一个字符串，删除最后一个字符串。

编辑：@Generic显示名称，请注意，输入可以是字符串列表，节省了6个字节。

编辑II：返回字符串列表，而不是单个字符串

Mathematica，10个字节

Rest@*Most

接受并返回字符串列表的未命名函数。

Rest丢弃最后一个元素，Most丢弃第一个元素，@*是函数组合。交换Rest和/ Most或使用正确的构图/*也可以。这比索引少#[[2;;-2]]&了一个字节。

Brain-Flak，86个字节

(()()){({}[()]<{{}((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}}{}{({}<>)<>}<>>)}{}

在线尝试！

此代码大部分来自此答案。如果您喜欢我的解决方案，则也应该赞成该解决方案。

#Push 2
(()())

#Loop twice
{({}[()]<

  #While not a space
  {
      #Pop
      {}

      #Not equals 32
      ((((()()()()){}){}){}[{}](<()>)){{}{}(<(())>)}{}

  #Endwhile
  }

  #Pop the 0
  {}

  #Reverse Stack
  {({}<>)<>}<>

#End loop twice
>)}{}

Java 7，74字节

String f(String s){return s.substring(s.indexOf(' '),s.lastIndexOf(' '));}

Java 8，49字节

s->s.substring(s.indexOf(' '),s.lastIndexOf(' '))

识别空格字符的第一个出现和最后一个出现并提取中间字符的函数。结果字符串以一个空格字符作为前缀（在发布时，OP尚不清楚是否允许使用前导空格），可以通过.trim()在代码中添加7字节的额外开销来消除该字符。

与C＃相比，Java具有指定结束索引而不是子字符串长度的优点，这减少了字节数。

JavaScript（ES6），22个字节

接收并输出一个字符串数组。

([_,...a])=>a.pop()&&a

测试用例

let f =

([_,...a])=>a.pop()&&a

console.log(f(["Samantha", "Vee", "Hills"]))
console.log(f(["Bob", "Dillinger"]))
console.log(f(["John", "Jacob", "Jingleheimer", "Schmidt"]))
console.log(f(["Jose", "Mario", "Carasco-Williams"]))

字符串版本（27字节）

接收并输出一个字符串。如果找不到中间名，则输出字符串可以是单个空格，也可以是带有前导和尾随空格的中间名。

s=>(/ .* /.exec(s)||' ')[0]

let f =

s=>(/ .* /.exec(s)||' ')[0]

console.log(f("Samantha Vee Hills"))
console.log(f("Bob Dillinger"))
console.log(f("John Jacob Jingleheimer Schmidt"))
console.log(f("Jose Mario Carasco-Williams"))

AWK，17 10字节

感谢@steve，节省了7个字节！

$NF=$1=x;1

在线尝试！

说明：

$NF=    set last word to
$1=     set first word to
x       an empty variable, ie empty string
1       default action, ie print everything

Groovy，19个字节

{it.split()[1..-2]}

说明：

{        
 it                  all closures have an implicit argument called "it"
   .split()          splits by spaces by default. Returns an array of words
           [1..-2]   take the whole array from the second index (1) to the penultimate index (-2). Implicitly return
                  }

一个闭包/匿名函数

PHP，37字节

<?=join(" ",array_slice($argv,2,-1));

-4字节用于数组输出

print_r(array_slice($argv,2,-1));

PHP，42字节

echo trim(trim($argn,join(range("!",z))));

PHP，50字节

echo preg_filter("#(^[^\s]+ |[^\s]+$)#","",$argn);

视网膜，11字节

^\S+ |\S+$

在线尝试！

匹配第一个单词（包括其后的空格）和最后一个单词，并将它们都删除。

如果I / O可以是换行符分隔的列表，则可以用8个字节来代替：

A1`
G-2`

在线尝试！

Perl 5中，27 18个字节

需要与-n选项一起运行。

/ (.+) /&&print$1

在线尝试！

想要先在sed中执行类似的操作，但不幸的是，它不支持非贪婪量词。如果中间名超过一个单词，则需要它。

编辑

-9个字节感谢Dada。

除其他外，不再需要非贪婪量词。

Javascript（ES6）49 16 bytes

编辑：

a=>a.slice(1,-1)

在线尝试！

松散：

function(name) {
  return a.slice(1, -1); //start at the second item and end at the second to last item
};

我忘记了一些简单的属性 slice, and that the input can be an array. Thanks to @Neil and @fəˈnɛtɪk I was able to remove 27 bytes. Still not really competing.

原版的：

这并不是真正的竞争，但这是一个Javascript解决方案：

a=>{a=a.split(' ');return a.slice(1, a.length-1)}

这将创建一个等于以下内容的匿名函数：

function(name) {
  let name = name.split(' '); //first middle last -> [first, middle, last]
  return name.slice(1, name.length - 1); //get the second item to the second to last item in the array.
}

我如何打高尔夫球

这是一个非常简单的高尔夫。我把功能变成了箭头功能。然后我“缩小”了代码。这包括重命名name为单个字符（a在本例中为该字符），并删除let对变量的取消复制。

片段

var a=b=>b.slice(1,-1)

//example code

let form = document.querySelector('#form'),
    input = document.querySelector('#input'),
    result = document.querySelector('#result');

form.addEventListener('submit', (event) => {
  event.preventDefault();
  let value = input.value.split` `;
  result.textContent = a(value).join(' ');
});

<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet"/>
<form id="form">
  <div class="input-group">
    <input id="input" class="form-control" />
    <div class="input-group-btn">
      <button class="btn btn-primary">Submit</button>
    </div>
  </div>
</form>

<p id="result"></p>

Hope this helps anyone who is stuck on the challenge.

Röda, 9 bytes

{_[1:-1]}

Try it online!

Not a very interesting solution. Takes a list from the stream and returns the middle names.

21 bytes and I/O:

{[(_/" ")[1:-1]&" "]}

Try it online!

This uses / (split) and & (join).

Jelly, 2 bytes

ḊṖ

Try it online!

This works as a non-inline link (i.e. function), not a full program.

'John','Jacob','Jingleheimer','Schmidt' → 'Jacob','Jingleheimer'

As a full program, it would be 3 bytes: ḊṖK, which prints a space-separated middle name.

Pyth, 2 bytes

Pt

Online interpreter

C#, 67 bytes

s=>s.Substring(s.IndexOf(' ')+1,s.LastIndexOf(' ')-s.IndexOf(' '));

Anonymous function which identifies the first occurrence of the space character and the last one and extracts the middle. It also extracts a trailing space, which can be removed at the cost of 2 bytes.

Full program with test cases:

using System;

namespace WhatsMyMiddleName
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f =
            s=>s.Substring(s.IndexOf(' ')+1,s.LastIndexOf(' ')-s.IndexOf(' '));

            Console.WriteLine(f("Jo Jean Smith"));          // "Jean"
            Console.WriteLine(f("Samantha Vee Hills"));     // "Vee"
            Console.WriteLine(f("Bob Dillinger"));          // ""
            Console.WriteLine(f("John Jacob Jingleheimer Schmidt"));// "Jacob Jingleheimer"
            Console.WriteLine(f("Jose Mario Carasco-Williams"));    // "Mario"
            Console.WriteLine(f("James Alfred Van Allen")); // "Alfred Van"
        }
    }
}

Kotlin, 39 bytes

s.filterIndexed{i,j->i!=0&&i!=s.size-1}

Try it online!

i.e.

s.filterIndexed{ index, value -> index != 0 && index != (s.size - 1) }

VBA, 69 bytes

Sub m(n)
f=InStr(1,n," ")
Debug.?Mid(n,f+1,InStrRev(n," ")-f)
End Sub

R, 30 27 22 bytes

Current solution due to user11599!

head(scan(,''),-1)[-1]

Takes input from stdin, returns each middle name as a separate string. Returns character() in the case of no middle name; that is, a vector of class character of length 0.

Explanation:

Read stdin into a list of strings, separated by spaces

     scan(,'')

Remove the last element. head returns the first n elements of a list, with n defaulting to 6. If n is -1 it returns all but the last element.

head(scan(,''),-1)

Now, remove the first element of this list.

head(scan(,''),-1)[-1]

This yields the middle name(s).

Ruby, 24 13 bytes

p ARGV[1..-2]

Saved 11 bytes thanks to Piccolo pointing out that array-like output is allowed.

Takes the name as separate command line arguments, e.g.:

$ ruby script.rb John Jacob Jingleheimer Schmidt

or

$ ruby -e 'p ARGV[1..-2]' John Jacob Jingleheimer Schmidt

Previous code (outputs a proper string):

puts ARGV[1..-2].join" "

Golang, 152 81 bytes

import ."strings"
func f(x string)[]string{var k=Fields(x);return k[1:len(k)-1];}

It takes input as "Samantha Vee Hills" (with double quotes) and return the middle name to the stdout.

Try it Online!

Edit: @Dada, note that the "function as answer is allowed" shorten my code 71 bytes. a big thanks!

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!

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.

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

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!