Generating random strings until a given string is generated

The task of generating random strings until a given string is generated involves using random combinations of characters and progressively improving the string through mutations until the target string is matched. For example, given a target string like "geek," the goal is to keep generating random strings until one exactly matches "geek."

Using genetic algorithm

Genetic Algorithm is an evolutionary approach where we generate a random string and progressively improve it through mutation. Instead of completely regenerating a new string every time, we modify the existing one by changing one character at a time, ensuring each change brings us closer to the target.

import string
import random

# Possible characters
possibleCharacters = string.ascii_lowercase + string.digits + \
                     string.ascii_uppercase + ' ., !?;:'

# Target string
t = "geek"

# Generate initial random string
def generate_random_string(length):
    return ''.join(random.choice(possibleCharacters) for _ in range(length))

# Fitness function: count matching characters
def fitness(current):
    return sum(1 for a, b in zip(current, t) if a == b)

# Mutation function: change one random character
def mutate(parent):
    index = random.randint(0, len(parent) - 1)
    child = list(parent)
    child[index] = random.choice(possibleCharacters)
    return ''.join(child)

# Main evolution loop
attempt = generate_random_string(len(t))
iteration = 0

while attempt != t:
    print(attempt)
    new_attempt = mutate(attempt)
    
    # Keep the mutation only if it improves fitness
    if fitness(new_attempt) >= fitness(attempt):
        attempt = new_attempt

    iteration += 1

print(f"Target matched after {iteration} iterations")

Output

FyFJ
.:YZ
aubo
.
.
.
g56G
gk6R
g7Se
gT o
gD d
gXek
g0ek
g ek
.
. 
gUek
giek
geek
Target matched after 168 iterations

Explanation:

• Generates Random String creates an initial random string of the same length as t.
• Defines Fitness Function counts matching characters in the correct positions.
• Mutation Function changes one random character in the string
• Main Evolution Loop starts with a random string, mutates it, compares fitness, accepts the mutation if fitness is maintained or improved, and repeats until the target is matched.

Using hill climbing approach

The Hill Climbing Algorithm takes a greedy approach by fixing correct characters and modifying only the incorrect ones. This ensures that once a character is correctly positioned, it remains unchanged.

import string
import random

# Possible characters
possibleCharacters = string.ascii_lowercase + string.digits + \
                     string.ascii_uppercase + ' ., !?;:'

# Target string
t = "geek"

# Generate initial random string
def generate_random_string(length):
    return ''.join(random.choice(possibleCharacters) for _ in range(length))

# Fitness function
def fitness(current):
    return sum(1 for a, b in zip(current, t) if a == b)

# Main hill-climbing loop
attempt = generate_random_string(len(t))
iteration = 0

while attempt != t:
    print(attempt)
    new_attempt = list(attempt)

    for i in range(len(t)):
        if new_attempt[i] != t[i]:
            new_attempt[i] = random.choice(possibleCharacters)
            if fitness(''.join(new_attempt)) < fitness(attempt):
                new_attempt[i] = attempt[i]  # Revert change if worse

    attempt = ''.join(new_attempt)
    iteration += 1

print(f"Target matched after {iteration} iterations")

Output :

FyFJ
.:YZ
aubo
.
.
.
g56G
gk6R
g7Se
gT o
gD d
gXek
g0ek
g ek
.
. 
gUek
giek
geek
Target matched after 168 iterations

Explanation:

• new_attempt list: This approach starts by converting the string to a list, allowing individual character manipulation.
• Hill Climbing iterates through each character in the current string, replacing non-matching characters with random ones, and reverts any changes that reduce fitness, ensuring that only improvements or unchanged states are kept.

Using iterative approach

This approach generates an initial random string and progressively replaces incorrect characters with random choices until the entire string matches the target.

# Importing string, random, and time modules
import string
import random
import time

# All possible characters including lowercase, uppercase, and special symbols
possibleCharacters = string.ascii_lowercase + string.digits + \
                     string.ascii_uppercase + ' ., !?;:'

# String to be generated
t = "geek"

# To take input from the user
# t = input(str("Enter your target text: "))

attemptThis = ''.join(random.choice(possibleCharacters)
                                for i in range(len(t)))
attemptNext = ''

completed = False
iteration = 0

# Iterate while completed is false
while completed == False:
    print(attemptThis)
    
    attemptNext = ''
    completed = True
    
    # Fix the index if matches with the string to be generated
    for i in range(len(t)):
        if attemptThis[i] != t[i]:
            completed = False
            attemptNext += random.choice(possibleCharacters)
        else:
            attemptNext += t[i]
            
    # Increment the iteration 
    iteration += 1
    attemptThis = attemptNext
    time.sleep(0.1)

# Driver Code
print("Target matched after " +
      str(iteration) + " iterations")

Output :

FyFJ
.:YZ
aubo
.
.
.
g56G
gk6R
g7Se
gT o
gD d
gXek
g0ek
g ek
.
. 
gUek
giek
geek

Target matched after 168 iterations

Explanation:

• attemptThis starts with a random string.
• For each incorrect character in attemptThis, it is replaced with a random character.
• If the character is already correct, it is preserved.
• This process repeats until the entire string matches the target string.
• time.sleep(0.1) adds a slight delay to visualize the process.