How can I scramble a word with a factor?

Question

I would like to scramble a word with a factor. The bigger the factor is, the more scrambled the word will become.

For example, the word "paragraphs" with factor of 1.00 would become "paaprahrgs", and it will become "paargarphs" with a factor of 0.50.

The distance from the original letter position and the number of scrambled letters should be taken into consideration.

This is my code so far, which only scrambles without a factor:

def Scramble(s): 
    return ''.join(random.sample(s, len(s)))

Any ideas?

P.S. This isn't an homework job - I'm trying to make something like this: http://d24w6bsrhbeh9d.cloudfront.net/photo/190546_700b.jpg

Note that such scramblings should leave the first and last letters in their original place, otherwise it will not have the same effect. — Jeff Mercado, Aug 07 '11 at 20:29
then "if len(word) > 3: print word[0] + Scramble(word[1:-1]) + word[-1]" would do the job — iTayb, Aug 07 '11 at 20:32
You should be aware that this scrambling of internal letters in a word has been thoroughly studied: http://www.mrc-cbu.cam.ac.uk/people/matt.davis/cmabridge/ — Greg Hewgill, Aug 07 '11 at 20:38

score 3 · Accepted Answer · answered Aug 07 '11 at 20:39

You could use the factor as a number of shuffling chars in the string around. As the factor seem's to be between 0 and 1, you can multiply the factor with the string's length.

from random import random

def shuffle(string, factor):
    string    = list(string)
    length      = len(string)
    if length < 2:
        return string
    shuffles    = int(length * factor)
    for i in xrange(shuffles):
        i, j    = tuple(int(random() * length) for i in xrange(2))
        string[i], string[j]    = string[j], string[i]

    return "".join(string)

x = "computer"
print shuffle(x, .2)
print shuffle(x, .5)
print shuffle(x, .9)

coupmter
eocpumtr
rpmeutoc

If you want the first and the last characters to stay in place, simply split them and add them later on.

def CoolWordScramble(string, factor = .5):
    if len(string) < 2:
        return string
    first, string, last = string[0], string[1:-1], string[-1]

    return first + shuffle(string, factor) + last

This is exactly what I was looking for..Thanks – anarchy Apr 11 '18 at 20:34 — anarchy, Apr 11 '18 at 20:34

score 2 · Answer 2 · answered Aug 07 '11 at 20:23

You haven't defined what your "factor" should mean, so allow me to redefine it for you: A scrambling factor N (an integer) would be the result of swapping two random letters in a word, N times.

With this definition, 0 means the resulting word is the same as the input, 1 means only one pair of letters is swapped, and 10 means the swap is done 10 times.

score 1 · Answer 3 · answered Aug 07 '11 at 20:22

You can make the "factor" roughly correspond to the number of times two adjacent letters of the word switch their positions (a transposition).

In each transposition, choose a random position (from 0 through the length-minus-two), then switch the positions of the letter at that position and the letter that follows it.

utdemir · Answer 4 · 2011-08-07T20:38:59.963

It could be implemented many ways, but here is my solution:

Wrote a function that just changes a letter's place:

def scramble(s):
    s = list(s) #i think more easier, but it is absolutely performance loss
    p = s.pop(random.randint(0, len(s)-1))
    s.insert(random.randint(0, len(s)-1), p)
    return "".join(s)

And wrote a function that apply to a string many times:

def scramble_factor(s, n):
    for i in range(n):
        s = scramble(s)
    return s

Now we can use it:

>>> s = "paragraph"
>>> scramble_factor(s, 0)
'paragraph'
>>> scramble_factor(s, 1)
'pgararaph'
>>> scramble_factor(s, 2)
'prahagrap'
>>> scramble_factor(s, 5)
'pgpaarrah'
>>> scramble_factor(s, 10)
'arpahprag'

Of course functions can be combined or nested, but it is clear I think.

Edit:

It doesn't consider distance, but the scramble function easily replaced just for swapping adjacent letters. Here is one:

def scramble(s):
    if len(s)<=1:
        return s
    index = random.randint(0, len(s)-2)
    return s[:index] + s[index + 1] + s[index] + s[index+2:]

This algorithm doesn't take distance into consideration, but it's a nice start. I'll use it. ThankS! — iTayb, Aug 07 '11 at 20:31
Added another scramble function, just swaps adjacent letters, it suits better. — utdemir, Aug 07 '11 at 20:39

score -1 · Answer 5 · answered Aug 07 '11 at 20:20

-1

You could do a for-loop that counts down to 0.

Convert the String into a Char-Array and use a RNG to choose 2 letters to swap.

answered Aug 07 '11 at 20:20

Velero

1

How can I scramble a word with a factor?

5 Answers5

Linked