Remarque: La réponse gagnante sera sélectionnée le 4/12/17, le gagnant actuel est Jolf, 1 octet .

Je suis surpris que nous n'ayons pas encore eu de défi pour mon deuxième prénom sur ce site. J'ai fait beaucoup de recherches mais je n'ai rien trouvé. S'il s'agit d'un dup, veuillez le signaler comme tel.

Votre défi

Analyser une chaîne qui ressemble Jo Jean Smithet retourner Jean.

Cas de test

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 

(Ce dernier est incorrect sur le plan technique, mais le corriger serait trop difficile.)

Remarques:

• Les noms auront toujours au moins 2 parties séparées par des espaces, avec des noms intermédiaires illimités entre eux ou peuvent être une liste / tableau de chaînes.
• Les noms peuvent contenir l'alphabet (insensible à la casse) et - ( 0x2d)
• Vous pouvez générer une nouvelle ligne de fin.
• Vous pouvez avoir besoin d'une entrée pour avoir une nouvelle ligne de fin.
• L'entrée de STDIN, d'un paramètre de fonction ou d'un argument de ligne de commande est autorisée, mais le codage en dur n'est pas autorisé.
• Failles standard interdites.
• La sortie peut être une valeur de retour de fonction, STDOUT, STDERR, etc.
• Les espaces / sauts de ligne / tabulations dans la sortie sont autorisés.
• Des questions? Commentaires ci-dessous!

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte!

Jolf, 1 octet

€

Obtient l'intérieur de l'entrée. Essayez-le ici!

Ohm , 2 octets (CP437)

Accepte et renvoie une liste de chaînes.

()

Explication:

()   Main wire, arguments: a

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

Vim, 6 5 octets

dW$BD

Essayez-le en ligne!

(sorties avec un espace de fin)

Puisque Vim est rétrocompatible avec V, j'ai inclus un lien TIO pour V.

Explication

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 octets

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

Essayez-le en ligne!

Format d'entrée: chaîne

Python 2 , 16 octets

lambda n:n[1:-1]

Essayez-le en ligne!

Format d'entrée: liste

Brain-Flak , 133 octets

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

Essayez-le en ligne!

132 octets de code, plus 1 octet pour l' -cindicateur qui permet l'entrée et la sortie ASCII.

Malheureusement, cela contient beaucoup de code dupliqué, mais il serait vraiment difficile de le réutiliser. J'y reviendrai plus tard. Voici une explication:

#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 octets

¦¨

Essayez-le en ligne!

Si la sortie d'une liste de prénoms n'est pas autorisée, je la changerai.

Haskell, 23 , 17 9 octets

init.tail

Prend et renvoie une liste de chaînes. Essayez-le en ligne!

Supprimer la première chaîne, supprimer la dernière chaîne.

Edit: @Generic Display Name a noté que l'entrée peut être une liste de chaînes, qui a sauvé 6 octets.

Edit II: retourne la liste des chaînes au lieu d'une seule chaîne

Mathematica, 10 octets

Rest@*Most

Une fonction sans nom qui accepte et renvoie une liste de chaînes.

Restjette le dernier élément, Mostjette le premier élément, @*est la composition de la fonction. L'échange Restet / Mostou l'utilisation de la bonne composition /*fonctionneraient également. Cela bat l'indexation #[[2;;-2]]&d'un octet.

Brain-Flak , 86 octets

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

Essayez-le en ligne!

La plupart de ce code provient de cette réponse . Si vous aimez ma solution, vous devriez également voter pour celle-ci.

#Push 2
(()())

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

  #While not a space
  {
      #Pop
      {}

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

  #Endwhile
  }

  #Pop the 0
  {}

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

#End loop twice
>)}{}

Java 7, 74 octets

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

Java 8, 49 octets

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

Fonction qui identifie la première occurrence du caractère espace et le dernier et extrait le milieu. La chaîne résultante est préfixée par un caractère espace (au moment de la publication, OP n'a pas précisé si les espaces de tête sont autorisés), ce qui peut être éliminé en ajoutant.trim() au code pour un coût supplémentaire de 7 octets.

Comparé à C #, Java a l'avantage de spécifier l'index de fin au lieu de la longueur de sous-chaîne, ce qui réduit le nombre d'octets.

JavaScript (ES6), 22 octets

Prend et sort un tableau de chaînes.

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

Cas de test

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"]))

Version chaîne (27 octets)

Prend et sort une chaîne. La chaîne de sortie est soit un espace unique si aucun deuxième prénom n'a été trouvé, soit les noms intermédiaires avec des espaces de début et de fin.

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 octets

7 octets enregistrés grâce à @steve!

$NF=$1=x;1

Essayez-le en ligne!

Explication:

$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 octets

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

Explication:

{        
 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
                  }

Une fonction de fermeture / anonyme

PHP, 37 octets

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

-4 octets pour une sortie sous forme de tableau

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

PHP, 42 octets

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

PHP, 50 octets

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

Rétine , 11 octets

^\S+ |\S+$

Essayez-le en ligne!

Correspond au premier mot (y compris l'espace après celui-ci) et au dernier mot, et les supprime tous les deux.

Si les E / S peuvent être une liste séparée par des sauts de ligne, cela peut être fait en 8 octets à la place:

A1`
G-2`

Essayez-le en ligne!

Perl 5 , 27 18 octets

Besoin de courir avec -noption.

/ (.+) /&&print$1

Essayez-le en ligne!

Wanted to do something similar in sed first, but, unfortunately, it doesn't support non-greedy quantifier. It is needed in case middle name is more than one word.

Edit

-9 bytes thanks to Dada.

Non-greedy quantifier is not needed anymore, among with some other things.

Javascript (ES6) 49 16 bytes

Edit:

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

Try it online!

ungolfed:

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

I forgot some of the simple properties of 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.

Original:

This isn't really competing but here's a Javascript solution:

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

This creates an anonymous function equal to:

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.
}

How I golfed it

This is a pretty simple golf. I turned the function into an arrow function. Then I "minified" the code. This included renaming name into a single character(a in this case) and removing the let decloration of the variable.

Snippet

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!