Tomado directamente del ACM Winter Programming Contest 2013. Eres una persona a la que le gusta tomar las cosas literalmente. Por lo tanto, para ti, el fin del mundo es ed; las últimas letras de "El" y "Mundo" se concatenaron.

Cree un programa que tome una oración y envíe la última letra de cada palabra en esa oración en el menor espacio posible (la menor cantidad de bytes). Las palabras se separan con cualquier cosa que no sean letras del alfabeto (65 - 90, 97 - 122 en la tabla ASCII). Eso significa que los subrayados, tildes, tumbas, llaves, etc. son separadores. Puede haber más de un separador entre cada palabra.

asdf jkl;__zxcv~< vbnm,.qwer| |uiop-> flvmrp
pigs, eat dogs; eat Bob: eat pigs-> ststbts
looc si siht ,gnitirw esreveR-> citwR
99_bottles_of_beer_on_the_wall->sfrnel

Perl 5, 18 bytes

s/\pL*(\pL)|./$1/g

Requiere un -pinterruptor de línea de comando. La propiedad nombrada Lsolo coincide con caracteres de letras A-Za-z. Hay varios cientos de propiedades con nombre, pero cuando se trata de texto ASCII, muy pocas de ellas son interesantes. Además \pL, el único otro de cualquier nota real es \pP, que coincide con la puntuación.

Pruébalo en línea!

Perl 5, 17 bytes

Una mejora de un byte por Dom Hastings

print/\pL*(\pL)/g

Requiere -n(y -lpara admitir múltiples entradas).

Pruébalo en línea!

Uso de la muestra

$ more in.dat
asdf jkl;__zxcv~< vbnm,.qwer| |uiop
pigs, eat dogs; eat Bob: eat pigs
looc si siht ,gnitirw esreveR
99_bottles_of_beer_on_the_wall

$ perl -p ends-in-ed.pl < in.dat
flvmrp
ststbts
citwR
sfrnel

ed, 35 caracteres

s/[a-zA-Z]*\([a-zA-Z]\)\|./\1/g
p
Q

Entonces, el mundo termina en ed. Como me gusta ser demasiado literal, decidí escribir para escribir la solución con ed, y aparentemente es en realidad un lenguaje de programación . Es sorprendentemente corto, incluso considerando que ya existen muchas soluciones más cortas en este hilo. Sería mejor si pudiera usar algo diferente [a-zA-Z], pero teniendo en cuenta que ed no es un lenguaje de programación, en realidad es lo suficientemente bueno.

Primero, me gustaría decir que esto solo analiza la última línea del archivo. Sería posible analizar más, simplemente escriba ,al comienzo de las dos primeras líneas (esto especifica el rango "todo", en oposición al rango estándar de la última línea), pero eso aumentaría el tamaño del código a 37 caracteres.

Ahora para explicaciones. La primera línea hace exactamente lo que hace la solución Perl (excepto sin soporte para caracteres Unicode). No he copiado la solución Perl, solo inventé algo similar por coincidencia.

La segunda línea imprime la última línea, para que pueda ver la salida. La tercera línea obliga a abandonar: tengo que hacerlo; de lo contrario ed, imprimiría ?para recordarle que no ha guardado el archivo.

Ahora para saber cómo ejecutarlo. Bueno, es muy simple. Simplemente ejecute edcon el archivo que contiene el caso de prueba, mientras canalizo mi programa, así.

ed -s testcase < program

-sEs silencioso. Esto evita que se edmuestre un tamaño de archivo feo al principio. Después de todo, lo uso como un script, no como editor, por lo que no necesito metadatos. Si no hiciera eso, ed mostraría un tamaño de archivo que no podría evitar de otra manera.

Javascript, 49

alert(prompt().replace(/.(?=[a-z])|[^a-z]/gi,''))

Utiliza una expresión regular para eliminar todos los caracteres que aparecen antes de una letra, así como todos los caracteres que no son letras. Luego nos queda la última letra de cada palabra.

Gracias a tomsmeding por una buena mejora.

C, 78

Golfizado:

main(int c,char**s){for(;c=*s[1]++;)isalpha(c)&&!isalpha(*s[1])?putchar(c):0;}

Con espacios en blanco:

main(int c,char**s)
{
  for(;c=*s[1]++;)
    isalpha(c)&&!isalpha(*s[1])?putchar(c):0;
}

Salida:

GNU Sed, 40 38 37

s/[a-z]\b/&\n/g; s/[^\n]*\(.\)\n/\1/g

Pruebas

cat << EOF > data.txt
asdf jkl;__zxcv~< vbnm,.qwer| |uiop
pigs, eat dogs; eat Bob: eat pigs
looc si siht ,gnitirw esreveR
EOF

Ejecute sed:

sed 's/[A-Za-z]\b/&\n/gi; s/[^\n]*\(.\)\n/\1/g' data.txt

Salida:

flvmrp
ststbts
citwR

Explicación

La primera sustitución reemplaza todos los límites de palabras, precedidos por el grupo de coincidencia deseado, con una nueva línea. Esto facilita la eliminación de todos los caracteres extraños en la segunda sustitución.

Editar

• Use una marca que no distinga entre mayúsculas y minúsculas (-2), gracias por su trabajo .
• No cuente los espacios en blanco (-1).

Grep and Paste, 36 34 28

> echo 'asdf jkl;__zxcv~< vbnm,.qwer| |uiop' | grep -io '[a-z]\b' | tr -d \\n
flvmrp

> echo 'pigs, eat dogs; eat Bob: eat pigs'   | grep -io '[a-z]\b' | tr -d \\n
ststbts

echo 'looc si siht ,gnitirw esreveR'         | grep -io '[a-z]\b' | tr -d \\n
citwR

Si se necesita una nueva línea final, reemplácela tr -d \\ncon paste -sd ''.

Editar

• Utilice grep que no distinga entre mayúsculas y minúsculas (-2), gracias manatwork .
• Use en trlugar de paste(-4), gracias manatwork .
• No cuente los espacios en blanco alrededor de la tubería (-2).

sed, 37 caracteres

Igual longitud a la respuesta de Thor , pero, creo, más simple.

s/[a-z]*\([a-z]\)/\1/ig;s/[^a-z]*//ig

La lógica es bastante trivial: reemplace las secuencias de letras con su última letra, luego elimine todas las que no sean letras.

Mathematica, 39

""<>StringCases[#,(__~~x_)?LetterQ:>x]&

Prueba:

""<>StringCases[#,(__~~x_)?LetterQ:>x]& /@
 {"asdf jkl;__zxcv~< vbnm,.qwer| |uiop",
  "pigs, eat dogs; eat Bob: eat pigs",
  "looc si siht ,gnitirw esreveR",
  "99_bottles_of_beer_on_the_wall"}

{"flvmrp", "ststbts", "citwR", "sfrnel"}

K, 49

{last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}

.

k){last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}"asdf jkl;__zxcv~< vbnm,.qwer| |uiop"
"flvmrp"
k){last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}"pigs, eat dogs; eat Bob: eat pigs"
"ststbts"
k){last'f@&"b"$#:'f:"|"\:@[x;&~x in,/.Q`a`A;:;"|"]}"looc si siht ,gnitirw esreveR"
"citwR"

Scala, 59 (o 43)

Suponiendo que la cadena ya está en s:

s.split("[^a-zA-Z]+").map(_.last).mkString

Si es necesario leer desde una línea e imprimir en lugar de utilizar la salida REPL, convertido sa readLiney envolver en println()el 59.

x86: 54 bytes

Asuma una rutina cdecl con la firma void world_end(char *input, char *output):

60 8b 74 24 24 8b 7c 24 28 33 d2 8a 0e 8a c1 24
df 3c 41 72 08 3c 5a 77 04 8a d1 eb 09 84 d2 74
05 88 17 47 33 d2 46 84 c9 75 e0 84 d2 74 03 88
17 47 88 0f 61 c3

Xi, 32

println$ @{=>.-1}<>input re"\W+"

Xi es un lenguaje aún en su fase beta, pero parece funcionar bien con el código de golf, así que pensé que podría mostrar otra solución corta y funcional (y anunciar el idioma un poco :-)).

Mathematica 62 57 52

Row@StringTake[StringCases[#,LetterCharacter..],-1]&

Pruebas

l = {"asdf jkl;__zxcv~<vbnm,.qwer| |uiop", 
     "pigs,eat dogs;eat Bob:eat pigs", 
     "looc si siht,gnitirw esreveR"}

Row@StringTake[StringCases[#,LetterCharacter..],-1]&/@ l
(*{flvmrp,ststbts,citwR}*)

Python3, 59 caracteres

import re;print(re.sub('.(?=[a-z])|[^a-z]','',input(),0,2))

Trata correctamente con letras mayúsculas y guiones bajos. El 2 es pasar re.subla re.IGNORECASEbandera sin tener que usar re.I.

Python, 76 caracteres

import re;print "".join(re.findall("([a-zA-Z])(?=$|[^a-zA-Z])",raw_input()))

Python 3.x, 64 bytes

import re;print(''.join(a[-1] for a in re.split('\W+',input())))

Lua, 42

print(((...):gsub('.-(.)%f[%A]%A*','%1')))

Ejemplo de uso: lua script.lua "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"

Mathematica 71 47 45 61

De vuelta al tablero de dibujo, después de que @belisarius encontró un error en el código.

StringCases[#, RegularExpression["[A-Za-z](?![A-Za-z])"]] <> "" &

Pruebas

l = {"asdf jkl;__zxcv~<vbnm,.qwer| |uiop", "asdf jkl__zxcv~<vbnm,.qwer| |uiop", 
"pigs,eat dogs;eat Bob:eat pigs", "looc si siht,gnitirw esreveR"};

StringCases[#, RegularExpression["[A-Za-z](?![A-Za-z])"]] <> "" & /@ l

{"flvmrp", "flvmrp", "ststbts", "citwR"}

Pitón 2, 88 80 75 69 68

s=p=''
for c in raw_input()+' ':a=c.isalpha();s+=p[a:];p=c*a
print s

Entrada: 435_ASDC__uio;|d re;fG o55677jkl..f

Salida: CodeGolf

Esta solución se puede acortar a 67 caracteres si permite que la salida incluya caracteres de retroceso (código ASCII 8) al principio. La salida será visualmente idéntica.

s=p='<BS>'
for c in raw_input()+p:a=c.isalpha();s+=p[a:];p=c*a
print s

Misma entrada, (visualmente) la misma salida. <BS>está destinado a ser el carácter de retroceso.

DO#

Método, 105 bytes: (asume usos para System, System.Text.RegularExpressions y System.Linq)

string R(string i){return string.Concat(Regex.Split(i,"[^a-zA-Z]").Where(x=>x!="").Select(n=>n.Last()));}

Programa, 211 bytes:

using System;using System.Text.RegularExpressions;using System.Linq;class A{static void Main(){Console.WriteLine(string.Concat(Regex.Split(Console.ReadLine(),"[^a-zA-Z]").Where(x=>x!="").Select(n=>n.Last())));}}

VBA, 147161

Sub a(s)
For n=0 To 255:m=Chr(n):s=Replace(s,IIf(m Like"[A-Za-z]","",m)," "):Next
For Each r In Split(s," "):t=t & Right(r,1):Next
MsgBox t
End Sub

Ruby 2.0, 25 (+1) caracteres

gsub(/(\w+)\W*/){$1[-1]}

Debe ejecutarse con el -pinterruptor:

 $ ruby -p ed.rb <<< "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"
flvmrp

Retina , 16 bytes

Li, -1|""`[a-z]+

Pruébalo en línea!

Explicación

Li, -1|""`[a-z]+
L         [a-z]+        List all the sequences of letters in the input
 i                      case insensitive
  ,                     Keep all the results
    -1                  but only the last character for each of them
      |""               Use the empty string as separator

Retina , 20 bytes

i`.(?=[a-z])|[^a-z]

Pruébalo en línea

Este programa es compatible con la versión 0.8.2

Java 8, 43 bytes

s->s.replaceAll("(?i).(?=[a-z])|[^a-z]","")

La respuesta de Retina del puerto de @ mbomb007 .

Explicación:

Pruébalo en línea.

s->  // Method with String as both parameter and return-type
  s.replaceAll("(?i).(?=[a-z])|[^a-z]","")
     //  Remove every match of this regex, and return as result

Explicación adicional para la expresión regular:

"(?i).(?=[a-z])|[^a-z]"  // Main regex to match
 (?i)                    //  Case insensitive
     .                   //   Any character
      (?=[a-z])          //   Followed by a letter (as positive look-ahead)
               |[^a-z]   //   or a non-letter

""                       // Replace it with: nothing

Smalltalk , Squeak / Pharo sabor
122 char con formato tradicional para este método agregado a String:

endOfWords
    ^(self subStrings: (CharacterSet allCharacters select: #isLetter) complement) collect: #last as: String

62 caracteres en Pharo 1.4, con expresiones regulares y formato extraño

endOfWords^''join:(self regex:'[a-zA-Z]+'matchesCollect:#last)

J: 60 caracteres (o 38 caracteres para una versión menos correcta)

(#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0

Si estamos dispuestos a dejar que el programa se interrumpa siempre que haya palabras que terminen en dos puntos o un guión bajo, entonces podemos simplificar esto a 38 caracteres.

(#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:

Ejecución de muestra:

    (#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0'asdf jkl;__zxcv~< vbnm,.qwer| |uiop'
flvmrp
    (#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0'pigs, eat dogs; eat Bob: eat pigs'
ststbts
    (#~e.&(,26&{.&(}.&a.)"0(97 65))){:&>;:]`(' '"_)@.(e.&'_:')"0'99_bottles_of_beer_on_the_wall'
sfrnel

Está en PHP . 197 bytes :( Soy principiante

$l=$_GET['line'];
$l=preg_replace('/(\W|_)+/',' ',$l);
$s=explode(' ',$l);
foreach($s as $d){
$a=substr($d,-1,1);
$o=ORD($a);
if(($o>=97 && $o<=122) || ($o>=65 && $o<=90)){
echo $a;
  }
}

EDITADO Ahora son 171 bytes

<?$l=$_GET['l'];$l=preg_replace('/(\W|_)+/',' ',$l);$s=explode(' ',$l);foreach($s as $d){$a=substr($d,-1,1);$o=ORD($a);if(($o>=97&&$o<=122)||($o>=65&&$o<=90)){echo$a;}}

K 30

q)k)f:{x@&-1=-':(1_x," ")in,/.Q`a`A}
q)f "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"
"flvmrp"
q)f "pigs, eat dogs; eat Bob: eat pigs"
"ststbts"
q)f "looc si siht ,gnitirw esreveR"
"citwR"
q)f "99_bottles_of_beer_on_the_wall"
"sfrnel"

Japt v2, 16 bytes

r/\L*\l+)\L*/@YÌ

Intentalo