Hello, I'm a young amateur python developer with barely any skills, but I've created an encoder/decoder using a modified Caesar cipher that I just wanted to share. It can also do a lot more if you type "SMenu" on the main menu part.
Has there ever been a Chinese version (or something close to a Chinese version) of a Caesar cipher? For reference, a Caesar cipher is a code written with the Latin alphabet that shifts letters over a designated number of places in the order.
Example:
"Hello", if the shift number is 5 would be "mjqqt."
(For reference, the order of the alphabet is abcdefghijklmnopqrstuvwxyz)
H: i, j, k, l: m
e: f, g, h, i: j
l: m, n, o p: q
o: p, q, r, s: t
I'm learning about Caesar ciphers in my coding class and I immediately wondered how one might have similarly written in code using Chinese characters in the past. I realize a Chinese version wouldn't imitate this exactly, but I'm interested in how that may have worked, of course!
Yesterday, I posted like I can't move further in coding. After billions of comments saying that I needed a break. I took a break. Guess what?
As of now, I have overcome my challenge and finally made Caesar Cipher on my own.
Hi all,
I am doing the problem set 2 and I am getting correct outputs but when I run the check i get almost all errors.
Here is my code
https://preview.redd.it/7m47zxj94o481.png?width=778&format=png&auto=webp&s=e25a658d0561c9d1b83f1bf0b865a5737272b214
And this is the result from the checks
https://preview.redd.it/6vwtwly34o481.png?width=1088&format=png&auto=webp&s=e04f93434633de5eaedfb242148b25e712214915
Newb C programmer here. Trying to recreate a caesar cipher program that I made in python. The program shifts alphabetical characters by a key and leaves anything else (such as spaces and symbols) as they are. It is also supposed to wrap around the alphabet so that the letter Z with a key of 2 would end up being B. My python programs works fine, but my program in C right now is only shifting the first character and not the rest. For example, Hello with a key of 2 is shifting to Jello. I can not figure out why. Any advice on how to fix it or any other tips to improve my code?
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
int main()
{
char msg[20];
printf("Enter a message\n");
fgets(msg, 20, stdin);
printf("How many positions should I shift forward?\n");
int key;
int i;
scanf("%i", &key);
bool isLetter;
for (i=0; msg[i] != '\n'; i++)
{
char newCharacter;
char symbol;
if (msg[i] == ' ')
{
printf("%c", msg[i]);
continue;
}
if (isalpha(msg[i]) == 1)
{
key %= 26;
int previousDecimalOfChar = (int) msg[i];
int shifted = (previousDecimalOfChar + key);
if ((int) msg[i] >= 65 && (int) msg[i] <= 90 && shifted > 90)
{
shifted = (previousDecimalOfChar + key) - 26;
}
else if((int) msg[i] >= 97 && (int) msg[i] <= 122 && shifted > 122)
{
shifted = (previousDecimalOfChar + key) - 26;
}
printf("%c", (char) shifted);
}
else
{
int previousDecimalOfChar =(int) msg[i];
symbol = (char) previousDecimalOfChar;
printf("%c", symbol);
}
}
return 0;
}57JF8381T86TT6I9A0 that's the ciphered key.
Update : The code has been redeemed. Congrats to whoever you are! If anyone wonders , here's the key phrase - "it's not a lake, it's an ocean"
So, there are 0 iterations , and the key to the cipher is the last phrase Alan Wake has spoken in the original "Alan Wake" game, NOT in DLCs.
Good luck, and I hope the key will be redeemed by someone who really wants to play this great game and not by some "collector" :/
Hello, i am making a caesar cipher and im getting stuck on the function to actually encode the string using the new cipher list. i am also stuck on the function to decode the newly encoded message. here is my code
ALPHABET=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',' ']
def main():
message=input("Enter the message to encode: ")
key_value=int(input("Enter the key: "))
message=message.lower()
cipher_list=generate_cipher(key_value)
encoded_message=encode_message(message,cipher_list)
print(f"Encoded message:{encoded_message}")
decoded_message=decode_message(encoded_message,cipher_list)
print(f"Decoded message:{decoded_message}")
#encode_message(message)
def generate_cipher(key):
shifted_list=ALPHABET[-key:] + ALPHABET[:-key]
return shifted_list
def encode_message(message,cipher_list):
for char in message:
def decode_message():
main()Right, so I've always considered amazing those movie scenes in which a code is broken by testing dozens of combinations, and I tried to do the same with Caesar's Cipher:
def array_element_checker(array, element):
count = 0
for e in array:
if count > len(array):
return False
if e == element:
return count
else:
count += 1
def cryptor(text, jumpcase=3):
cryptotext = ''
text = text.upper()
alphabet = ', A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, '
alphabet = alphabet.split(', ')
jalphabet = ', A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, '
jalphabet = jalphabet.split(', ')
for letter in text:
index = array_element_checker(jalphabet, letter)
if not index:
cryptotext = cryptotext + letter
else:
index = index + jumpcase
while True:
if index > 26:
index -= 26
else:
break
cryptotext = cryptotext + jalphabet[index]
return cryptotext
text = str(input('>>> '))
for count in range(0, 26):
print(f'Jumpcase: {count} | {cryptor(text, count)}')
I ran into some bugs (like the letter "A" always being translated as "A", or Z never being ciphered) but was able to fix it changing some values in the code (please don't ask me how I made it work. It simply works and I have no idea why).
If you write any text, ciphered or not, it will return all the possible ciphered/unciphered results.
And I'm flairing it as easy because if I, a newbie, was able to build this from zero, it's probably very easy.
i have the following caesar cipher code that can transform any text into its "crypted version" but i don't understand how to do the opposite, i don't know how to decrypt it using the same key... could you guys help me out? I've been trying for almost a hour now...
key = input("key? ")
result = ""
for i in range(len(text)):
char = text[i]
if (char.isupper()):
result += chr((ord(char) + key -65) % 26 + 65)
else:
result += chr((ord(char) + key - 97) % 26 + 97)
print(result)that bunch of random text on matts video is actually a cipher and it was indeed morse code
the morse spelled out this gibberish
uvof joupu ifnbe oftt podf nspf
but if you put that text into a caesar cipher decoder forward it 27 and on an a to b format you get this:
tune intot hemad ness once more
Or
Tune into the madness once more.
I believe this is a reference as to how there's always an old tv involved in owo's arg videos
and with old tv's you had to tune into channels so it's just a cool little message I found watching matpat's video
Hufvul jhu hzr huf UWJ xblzapvuz vu aolpy zvjphs tlkph hjjvbuaz. Johyhjalyz vusf ruvd doha aol johyhjaly ruvdz myvt aolpy wlyzwljapcl pu Pu-Nhtl. KWY
Warmup
Given a lowercase letter and a number between 0 and 26, return that letter Caesar shifted by that number. To Caesar shift a letter by a number, advance it in the alphabet by that many steps, wrapping around from z back to a:
warmup('a', 0) => 'a'
warmup('a', 1) => 'b'
warmup('a', 5) => 'f'
warmup('a', 26) => 'a'
warmup('d', 15) => 's'
warmup('z', 1) => 'a'
warmup('q', 22) => 'm'
Hint: taking a number modulo 26 will wrap around from 25 back to 0. This is commonly represented using the modulus operator %. For example, 29 % 26 = 3. Finding a way to map from the letters a-z to the numbers 0-25 and back will help.
Challenge
Given a string of lowercase letters and a number, return a string with each letter Caesar shifted by the given amount.
caesar("a", 1) => "b"
caesar("abcz", 1) => "bcda"
caesar("irk", 13) => "vex"
caesar("fusion", 6) => "layout"
caesar("dailyprogrammer", 6) => "jgorevxumxgsskx"
caesar("jgorevxumxgsskx", 20) => "dailyprogrammer"
Hint: you can use the warmup function as a helper function.
Optional bonus 1
Correctly handle capital letters and non-letter characters. Capital letters should also be shifted like lowercase letters, but remain capitalized. Leave non-letter characters, such as spaces and punctuation, unshifted.
caesar("Daily Programmer!", 6) => "Jgore Vxumxgsskx!"
If you speak a language that doesn't use the 26-letter A-Z alphabet that English does, handle strings in that language in whatever way makes the most sense to you! In English, if a string is encoded using the number N, you can decode it using the number 26 - N. Make sure that for your language, there's some similar way to decode strings.
Optional bonus 2
Given a string of English text that has been Caesar shifted by some number between 0 and 26, write a function to make a best guess of what the original string was. You can typically do this by hand easily enough, but the challenge is to write a program to do it automatically. Decode the following strings:
Zol abyulk tl puav h ulda.
Tfdv ef wlikyvi, wfi uvrky rnrzkj pfl rcc nzky erjkp, szx, gfzekp kvvky.
Qv wzlmz bw uiqvbiqv iqz-axmml dmtwkqbg, i aeittwe vmmla bw jmib qba eqvoa nwzbg-bpzmm bquma mdmzg amkwvl, zqopb?
One simple way is by using a letter frequency table. Assign each letter in the string a score, with 3 for a, -1 for b, 1 for c, etc., as follows:
3,-1,1,read a while ago in late primary school, i remember there were 2 guys and 2 girls in the group i think? one of the girls is very skilled at manipulation and has green eyes i believe. she refuses to sit in the back of the car as that is how she witnessed her parents dying.
Bnphvt
Coqiwu
Dprjxv
Eqskyw
Frtlzx
Gsumay
Htvnbz
Iuwoca
Jvxpdb
Kwyqec
Lxzrfd
Myasge
Nzbthf
Oacuig
Pbdvjh
Qcewki
Rdfxlj
Segymk
Tfhznl
Ugiaom
Vhjbpn
Wikcqo
Xjldrp
Ykmesq
Zlnftr
(All the letters of Amogus have an odd number as a position in the alphabet, for example A is 1, M is 13, O is 15, and so on. All the vowels also have odd numbers as positions in the alphabet. So the odd shifts of Amogus will change all the letters to even letters, which aren't vowels, so there can't be any words in odd shifts of Amogus. Only even shifts of Amogus could create words, which they don't. The 6 and 20-shifts of Amogus are only one letter away from being anagrams of Amogus.)
rot3 = dict(zip(map(ord, 'abcdefghijklmnopqrstuvwxyz'), 'defghijklmnopqrstuvwxyzabc'))
'tiberivs clavdivs caesar'.translate(rot3)
# 'wlehulyv fodyglyv fdhvdu'Caesar Cipher for people who don't know is when you move a letter a long the alphabet. For example. If I moved Hello by 1 it'd be immp.
If I move Kvothe by 21, it becomes Patymj. First 3 letters are Pat.
Pat likes using 3s and 7s to describe things so could make sense. 3 x 7 = 21.
Probably is unintentional but could be the way Pat chose the name Kvothe. As he may have liked the idea of starting a name with Kvo.
Pat also always says Kvothe is my character.
(Update)Found more evidence, during the time Kvothe is making the Denna Resin Apricots for the Drakus he says something along the lines of "21 3 times seven, a great number, it should do"
Other caesar ciphers of pat include.
Ale Epi Itm Cng Doh Hsl Nyr Sdw Wha Ozs Tex Bmf 6Jun 4Lwp Ufy XibGrk Qbu Rcv Yjc Fqj Mxq Vgz Zkd
If someone's noticed this before, sorry. It probably is coincidental but you never know.
I followed a tutorial and this is exactly the code they provided. It works, but letters like X, Y, Z are decrypted as symbols. What is going on here, please? π
function caesar_cipher(string, key) {
var output = "";
for (var i = 0; i < string.length; i++) {
var unicode = string.charCodeAt(i);
// Uppercase
if ((unicode >= 65) && (unicode <= 90)) {
var res_unicode = ((unicode - 65 + key) % 26) + 65;
output += String.fromCharCode(res_unicode);
}
// Lowercase
else if ((unicode >= 97) && (unicode <= 122)) {
var res_unicode = ((unicode - 97 + key) % 26) + 97;
output += String.fromCharCode(res_unicode);
}
// Not a letter
else {
output += String.fromCharCode(unicode);
}
}
return output;
}Just now completed my project of implementing Caesar cipher in Python. Have a look at it.
https://dev.to/bharadwaj6262/caesar-cipher-in-python-3j09
TRF OD DID YTSMDLSYR TRF FPMY NPMN MR LSYR OD DJPTY NLPPFU JRLL TRF OD FIZN TRF ARYD DRR GLVE TRBOSA
Hello, I'm a young amateur python developer with barely any skills, but I've created an encoder/decoder using a modified Caesar cipher that I just wanted to share. It can also do a lot more if you type "SMenu" on the main menu part.
rot3 = dict(zip(map(ord, 'abcdefghijklmnopqrstuvwxyz'), 'defghijklmnopqrstuvwxyzabc'))
'tiberivs clavdivs caesar'.translate(rot3)
# 'wlehulyv fodyglyv fdhvdu'yep, just that,
caesar cipher link https://en.wikipedia.org/wiki/Caesar_cipher
It can handle spaces and lowercase characters. other things will break it
$echo -n "e07 hello world" | bf caesar.bf
olssv dvysk
$ echo -n "d07 olssv dvysk" | bf caesar.bf
hello world
>,>++++++++++[<---------->-]<>+<>>+<<>>>[-]<<<[>>[-]<<>>>+<<<-[>[-]<,>>+<<[-]][-]]>[>>>,>+++++++++[<----->-]<--->,>+++++++++[<----->-]<---<[>++++++++++<-]>[<+>-]<>>>,[>+<""<++++++[>-----<-]>--[>[-]<<++++++[>+++++<-]>++<<</[>+>+<<-]>[<+>-]<<<<[-]<[-]<[-]>>>[[-]<<<+>>>>>>>[->-<]<<<<]>[[-]<<<+>>>>>>[->+<]<<<]<<<<[>>>+<<<[-]]>[>>>+<<<[-]]>>>>>>>------------------------------------------------------------------------------------------------->[-]>[-]>[-]>[-]>[-]<<<<<++++++++++++++++++++++++++>>>>++++++++++++++++++++++++++<<<<[->+>>+>-[<-]<[<<[->>>+<<<]>>>>+<<-<]<<]>[<+>-]<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]]>[<<++++++[>+++++<-]>++.[-]>[-]<>]<,]>[-]<]>[[-]>[-]>[-]<<""""+++++++++[>++++++++>++++++++++++>++++>+++++++++++<<<<-]>--.>---.+++++++++.+.+.>----.>.+++++.-------.<<--.>>.++.<<++.>>++.<<--.>.<-----.++++++++.--.+.>.>---.+++.<.>.++++.<<.>>-.---.<<--.>.++.>.<.--.>+.<<---.+++.>.>-.<<----.>>--.<<+.>>+.+.<.<.+++.>.++.>-.<.--.>++.<<---.+++.>.>--.+.--.<<---.>>+.+.[-]>[-]>[-]<<+++++++[>+>+++++++>++++++++++++++++>+++++>++++++++++++++++<<<<<-]>+++.>+.>--.----------.>---.<---.>>--.<<+++.>.<<+.>>>++++.<<.>.<-.+++++.-------.>>.+.<.>------.++++++++.--.