# Burrows, Wheeler and Back

### Background

The Burrows–Wheeler transform (BWT) is a reversible permutation of the characters of a string that results in large runs of similar characters for certain types of strings such as plain text. It is used, for example, in the bzip2 compression algorithm.

The BWT is defined as follows:

Given an input string such as codegolf, compute all possible rotations of it and sort them in lexicographical order:

codegolf
degolfco
egolfcod
fcodegol
golfcode
lfcodego
odegolfc
olfcodeg


The BWT of the string codegolf is the string consisting of the last character of each string in that order, i.e., the last column of the block above. For codegolf, this yields fodleocg.

By itself, this transformation isn't reversible, since the strings codegolf and golfcode result in the same string. However, if we know that the string ends with an f, there is only one possible preimage.

Implement an involutive program or function that reads a single string from STDIN or as command-line or function argument and prints or returns either the BWT or its inverse of the input string.

If the input string contains no spaces, your submission should append a single space to the input and compute the BWT.

If the input string already contains a space, it should compute the preimage of the BWT that has a trailing space and strip that space.

### Examples

INPUT:  ProgrammingPuzzles&CodeGolf
OUTPUT: fs&e grodllnomzomaiCrGgPePzu

INPUT:  fs&e grodllnomzomaiCrGgPePzu
OUTPUT: ProgrammingPuzzles&CodeGolf

INPUT:  bt4{2UK<({ZyJ>LqQQDL6!d,@:~L"#Da\6%EYp%y_{ed2GNmF"1<PkB3tFbyk@u0#^UZ<52-@bw@n%m5xge2w0HeoM#4zaT:OrI1I<|f#jyV9tGZA5su*b7X:Xn%L|9MX@\2W_NwQ^)2Yc*1b7W<^iY2i2Kr[mB;,c>^}Z]>kT6_c(4}hIJAR~x^HW?l1+^5\VW'\)h{6:TZ)^#lJyH|J2Jzn=V6cyp&eXo4]el1WAQpHCCYpc;5Tu@$[P?)_a?-RV82[):[@94{*#!;m8k"LXT~5EYyD<z=nGfn/;%}did\fw+/AzVuz]7^N%vm1lJ)PK*-]H~I5ixZ1*Cn]k%dxiQ!UR48<U/fbT\P(!z5l<AefL=q"mx_%C:2=w3rrIL|nghm1i\;Ho7q+44D<74y/l/A)-R5zJx@(h8~KK1H6v/{N8nB)vPgI$\WI;%,DY<#fz>is"eB(/gvvP{7q*$M4@U,AhX=JmZ}L^%*uv=#L#S|4D#< OUTPUT: <#Q6(LFksq*MD"=L0<f^*@I^;_6nknNp;pWPBc@<A^[JZ?\B{qKc1u%wq1dU%;2)?*nl+U(yvuwZl"KIl*mm5:dJi{\)8YewB+RM|4o7#9t(<~;^IzAmRL\{TVH<bb]{oV4mNh@|VCT6X)@I/Bc\!#YKZDl18WDIvXnzL2Jcz]PaWux[,4X-wk/ZJ<,/enkm%HC*44yQ,#%5mt2t1p^0;y]gr~W1hrl|yI=zl2PKU~2~#Df"}>%Io$9^{G_:\[)v<viQqwAU--A#ka:b5X@<2!^=R\zV7H\217hML:eiD2ECETxUG}{m2:$r'@aiT5$dzZ-4n)LQ+x7#<>xW)6yWny)_zD1*f @F_Yp,6!ei}%g"&{A]H|e/G\#Pxn/(}Ag2x^1d>5#8]yP>/?e51#hv%;[NJ"X@fz8C=|XHeYyQY=77LOrK3i5b39s@T*V6u)v%gf2=bNJi~m5d4YJZ%jbc!<f5Au4J44hP/(_SLH<LZ^%4TH8:R

INPUT:  <#Q6(LFksq*MD"=L0<f^*@I^;_6nknNp;pWPBc@<A^[JZ?\B{qKc1u%wq1dU%;2)?*nl+U(yvuwZl"KIl*mm5:dJi{\)8YewB+RM|4o7#9t(<~;^IzAmRL\{TVH<bb]{oV4mNh@|VCT6X)@I/Bc\!#YKZDl18WDIvXnzL2Jcz]PaWux[,4X-wk/ZJ<,/enkm%HC*44yQ,#%5mt2t1p^0;y]gr~W1hrl|yI=zl2PKU~2~#Df"}>%Io$9^{G_:\[)v<viQqwAU--A#ka:b5X@<2!^=R\zV7H\217hML:eiD2ECETxUG}{m2:$r'@aiT5$dzZ-4n)LQ+x7#<>xW)6yWny)_zD1*f @F_Yp,6!ei}%g"&{A]H|e/G\#Pxn/(}Ag2x^1d>5#8]yP>/?e51#hv%;[NJ"X@fz8C=|XHeYyQY=77LOrK3i5b39s@T*V6u)v%gf2=bNJi~m5d4YJZ%jbc!<f5Au4J44hP/(_SLH<LZ^%4TH8:R OUTPUT: bt4{2UK<({ZyJ>LqQQDL6!d,@:~L"#Da\6%EYp%y_{ed2GNmF"1<PkB3tFbyk@u0#^UZ<52-@bw@n%m5xge2w0HeoM#4zaT:OrI1I<|f#jyV9tGZA5su*b7X:Xn%L|9MX@\2W_NwQ^)2Yc*1b7W<^iY2i2Kr[mB;,c>^}Z]>kT6_c(4}hIJAR~x^HW?l1+^5\VW'\)h{6:TZ)^#lJyH|J2Jzn=V6cyp&eXo4]el1WAQpHCCYpc;5Tu@$[P?)_a?-RV82[):[@94{*#!;m8k"LXT~5EYyD<z=nGfn/;%}did\fw+/AzVuz]7^N%vm1lJ)PK*-]H~I5ixZ1*Cn]k%dxiQ!UR48<U/fbT\P(!z5l<AefL=q"mx_%C:2=w3rrIL|nghm1i\;Ho7q+44D<74y/l/A)-R5zJx@(h8~KK1H6v/{N8nB)vPgI$\WI;%,DY<#fz>is"eB(/gvvP{7q*$M4@U,AhX=JmZ}L^%*uv=#L#S|4D#<

INPUT:  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
OUTPUT: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

INPUT:  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
OUTPUT: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa


• You cannot use any built-in operators that compute the BWT (or its inverse) of a string.

• You cannot use any built-in operators that invert functions.

• Your code may print a trailing newline if you choose STDOUT for output, even if it doesn't support trailing newlines in the input.

• Your code has to work for any input of 500 or less printable ASCII characters (0x20 to 0x7E), including at most one space.

• For any of the possible inputs described above, your code must finish in under ten minutes on my machine (Intel Core i7-3770, 16 GiB RAM). The last test case should be the slowest, so make sure you time your code with that one.

For most languages and approaches, it should be easy to comply with the time limit. This rule is solely meant to prevent implementing either transform as a brute-force inverse of the other.

• Standard code golf rules apply. The shortest submission in bytes wins.

• "You cannot use any built-in operators that invert functions." I'd be very surprised if such a thing existed! – Hugh Allen Jun 7 '15 at 15:01
• @HughAllen J has inv. – Dennis Jun 7 '15 at 15:02
• It might work for trivial or builtin functions, but how could it work for general user-defined functions? Is this "inv" documented somewhere? – Hugh Allen Jun 7 '15 at 15:09
• @HughAllen: I don't really know J, but here is an example of inv working on a user-defined function. I'm not sure if inv would work for the BWT, but better safe than sorry. – Dennis Jun 7 '15 at 15:16
• Related, see codegolf.stackexchange.com/questions/4771/… for a full bzip2. – Keith Randall Jun 8 '15 at 2:42

# Pyth, 29 bytes

?tthu+VzSGzz}dzseMS.>L+z\ hlz


This straightforwardly divides into an encoding and decoding segment, with the code deciding which one to use with a ternary.

?tthu+VzSGzz}dzseMS.>L+z\ hlz
Implicit:
z = input()
d = ' '

?           }dz                  If there is a space in the input,
u     zz                     Update G to the result of the following,
with G starting as z and repeating len(z) times:
+V                          The vectorized sum of
zSG                       z and sorted(G)
h                             Take the first such result, which will consist of
the first character of z followed by the
first cyclic permuation of the pre-BWT string,
tt                              Remove the first two characters and return.
L               Otherwise, left-map (map with the variable as the
left parameter and a constant as the right)
.>                cyclic right shift
+z\            of z + ' '
hlz        over range(len(z)+1)
S                  Sort the shifted strings,
eM                   take their last charactes,
s                     combine into one string and return.


# CJam, 4136 35 bytes

q:XS&LX,{X\.+$}*0=1>XS+_,,\fm<$zW>?


Test it here.

## Explanation

q:X   e# Read STDIN and store it in X.
S&    e# Take the set intersection with " ". We'll use this as a truthy/falsy value to
e# select the correct output later.

# Compute the iBWT:
LX,   e# Push an empty array, compute the length of X.
{     e# Run the following block that many times:
X\  e# Push X and pull the other array on top.
.+  e# Add the characters of X to the corresponding line of the other array,
e# i.e. prepend X as a new column.
$e# Sort the rows. }* 0= e# Since we just sorted the rows, the first permutation of the output will be e# one starting with a space, followed by the string we actually want. So just e# pick the first permutation. 1> e# Remove the leading space. # Compute the BWT: XS+ e# Push X and append a space. _, e# Get that string's length N. ,\ e# Turn it into a range [0 .. N-1], swap it with the string. fm< e# Map each value in the range to the string shifted left by that many characters.$     e# Sort the permutations.
zW>   e# Transpose the grid and discard all lines but the last.

?     e# Choose between the iBWT and the BWT based on whether the input had a space.


# Perl 5, 179

Another not-so-good one from me. There are probably some gains to be had in this one, but it's not going to compete with the purpose-built golf languages.

$_=<>;@y=/./g;if(/ /){@x=sort@y;for(1..$#y){@x=sort map$y[$_].$x[$_],0..$#x} say$x[0]=~/^ (.*)/}else{push@y," ";say map/(.)$/,sort map{$i=$_;join"", map$y[($_+$i)%@y],0..$#y}0..$#y}


Un-golfed:

# Read input
$_ = <>; # Get all the chars of the input my @chars = /./g; if (/ /) { # If there's a space, run the IBWT: # Make the first column of the table my @working = sort @chars; # For each remaining character for (1 ..$#chars) {
# Add the input as a new column to the left of @working,
# then sort @working again
@working = sort map {
$chars[$_] . $working[$_]
} 0 .. $#working; } # Print the first element of @working (the one beginning with space), sans space say$working[0] =~ /^ (.*)/;
} else {
# BWT
# Add a space to the end of the string
push @chars, " ";
# Get all the rotations of the string and sort them
@rows = sort map {
my $offset =$_;
join "", map {
$chars[($_ + $offset) % @chars] } 0 ..$#chars
} 0 .. $#chars; # Print all the last characters say map /(.)$/, @rows;
}

• A few minor improvements: 1. If you use the -n switch (usually counted as 1 byte), you don't need $_=<>;. 2. for(1..$#y){...} can become ... for 1..$#y. 3. $" is initialized to " " and one byte shorter. – Dennis Jun 8 '15 at 2:12
• @Dennis good call. I had had multiple statements in the for at one point so the postfix form wasn't a win, but when I pared it down to one I didn't notice :) – hobbs Jun 8 '15 at 4:59