Tratto direttamente dall'ACM Winter Programming Contest 2013. Sei una persona a cui piace prendere le cose alla lettera. Pertanto, per te, la fine di The World è ed; le ultime lettere di "Il" e "Mondo" concatenate.

Crea un programma che prende una frase e genera l'ultima lettera di ogni parola in quella frase nel minor spazio possibile (meno byte). Le parole sono separate con qualsiasi cosa tranne le lettere dell'alfabeto (65 - 90, 97 - 122 nella tabella ASCII). Ciò significa che caratteri di sottolineatura, tilde, tombe, parentesi graffe, ecc. Sono separatori. Tra ogni parola può esserci più di un separatore.

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 byte

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

Richiede -pun'opzione della riga di comando. La proprietà denominata Lcorrisponde solo ai caratteri lettera A-Za-z. Esistono diverse centinaia di tali proprietà con nome, ma quando si tratta di testo ASCII, pochissime sono interessanti. Inoltre \pL, l'unica altra di qualsiasi nota reale è \pP, che corrisponde alla punteggiatura.

Provalo online!

Perl 5, 17 byte

Un miglioramento di un byte di Dom Hastings

print/\pL*(\pL)/g

Richiede -n(e -lper supportare più input).

Provalo online!

Utilizzo del campione

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

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

Quindi, il mondo finisce in ed. Dato che mi piace essere troppo letterale, ho deciso di scrivere per scrivere la soluzione con ed - e apparentemente è in realtà un linguaggio di programmazione . È sorprendentemente breve, anche considerando che in questo thread esistono già molte soluzioni più brevi. Sarebbe più bello se potessi usare qualcosa di diverso [a-zA-Z], ma considerando che non è un linguaggio di programmazione, in realtà è abbastanza buono.

Innanzitutto, vorrei dire che analizza solo l'ultima riga del file. Sarebbe possibile analizzare di più, basta digitare ,all'inizio di due prime righe (questo intervallo "tutto" specificato, al contrario dell'intervallo dell'ultima riga standard), ma ciò aumenterebbe la dimensione del codice a 37 caratteri.

Ora per spiegazioni. La prima riga fa esattamente quello che fa la soluzione Perl (tranne senza supporto per i caratteri Unicode). Non ho copiato la soluzione Perl, ho appena inventato qualcosa di simile per coincidenza.

La seconda riga stampa l'ultima riga, in modo da poter vedere l'output. La terza riga forza la chiusura - Devo farlo, altrimenti edverrebbe stampato ?per ricordarti che non hai salvato il file.

Ora per come eseguirlo. Bene, è molto semplice. Esegui semplicemente edil file contenente il test case, mentre esegui il piping del mio programma, in questo modo.

ed -s testcase < program

-sè silenzioso. Questo impedisce eddi produrre file di dimensioni brutte all'inizio. Dopotutto, lo uso come script, non come editor, quindi non ho bisogno di metadati. Se non lo facessi, ed mostrerebbe la dimensione del file che altrimenti non avrei potuto impedire.

Javascript, 49

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

Utilizza un'espressione regolare per rimuovere tutti i caratteri che precedono una lettera, nonché tutti i caratteri non lettera. Quindi restiamo con l'ultima lettera di ogni parola.

Grazie a tomsmeding per un bel miglioramento.

C, 78

golfed:

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

Con spazi bianchi:

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

Produzione:

GNU Sed, 40 38 37

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

analisi

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

Esegui sed:

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

Produzione:

flvmrp
ststbts
citwR

Spiegazione

La prima sostituzione sostituisce tutti i limiti di parole, preceduti dal gruppo di corrispondenze desiderato, con una nuova riga. Ciò semplifica la rimozione di tutti i caratteri estranei nella seconda sostituzione.

modificare

• Usa la bandiera senza distinzione tra maiuscole e minuscole (-2), grazie manatwork .
• Non contare gli spazi bianchi (-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 è necessaria una nuova riga finale, sostituirla tr -d \\ncon paste -sd ''.

modificare

• Usa grep senza distinzione tra maiuscole e minuscole (-2), grazie a Manatwork .
• Usa trinvece di paste(-4), grazie manatwork .
• Non contare gli spazi bianchi attorno alla pipe (-2).

sed, 37 caratteri

Uguale lunghezza alla risposta di Thor , ma, credo, più semplice.

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

La logica è piuttosto banale: sostituisci le sequenze di lettere con l'ultima lettera, quindi elimina tutte le non lettere.

Mathematica, 39

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

Test:

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

Supponendo che la stringa sia già in s:

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

Se è necessario leggere da un prompt e stampare anziché utilizzare l'output REPL, convertire sin readLinee completare println()per 59.

x86: 54 byte

Assumi una routine 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 è una lingua ancora nella sua fase beta, ma sembra funzionare bene con il golf del codice, quindi ho pensato che potrei anche mostrare un'altra soluzione breve e funzionale (e pubblicizzare un po 'la lingua :-)).

Mathematica 62 57 52

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

analisi

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 caratteri

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

Gestisce correttamente lettere maiuscole e caratteri di sottolineatura. Il 2 è quello di passare re.subla re.IGNORECASEbandiera senza dover usare re.I.

Python, 76 caratteri

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

Python 3.x, 64 byte

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

Lua, 42

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

Esempio di utilizzo: lua script.lua "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"

Mathematica 71 47 45 61

Torna al tavolo da disegno, dopo che @belisarius ha trovato un errore nel codice.

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

analisi

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

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

Produzione: CodeGolf

Questa soluzione può essere ridotta a 67 caratteri se si consente all'output di includere caratteri backspace (codice ASCII 8) all'inizio. L'output sarà visivamente identico.

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

Stesso input, (visivamente) stesso output. <BS>è pensato per essere il personaggio del backspace.

C #

Metodo, 105 byte: (presuppone l'utilizzo per 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()));}

Programma, 211 byte:

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

Ruby 2.0, 25 (+1) caratteri

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

Deve essere eseguito con l' -pinterruttore:

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

Retina , 16 byte

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

Provalo online!

Spiegazione

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 byte

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

Provalo online

Questo programma è compatibile con la versione 0.8.2

Java 8, 43 byte

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

Porta della risposta Retina di @ mbomb007 .

Spiegazione:

Provalo 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

Spiegazione aggiuntiva per la 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

Carattere Smalltalk , Squeak / Pharo
122 con formattazione tradizionale per questo metodo aggiunto a String:

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

62 caratteri in Pharo 1.4, con regex e strana formattazione

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

J: 60 caratteri (o 38 caratteri per una versione meno corretta)

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

Se vogliamo lasciare che il programma si interrompa ogni volta che ci sono parole che terminano in due punti o un trattino basso, allora possiamo semplificare questo a 38 caratteri.

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

Esecuzione di esempio:

    (#~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

È in PHP . 197 byte :( Sono 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;
  }
}

MODIFICATO Ora sono 171 byte

<?$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 byte

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

Provalo