Merge pull request #2560 from andoriyaprashant/branch22

Crytogram Solver Script added

Author: avinashkranjan

Cryptogram Solver/README.md

@@ -0,0 +1,36 @@
+# Cryptogram Solver
+
+## Description
+Cryptogram Solver is a Python script that automatically decrypts cryptograms. Cryptograms are word puzzles where each letter in the original word is replaced with another letter, and your task is to find the original word. This script uses frequency analysis techniques and a dictionary of words to solve the cryptogram.
+
+## Features
+1. **Letter Frequency Visualization**: The script displays a bar chart to visualize the letter frequency in the cryptogram.
+2. **Letter Substitution Game**: You can manually guess the letter substitutions to solve the cryptogram.
+3. **Hint System**: The script provides frequency analysis of letters to help you make educated guesses.
+4. **Save/Load Progress**: Your progress is saved and loaded for future sessions.
+
+## How to Use
+1. Install Python on your computer (Python 3.x is recommended).
+2. Download the script `cryptogram_solver.py` and the word dictionary file `english.words.txt` (or use your own word dictionary).
+3. Run the script using the command `python cryptogram_solver.py`.
+4. Enter the cryptogram when prompted.
+5. Optionally, enter the path to your word dictionary file.
+6. The script will automatically attempt to decrypt the cryptogram using frequency analysis and the word dictionary.
+7. After decryption, you can play the letter substitution game, view frequency analysis, and manually modify the decrypted message.
+
+## Requirements
+- Python 3.x
+- Matplotlib (for letter frequency visualization)
+- nltk
+
+## File Structure
+- `cryptogram_solver.py`: The main Python script for solving cryptograms.
+- `english.words.txt`: A text file containing a list of English words, one word per line, to use as a word dictionary.
+- `progress.pickle`: A binary file that stores your progress during decryption.
+
+## Notes
+- The success of the decryption depends on the quality of the word dictionary used and the length of the cryptogram.
+- The letter frequency analysis may not be perfect for very short cryptograms.
+- Have fun and enjoy solving cryptograms!
+
+

Cryptogram Solver/cryptogram_solver.py

@@ -0,0 +1,90 @@
+import string
+import matplotlib.pyplot as plt
+import pickle
+import os
+
+def load_word_dictionary(file_path):
+    with open(file_path, 'r') as file:
+        return set(word.strip().lower() for word in file.readlines())
+
+def get_letter_frequencies(text):
+    frequencies = {}
+    for char in text:
+        if char.isalpha():
+            char_lower = char.lower()
+            frequencies[char_lower] = frequencies.get(char_lower, 0) + 1
+    return frequencies
+
+def decrypt_cryptogram(cryptogram, frequency_map, word_dict):
+    alphabet = string.ascii_lowercase
+    sorted_freq = sorted(frequency_map.items(), key=lambda x: x[1], reverse=True)
+    freq_letters = ''.join(letter for letter, _ in sorted_freq)
+
+    def decrypt_letter(letter):
+        if letter.isalpha():
+            index = freq_letters.find(letter.lower())
+            decrypted_letter = alphabet[index] if letter.islower() else alphabet[index].upper()
+            return decrypted_letter
+        return letter
+
+    decrypted_text = ''.join(decrypt_letter(char) for char in cryptogram)
+    words = decrypted_text.split()
+    decrypted_words = [word if word.lower() not in word_dict else word_dict[word.lower()] for word in words]
+    return ' '.join(decrypted_words)
+
+def guess_word_length(cryptogram):
+    spaces = cryptogram.count(' ')
+    return len(cryptogram) // (spaces + 1)
+
+def manual_decryption(decrypted_text, cryptogram):
+    print("\nManual Decryption:")
+    while True:
+        print("Current decrypted text:", decrypted_text)
+        guess = input("Enter a letter to replace or press 'Enter' to finish: ")
+        if not guess:
+            break
+        replacement = input(f"Enter the replacement for '{guess}': ")
+        decrypted_text = decrypted_text.replace(guess, replacement)
+    return decrypted_text
+
+def visualize_frequency(frequency_map):
+    sorted_freq = sorted(frequency_map.items(), key=lambda x: x[1], reverse=True)
+    letters, frequencies = zip(*sorted_freq)
+    plt.bar(letters, frequencies)
+    plt.xlabel('Letters')
+    plt.ylabel('Frequency')
+    plt.title('Letter Frequency in the Cryptogram')
+    plt.show()
+
+def save_progress(decrypted_text):
+    with open('progress.pickle', 'wb') as file:
+        pickle.dump(decrypted_text, file)
+
+def load_progress():
+    if os.path.exists('progress.pickle'):
+        with open('progress.pickle', 'rb') as file:
+            return pickle.load(file)
+    else:
+        return None
+
+if __name__ == '__main__':
+    cryptogram = input("Enter the cryptogram: ")
+    word_dict_path = input("Enter the path to the word dictionary file: ")
+
+    word_dictionary = load_word_dictionary(word_dict_path)
+
+    letter_frequencies = get_letter_frequencies(cryptogram)
+    decrypted_message = load_progress() or decrypt_cryptogram(cryptogram, letter_frequencies, word_dictionary)
+
+    print("\nOriginal cryptogram:", cryptogram)
+    print("Decrypted message:", decrypted_message)
+
+    word_length_guess = guess_word_length(cryptogram)
+    print(f"Guessed word length: {word_length_guess}")
+
+    visualize_frequency(letter_frequencies)
+
+    decrypted_message = manual_decryption(decrypted_message, cryptogram)
+    print("\nFinal decrypted message:", decrypted_message)
+
+    save_progress(decrypted_message)