Retirado diretamente do ACM Winter Programming Contest 2013. Você é uma pessoa que gosta de interpretar as coisas literalmente. Portanto, para você, o fim do mundo é ed; as últimas letras de "O" e "Mundo" concatenaram.

Faça um programa que use uma frase e imprima a última letra de cada palavra nessa frase no menor espaço possível (menos bytes). As palavras são separadas por qualquer coisa, exceto letras do alfabeto (65 - 90, 97 - 122 na tabela ASCII.) Isso significa sublinhados, til, sepulturas, chaves, etc. são separadores. Pode haver mais de um separador entre cada palavra.

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

Requer uma -popção de linha de comando. A propriedade nomeada Lcorresponde apenas aos caracteres da letra A-Za-z. Existem várias centenas dessas propriedades nomeadas, mas ao lidar com texto ASCII, muito poucas são interessantes. Além disso \pL, a única outra nota real é a \pPque corresponde à pontuação.

Experimente online!

Perl 5, 17 bytes

Uma melhoria de um byte por Dom Hastings

print/\pL*(\pL)/g

Requer -n(e -lpara suportar várias entradas).

Experimente online!

Uso da amostra

$ 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

Então, o mundo termina em ed. Como gosto de ser literal demais, decidi escrever para escrever a solução com ed - e, aparentemente, é realmente uma linguagem de programação . É surpreendentemente curto, mesmo considerando que muitas soluções mais curtas já existem neste segmento. Seria melhor se eu pudesse usar algo diferente [a-zA-Z], mas considerando que ed não é uma linguagem de programação, é realmente bom o suficiente.

Primeiro, eu gostaria de dizer que isso apenas analisa a última linha do arquivo. Seria possível analisar mais, basta digitar ,no início das duas primeiras linhas (isso especificou o intervalo "tudo", em oposição ao intervalo padrão da última linha), mas isso aumentaria o tamanho do código para 37 caracteres.

Agora, para explicações. A primeira linha faz exatamente o que a solução Perl faz (exceto sem suporte para caracteres Unicode). Não copiei a solução Perl, apenas inventei algo semelhante por coincidência.

A segunda linha imprime a última linha, para que você possa ver a saída. As forças da terceira linha são encerradas - eu tenho que fazer isso, caso contrário, edseria impresso ?para lembrá-lo de que você não salvou o arquivo.

Agora, como executá-lo. Bem, é muito simples. Basta executar edcom o arquivo que contém o caso de teste, enquanto canaliza meu programa, assim.

ed -s testcase < program

-sé silencioso. Isso impede a edsaída de um tamanho de arquivo feio no início. Afinal, eu o uso como um script, não como editor, portanto não preciso de metadados. Se eu não fizesse isso, ed mostraria o tamanho do arquivo que não poderia impedir de outra forma.

Javascript, 49

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

Ele usa uma expressão regular para remover todos os caracteres anteriores a uma letra, bem como todos os caracteres que não são da letra. Então ficamos com a última letra de cada palavra.

Obrigado a tomsmeding por uma boa melhoria.

C, 78

Golfe:

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

Com espaço em branco:

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

Saída:

GNU Sed, 40 38 37

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

Teste

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

Executar sed:

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

Saída:

flvmrp
ststbts
citwR

Explicação

A primeira substituição substitui todos os limites de palavras precedidos pelo grupo de correspondência desejado por uma nova linha. Isso facilita a remoção de todos os caracteres estranhos na segunda substituição.

Editar

• Use sinalizador sem distinção entre maiúsculas e minúsculas (-2), graças a manatwork .
• Não conte com espaço em branco (-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

Se for necessária uma nova linha final, substitua tr -d \\npor paste -sd ''.

Editar

• Use grep que não diferencia maiúsculas de minúsculas (-2), graças ao manatwork .
• Use em trvez de paste(-4), obrigado manatwork .
• Não conte espaço em branco ao redor do pipe (-2).

sed, 37 caracteres

Comprimento igual à resposta de Thor , mas, eu acho, mais simples.

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

A lógica é bastante trivial - substitua as seqüências de letras pela última letra e exclua todas as não letras.

Mathematica, 39

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

Teste:

""<>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 (ou 43)

Supondo que a string já esteja em s:

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

Se você precisa ler a partir de um prompt e imprimir ao invés de usar a saída REPL, convertido spara readLinee embrulhe em println()para 59.

x86: 54 bytes

Assuma uma rotina de cdecl com a assinatura 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+"

O Xi é um idioma ainda em fase beta, mas parece funcionar bem com o código golf, então imaginei que também poderia mostrar outra solução curta e funcional (e anunciar um pouco o idioma :-)).

Mathematica 62 57 52

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

Teste

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

Lida corretamente com letras maiúsculas e sublinhados. O 2 é para passar re.suba re.IGNORECASEbandeira sem ter 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')))

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

Mathematica 71 47 45 61

De volta à prancheta, depois que o @belisarius encontrou um erro no código.

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

Teste

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

Python 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

Saída: CodeGolf

Esta solução pode ser reduzida para 67 caracteres se você permitir que a saída inclua caracteres de backspace (código ASCII 8) no início. A saída será visualmente idêntica.

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

Mesma entrada, (visualmente) mesma saída. <BS>deve ser o caractere de backspace.

C #

Método, 105 bytes: (assume utilizações para System, System.Text.RegularExpressions e 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, 147 161

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

Caracteres Ruby 2.0, 25 (+1)

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

Deve ser executado com o -pcomutador:

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

Retina , 16 bytes

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

Experimente online!

Explicação

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]

Experimente online

Este programa é compatível com a versão 0.8.2

Java 8, 43 bytes

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

Porto da resposta Retina de @ mbomb007 .

Explicação:

Experimente online.

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

Explicação adicional para a regex:

"(?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 com formatação tradicional para este método adicionado à String:

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

62 caracteres no Pharo 1.4, com regex e formatação estranha

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

J: 60 caracteres (ou 38 caracteres para uma versão menos correta)

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

Se quisermos que o programa seja interrompido sempre que houver palavras que terminem em dois-pontos ou sublinhado, podemos simplificá-lo para 38 caracteres.

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

Exemplo de execução:

    (#~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á em PHP . 197 bytes :( eu sou iniciante

$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 Agora são 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Ì

Tente