Домашни > Енигма > Решения > Решението на Нелина Тотева
Резултати
10 точки от тестове
0 точки от учител
10 точки общо
9 успешни теста
0 неуспешни теста
Код (plugboard function-pop method added)
 1plugboard_position = [{'a', 'c'}, {'t', 'z'}]
 2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',
 3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',
 4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',
 5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',
 6                  'm': 'r', 'c': 'k'}
 7
 8
 9def plugboard(text, list_of_rules):
10    changed_word = ""
11
12    for letter in text:
13        for set_of_letters in list_of_rules:
14            if letter in set_of_letters:
15                letter = set_of_letters.difference({letter}).pop()
16
17        changed_word += letter
18
19    return changed_word
20
21def rotor(text, dict_of_rules):
22    changed_text = ""
23
24    for letter in text:
25        changed_text += dict_of_rules.get(letter, " ")
26
27    return changed_text
28
29def enigma_encrypt(plugboard_position, rotor_position):
30    def decorator(func):
31        def crypting(text):
32            crypted_text = plugboard(text, plugboard_position)
33            crypted_text = rotor(crypted_text, rotor_position)
34            return func(crypted_text)
35        return crypting
36    return decorator
37    
38@enigma_encrypt(plugboard_position, rotor_position)
39def encrypt_decorated(text):
40    return text
41
42def enigma_decrypt(plugboard_position, rotor_position):
43    def decorator(func):
44        def decrypting(text):
45            rotor_position_reversed = {y: x for x, y in rotor_position.items()}
46            decrypted_text = rotor(text, rotor_position_reversed)
47            decrypted_text = plugboard(decrypted_text, plugboard_position)
48
49            return func(decrypted_text)
50        return decrypting
51    return decorator
52    
53@enigma_decrypt(plugboard_position, rotor_position)
54def decrypt_decorated(text):
55    return text

.........
----------------------------------------------------------------------
Ran 9 tests in 0.001s

OK

Дискусия
Георги Кунчев
30.10.2023 19:28
Да, хванах идеята за стринга и `.join()`, но беше прекалено изкуствено. Това ти решение е далеч по-добре. Индекс нула отново е изкуствен, но така е по-добре. Можеш да видиш `pop()` метода на `set`.
Нелина Тотева
30.10.2023 18:31
Относно коментара за .join() в plugboard функцията. Използвах го понеже в протичен случай ми връща сет. Тоест като обединя думата със сета ми дава проблем. Поразрових се из интеренет и открих, че .difference е със същия смисъл като това, което аз бях използвала и го замених с него и понеже то е само с 1 елемент вътре взимам нулевия, който е стринг и нямам проблем с конкатенирането. Не знам доколко е оптимално, но в случая работи. Благодаря за идеята с .get() метода. Наистина е доста по-удобно.
История
f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]
2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',
3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',
4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',
5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',
6                  'm': 'r', 'c': 'k'}6                  'm': 'r', 'c': 'k'}
77
88
9def plugboard(text, list_of_rules):9def plugboard(text, list_of_rules):
10    changed_word = ""10    changed_word = ""
1111
12    for letter in text:12    for letter in text:
13        for set_of_letters in list_of_rules:13        for set_of_letters in list_of_rules:
14            if letter in set_of_letters:14            if letter in set_of_letters:
t15                letter = list(set_of_letters.difference({letter}))[0]t15                letter = set_of_letters.difference({letter}).pop()
1616
17        changed_word += letter17        changed_word += letter
1818
19    return changed_word19    return changed_word
2020
21def rotor(text, dict_of_rules):21def rotor(text, dict_of_rules):
22    changed_text = ""22    changed_text = ""
2323
24    for letter in text:24    for letter in text:
25        changed_text += dict_of_rules.get(letter, " ")25        changed_text += dict_of_rules.get(letter, " ")
2626
27    return changed_text27    return changed_text
2828
29def enigma_encrypt(plugboard_position, rotor_position):29def enigma_encrypt(plugboard_position, rotor_position):
30    def decorator(func):30    def decorator(func):
31        def crypting(text):31        def crypting(text):
32            crypted_text = plugboard(text, plugboard_position)32            crypted_text = plugboard(text, plugboard_position)
33            crypted_text = rotor(crypted_text, rotor_position)33            crypted_text = rotor(crypted_text, rotor_position)
34            return func(crypted_text)34            return func(crypted_text)
35        return crypting35        return crypting
36    return decorator36    return decorator
37    37    
38@enigma_encrypt(plugboard_position, rotor_position)38@enigma_encrypt(plugboard_position, rotor_position)
39def encrypt_decorated(text):39def encrypt_decorated(text):
40    return text40    return text
4141
42def enigma_decrypt(plugboard_position, rotor_position):42def enigma_decrypt(plugboard_position, rotor_position):
43    def decorator(func):43    def decorator(func):
44        def decrypting(text):44        def decrypting(text):
45            rotor_position_reversed = {y: x for x, y in rotor_position.items()}45            rotor_position_reversed = {y: x for x, y in rotor_position.items()}
46            decrypted_text = rotor(text, rotor_position_reversed)46            decrypted_text = rotor(text, rotor_position_reversed)
47            decrypted_text = plugboard(decrypted_text, plugboard_position)47            decrypted_text = plugboard(decrypted_text, plugboard_position)
4848
49            return func(decrypted_text)49            return func(decrypted_text)
50        return decrypting50        return decrypting
51    return decorator51    return decorator
52    52    
53@enigma_decrypt(plugboard_position, rotor_position)53@enigma_decrypt(plugboard_position, rotor_position)
54def decrypt_decorated(text):54def decrypt_decorated(text):
55    return text55    return text
Legends
Colors
 Added 
Changed
Deleted
Links
(f)irst change
(n)ext change
(t)op
f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]
2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',
3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',
4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',
5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',
6                  'm': 'r', 'c': 'k'}6                  'm': 'r', 'c': 'k'}
77
88
9def plugboard(text, list_of_rules):9def plugboard(text, list_of_rules):
10    changed_word = ""10    changed_word = ""
1111
12    for letter in text:12    for letter in text:
13        for set_of_letters in list_of_rules:13        for set_of_letters in list_of_rules:
14            if letter in set_of_letters:14            if letter in set_of_letters:
n15                letter = ', '.join(set_of_letters - {letter})n15                letter = list(set_of_letters.difference({letter}))[0]
1616
17        changed_word += letter17        changed_word += letter
1818
19    return changed_word19    return changed_word
2020
21def rotor(text, dict_of_rules):21def rotor(text, dict_of_rules):
22    changed_text = ""22    changed_text = ""
2323
24    for letter in text:24    for letter in text:
n25        if letter == " ":n
26            changed_text += " "
27        else:
28            changed_text += dict_of_rules[letter]25        changed_text += dict_of_rules.get(letter, " ")
2926
30    return changed_text27    return changed_text
3128
n32def enigma_encrypt(plugboard_position , rotor_position ):n29def enigma_encrypt(plugboard_position, rotor_position):
33    def decorator(func):30    def decorator(func):
34        def crypting(text):31        def crypting(text):
n35            crypted_text = plugboard(text,plugboard_position)n32            crypted_text = plugboard(text, plugboard_position)
36            crypted_text = rotor(crypted_text, rotor_position)33            crypted_text = rotor(crypted_text, rotor_position)
n37            return func( crypted_text)n34            return func(crypted_text)
38        return crypting35        return crypting
39    return decorator36    return decorator
40    37    
n41@enigma_encrypt(plugboard_position , rotor_position )n38@enigma_encrypt(plugboard_position, rotor_position)
42def encrypt_decorated(text):39def encrypt_decorated(text):
43    return text40    return text
4441
n45def enigma_decrypt(plugboard_position , rotor_position ):n42def enigma_decrypt(plugboard_position, rotor_position):
46    def decorator(func):43    def decorator(func):
47        def decrypting(text):44        def decrypting(text):
48            rotor_position_reversed = {y: x for x, y in rotor_position.items()}45            rotor_position_reversed = {y: x for x, y in rotor_position.items()}
49            decrypted_text = rotor(text, rotor_position_reversed)46            decrypted_text = rotor(text, rotor_position_reversed)
n50            decrypted_text = plugboard(decrypted_text,plugboard_position)n47            decrypted_text = plugboard(decrypted_text, plugboard_position)
5148
n52            return func( decrypted_text)n49            return func(decrypted_text)
53        return decrypting50        return decrypting
54    return decorator51    return decorator
55    52    
t56@enigma_decrypt(plugboard_position , rotor_position )t53@enigma_decrypt(plugboard_position, rotor_position)
57def decrypt_decorated(text):54def decrypt_decorated(text):
58    return text55    return text
Legends
Colors
 Added 
Changed
Deleted
Links
(f)irst change
(n)ext change
(t)op
f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]
2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',
3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',
4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',
5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',
6                  'm': 'r', 'c': 'k'}6                  'm': 'r', 'c': 'k'}
77
88
9def plugboard(text, list_of_rules):9def plugboard(text, list_of_rules):
10    changed_word = ""10    changed_word = ""
1111
12    for letter in text:12    for letter in text:
13        for set_of_letters in list_of_rules:13        for set_of_letters in list_of_rules:
14            if letter in set_of_letters:14            if letter in set_of_letters:
15                letter = ', '.join(set_of_letters - {letter})15                letter = ', '.join(set_of_letters - {letter})
1616
17        changed_word += letter17        changed_word += letter
1818
19    return changed_word19    return changed_word
2020
21def rotor(text, dict_of_rules):21def rotor(text, dict_of_rules):
22    changed_text = ""22    changed_text = ""
2323
24    for letter in text:24    for letter in text:
tt25        if letter == " ":
26            changed_text += " "
27        else:
25        changed_text += dict_of_rules[letter]28            changed_text += dict_of_rules[letter]
2629
27    return changed_text30    return changed_text
2831
29def enigma_encrypt(plugboard_position , rotor_position ):32def enigma_encrypt(plugboard_position , rotor_position ):
30    def decorator(func):33    def decorator(func):
31        def crypting(text):34        def crypting(text):
32            crypted_text = plugboard(text,plugboard_position)35            crypted_text = plugboard(text,plugboard_position)
33            crypted_text = rotor(crypted_text, rotor_position)36            crypted_text = rotor(crypted_text, rotor_position)
34            return func( crypted_text)37            return func( crypted_text)
35        return crypting38        return crypting
36    return decorator39    return decorator
37    40    
38@enigma_encrypt(plugboard_position , rotor_position )41@enigma_encrypt(plugboard_position , rotor_position )
39def encrypt_decorated(text):42def encrypt_decorated(text):
40    return text43    return text
4144
42def enigma_decrypt(plugboard_position , rotor_position ):45def enigma_decrypt(plugboard_position , rotor_position ):
43    def decorator(func):46    def decorator(func):
44        def decrypting(text):47        def decrypting(text):
45            rotor_position_reversed = {y: x for x, y in rotor_position.items()}48            rotor_position_reversed = {y: x for x, y in rotor_position.items()}
46            decrypted_text = rotor(text, rotor_position_reversed)49            decrypted_text = rotor(text, rotor_position_reversed)
47            decrypted_text = plugboard(decrypted_text,plugboard_position)50            decrypted_text = plugboard(decrypted_text,plugboard_position)
4851
49            return func( decrypted_text)52            return func( decrypted_text)
50        return decrypting53        return decrypting
51    return decorator54    return decorator
52    55    
53@enigma_decrypt(plugboard_position , rotor_position )56@enigma_decrypt(plugboard_position , rotor_position )
54def decrypt_decorated(text):57def decrypt_decorated(text):
55    return text58    return text
Legends
Colors
 Added 
Changed
Deleted
Links
(f)irst change
(n)ext change
(t)op
f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]f1plugboard_position = [{'a', 'c'}, {'t', 'z'}]
2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',
3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',
4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',
5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',
6                  'm': 'r', 'c': 'k'}6                  'm': 'r', 'c': 'k'}
77
88
9def plugboard(text, list_of_rules):9def plugboard(text, list_of_rules):
n10    changed_word=""n10    changed_word = ""
1111
12    for letter in text:12    for letter in text:
13        for set_of_letters in list_of_rules:13        for set_of_letters in list_of_rules:
14            if letter in set_of_letters:14            if letter in set_of_letters:
15                letter = ', '.join(set_of_letters - {letter})15                letter = ', '.join(set_of_letters - {letter})
1616
17        changed_word += letter17        changed_word += letter
1818
19    return changed_word19    return changed_word
2020
21def rotor(text, dict_of_rules):21def rotor(text, dict_of_rules):
22    changed_text = ""22    changed_text = ""
2323
24    for letter in text:24    for letter in text:
25        changed_text += dict_of_rules[letter]25        changed_text += dict_of_rules[letter]
2626
27    return changed_text27    return changed_text
2828
29def enigma_encrypt(plugboard_position , rotor_position ):29def enigma_encrypt(plugboard_position , rotor_position ):
30    def decorator(func):30    def decorator(func):
31        def crypting(text):31        def crypting(text):
32            crypted_text = plugboard(text,plugboard_position)32            crypted_text = plugboard(text,plugboard_position)
33            crypted_text = rotor(crypted_text, rotor_position)33            crypted_text = rotor(crypted_text, rotor_position)
34            return func( crypted_text)34            return func( crypted_text)
35        return crypting35        return crypting
36    return decorator36    return decorator
37    37    
n38 n
39@enigma_encrypt(plugboard_position , rotor_position )38@enigma_encrypt(plugboard_position , rotor_position )
40def encrypt_decorated(text):39def encrypt_decorated(text):
41    return text40    return text
4241
43def enigma_decrypt(plugboard_position , rotor_position ):42def enigma_decrypt(plugboard_position , rotor_position ):
44    def decorator(func):43    def decorator(func):
45        def decrypting(text):44        def decrypting(text):
46            rotor_position_reversed = {y: x for x, y in rotor_position.items()}45            rotor_position_reversed = {y: x for x, y in rotor_position.items()}
47            decrypted_text = rotor(text, rotor_position_reversed)46            decrypted_text = rotor(text, rotor_position_reversed)
48            decrypted_text = plugboard(decrypted_text,plugboard_position)47            decrypted_text = plugboard(decrypted_text,plugboard_position)
4948
50            return func( decrypted_text)49            return func( decrypted_text)
51        return decrypting50        return decrypting
52    return decorator51    return decorator
53    52    
t54 t
55@enigma_decrypt(plugboard_position , rotor_position )53@enigma_decrypt(plugboard_position , rotor_position )
56def decrypt_decorated(text):54def decrypt_decorated(text):
57    return text55    return text
Legends
Colors
 Added 
Changed
Deleted
Links
(f)irst change
(n)ext change
(t)op
tt1plugboard_position = [{'a', 'c'}, {'t', 'z'}]
2rotor_position = {'v': 'd', 'd': 'v', 'y': 'u', 'n': 'n', 'i': 'w', 'z': 'p',
3                  's': 'e', 'x': 's', 'h': 'f', 'b': 'x', 'u': 'c', 'p': 'q',
4                  'r': 'g', 'q': 'j', 'e': 't', 'l': 'y', 'o': 'z', 'g': 'o',
5                  'k': 'b', 't': 'h', 'j': 'm', 'a': 'a', 'w': 'i', 'f': 'l',
6                  'm': 'r', 'c': 'k'}
7 
8 
1def plugboard(text, list_of_rules):9def plugboard(text, list_of_rules):
2    changed_word=""10    changed_word=""
311
4    for letter in text:12    for letter in text:
5        for set_of_letters in list_of_rules:13        for set_of_letters in list_of_rules:
6            if letter in set_of_letters:14            if letter in set_of_letters:
7                letter = ', '.join(set_of_letters - {letter})15                letter = ', '.join(set_of_letters - {letter})
816
9        changed_word += letter17        changed_word += letter
1018
11    return changed_word19    return changed_word
1220
13def rotor(text, dict_of_rules):21def rotor(text, dict_of_rules):
14    changed_text = ""22    changed_text = ""
1523
16    for letter in text:24    for letter in text:
17        changed_text += dict_of_rules[letter]25        changed_text += dict_of_rules[letter]
1826
19    return changed_text27    return changed_text
2028
21def enigma_encrypt(plugboard_position , rotor_position ):29def enigma_encrypt(plugboard_position , rotor_position ):
22    def decorator(func):30    def decorator(func):
23        def crypting(text):31        def crypting(text):
24            crypted_text = plugboard(text,plugboard_position)32            crypted_text = plugboard(text,plugboard_position)
25            crypted_text = rotor(crypted_text, rotor_position)33            crypted_text = rotor(crypted_text, rotor_position)
26            return func( crypted_text)34            return func( crypted_text)
27        return crypting35        return crypting
28    return decorator36    return decorator
29    37    
3038
31@enigma_encrypt(plugboard_position , rotor_position )39@enigma_encrypt(plugboard_position , rotor_position )
32def encrypt_decorated(text):40def encrypt_decorated(text):
33    return text41    return text
3442
35def enigma_decrypt(plugboard_position , rotor_position ):43def enigma_decrypt(plugboard_position , rotor_position ):
36    def decorator(func):44    def decorator(func):
37        def decrypting(text):45        def decrypting(text):
38            rotor_position_reversed = {y: x for x, y in rotor_position.items()}46            rotor_position_reversed = {y: x for x, y in rotor_position.items()}
39            decrypted_text = rotor(text, rotor_position_reversed)47            decrypted_text = rotor(text, rotor_position_reversed)
40            decrypted_text = plugboard(decrypted_text,plugboard_position)48            decrypted_text = plugboard(decrypted_text,plugboard_position)
4149
42            return func( decrypted_text)50            return func( decrypted_text)
43        return decrypting51        return decrypting
44    return decorator52    return decorator
45    53    
4654
47@enigma_decrypt(plugboard_position , rotor_position )55@enigma_decrypt(plugboard_position , rotor_position )
48def decrypt_decorated(text):56def decrypt_decorated(text):
49    return text57    return text
Legends
Colors
 Added 
Changed
Deleted
Links
(f)irst change
(n)ext change
(t)op