Julia: how to get a random permutation of a given string s? - string

Question

I thought about two different ways, but both seem pretty ugly.
Transform the string s into an array a by splitting it, then use sample(a, length(s), replace=false) and join the array again into a string
Get a RandomPermutation r of length length(s) and join the single s[i] for i in r.
What's the right way? Unfortunately there is no method matching sample(::String, ::Int64; replace=false).

Answer 1

Perhaps defining a shuffle method for String constitutes type piracy, but, anyway, here's a suggested implemetation:
Base.shuffle(s::String) = isascii(s) ? s[randperm(end)] : join(shuffle!(collect(s)))

Answer 2

If you wanted to squeeze out performance from shuffle then you can consider:
function shufflefast(s::String)
ss = sizeof(s)
l = length(s)
ss == l && return String(shuffle!(copy(Vector{UInt8}(s))))
v = Vector{Int}(l)
i = start(s)
for j in 1:l
v[j] = i
i = nextind(s, i)
end
p = pointer(s)
u = Vector{UInt8}(ss)
k = 1
for i in randperm(l)
for j in v[i]:(i == l ? ss : v[i+1]-1)
u[k] = unsafe_load(p, j)
k += 1
end
end
String(u)
end
For large strings it is over 4x faster for ASCII and 3x faster for UTF-8.
Unfortunately it is messy - so I would rather treat it as an exercise. However, it uses only exported functions so it is not a hack.

Answer 3

Inspired by the optimization tricks in Bogumil Kaminski's answer, the following is a version with almost the same performance, but a bit clearer (in my opinion) and using a second utility function which may be of value in itself:
function strranges(s) # returns the ranges of bytes spanned by chars
u = Vector{UnitRange{Int64}}()
sizehint!(u,sizeof(s))
i = 1
while i<=sizeof(s)
ii = nextind(s,i)
push!(u,i:ii-1)
i = ii
end
return u
end
function shufflefast(s)
ss = convert(Vector{UInt8},s)
uu = Vector{UInt8}(length(ss))
i = 1
#inbounds for r in shuffle!(strranges(s))
for j in r
uu[i] = ss[j]
i += 1
end
end
return String(uu)
end
Example timing:
julia> using BenchmarkTools
julia> s = "ďaľšý"
julia> #btime shuffle($s) # shuffle from DNF's answer
831.200 ns (9 allocations: 416 bytes)
"ýľďša"
julia> #btime shufflefast($s) # shuffle from this answer
252.224 ns (5 allocations: 432 bytes)
"ľýďaš"
julia> #btime kaminskishufflefast($s) # shuffle from Kaminski's answer
197.345 ns (4 allocations: 384 bytes)
"ýašďľ"

Answer 4

EDIT: a little better performance - see code comments
This is from Bogumil Kaminski's answer where I am trying to avoid calculating length (*) if it is not necessary:
function shufflefast2(s::String)
ss = sizeof(s)
local l
for l in 1:ss
#if ((codeunit(s,l) & 0xc0) == 0x80)
if codeunit(s,l)>= 0x80 # edit (see comments bellow why)
break
end
end
ss == l && return String(shuffle!(copy(Vector{UInt8}(s))))
v = Vector{Int}(ss)
i = 1
l = 0
while i<ss
l += 1
v[l] = i
i = nextind(s, i)
end
v[l+1] = ss+1 # edit - we could do this because ss>l
p = pointer(s)
u = Vector{UInt8}(ss)
k = 1
for i in randperm(l)
# for j in v[i]:(i == l ? ss : v[i+1]-1)
for j in v[i]:v[i+1]-1 # edit we could do this because v[l+1] is defined (see above)
u[k] = unsafe_load(p, j)
k += 1
end
end
String(u)
end
Example timing for ascii string:
julia> srand(1234);#btime for i in 1:100 danshufflefast("test") end
19.783 μs (500 allocations: 34.38 KiB)
julia> srand(1234);#btime for i in 1:100 bkshufflefast("test") end
10.408 μs (300 allocations: 18.75 KiB)
julia> srand(1234);#btime for i in 1:100 shufflefast2("test") end
10.280 μs (300 allocations: 18.75 KiB)
Difference is too small, sometimes bkshufflefast is faster. Performance has to be equal. Whole length has to be count and there is same allocation.
Example timing for unicode string:
julia> srand(1234);#btime for i in 1:100 danshufflefast(s) end
24.964 μs (500 allocations: 42.19 KiB)
julia> srand(1234);#btime for i in 1:100 bkshufflefast(s) end
20.882 μs (400 allocations: 37.50 KiB)
julia> srand(1234);#btime for i in 1:100 shufflefast2(s) end
19.038 μs (400 allocations: 40.63 KiB)
shufflefast2 is a little but clearly faster here. A little more allocation than Bogumil's function and a little less allocation than in Dan's solution.
(*) - I a little hope that String implementation in Julia will be faster in future and length could be much quicker than it is now.