Question

Are my codes correct?

#include <iostream>
#include <string>

#include <cassert>

#include <cctype>

#include <cstring>

#include <stdio.h>

#include <ctype.h>

#include<fstream>

int locateMinimum( const std::string array[ ], int n ){

   if(n <= 0){

   return -1;

   }

   else{

   int minInd = 0;

   for(int i = 0; i < n; ++i){

   if(array[i] < array[minInd]){

   minInd = i;

   }

   }

   return minInd;

   }

}

int countPunctuation( const std::string array[], int n)

{

int count = 0;

for (int i=0;i<= n;i++)

{

if (array[i]== ('!', ',' ,':' ,';' ,'.', '-' ,'?'))

{

count = count + 1;

return count;

}

else {

return 0;

}

bool hasReverse(const std::string array[ ], int n )

{

   // entire array

   for(int i=0;i<n;i++)

   {

   //finding the reverse of the string

   string rev = string(array[i].rbegin(),array[i].rend());

   //checking that reverse of the string is present in the array or not

   //if present returning true or we are returning false

   for(int j=0;j<n;j++)

   {

   if(array[j] == rev){

   return true;

   }

   }

   }

   return false;

   }

char highestOccurredCharacter(const std::string array[ ], int n, int index ){

if( n <= 0 || index >= n || index < 0) //if invalid array length n or invalid index is given the function returns null character

return '\0';

int highest=0; //initially considering the highest to be 0

char c = '\0'; //to save the most repeating character

for(int i=0;i<array[index].length();i++){ //traversing through the string array[index]

int count = 0; //initial count of character array[index][i] is 0

for(int j=0;j<array[index].length();j++) //traversing through the string array[index] again to find the count of repeatetions of array[index][i] character

if(array[index][i]==array[index][j])

count++;

if(count>highest){ //if count is greater than the highest count then we have a new highest which has to be stored in highest

highest = count; //save the latest highest in highest

c = array[index][i]; //save the character of latest highest in c

}

}

return c; //return the total highest repeated character

}

bool isInIncreasingOrder( const std::string array[ ], int n )

{

if(n < 0){

return false;

}

else if(n == 0){

return true;

}

else{

for(int i = 1; i < n; ++i){

if(fruit[i] <= fruit[i - 1]){

return false;

}

}

return true;

}

}

char firstNonRepeatedCharacter(const std::string array[ ], int n, int index);

   //This function finds out the first non repeating chracter and returns it

if( n <= 0 || index>= n || index < 0) { //if invalid array length n or invalid index is given the function returns null character

return '\0';}

for(int i=0;i<array[index].length();i++){ //traversing through the string array[index] chracters

int count = 0; //initialising count to 0 initially

for(int j=0;j<array[index].length();j++) //traversing through the string array[index] chracters to count the occurrences

if(array[index][i]==array[index][j]) //

count++;

if(count==1) //the count of non Repeating Character is 1 so if any chracter gets a count 1 it must be returned and it would be the firstNonRepeatedCharacter

return array[index][i];

}

bool isOnlyDigits( const std::string array[ ], int n ){

//traversing array

for(int i=0;i<n;i++)

{

//traversing each string of the array

for(int j=0;j<array[i].length();j++)

{

//checking the string contains only digits or not if not we are returning false

if (!(array[i][j] >= '0' && array[i][j] <= '9'))

return false;

}

}

return true;

}

}

Answer 1

• The method locateMinimum() is correct. But you can start the loop from i = 1 rather than i = 0, because minInd is already set as 0 and you don't need to compare array[0] with array[0] again.
• countPunctuation is incorrect.
  1. You cannot compare string with characters. array[i] is a string, it cannot be compared to '?'.
  2. The commad operator returns the last value. Which means everytime you are doing, "array[i]== ('!', ',' ,':' ,';' ,'.', '-' ,'?')", it's the same as "array[i] == '?'", which is again not a valid operation (refer to point 1)
  3. To check if a value is equal to one value in a seperate values, you need to check for equality with each element in the set and combine all of them using the logical OR (||) operator.
  4. To count the number of punctuations, you need to traverse through each character in each array. Here's the corrected code:

int countPunctuation(const std::string array[], int n) {

    int count = 0;

    for(int i = 0; i < n; i++) {

        for(int j = 0; j < array[i].length(); j++) {

            if(array[i][j] == '!' || array[i][j] == ',' || array[i][j] == ':' || array[i][j] == ';' || array[i][j] == '-' || array[i][j] == '?')

                count++;

        }

    }

    return count;

}

• hasReverse() has a small logical error. Instead of returning true when you have a string in the array which is the same as its reverse, you want to return false when you find one that is not a pallindrome. What this will do, is you will say you have found one non-pallindromic string, which means all strings in the array are not pallindromic. Otherwise if you have checked all the strings and they are all pallindromes, then you just return false, because all are pallindromic. Here's the corrected code:

bool hasReverse(const std::string array[], int n) {

    for(int i = 0; i < n; i++) {

        string rev = string(array[i].rbegin(),array[i].rend());

        if(array[i] != rev)

            return false;

    }

    return true;

}

• highestOccurredCharacter() is correct. Keep in mind though, that this has an O(n²) complexity and is a brute force solution. You can have a linear time O(n) solution if you use some more space. By that I mean you can use a HashMap to count the occurences of each character use it to find the one with the higesht occurence.
• isInIncreasingOrder() is correct for a strictly increasing constraint. For a more relaxed constraint (two equal elements can be place one after the other) which is not strictly increasing just use the less than operator instead of a less than equal to operator.
• firstNonRepeatedCharacter() is correct. This can be further optimized though.
• isOnlyDigits() is correct. This will run perfectly.