How can I scramble a word with a factor?

若如初见. 提交于 2020-01-06 12:57:01

问题


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


回答1:


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



回答2:


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.




回答3:


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.




回答4:


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:]



回答5:


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.



来源:https://stackoverflow.com/questions/6975437/how-can-i-scramble-a-word-with-a-factor

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!