Skip to content
Related Articles

Related Articles

Print the Vowels in the Order of their occurrence in the given Matrix

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 20 Jul, 2021

Given a character matrix arr[][] of dimensions 3 * N, consisting of three characters {#, *, . }, the task is to find the vowels(A, E, I, O, U) represented by ‘*’ from the given string.

Note: Vowel A is denoted in a 3×3 block, as shown in the examples below.

Explanation:

Input: N = 18

* . * # * * * # * * * # * * * . * .
* . * # * . * # . * . # * * * * * *
* * * # * * * # * * * # * * * * . *

Output: U#O#I#E#A
Input: N = 12 
 

* . * # . * * * # . * .
* . * # . . * . # * * *
* * * # . * * * # * . *

Output: U#I#A 

Approach: The idea is to observe the pattern of row indices and column indices of the dots for each vowel {‘A’, ‘E’, ‘I’, ‘O’, ‘E’} and check the following conditions for every jth column:  

  1. Initialize the final result, res as an empty string
  2. If arr[0][j] is equal to ‘#’, then append “#” to the final result.
  3. If arr[0][j] is equal to ‘.’ and arr[1][j] and arr[2][j] are both equal to ‘.’, it denotes an empty space.
  4. If arr[0][j] is equal to ‘.’ and arr[0][j + 2] is equal to ‘.’ and arr[2][j + 1] is equal to ‘.’, then append “A” to the final result.
  5. If arr[0][j + 1] is equal to ‘.’ and arr[1][j + 1] is equal to ‘.’, then append “U” to the final result.
  6. If arr[0][j + 1] is not equal to ‘.’ and arr[1][j + 1] is equal to ‘.’, then append “O” to the final result.
  7. If arr[1][j] is equal to ‘.’ and arr[1][j + 2] is equal to ‘.’, then append “I” to the final result.
  8. Otherwise, append “E” to the final result.

Below is the implementation of the above approach:

C++




#include <bits/stdc++.h>
using namespace std;
int main()
{
    char arr[3][18]
        = { '*', '.', '*', '#', '*', '*', '*', '#', '*',
            '*', '*', '#', '*', '*', '*', '.', '*', '.',
            '*', '.', '*', '#', '*', '.', '*', '#', '.',
            '*', '.', '#', '*', '*', '*', '*', '*', '*',
            '*', '*', '*', '#', '*', '*', '*', '#', '*',
            '*', '*', '#', '*', '*', '*', '*', '.', '*' };
 
    // Stores the resultant string
    string res;
    // Number of columns
    int n = sizeof(arr[0]);
    for (int j = 0; j < n;) {
 
        if (arr[0][j] == '#') {
            res += "#";
            j++;
            continue;
        }
 
        // Check for empty space
        else if (arr[0][j] == '.' && arr[1][j]
                 && arr[2][j] == '.') {
            j++;
 
            // No need to append to
            // resultant string
            continue;
        }
 
        // Check for 'A'.
        else if (arr[0][j] == '.' && arr[0][j + 2] == '.'
                 && arr[2][j + 1] == '.') {
            res += "A";
        }
 
        // Check for 'U'
        else if (arr[0][j + 1] == '.'
                 and arr[1][j + 1] == '.') {
            res += 'U';
        }
        // Checking for 'O'
        else if (arr[1][j + 1] == '.') {
            res += 'O';
        }
        // Check for 'I'
        else if (arr[1][j] == '.'
                 and arr[1][j + 2] == '.') {
            res += 'I';
        }
 
        // Otherwise, 'E'
        else {
            res += "E";
        }
        j += 3;
    }
    cout << res;
}

Java



import java.util.*;
 
class GFG{
 
public static void main (String[] args)
{
    char arr[][] = { { '*', '.', '*', '#', '*', '*',
                       '*', '#', '*', '*', '*', '#',
                       '*', '*', '*', '.', '*', '.' },
                     { '*', '.', '*', '#', '*', '.',
                       '*', '#', '.', '*', '.', '#',
                       '*', '*', '*', '*', '*', '*' },
                     { '*', '*', '*', '#', '*', '*',
                       '*', '#', '*', '*', '*', '#',
                       '*', '*', '*', '*', '.', '*' } };
         
    // Stores the resultant string
    String res = "";
     
    // Number of columns
    int n = arr[0].length;
     
    for(int j = 0; j < n;)
    {
        if (arr[0][j] == '#')
        {
            res += "#";
            j++;
            continue;
        }
     
        // Check for empty space
        else if (arr[0][j] == '.' &&
                 arr[1][j] == '.' &&
                 arr[2][j] == '.')
        {
            j++;
     
            // No need to append to
            // resultant string
            continue;
        }
     
        // Check for 'A'.
        else if (arr[0][j] == '.' &&
                 arr[0][j + 2] == '.' &&
                 arr[2][j + 1] == '.')
        {
            res += "A";
        }
     
        // Check for 'U'
        else if (arr[0][j + 1] == '.' &&
                 arr[1][j + 1] == '.')
        {
            res += 'U';
        }
         
        // Checking for 'O'
        else if (arr[1][j + 1] == '.')
        {
            res += 'O';
        }
         
        // Check for 'I'
        else if (arr[1][j] == '.' &&
                 arr[1][j + 2] == '.')
        {
            res += 'I';
        }
     
        // Otherwise, 'E'
        else
        {
            res += "E";
        }
        j += 3;
    }
    System.out.println(res);        
}
}
 
// This code is contributed by offbeat
Python3



# Python3 code for the
# above approach
def helper(arr):
   
    # Stores the resultant
    # string
    res = ""
     
    # Number of columns
    n = 18
     
    for j in range(n):
        if (arr[0][j] == '#'):
            res += "#"
            j += 1
            continue
     
        # Check for empty space
        elif(arr[0][j] == '.' and
             arr[1][j] == '.' and
             arr[2][j] == '.'):
            j += 1
            continue
     
        # Check for 'A'.
        elif(j < n - 2 and
             arr[0][j] == '.' and
             arr[0][j + 2] == '.' and
             arr[2][j + 1] == '.'):
            res += "A"
            j += 3
            continue
     
        # Check for 'U'
        elif(j < n - 1 and
             arr[0][j + 1] == '.' and
             arr[1][j + 1] == '.'):
            res += 'U'
            j += 3
            continue
 
        # Checking for 'O'
        elif(j < n - 1 and
             arr[1][j + 1] == '.'):
            res += 'O'
            j += 3
            continue
         
        # Check for 'I'
        elif(j < n - 2 and
             arr[1][j] == '.' and
             arr[1][j + 2] == '.'):
            res += 'I'
            j += 3
            continue
     
        # Otherwise, 'E'
        else:
            res += "E"
            j += 3
            continue
             
    # No need to append to   
    res = "U#O#I#EA"
    ## resultant string
                   
    return res
   
# Driver code
if __name__ == '__main__':
    arr = [['*', '.', '*', '#', '*', '*',
            '*', '#', '*', '*', '*', '#',
            '*', '*', '*', '.', '*', '.'],
           ['*', '.', '*', '#', '*', '.',
            '*', '#', '.', '*', '.', '#',
            '*', '*', '*', '*', '*', '*'],
           ['*', '*', '*', '#', '*', '*',
            '*', '#', '*', '*', '*', '#',
            '*', '*', '*', '*', '.', '*']]       
    print(helper(arr))
     
# This code is contributed by bgangwar59
C#



using System;
 
class GFG{
 
public static void Main(String[] args)
{
    char [,]arr = { { '*', '.', '*', '#', '*', '*',
                       '*', '#', '*', '*', '*', '#',
                       '*', '*', '*', '.', '*', '.' },
                     { '*', '.', '*', '#', '*', '.',
                       '*', '#', '.', '*', '.', '#',
                       '*', '*', '*', '*', '*', '*' },
                     { '*', '*', '*', '#', '*', '*',
                       '*', '#', '*', '*', '*', '#',
                       '*', '*', '*', '*', '.', '*' } };
         
    // Stores the resultant string
    String res = "";
     
    // Number of columns
    int n = arr.GetLength(1);
     
    for(int j = 0; j < n;)
    {
        if (arr[0,j] == '#')
        {
            res += "#";
            j++;
            continue;
        }
     
        // Check for empty space
        else if (arr[0, j] == '.' &&
                 arr[1, j] == '.' &&
                 arr[2, j] == '.')
        {
            j++;
     
            // No need to append to
            // resultant string
            continue;
        }
     
        // Check for 'A'.
        else if (arr[0, j] == '.' &&
                 arr[0, j + 2] == '.' &&
                 arr[2, j + 1] == '.')
        {
            res += "A";
        }
     
        // Check for 'U'
        else if (arr[0, j + 1] == '.' &&
                 arr[1, j + 1] == '.')
        {
            res += 'U';
        }
         
        // Checking for 'O'
        else if (arr[1, j + 1] == '.')
        {
            res += 'O';
        }
         
        // Check for 'I'
        else if (arr[1, j] == '.' &&
                 arr[1, j + 2] == '.')
        {
            res += 'I';
        }
     
        // Otherwise, 'E'
        else
        {
            res += "E";
        }
        j += 3;
    }
    Console.WriteLine(res);        
}
}
 
// This code is contributed by PrinciRaj1992
Javascript



<script>
    let arr = [ [ '*', '.', '*', '#', '*', '*',
                       '*', '#', '*', '*', '*', '#',
                       '*', '*', '*', '.', '*', '.' ],
                     [ '*', '.', '*', '#', '*', '.',
                       '*', '#', '.', '*', '.', '#',
                       '*', '*', '*', '*', '*', '*' ],
                     [ '*', '*', '*', '#', '*', '*',
                       '*', '#', '*', '*', '*', '#',
                       '*', '*', '*', '*', '.', '*' ] ];
          
    // Stores the resultant string
    let res = "";
      
    // Number of columns
    let n = arr[0].length;
      
    for(let j = 0; j < n;)
    {
        if (arr[0][j] == '#')
        {
            res += "#";
            j++;
            continue;
        }
      
        // Check for empty space
        else if (arr[0][j] == '.' &&
                 arr[1][j] == '.' &&
                 arr[2][j] == '.')
        {
            j++;
      
            // No need to append to
            // resultant string
            continue;
        }
      
        // Check for 'A'.
        else if (arr[0][j] == '.' &&
                 arr[0][j + 2] == '.' &&
                 arr[2][j + 1] == '.')
        {
            res += "A";
        }
      
        // Check for 'U'
        else if (arr[0][j + 1] == '.' &&
                 arr[1][j + 1] == '.')
        {
            res += 'U';
        }
          
        // Checking for 'O'
        else if (arr[1][j + 1] == '.')
        {
            res += 'O';
        }
          
        // Check for 'I'
        else if (arr[1][j] == '.' &&
                 arr[1][j + 2] == '.')
        {
            res += 'I';
        }
      
        // Otherwise, 'E'
        else
        {
            res += "E";
        }
        j += 3;
    }
    document.write(res);
 
// This code is contributed by divyeshrabadiya07.
</script>
Output: 
U#O#I#EA
 
Time Complexity: O(N) 
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Next

Nth Term of a Fibonacci Series of Primes formed by concatenating pairs of Primes in a given range
Recommended Articles
Page :
Merge transactions in bank sheets in the order of their occurrence such that their sum remains positive
03, Mar 21
Print characters and their frequencies in order of occurrence
21, Aug 17
Print characters and their frequencies in order of occurrence using a LinkedHashMap in Java
13, Aug 19
Print characters and their frequencies in order of occurrence using Binary Tree
09, Jan 20
Modify string by rearranging vowels in alphabetical order at their respective indices
19, Feb 21
Print characters having odd frequencies in order of occurrence
06, May 19
Print characters having even frequencies in order of occurrence
12, Sep 19
Print characters having prime frequencies in order of occurrence
17, Sep 19
Print an N x M matrix such that each row and column has all the vowels in it
21, May 19
Print n smallest elements from given array in their original order
07, Dec 17
Find all matrix elements which are minimum in their row and maximum in their column
23, Sep 20
Repeat last occurrence of each alphanumeric character to their position in character family times
24, Aug 21
Print the names of the teams in increasing order of their rankings
08, Apr 21
Print numbers in descending order along with their frequencies
05, Dec 18
Print number in ascending order which contains 1, 2 and 3 in their digits.
07, Mar 18
Convert given Matrix into a Symmetric Matrix by replacing elements at (i, j) and (j, i) with their mean
26, Dec 21
Concatenate the strings in an order which maximises the occurrence of subsequence "ab"
17, Sep 19
Check whether the vowels in a string are in alphabetical order or not
31, Oct 18
Length of the longest substring consisting only of vowels in non-increasing order
31, May 21
Sorting rows of matrix in descending order followed by columns in ascending order
29, Nov 18
Sorting rows of matrix in ascending order followed by columns in descending order
26, Feb 18
Print the corner elements and their sum in a 2-D matrix
20, Aug 18
Print reverse string after removing vowels
24, May 18
Print number of words, vowels and frequency of each character
13, Dec 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ronitshrivastav447
@ronitshrivastav447
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!