def code(n, string):
  s, ret = 1, ''
  for i in string:
    if i.isupper(): 
      ret += chr((ord(i)-65+s)%26+65)
      s, n = n, s+n
    else: ret += i
  return ret

def pibo(user_,n):
    f1,f2,if_=1,n,True
    list_=[f1,f2]
    for i in range(len(user_)-2):
        if if_==True:
            result=f1+f2
            f1=result
            list_.append(result)
            if_=not(if_)
        else:
            result=f1+f2
            f2=result
            list_.append(result)
            if_=not(if_)
    return list_
def main(sj,n):
    sum=0
    abc='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    result=''
    pibo_=pibo(sj,n)
    for i in range(len(pibo_)):
        if abc.index(sj[i])+pibo_[i]>len(abc)-1:
            in_dex=abc.index(sj[i])+pibo_[i]-len(abc)
        else:
            in_dex=abc.index(sj[i])+pibo_[i]
        result=result+abc[in_dex]
        sum+=i
    return result

print(main('ZBCDE',3))

특수문자처리;;; 어떻게하죠? 엉망진창코드네요 다시짜야지;

python 2.7

def pibo(x):
    a = x.split("\n")
    text = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    for i in range((len(a)-1)/3):
        b = int(a[3*i+1])
        c = a[3*i+2]
        spe = []
        ind_spe = []
        for w in list(c):
            if not(w.isalpha()):
                spe.append(w)
                ind_spe.append(c.index(w))
                c = c[:c.index(w)] + c[(c.index(w)+1):]
        d = [1,b]
        for j in range(len(c)-2):
            d.append(d[-1]+d[-2])
        e = map(lambda x: text.index(x),c)
        f = map(lambda x: d[x]+e[x], list(range(len(d))))
        g = map(lambda x: (text*(f[-1]/26+1))[x],f)
        l = range(len(spe))
        l.reverse()
        for k in l:
            g = g[:ind_spe[k]] + [spe[k]] + g[ind_spe[k]:]
        print("".join(g))
        print ""

코드를 짰는데, 공백은 어떻게 처리되는건가요? 예시 input 두번째 줄에 대한 ouput에서 공백 이후가 하나씩 밀리네요.

apv = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
p = [1,int(input("암호키를 입력하세요"))]
s = list(input("문자를 입력해주세요"))
for x in range(len(s)):
       if s[x] in apv:
              p.append(p[x] + p[x+1])
              s[x] = apv[(apv.index(s[x])+p[x])%26]
       else:
              p.insert(0,0)
print(''.join(s))

def fib(key, len):
    lst = [1, key]
    for i in range(len - 2):
        lst.append(lst[-1] + lst[-2])

    return lst

def encrypt(key, plaintext):
    book = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    fib_lst = fib(key, len(plaintext))
    ciphertext = ''
    for char in plaintext:
        if char in book:
            offset = (book.index(char) + fib_lst.pop(0)) % len(book)
            ciphertext += book[offset]
        else:
            ciphertext += char

    return ciphertext


print(encrypt(1, 'AAAAA'))
print(encrypt(1, 'HELLO, WORLD!'))
print(encrypt(3, 'ABCDE'))

실행 결과

BBCDF
IFNOT, EBMTG!
BEGKP

C#

using System;
using System.Collections.Generic;

namespace CD198
{
    class Program
    {
        static void Main()
        {
            int key = int.Parse(Console.ReadLine());
            string aString = Console.ReadLine();
            Console.WriteLine(EncryptString(aString, key));
        }

        static string EncryptString(string aString, int key) 
        {
            List<char> Encrypted = new List<char>();
            int fib = 1, nextFib = key;
            foreach (var s in aString)
            {
                if (Char.IsUpper(s))
                {
                    int newChar = s + fib % ('Z' - 'A' + 1);
                    newChar = newChar > 'Z' ? newChar - 'Z' + 'A' - 1 : newChar;
                    Encrypted.Add((char)newChar);

                    int tmpFib = fib + nextFib;
                    fib = nextFib; nextFib = tmpFib;
                }
                else { Encrypted.Add(s); }
            }
            return new String(Encrypted.ToArray());
        }
    }
}

# 주어진 seed를 이용해 seqnumber 만큼 피보나치 수열을 생성하여, 리스트로 돌려줌
def pibo(seed, seqnumber) :
    # 피보나치 수열은 아래처럼 시작
    piboseq = [1, seed]

    for i in range(seqnumber - 2) :
        piboseq.append(piboseq[i + 1] + piboseq[i])

    return piboseq


# 주어진 seed를 이용해 피보나치 수열을 만들고, origintext를 암호화한 문자열을 돌려줌
def encode(seed, origintext) :
    # 주어진 seed를 이용해 암호화할 문자열의 수만큼 피보나치 수열 생성
    piboseq = pibo(seed, len(origintext))

    # 암호화된 문자열을 저장할 변수
    encodedtext = ''

    # 암호화한 숫자를 카운트하는 변수
    # (대문자가 아닌 문자는 암호화하지 않으므로, 피보나치 수열을 저장한 리스트에서 해당되는 수를 찾기 위해 필요)
    i = 0

    # 주어진 문자열의 문자를 한 글자씩 암호화함
    for ch in origintext :
        # 대문자인 경우만 암호화하여 암호 문자열 변수에 추가
        if ch.isupper() :
            # 선택된 문자(ch)의 ASCII 값에 피보나치 수열의 값을 더해서 암호화하고, 암호화된 문자열 뒤에 붙임
            # ord(ch) - ord('A') : ASCII값의 기준을 A = "0"으로 이동시킴
            # ord() : 문자의 ASCII 값을 돌려주는 함수
            # chr() : ASCII값에 해당하는 문자를 돌려주는 함수
            encodedtext += chr(ord('A') + (ord(ch) - ord('A') + piboseq[i]) % 26)
            i += 1
        # 대문자가 아닌 경우는, 그대로 암호 문자열 변수에 추가
        else :
            encodedtext += ch

    # 암호화된 문자열을 돌려줌
    return encodedtext

Python 3

cur, next = 1, int(input())
message = list(input())
for i in range(len(message)):
    message[i] = chr(ord(message[i]) + cur)
    temp = cur
    cur = next
    next += temp
print("".join(message))

# input
num = int(input())
string_inp = input()

# output
string_out = ''

# FB list
FB = [1] + [num]
for i in range(2,26):
    FB.append(FB[i-2] + FB[i-1])

i = 0
for c in string_inp:
    if ord(c) < 65 or ord(c) > 90:
        string_out = string_out + c
    else:
        string_add = chr((ord(c) + FB[i] - ord('A'))%26 + ord('A'))
        string_out = string_out + string_add
        i += 1

print(string_out)

alp='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
N=int(input("Input password key: "))
t=input("Input string: ")
tfib=''

fibN=[1,N%26,(1+N)%26]
while len(fibN)<=len(t):
    fibN.append((fibN[-2]+fibN[-1])%26)

ind=0
for i in t:
    if i in alp:
        tfib+=alp[(alp.index(i)+fibN[ind])%26]
        ind+=1
    else:
        tfib+=i

print(tfib)

#n=정수인 암호키
#s=변환하고 싶은 문자열
def fibonacci_password(n,s):
    li=[]
    result=[]
    s=list(s.upper())
    len_s=len(s)
    #피보나치 암호키 생성
    for i in range(1,len_s+1):
        li.append(fibonacci(n,i))
    #암호 변환
    for i in range(0,len_s) :        
        if s[i].isalpha():
            num=ord(s[i])+li[i]
            num=(num, num-26)[num>90]            
            result.append(chr(num))
        else :
            result.append(i)
    return result

def fibonacci(n,s):
    if s==1 :
        return 1
    elif s==2 :
        return n 
    return fibonacci(n,s-2)+fibonacci(n,s-1)

n = int(input())
s = input()

def fib_code(n, s):
    sample = 'ABCDEFGHIJKLMNOPQRSTUCWXYZ'
    start, result = 1, ''

    for i in s:
        if i in sample:
            result += chr((ord(i) - 65 + start) % 26 + 65)
            start, n = n, start + n
        else:
            result += i
    return result

print(fib_code(n, s))

def fib(key, n):
  lst = [1, key]

  for i in range(n - 2):
    lst.append(lst[-1] + lst[-2])
  return lst

def fib_pass(key, plaintext):
    char = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    fib_list = fib(key, len(plaintext))

    ciphertext = ''

    for word in plaintext:
      if word in char:
        cipher_index = (char.index(word) + fib_list.pop(0)) % 26
        ciphertext += char[cipher_index]
      else:
        ciphertext += word

    return ciphertext

keystart = int(input("Enter encrypt key: "))
string = input("Enter encrypting string: ")
def fib(n,k):
    a = 1
    b = k
    for i in range(0,n-1):
        a, b = b, a+b
    return a

res = ""
i = 0
for entry in string:

    if ord(entry) in range(65,91):
        res += chr(((ord(entry)-65+fib(i+1,keystart))%26)+65)
        i += 1
    else:
        res += entry

print(res)

입력값을 하나하나 나눠서 만약 대문자이면 피보나치를 적용하여 int형으로 바꾼 뒤 list에 추가하고, 그렇지 않으면 피보나치를 적용하지 않고 그냥 int형으로 바꿔 list에 추가한 뒤, list값들을 다시 char형으로변형하여 StringBuffer에 추가했습니다. 초보라서 이정도 밖에....

public class 피보나치시저암호 {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int a = 1;
        int b = scan.nextInt();
        Scanner scan2 = new Scanner(System.in);
        String str = scan2.nextLine();
        ArrayList<Integer> list = new ArrayList<Integer>();

        for(int i=0; i<str.length(); i++) {
            if(i==0) {
                list.add((int)str.charAt(0)+a);
            }
            else if(i==1) {
                if(64<(int)str.charAt(1)&&(int)str.charAt(1)<91) {
                    list.add((int)str.charAt(1)+b);
                }
                else {
                    list.add((int)str.charAt(1));
                }
            }
            else {
                if(64<(int)str.charAt(i)&&(int)str.charAt(i)<91) {
                    if(a>b) {
                        b+=a;
                        list.add((int)str.charAt(i)+b);
                    }
                    else {
                        a+=b;
                        list.add((int)str.charAt(i)+a);
                    }
                }
                else {
                    list.add((int)str.charAt(i));
                }
            }
        }
        StringBuffer bf = new StringBuffer();
        for(int i=0; i<list.size(); i++) {
            int k = list.get(i);
            if(k>=91) {
                for(int j=0;; j++) {
                    k=k-91+65;
                    if(64<k&&k<91) {
                        break;
                    }
                }
            }
            bf.append((char)k);
        }
        System.out.println(bf);
    }
}

elst=[]
def fib(n,k):
    a,b=1,n
    for i in range(k):
        elst.append(a)
        a, b=b,a+b
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
n=int(input("정수 n(0<n<10000)을 입력하십시오: ")) #1
s=input("변환하고 싶은 문자열을 입력하십시오: ") #HELLO, WORLD!
lst=list(map(str,s))
fib(n,len(s))
for i in range(len(s)):
    if lst[i] not in alpha: #공백, 특수문자로 인해 문자 변환이 밀리는 것을 막기 위해 피보나치 수열의 해당 위치에 0을 삽입
        elst.insert(i,0)
for i in range(len(s)):
    if lst[i] in alpha:
        lst[i]=alpha[(alpha.index(lst[i])+elst[i])%26]
    else:
        lst[i]=lst[i]
print("".join(lst)) #IFNOT, EBMTG!

def Dynamic_Programming(n, li) :
    if n == 1  or n == 2 :
        return li[n-1]
    else :
        if li[n-1] != '#' : return li[n-1]
        elif li[n-1] == '#' :
            li[n-1] = Dynamic_Programming(n-1, li)+ Dynamic_Programming(n-2, li)
    return li[n-1]

def fib(N, sec) :
    LI = [1]+[sec]+['#' for i in range(N-2)]
    Dynamic_Programming(N, LI)
    return LI

def main() :
    str_input = input("STRING : ")
    key = int(input("KEY : "))
    cod, res = fib(len(str_input), key), ''
    map_ = 'aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ'

    for i in range(0, len(str_input)) :
        res += map_[(map_.index(str_input[i])+2*cod[i])%52]
    return res

main()

마침 동적계획법에 대해 공부하고 있어서 한번 짜봤습니다.

결과

STRING : Hello World!
KEY : 2
Igoqw Rwuwr!

key=int(input("Enter the Key: "))
word=list(input("Enter the word: "))
alpha=list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
fibo=[1,key]
for i in range(len(word)):
    if i>len(fibo)-1:
        fibo.append(fibo[i-1]+fibo[i-2])
    if word[i].isalpha():
        word[i]=alpha[(fibo[i]+alpha.index(word[i]))%26]
    else: continue
print(''.join(word))

a=1
b=int(input('Password Key (1~10000)...'))

words=input('Input words....')
for i in range (0,len(words)):
    wordss=ord(words[i])
    if wordss>=32 and wordss<=64:
        print(chr(wordss),end='')
    elif wordss>=65 and wordss<=90:
        c=a+b
        wordss+=a
        print(chr(((wordss-64)%26)+64),end='')
        a=b
        b=c

int_data = int(input("숫자 : " ))
str_data = input("암호 : ")

result = [1,int_data]
for i in range(len(str_data)-1):
    temp = result[i]+result[i+1]
    result.append(temp)
print(result)

secret =""
for j in range(len(str_data)):
    if str_data[j].isupper():
        secret += chr((ord(str_data[j])+result[j]-ord('A'))%26+ord('A'))
    else :
        secret += str_data[j]
print(secret)

def fibo(n, strings):
    a, b = 1, n
    fibo = [1, n]
    for s in strings[2:]:
        if s.isalpha():
            c = a + b
            fibo.append(c)
            a, b = b, c
        else:
            fibo.append(s)

    alpha_list = [chr(i) for i in range(65, 91)]
    conv = []
    for i, s in enumerate(list(strings)):
        if s.isalpha():
            j = alpha_list.index(s) + fibo[i]
            m = (j, j-(26*(j//26)))[j > 25]
            conv.append(alpha_list[m])
        else:
            conv.append(fibo[i])
    print(''.join(conv))


if __name__ == '__main__':
    n, strings = 1, 'HELLO, WORLD!'
    fibo(n, strings)

ABC = "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"
ABC = ABC.split(",")
n = int(input())
s = input()
first = 1
second = n
fibo = []
for i in range(len(s)):
    fibo.append(first)
    fibo.append(second)
    first = first + second
    second = first + second
temp = ""
i = 0
k = 0
while 1:
    if s[i] in ABC:
        if ABC.index(s[i]) + fibo[k] > len(ABC):
            temp += ABC[(ABC.index(s[i]) + fibo[k]) % len(ABC)]
        else:
            temp += ABC[ABC.index(s[i]) + fibo[k]]
        k += 1
    else:
        temp += s[i]
    i += 1
    if len(temp) == len(s):
        print(temp)
        break

n=int(input())
str1=input()


str2=""


a=1
b=n
sum=a+b

count=1


for i in str1:
  if i.isalpha():
    if count==1:
      n=a
    elif count>2:
      n=sum

      a=b
      b=sum
      sum=a+b

    if i.islower():
      if ord(i)+n <= 122:
        str2+= chr(ord(i)+n)
      else:
       str2+= chr(97+(n-(122-ord(i))-1))
    elif i.isupper():
      if ord(i)+n <= 90:
        str2+= chr(ord(i)+n)
      else:
        str2+= chr(65+(n-(90-ord(i))-1))
    count+=1
  else:
    str2+=i


print(str2)

n = int(input("number: "))
word = input("word: ")
alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
output = ''

fb_lst = [1, n]
while len(fb_lst) < len(word):
    fb_lst.append(fb_lst[-2] + fb_lst[-1])

for w in word:
    if w in alph:
        w_index = alph.index(w)
        n_index = int((w_index + fb_lst.pop(0)) % 26)
        output += alph[n_index]
    else:
        output += w

print(output)

n = int(input("N : "))
s = input("STR : ")

a = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
ans = ""
f1 = 1
f2 = n
for i in range(0, len(s)):
    try:
        ans += a[a.index(s[i]) + (f1 % 26)]
        t = f2
        f2 += f1
        f1 = t
    except:
        ans += s[i]
print(ans)

while True:
    key = int(input("암호키를 입력하시오"))
    if key>0 and key<10000:
        break
while True:
    content = str(input("변환할 문자열 입력하시오"))
    if content.isupper() :
        break

def pivo (a,n):
    p_arr=[1]
    i0 = 1
    i1 = a
    p_arr.append(i1)
    for k in range(n-2):
        i2 = i0+i1
        p_arr.append(i2)
        i0=i1
        i1=i2
    return p_arr

def convert(s,n):
    a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    b = a.index(s) + n
    return a[b%26]

p_arr = pivo(key,len(content))
arr = []

n=0
for i in range(len(content)):
    if ord(content[i])>=65 and ord(content[i]) <=90:
        arr.append(convert(content[i],p_arr[n]))
        n+=1
    else: 
        arr.append(content[i])
print("".join(arr))

public class test {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        while(true) {
            String str =sc.nextLine();
            int code = sc.nextInt();
        int[] arr = new int[str.length()];
        for(int i=0; i<str.length(); i++) {
            if(i==0) {
                arr[i]=1;
            }
            if(i==1) {
                arr[i]=code;
            }
            if(i>=2) {
                arr[i]+=arr[i-2]+arr[i-1];
            }
        }
        for(int i=0; i<arr.length; i++) {
            int pp = (int)(str.charAt(i));
            int ap = ((int)( pp + arr[i]));
            if(ap>=65 && ap<=90) {
            char ti = (char)ap;
            System.out.print(ti);}
            if(pp<=33 || pp<=47) {
                System.out.print(str.charAt(i));
            }
                    }
        System.out.print("\n");
     }  
}
}