The world ends in ed

Question

Taken straight from the ACM Winter Programming Contest 2013. You are a person who likes to take things literally. Therefore, for you, the end of The World is ed; the last letters of "The" and "World" concatenated.

Make a program which takes a sentence, and output the last letter of each word in that sentence in as little space as possible (fewest bytes). Words are separated with anything but letters from the alphabet (65 - 90, 97 - 122 on the ASCII table.) That means underscores, tildes, graves, curly braces, etc. are separators. There can be more than one seperator between each word.

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

Answer 1

ed, 35 characters

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

So, the world ends in ed. As I like to be too literal, I decided to write to write the solution with ed - and apparently it is actually a programming language. It's surprisingly short, even considering many shorter solutions already exist in this thread. It would be nicer if I could use something other than [a-zA-Z], but considering ed isn't a programming language, it's actually good enough.

First, I would like to say this only parses the last line in file. It would be possible to parse more, just type , at beginning of two first lines (this specified "everything" range, as opposed to standard last line range), but that would increase code size to 37 characters.

Now for explanations. The first line does exactly what Perl solution does (except without support for Unicode characters). I haven't copied the Perl solution, I just invented something similar by coincidence.

The second line prints last line, so you could see the output. The third line forces quit - I have to do it, otherwise ed would print ? to remind you that you haven't saved the file.

Now for how to execute it. Well, it's very simple. Just run ed with the file containing test case, while piping my program, like that.

ed -s testcase < program

-s is silent. This prevents ed from outputing ugly file size at beginning. After all, I use it as a script, not editor, so I don't need metadata. If I wouldn't do that, ed would show file size that I couldn't prevent otherwise.

Answer 2

Perl 5, 18 bytes

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

Requires a -p command line switch. The named property L matches only letter characters A-Za-z. There are several hundred such named properties, but when dealing with ASCII text, very few of them are interesting. Besides \pL, the only other one of any real note is \pP, which matches punctuation.

Try it online!

---

Perl 5, 17 bytes

A one byte improvement by Dom Hastings

print/\pL*(\pL)/g

Requires -n (and -l to support multiple inputs).

Try it online!

---

Sample usage

$ 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

Answer 3

Javascript, 49

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

It uses a regular expression to remove all characters that come before a letter, as well as all non-letter characters. Then we're left with the last letter of each word.

Thanks to tomsmeding for a nice improvement.

Answer 4

C, 78

Golfed:

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

With whitespace:

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

Output:

Answer 5

GNU Sed, 40 38 37

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

Testing

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

Run sed:

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

Output:

flvmrp
ststbts
citwR

Explanation

The first substitution replaces all word boundaries, that are preceded by the desired match group, with a new-line. This makes it easy to remove all extraneous characters in the second substitution.

Edit

• Use case-insensitive flag (-2), thanks manatwork.
• Don't count whitespace (-1).

Answer 6

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

If a final new-line is needed, replace tr -d \\n with paste -sd ''.

Edit

• Use case-insensitive grep (-2), thanks manatwork.
• Use tr instead of paste (-4), thanks manatwork.
• Don't count whitespace around pipe (-2).

Answer 7

sed, 37 chars

Equal length to Thor's answer, but, I think, simpler.

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

The logic is quite trivial - replace letter sequences with their last letter, then delete all non-letters.

Answer 8

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

Answer 9

Nibbles, 4.5 bytes (9 nibbles)

.%~$\$a/\

.%~$\$a/\       # 9 nibble program
.%~$\$a/\$$     # with implicit variables added:
 $~             # split
   $            # the input
    \           # by whether the character class
     $          # of each element
      a         # is alphabetic;
.               # now, map over this
        \       # reversing
         $      # each group
       /        # and folding across these
          $     # returning the first (left-hand) argument
                # (in other words, return the first character of each group)

Answer 10

Zsh (builtins only), 40

for j (${=@//[^a-zA-Z]/ });printf $j[-1]

Try it Online...

Answer 11

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"

Answer 12

Scala, 59 (or 43)

Assuming the string in already in s:

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

If you need to read from a prompt and print rather than using the REPL output, convert s to readLine and wrap in println() for 59.

Answer 13

x86: 54 bytes

Assume a cdecl routine with the signature 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

Answer 14

Xi, 32

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

Xi is a language still in its beta phase, but it seems to work well with code golf so I figured I might as well show yet another short and functional solution (and advertise the language a little :-)).

Answer 15

Mathematica 62 57 52

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

Testing

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

Answer 16

Python3, 59 chars

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

Correctly deals with capital letters and underscores. The 2 is to pass re.sub the re.IGNORECASE flag without having to use re.I.

Answer 17

Python, 76 chars

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

Answer 18

R, 126

My R solution

function(x){cat(paste(unlist(sapply(strsplit(unlist(strsplit(gsub("
[^[:alpha:]]"," ",x)," ")),""),tail,1)),collapse=""),"\n")}

Answer 19

Pip, 8 bytes

DQ*a@+XA

Verify all test cases: Try it online!

Explanation

      XA  Built-in regex variable: `[A-Za-z]`
     +    Apply regex + quantifier: `[A-Za-z]+`
   a@     Find all matches in the input
DQ*       Dequeue the last character from each match
          Concatenate together and autoprint (implicit)

Answer 20

Haskell, 62 60 bytes

f s=last<$>words[last$' ':[c|'@'<c,c<'{','`'<c||c<'[']|c<-s]

Try it online! Thanks to Wheat Wizard for a version without the import, saving two bytes!

---

Haskell, 62 bytes

import Data.Char
f s=last<$>words[last$' ':[c|isAlpha c]|c<-s]

Try it online!

Given an input string s, [last$' ':[c|isAlpha c]|c<-s] converts all non-alphabetic characters to spaces. words splits the resulting string on white space and last<$> takes the last character of each of the resulting strings.

Answer 21

Japt v2.0a0 -P, 16 9 6 bytes

q\L mÌ

Try it or run all test cases

q\L mÌ     :Implicit input of string U
q          :Split on
 \L        :  Regex /[^a-z]/gi
    m      :Map
     Ì     :  Last character
           :Implicitly join & output

Answer 22

Pyth, 27 19 bytes

seMc:z"[^A-Za-z]+"d

Test suite

Explanation:

seMc:z"[^A-Za-z]+"d | Full code
--------------------+---------------------------------------------
    :z"[^A-Za-z]+"d | In the input, replace non-letters with space
   c                | Split on spaces
 eM                 | Replace each word with its last letter
s                   | Concatenate each letter

Answer 23

Python 3.x, 64 bytes

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

Answer 24

Lua, 42

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

Usage example: lua script.lua "asdf jkl;__zxcv~< vbnm,.qwer| |uiop"

Answer 25

Mathematica 71 47 45 61

Back to the drawing board, after @belisarius found an error in the code.

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

Testing

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

Answer 26

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

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

Output: CodeGolf

---

This solution can be shortened to 67 characters if you allow the output to include backspace characters (ASCII code 8) at the beginning. The output will be visually identical.

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

Same input, (visually) same output. <BS> is meant to be the backspace character.

Answer 27

Smalltalk, Squeak/Pharo flavour
122 char with traditional formatting for this method added to String:

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

62 chars in Pharo 1.4, with regex and weird formatting

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

Answer 28

J: 60 characters (or 38 characters for a less correct version)

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

If we're willing let the program break whenever there are words ending in a colon or an underscore, then we can simplify this to 38 characters.

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

Sample run:

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

Answer 29

C#

Method, 105 bytes: (assumes usings for System, System.Text.RegularExpressions and System.Linq)

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

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

Answer 30

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