CS50 Vigenere - Ausgabe falsch

Question

Mann ich dachte, ich hätte es! Ich habe an dem Vigenere-Problem gearbeitet und bin nahe dran, bekomme aber immer wieder diesen Fehler, wenn ich nachschaue. Es sieht so aus, als gäbe es ein Problem, wenn der Schlüssel zurückgeschleift werden muss. Gedanken? Hier

ist der Fehler:

:) vigenere.c exists 

:) vigenere.c compiles 

:) encrypts "a" as "a" using "a" as keyword :(encrypts "world, say hello!" as "xoqmd, rby gflkp!" using "baz" as keyword \ expected output, but not "xoqmj, yfz gflkp!\n" 

:(encrypts "BaRFoo" as "CaQGon" using "BaZ" as keyword \ expected output, but not "CaQAun\n" 

:(encrypts "BARFOO" as "CAQGON" using "BAZ" as keyword \ expected output, but not "CAQAON\n" 

:) handles lack of argv[1] 

:) handles argc > 2 

:) rejects "Hax0r2" as keyword 

und hier ist mein Code:

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

#define FALSE 0 
#define TRUE 1 

int main(int argc, string argv[]) 
{ 
    string key = argv[1]; 

    if (argc!= 2) 
    { 
     printf("please provide only one perameter \n"); 

     // stop the program 
     return 1; 
    } 

    // iterate over the key to make sure its all alpha 
    int i,j; 
    for (i = 0, j = strlen(key); i < j; i++) 
    { 
     if (!isalpha(key[i])) 
     { 
      printf("please use only alphanumeric values \n"); 
      return 1; 
     } 
    } 

    // now we have a key, "key" from the ONE perameter that is all alpha 

    string message = GetString(); 
    int k = 0; 
    int keyindex; 

    for (i = 0, j = strlen(message); i < j; i++, k++) 
    { 
     if (isalpha(message[i])) 
     { 
      keyindex = k % strlen(argv[1]); 
      // covering the upper case letters 
      if (isupper(message[i])) 
      { 
       // covering the upper case letters with upper case key letters 

       if isupper(key[i]) 
       { 
        // print cipher according to two upper case 
        int cipher = ((message[i] - 65 + key[keyindex] - 65) % 26) 
         + 65; 
        printf("%c", cipher); 
       } 
       else 
       { 
        // print according to upper case message lower case key 
        int cipher = ((message[i] - 65 + key[keyindex] - 97) % 26) 
         + 65; 
        printf("%c", cipher); 
       } 
      } 
      // this is for the non upper case letters 
      if (islower(message[i])) 
      { 
       if isupper(key[i]) 
       { 
        // print cipher according to lower case message and 
        // upper case key letter 
        int cipher = ((message[i] - 97 + key[keyindex] - 65) % 26) 
         + 97; 
        printf("%c", cipher); 
       } 
       else 
       { 
        // print according to lower case message and lower case key 
        int cipher = ((message[i] - 97 + key[keyindex] - 97) % 26) 
         + 97; 
        printf("%c", cipher); 
       } 
      } 

     } 
     // non alpha symbols 
     else 
     { 
      printf("%c", message[i]); 
     } 
    } 

    // end program after iterating 
    printf("\n"); 

} 

Answer 1

Probleme mit Ihrem Programm:

1) sytax Fehler, die es von der Zusammenstellung halten sollte:

if isupper(key[i]) ->if (isupper(key[i]))

Es gibt zwei davon, also stellen Sie sicher, sie beide zu beheben. Inkrementieren

2) k

int k = 0; 
... 
for (i = 0, j = strlen(message); i < j; i++, k++) 
{ 
    if (isalpha(message[i])) 
    { 
     keyindex = k % strlen(argv[1]); 

Es zwei Jahre alt war, diesen Ansatz, entweder erhöhen k auf immer Charakter oder k auf jedem Brief erhöhen. Der Designer dieses Problem wählte Brief so stattdessen müssen wir tun, um:

int k = 0; 
... 
for (i = 0, j = strlen(message); i < j; i++) 
{ 
    if (isalpha(message[i])) 
    { 
     keyindex = k++ % strlen(argv[1]); 

3) Verwenden Sie keyindex jetzt, dass wir es definiert haben:

if isupper(key[i]) ->if isupper(key[keyindex])

Es gibt zwei Achten Sie darauf, beide zu reparieren.

diese Änderungen und ein wenig Stil Bereinigungs, erhalten wir:

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

int main(int argc, string argv[]) 
{ 
    if (argc != 2) 
    { 
     printf("please provide only one parameter \n"); 

     return 1; // stop the program 
    } 

    string key = argv[1]; 

    // iterate over the key to make sure it's all alpha 

    for (int i = 0, j = strlen(key); i < j; i++) 
    { 
     if (!isalpha(key[i])) 
     { 
      printf("please use only alphanumeric values \n"); 

      return 1; 
     } 
    } 

    // now we have a key, "key" from the ONE parameter that is all alpha 

    string message = GetString(); 

    for (int i = 0, k = 0, j = strlen(message); i < j; i++) 
    { 
     if (isalpha(message[i])) 
     { 
      int keyindex = k++ % strlen(key); 

      if (isupper(message[i])) // covering the upper case letters 
      { 
       if (isupper(key[keyindex])) 
       { 
        // print cipher according to both upper case 
        int cipher = ((message[i] - 'A' + key[keyindex] - 'A') % 26) + 'A'; 
        printf("%c", cipher); 
       } 
       else 
       { 
        // print cipher according to upper case message and lower case key 
        int cipher = ((message[i] - 'A' + key[keyindex] - 'a') % 26) + 'A'; 
        printf("%c", cipher); 
       } 
      } 
      else // this is for the non upper case letters 
      { 
       if (isupper(key[keyindex])) 
       { 
        // print cipher according to lower case message and upper case key letter 
        int cipher = ((message[i] - 'a' + key[keyindex] - 'A') % 26) + 'a'; 
        printf("%c", cipher); 
       } 
       else 
       { 
        // print cipher according to both lower case 
        int cipher = ((message[i] - 'a' + key[keyindex] - 'a') % 26) + 'a'; 
        printf("%c", cipher); 
       } 
      } 

     } 
     else // non alpha symbols 
     { 
      printf("%c", message[i]); 
     } 
    } 

    printf("\n"); // end program after iterating 

} 

Ihr Code eine Menge Logik dupliziert, die Sie mit geringfügigen Änderungen kombinieren könnte - dupliziert Logik ist eine Möglichkeit, dass schwer zu finden Fehler schleichen sich in den Code ein.