Su desafío es tomar un nombre (cadena) como entrada, como

Albert Einstein

y salida:

Einstein, Albert

Pseudocódigo:

set in to input
set arr to in split by " "
set last to the last element of arr
remove the last element of arr
set out to arr joined with " "
prepend ", " to out
prepend last to out
output out

Más casos de prueba:

John Fitzgerald Kennedy => Kennedy, John Fitzgerald
Abraham Lincoln => Lincoln, Abraham

Reglas

• La entrada siempre coincidirá con la expresión regular ^([A-Z][a-z]+ )+([A-Z][a-z]+)$.
• No necesita manejar nombres extraños , incluso si la salida es técnicamente incorrecta, aquí está bien.
• El espacio en blanco al final / nueva línea está bien.
• ¿Alguna pregunta? ¡Comenta abajo!

05AB1E , 7 bytes

Código:

',ì#Áðý

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

',ì         # Prepend the input to ","
   #        # Split on spaces
    Á       # Rotate every element one position to the right (wrapping)
     ðý     # Join the array by spaces

JavaScript (ES6), 34 bytes

s=>s.replace(/(.+) (.+)/,'$2, $1')

Manifestación:

let f = s=>s.replace(/(.+) (.+)/,'$2, $1')

;[ 'Albert Einstein', 'John Fitzgerald Kennedy', 'Abraham Lincoln' ].forEach(
  s => console.log(`${s} => ${f(s)}`)
)

Retina , 19 17 16 bytes

Editar: Gracias a Riker por guardar 3 bytes

(.+) (.+)
$2, $1

Pruébalo en línea!

Jalea , 7 bytes

;”,Ḳṙ-K

Pruébalo en línea!

No conozco a Jelly muy bien, pero al leer otras respuestas parecía que no usaban un algoritmo óptimo ... así que aquí está:

Explicación

;”,Ḳṙ-K
;”,        Append a comma to the end of the string
   Ḳ       Split on spaces
    ṙ-     Rotate the array by -1 (1 time towards the right)
      K    Join with spaces

Vim, 10 bytes / pulsaciones de teclas

v$F dA, <esc>p

Pruébalo en línea!

V / vim, 9 8 bytes

$bD0Pa, 

Pruébalo en línea!

Guardado un byte gracias a

Tenga en cuenta que hay un carácter de espacio final. Deja un espacio final, que está permitido según las reglas.

Explicación:

$       " move the cursor to the end of the line
 b      " move the cursor to the beginning of the current word
  D     " delete to the end of the line
   0    " move the cursor to the start of the line
    P   " paste in front of the cursor.
     a  " append (enter insert mode with the cursor one character forward)
      , " Literal text, ", "

Python 2 , 39 bytes

f,l=input().rsplit(' ',1);print l+',',f

Pruébalo en línea!

Sí, rsplit.

Mathematica, 52 40 bytes

StringReplace[x__~~" "~~y__:>y<>", "<>x]

> <> , 27 bytes

i:0(?v
" ,"~<^r/
=" ":}o!/?

Pruébalo en línea!

C, 45 bytes

EDITAR: Acabo de notar el requisito de que la entrada posiblemente tenga más de dos palabras. Lo dejaré como está con una nota de que esto solo funciona para dos palabras.

EDITAR: eliminado \n. Agregue 2 bytes si lo considera necesario.

main(a,b)int**b;{printf("%s, %s",b[2],b[1]);}

Compila con gcc name.cGCC 6.3.1. Ignorar las advertencias. Uso:

$./a.out Albert Einstein
Einstein, Albert

Abuso de lenguaje:

• Tipo intde retorno implícito mainy nada devuelto.
• Declaración implícita de printf. GCC lo incluirá de todos modos.
• Tipo incorrecto de b. No importa con%s

Gracias a @ Khaled.K por los consejos sobre el uso en main(a,b)int**b;lugar de main(int a, int **b).

Ruby , 22 bytes

->s{s[/\w+$/]+", #$`"}

Pruébalo en línea!

sed, 19 + 1 para -E = 20 bytes

s/(.*) (.*)/\2, \1/

Debe usar -r (GNU) o -E (BSD, GNU recientes) para evitar tener que escapar del paréntesis de agrupación.

Si está escrito en la línea de comandos, debe estar entre comillas para evitar que el shell lo analice como tokens múltiples:

sed -E 's/(.*) (.*)/\2, \1/'

C, 68 bytes

Espero que no esté mal agregar otra publicación, pero aquí hay una solución ligeramente diferente a mi solución C publicada anteriormente. Este acepta cualquier número de nombres.

main(a,b)int**b;{for(printf("%s,",b[--a]);--a;printf(" %s",*++b));}

Compile con gcc name.c(GCC 6.3.1) e ignore las advertencias. Uso:

$./a.out John Fitzgerald Kennedy
Kennedy, John Fitzgerald

Gracias a @ Khaled.K por los consejos sobre main(a,b)int**b;

Gracias por el consejo sobre el bucle for a @Alkano.

Mathematica, 45 bytes

#/.{a__,s=" ",b__}/;{b}~FreeQ~s->{b,",",s,a}&

Se guardaron algunos bytes sobre la respuesta de ngenisis tomando la entrada como una lista de caracteres en lugar de como una cadena. Función pura que usa una regla de reemplazo de patrones.

Mathematica, 49 bytes

#~Join~{","," "}~RotateLeft~Last@Position[#," "]&

Otra función pura que toma una lista de caracteres como entrada y devuelve una lista de caracteres. Éste añade ","y " "a la entrada y luego gira la lista de caracteres hasta el último espacio se encuentra al final. (Por lo tanto, la salida tiene un espacio final, a diferencia de la primera función anterior).

C #, 76 72 bytes

s=>System.Text.RegularExpressions.Regex.Replace(s,"(.+) (.+)","$2, $1");

Guardado 4 bytes con la ayuda de @KevinCruijssen

Versión antigua que usa subcadenas para 76 bytes:

s=>s.Substring(s.LastIndexOf(' ')+1)+", "+s.Substring(0,s.LastIndexOf(' '));

Awk, 18 personajes

{$1=$NF", "$1}NF--

Ejecución de muestra:

bash-4.4$ awk '{$1=$NF", "$1}NF--' <<< 'John Fitzgerald Kennedy'
Kennedy, John Fitzgerald

Pruébalo en línea!

Jalea , 8 bytes

Ḳ©Ṫ”,⁶®K

Pruébalo en línea!

05AB1E , 9 bytes

#`',«.Áðý

Pruébalo en línea!

Explicación

#           # split input on spaces
 `          # push each name separately to stack
  ',«       # concatenate a comma to the last name
     .Á     # rotate stack right
       ðý   # join stack by spaces

Pyth , 11 bytes

jd.>c+z\,d1

Explicación:

jd.>c+z\,d1
     +z\,      Append the "," to the input
    c+z\,d     Split the string on " "
  .>c+z\,d1    Rotate the array one element right
jd.>c+z\,d1    Join the array on " "

¡Pruébalo en línea!

PHP, 45 bytes

<?=preg_filter("#(.*) (.+)#","$2, $1",$argn);

Pruébalo en línea!

MATLAB / Octave , 37 bytes

@(a)regexprep(a,'(.+) (.+)','$2, $1')

Pruébalo en línea!

Basado en la respuesta Retina de @ngenisis, también podemos jugar el juego de expresiones regulares tanto en Octave como en MATLAB, ahorrando unos pocos bytes sobre mi respuesta anterior.

Vieja respuesta:

Voy a dejar esta respuesta aquí también teniendo en cuenta que es una forma más única de hacerlo en comparación con una simple expresión regular.

Octava , 49 47 bytes

@(a)[a((b=find(a==32)(end))+1:end) ', ' a(1:b)]

¡Inténtalo en línea!

Una función anónima para generar la salida.

Básicamente, el código primero encuentra el último espacio en la cadena usando b=find(a==32)(end). Luego toma la parte final de la cadena (después del espacio) usando a(b+1:end), donde bes la salida de encontrar el último espacio. También toma el inicio de la cadena con a(1:b-1), y concatena ambos junto con un ', 'en el medio.

Ya he guardado algunos bytes en comparación con el típico find(a==32,1,'last'). No estoy seguro de que haya mucho más para ahorrar.

Jalea , 9 bytes

ḲµṪ;⁾, ;K

Explicado, ish:

ḲµṪ;⁾, ;K
Ḳ           # Split the input by spaces
 µ          # Separate the link into two chains. Essentially calls the right half with the split string monadically.
  Ṫ         # The last element, (The last name), modifying the array.
   ;        # Concatenated with...
    ⁾,      # The string literal; ", "
       ;    # Concatenated with...
        K   # The rest of the array, joined at spaces.

Pruébalo en línea!

Probar en todos los casos de prueba.

Python 3, 52 bytes

lambda s:s.split()[-1]+", "+" ".join(s.split()[:-1])

Muy simple, podría usar ayuda de golf. Simplemente pone la última palabra al frente y las une con ",".

Caso de prueba:

>>> f=lambda s:s.split()[-1]+", "+" ".join(s.split()[:-1])
>>> f("Monty Python")
'Python, Monty'
>>> f("Albus Percival Wulfric Brian Dumbledore")
'Dumbledore, Albus Percival Wulfric Brian'

Japt, 14 bytes

U+', q'  é q' 

Un puerto de la respuesta de JavaScript de @ programmer5000 .

Pruébalo en línea!

Java, 110 62 bytes

String d(String s){return s.replaceAll("(.+) (.+)","$2, $1");}

Método no estático.

-48 bytes gracias a Kevin Cruijssen

PHP , 62 59 bytes

-3 bytes, gracias Jörg

$a=explode(' ',$argn);echo array_pop($a).', '.join(' ',$a);

Pruébalo en línea!

Solución anterior, 63 bytes

No funciona si la persona tiene 3 nombres repetidos.

<?=($a=strrchr($argv[1]," ")).", ".str_replace($a,'',$argv[1]);

Pruébalo en línea

Excel, 174 170 168 bytes

_{^{Guardado 2 bytes gracias a Wernisch}}

=MID(A1,FIND("^",SUBSTITUTE(A1," ","^",LEN(A1)-LEN(SUBSTITUTE(A1," ",""))))+1,LEN(A1))&", "&LEFT(A1,FIND("^",SUBSTITUTE(A1," ","^",LEN(A1)-LEN(SUBSTITUTE(A1," ","")))))

Esto no es elegante ni inteligente. Es un método bastante básico. Parece que debería haber una forma más corta con las fórmulas de matriz, pero no puedo encontrar una que funcione.

JS (ES6), 52 44 bytes

i=>(i=i.split` `,l=i.pop(),l+", "+i.join` `)

MATL , 10 bytes

44hYb1YSZc

Pruébalo en línea!

Explicación

44h    % Implicitly input a string. Postpend a comma
       % STACK: 'John Fitzgerald Kennedy,'
Yb     % Split on spaces
       % STACK: {'John', 'Fitzgerald', 'Kennedy,'}
1YS    % Circularly shift 1 step to the right
       % STACK: {'Kennedy,', 'John', 'Fitzgerald'}
Zc     % Join with spaces between. Implicitly display
       % STACK: 'Kennedy, John Fitzgerald'

Gema, 23 personajes

* =@append{s; *}
\Z=,$s

Lo único notable aquí es cómo el desafío logró golpear la debilidad de la no codicia de los patrones Gema.

Ejecución de muestra:

bash-4.4$ echo -n 'John Fitzgerald Kennedy' | gema '* =@append{s; *};\Z=,$s'
Kennedy, John Fitzgerald