Nota: A resposta vencedora será selecionada em 12/04/17, o vencedor atual é Jolf, 1 byte .

Estou surpreso por ainda não termos enfrentado o desafio do meu nome do meio neste site. Eu fiz muita pesquisa, mas não encontrei nada. Se este é um dup, sinalize-o como tal.

Seu desafio

Analise uma string com aparência Jo Jean Smithe retorne Jean.

Casos de teste

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 

(Esse último está incorreto tecnicamente, mas corrigir isso seria muito difícil.)

Notas:

• Os nomes sempre terão pelo menos duas partes separadas por espaço, com nomes intermediários ilimitados entre elas ou podem ser uma lista / matriz de cadeias.
• Os nomes podem conter o alfabeto (sem distinção entre maiúsculas e minúsculas) e - ( 0x2d)
• Você pode gerar uma nova linha à direita.
• Você pode precisar de entrada para ter uma nova linha à direita.
• A entrada de STDIN, um parâmetro de função ou argumento de linha de comando é permitida, mas a codificação não é permitida.
• Falhas padrão proibidas.
• A saída pode ser um valor de retorno da função, STDOUT, STDERR, etc.
• Espaços finais / novas linhas / guias na saída são permitidos.
• Alguma pergunta? Comente abaixo!

Isso é código-golfe , então a resposta mais curta em bytes vence!

Jolf, 1 byte

€

Obtém o interior da entrada. Experimente aqui!

Ohm , 2 bytes (CP437)

Aceita e retorna uma lista de cadeias.

()

Explicação:

()   Main wire, arguments: a

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

Vim, 6 5 bytes

dW$BD

Experimente online!

(saídas com um espaço à direita)

Como o Vim é compatível reversamente com o V, incluí um link TIO para V.

Explicação

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 bytes

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

Experimente a entrada de string online!

Formato de entrada: string

Python 2 , 16 bytes

lambda n:n[1:-1]

Experimente a entrada da lista online!

Formato de Entrada: Lista

Flacidez Cerebral , 133 bytes

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

Experimente online!

132 bytes de código, mais 1 byte para o -c sinalizador que permite entrada e saída ASCII.

Infelizmente, isso contém muito código duplicado, mas seria muito difícil reutilizá-lo. Vou dar uma olhada mais tarde. Aqui está uma explicação:

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

¦¨

Experimente online!

Se a saída de uma lista de nomes do meio não for permitida, vou alterá-la.

Haskell, 23 , 17 9 bytes

init.tail

Pega e retorna uma lista de strings. Experimente online!

Solte a primeira string, solte a última string.

Edit: @Generic Display Name observado, que a entrada pode ser uma lista de strings, que salvou 6 bytes.

Editar II: retornar lista de strings em vez de uma única string

Mathematica, 10 bytes

Rest@*Most

Uma função sem nome que aceita e retorna uma lista de seqüências de caracteres.

Restdescarta o último elemento, Mostdescarta o primeiro elemento, @*é a composição da função. Trocar Reste / Mostou usar a composição correta /*também funcionaria. Isso supera a indexação #[[2;;-2]]&por um byte.

Flacidez Cerebral , 86 bytes

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

Experimente online!

A maior parte desse código vem dessa resposta . Se você gosta da minha solução, também deve votar nessa.

#Push 2
(()())

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

  #While not a space
  {
      #Pop
      {}

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

  #Endwhile
  }

  #Pop the 0
  {}

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

#End loop twice
>)}{}

Java 7, 74 bytes

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

Java 8, 49 bytes

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

Função que identifica a primeira ocorrência do caractere de espaço e a última e extrai o meio. A sequência resultante é prefixada por um caractere de espaço (no momento da postagem, o OP não esclareceu se espaços iniciais são permitidos), que podem ser eliminados adicionando- .trim()se ao código por um custo extra de 7 bytes.

Comparado ao C #, o Java tem a vantagem de especificar o índice final em vez do comprimento da sub-cadeia, o que reduz a contagem de bytes.

JavaScript (ES6), 22 bytes

Pega e gera uma matriz de seqüências de caracteres.

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

Casos de teste

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

Versão da string (27 bytes)

Pega e gera uma string. A cadeia de saída é um espaço único se nenhum nome do meio foi encontrado ou os nomes do meio com espaços à esquerda e à direita.

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 bytes

Guardado 7 bytes graças a @steve!

$NF=$1=x;1

Experimente online!

Explicação:

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

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

Explicação:

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

Uma função de fechamento / anônima

PHP, 37 bytes

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

-4 bytes para uma saída como matriz

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

PHP, 42 bytes

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

PHP, 50 bytes

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

Retina , 11 bytes

^\S+ |\S+$

Experimente online!

Corresponde à primeira palavra (incluindo o espaço após ela) e à última palavra e remove as duas.

Se a E / S puder ser uma lista separada por avanço de linha, poderá ser feita em 8 bytes:

A1`
G-2`

Experimente online!

Perl 5 , 27 18 bytes

Precisa executar com a -nopção

/ (.+) /&&print$1

Experimente online!

Queria fazer algo semelhante no sed primeiro, mas, infelizmente, ele não suporta quantificadores não-gananciosos. É necessário caso o nome do meio tenha mais de uma palavra.

Editar

-9 bytes graças a Dada .

O quantificador não ganancioso não é mais necessário, entre outras coisas.

Javascript (ES6) 49 16 bytes

Editar:

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

Experimente online!

ungolfed:

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

Esqueci algumas das propriedades simples de slice, e que a entrada pode ser uma matriz. Graças a @Neil e @ fəˈnɛtɪk, consegui remover 27 bytes. Ainda não está realmente competindo.

Original:

Isso não é realmente competitivo, mas aqui está uma solução Javascript:

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

Isso cria uma função anônima igual a:

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

Como eu jogava golfe

Este é um golfe bem simples. Eu transformei a função em uma função de seta . Então eu "minifiquei" o código. Isso incluiu renomear nameem um único caractere ( aneste caso) e remover a letdecloração da variável.

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>

Espero que isso ajude quem está preso ao desafio.

Röda , 9 bytes

{_[1:-1]}

Experimente online!

Não é uma solução muito interessante. Pega uma lista do fluxo e retorna os nomes do meio.

21 bytes e E / S:

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

Experimente online!

Isso usa /(divisão) e &(associação).

Geléia , 2 bytes

ḊṖ

Experimente online!

Isso funciona como um link não embutido (ou seja, função), não como um programa completo.

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

Como um programa completo, seria 3 bytes:, ḊṖKque imprime um nome do meio separado por espaço.

Pitão, 2 bytes

Pt

Intérprete online

C #, 67 bytes

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

Função anônima que identifica a primeira ocorrência do caractere de espaço e a última e extrai o meio. Também extrai um espaço à direita, que pode ser removido ao custo de 2 bytes.

Programa completo com casos de teste:

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}

Experimente online!

ie

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

Solução atual devido ao usuário11599!

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

Pega a entrada de stdin, retorna cada nome do meio como uma sequência separada. Retorna character()no caso de nenhum nome do meio; isto é, um vetor de classe characterde comprimento 0.

Explicação:

Leia stdin em uma lista de strings, separadas por espaços

     scan(,'')

Remova o último elemento. headretorna os primeiros nelementos de uma lista, com o npadrão para 6. Se nfor -1, retorna tudo, exceto o último elemento.

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

Agora, remova o primeiro elemento desta lista.

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

Isso produz o (s) nome (s) do meio.

Ruby, 24 13 bytes

p ARGV[1..-2]

11 bytes salvos graças ao Piccolo, indicando que a saída do tipo matriz é permitida.

Leva o nome como argumentos de linha de comando separados, por exemplo:

$ ruby script.rb John Jacob Jingleheimer Schmidt

ou

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

Código anterior (gera uma sequência adequada):

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];}

Ele recebe a entrada como "Samantha Vee Hills" (com aspas duplas) e retorna o nome do meio ao stdout.

Experimente Online!

Edit: @Dada, observe que a "função como resposta é permitida" diminui meu código 71 bytes. um grande obrigado!

Matlab, 81 , 79 , 78 , 55 bytes

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

Recebe uma sequência de entrada, s é dividida (pelo delimitador padrão, espaço em branco char) em uma matriz de células, a partir da qual o elemento do meio é acessado. Em seguida, os elementos do meio são concatenados ou uma string vazia é retornada.

Edit: obrigado a Luis Mendo por salvar 3 bytes!

Edit 2: Melhor solução do Ankit!

C, 42 bytes

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

O parâmetro é uma matriz de ponteiros terminada em NULL para char.

Veja como funciona aqui .

Os argumentos da linha de comando também podem ser usados ​​com a mesma função .

C, 51 bytes

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

Um programa completo. A entrada é feita através de argumentos de linha de comando.

Veja como funciona aqui .

C, 54 bytes

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

O parâmetro é um parâmetro de entrada / saída.

Veja como funciona aqui .

Python 2, 42. 19 16 bytes

lambda n:n[1:-1]

Experimente online! Obrigado a @Kritixi Lithos por salvar 23 bytes! Obrigado @math_junkie por salvar mais 3 bytes. Para entrada, coloque cada parte do nome como uma string em uma lista da seguinte maneira:

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

E sim, o OP aprovou uma lista para ser uma entrada válida.

Explicação

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();}

Recebe a entrada como referência a uma lista de cadeias e modifica a lista diretamente.

Experimente online!