V @ genere加密黑鹰坠落 [英] Vigenere Cipher Black Hawk Down

问题描述

我不明白，为什么这件事没有正确争抢。我读了一些其他职位这个密码而据我可以告诉我使用的是完全相同的算法，他们是...

注释掉的领域是测试我想，以确保一切被路过正确。我相信这一切都经过正确，则在算法失败。

 的#include＆LT;＆stdio.h中GT;
＃包括LT＆;＆cs50.h GT;
＃包括LT＆;＆string.h中GT;
＃包括LT＆;＆文件ctype.h GT;
＃包括LT＆;＆stdlib.h中GT;字符串get_message（无效）;
字符串争抢（字符串键，字符串消息）;INT主（INT ARGC，ARGV串[]）
{
    如果（的argc == 2）
    {
        字符串键;
        字符串消息;        键=的argv [1];
        //的printf（键：％S＆LT;＆LT;键）;
        消息= get_message（）;
        争夺（键，消息）;
    }
    其他
    {
        的printf（请输入2个参数\\ n）;
        返回1;
    }
}字符串get_message（无效）
{
    字符串消息=;
    做
    {
        消息= GetString的（）;
    }
    而（strlen的（消息）。1）;
    返回消息;
}字符串争抢（字符串键，字符串消息）
{
    的for（int i = 0，长度= strlen的（消息），key_len = strlen的（关键）; I＆LT; LEN，我++）
    {
        INT信=消息[I]
        // INT TKEY =的atoi（键[我％key_len]）;
        //的printf（键：％D＆LT;＆LT; \\ N，TKEY）;        如果（islower判断（字母））
        {
            //的printf（键（％D），（键[I％key_len] -97））;
            信=（（（信 -  97）+（键[我％key_len））％26 + 97）;
            //的printf（（％D），（信 -  97）+（键[我％key_len]）％26）;
            的printf（％C字母）;
        }
        否则，如果（isupper（字母））
        {
            //的printf（（％D），重点[I]）;
            //的printf（（％C），字母）;我们有正确的字母
            信=（（（信 -  65）+（键[我％key_len））％26 + 65）;
            的printf（％C字母）;
        }
    }
    的printf（\\ n）;
    返回0;
}
 

解决方案

我觉得你的计算是错误的：

您目前有

  encryptedLetter =（字母 -  firstLetterOffset）+键[位置％keyLength]％26 + firstLetterOffset
 

通过检查 C运算符precedence表我们注意到％之前评估 - 或 + ，这意味着你的code实际上意味着：

  encryptedLetter =（字母 -  firstLetterOffset）+（键[位置％keyLength] 26％）+ firstLetterOffset
 

在那里你想要的东西：

  encryptedLetter =（（字母 -  firstLetterOffset）+键[位置％keyLength]）％26 + firstLetterOffset
 

结论：你需要把更多的parenthese来指定命令你要评估你的前pression

。

---

另外，你把信号码的文本字符，但不是关键！

修正前pression

  encryptedLetter =（（字母 -  firstLetterOffset）+键[位置％keyLength]  -  firstLetterOffset）％26 + firstLetterOffset
 

示范的JavaScript

I cannot figure out why this thing doesn't scramble correctly. I read some other posts on this cipher and as far as I can tell I'm using the exact same algorithm as they are...

The areas commented out are tests I tried to make sure everything was passing through correctly. I believe it all goes through correctly then fails in the algorithm.

#include <stdio.h>
#include <cs50.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

string get_message(void);
string scramble(string key, string message);

int main(int argc, string argv[])
{
    if(argc == 2)
    {
        string key;
        string message;

        key = argv[1]; 
        //printf("KEY: %s<<",key); 
        message = get_message();
        scramble(key, message);
    }
    else
    {
        printf("Please enter 2 arguments.\n");
        return 1;
    }
}

string get_message(void)
{   
    string message = "";
    do
    {
        message = GetString();
    }
    while(strlen(message) < 1);
    return message;
}

string scramble(string key,string message)
{       
    for(int i = 0, len = strlen(message), key_len = strlen(key); i < len; i++)
    {   
        int letter = message[i];
        //int Tkey = atoi(key[i % key_len]); 
        //printf("KEY: %d<<\n",Tkey);

        if(islower(letter))
        {
            //printf("KEY(%d)",(key[i % key_len]-97));
            letter = (((letter - 97) + (key[i % key_len])) % 26 + 97);
            //printf("(%d)",(letter - 97) + (key[i % key_len])%26);
            printf("%c",letter);
        }       
        else if(isupper(letter))
        {
            //printf("(%d)", key[i]);
            //printf("(%c)",letter); WE HAVE CORRECT LETTER
            letter = (((letter - 65) + (key[i % key_len])) % 26 + 65);
            printf("%c",letter);
        }
    }
    printf("\n");
    return 0;
}

解决方案

I think your calculation is wrong:

You currently have

encryptedLetter = (letter - firstLetterOffset) + key[position % keyLength] % 26 + firstLetterOffset

by check the C operator precedence table we notice that % is evaluated before - or +, meaning that your code actually mean :

encryptedLetter = (letter - firstLetterOffset) + ( key[position % keyLength] % 26 ) + firstLetterOffset

Where you wanted :

encryptedLetter = ( (letter - firstLetterOffset) + key[position % keyLength] ) % 26 + firstLetterOffset

Conclusion : you need to put more parenthese to specify in which order you which to evaluate your expression.

---

In addition you took the letter number for the text character but not for the key !

Correct expression

encryptedLetter = ( (letter - firstLetterOffset) + key[position % keyLength] - firstLetterOffset ) % 26 + firstLetterOffset

Demonstration in javascript

这篇关于V @ genere加密黑鹰坠落的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！