Skip to content
Related Articles

Related Articles

Move matrix elements in given direction and add elements with same value

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 19 Aug, 2022
View Discussion
Improve Article
Save Article

Given a matrix m[ ][ ] of size n x n consisting of integers and given a character ‘x’ indicating the direction. Value of ‘x’ can be ‘u’, ‘d’, ‘l’, ‘r’ indicating Up, Down, Left, Right correspondingly. The task is to move the element to given direction such that the consecutive elements having same value are added into single value and shift the rest element. Also, shift the element if the next element in given direction is 0. 

For example : 
Consider x = ‘l’ and matrix m[][], 
32 3 3 
0 0 1 
10 10 8
After adding 3 in first row, 10 in third row and moving 1 in second row, 
Matrix will become 
32 6 0 
1 0 0 
20 8 0

Examples :  

Input : x = 'l'
m[][] = { { 32, 3, 3, 3, 3 },
          { 0, 0, 1, 0, 0 },
          { 10, 10, 8, 1, 2},
          { 0, 0, 0, 0, 1},
          { 4, 5, 6, 7, 8 } }
Output :
32 6 6 0 0
1 0 0 0 0
20 8 1 2 0
1 0 0 0 0 0
4 5 6 7 8

Input : x = 'u'
m[][] = { { 10, 3, 32 },
        { 10, 0, 96 },
        { 5, 32, 96 } }
Output :
20 3 32
5 32 192
0 0 0

Approach : The idea is to traverse each row or column (depending on given direction) from side x of row or column towards x’ (opposite of x). For example, if the given value of x is ‘l’ (left) then start scanning each row from left side to right. While traversing, store row or column element in the temporary 1-D array (say temp[]) by skipping elements having value 0 and sum of the consecutive element if they have equal value. After that, start copying the temporary array temp[0..k] to the current row or column from the x side (of row or column) to x’ (opposite of x) and fill reset of the element by 0.

Let, x = ‘l’ i.e move towards left. So, start copying each row from left most index to right most index of the row and store in temporary array with processing of ignoring 0s and adding two consecutive element into one if they have same value. Below is the illustration for row 1,  

Now, for each, copy temporary array to current row from left most index to right most index. Below is illustration for row 1,  

Below is the implementation of this approach : 

C++




// C++ code to move matrix elements
// in given direction with add
// element with same value
#include <bits/stdc++.h>
using namespace std;
 
#define MAX 50
 
// Function to shift the matrix
// in the given direction
void moveMatrix(char d[], int n,
                int a[MAX][MAX])
{
 
    // For right shift move.
    if (d[0] == 'r') {
 
        // for each row from
        // top to bottom
        for (int i = 0; i < n; i++) {
            vector<int> v, w;
            int j;
 
            // for each element of
            // row from right to left
            for (j = n - 1; j >= 0; j--) {
                // if not 0
                if (a[i][j])
                    v.push_back(a[i][j]);
            }
 
            // for each temporary array
            for (j = 0; j < v.size(); j++) {
                // if two element have same
                // value at consecutive position.
                if (j < v.size() - 1 && v[j] == v[j + 1]) {
                    // insert only one element
                    // as sum of two same element.
                    w.push_back(2 * v[j]);
                    j++;
                }
                else
                    w.push_back(v[j]);
            }
 
            // filling the each row element to 0.
            for (j = 0; j < n; j++)
                a[i][j] = 0;
 
            j = n - 1;
 
            // Copying the temporary
            // array to the current row.
            for (auto it = w.begin();
                 it != w.end(); it++)
                a[i][j--] = *it;
        }
    }
 
    // for left shift move
    else if (d[0] == 'l') {
 
        // for each row
        for (int i = 0; i < n; i++) {
            vector<int> v, w;
            int j;
 
            // for each element of the
            // row from left to right
            for (j = 0; j < n; j++) {
                // if not 0
                if (a[i][j])
                    v.push_back(a[i][j]);
            }
 
            // for each temporary array
            for (j = 0; j < v.size(); j++) {
                // if two element have same
                // value at consecutive position.
                if (j < v.size() - 1 && v[j] == v[j + 1]) {
                    // insert only one element
                    // as sum of two same element.
                    w.push_back(2 * v[j]);
                    j++;
                }
                else
                    w.push_back(v[j]);
            }
 
            // filling the each row element to 0.
            for (j = 0; j < n; j++)
                a[i][j] = 0;
 
            j = 0;
 
            for (auto it = w.begin();
                 it != w.end(); it++)
                a[i][j++] = *it;
        }
    }
 
    // for down shift move.
    else if (d[0] == 'd') {
        // for each column
        for (int i = 0; i < n; i++) {
            vector<int> v, w;
            int j;
 
            // for each element of
            // column from bottom to top
            for (j = n - 1; j >= 0; j--) {
                // if not 0
                if (a[j][i])
                    v.push_back(a[j][i]);
            }
 
            // for each temporary array
            for (j = 0; j < v.size(); j++) {
 
                // if two element have same
                // value at consecutive position.
                if (j < v.size() - 1 && v[j] == v[j + 1]) {
                    // insert only one element
                    // as sum of two same element.
                    w.push_back(2 * v[j]);
                    j++;
                }
                else
                    w.push_back(v[j]);
            }
 
            // filling the each column element to 0.
            for (j = 0; j < n; j++)
                a[j][i] = 0;
 
            j = n - 1;
 
            // Copying the temporary array
            // to the current column
            for (auto it = w.begin();
                 it != w.end(); it++)
                a[j--][i] = *it;
        }
    }
 
    // for up shift move
    else if (d[0] == 'u') {
        // for each column
        for (int i = 0; i < n; i++) {
            vector<int> v, w;
            int j;
 
            // for each element of column
            // from top to bottom
            for (j = 0; j < n; j++) {
                // if not 0
                if (a[j][i])
                    v.push_back(a[j][i]);
            }
 
            // for each temporary array
            for (j = 0; j < v.size(); j++) {
                // if two element have same
                // value at consecutive position.
                if (j < v.size() - 1 && v[j] == v[j + 1]) {
                    // insert only one element
                    // as sum of two same element.
                    w.push_back(2 * v[j]);
                    j++;
                }
                else
                    w.push_back(v[j]);
            }
 
            // filling the each column element to 0.
            for (j = 0; j < n; j++)
                a[j][i] = 0;
 
            j = 0;
 
            // Copying the temporary array
            // to the current column
            for (auto it = w.begin();
                 it != w.end(); it++)
                a[j++][i] = *it;
        }
    }
}
 
// Driven Program
int main()
{
    char d[2] = "l";
    int n = 5;
    int a[MAX][MAX] = { { 32, 3, 3, 3, 3 },
                        { 0, 0, 1, 0, 0 },
                        { 10, 10, 8, 1, 2 },
                        { 0, 0, 0, 0, 1 },
                        { 4, 5, 6, 7, 8 } };
 
    moveMatrix(d, n, a);
 
    // Printing the final array
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << a[i][j] << " ";
 
        cout << endl;
    }
 
    return 0;
}

Java



// Java code to move matrix
// elements in given direction
// with add element with same value
import java.io.*;
import java.util.*;
 
class GFG {
    // Function to shift the matrix
    // in the given direction
    static void moveMatrix(char d,
                           int n,
                           int a[][])
    {
 
        // For right shift move.
        if (d == 'r') {
 
            // for each row from
            // top to bottom
            for (int i = 0; i < n; i++) {
                ArrayList<Integer> v = new ArrayList<Integer>();
                ArrayList<Integer> w = new ArrayList<Integer>();
                int j;
 
                // for each element of
                // row from right to left
                for (j = n - 1; j >= 0; j--) {
                    // if not 0
                    if (a[i][j] != 0)
                        v.add(a[i][j]);
                }
 
                // for each temporary array
                for (j = 0; j < v.size(); j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.size() - 1 && v.get(j) == v.get(j + 1)) {
                        // insert only one element
                        // as sum of two same element.
                        w.add(2 * v.get(j));
                        j++;
                    }
                    else
                        w.add(v.get(j));
                }
 
                // filling the each
                // row element to 0.
                for (j = 0; j < n; j++)
                    a[i][j] = 0;
 
                j = n - 1;
 
                // Copying the temporary
                // array to the current row.
                for (int it = 0; it < w.size(); it++)
                    a[i][j--] = w.get(it);
            }
        }
 
        // for left shift move
        else if (d == 'l') {
 
            // for each row
            for (int i = 0; i < n; i++) {
                ArrayList<Integer> v = new ArrayList<Integer>();
                ArrayList<Integer> w = new ArrayList<Integer>();
                int j;
 
                // for each element of the
                // row from left to right
                for (j = 0; j < n; j++) {
                    // if not 0
                    if (a[i][j] != 0)
                        v.add(a[i][j]);
                }
 
                // for each temporary array
                for (j = 0; j < v.size(); j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.size() - 1 && v.get(j) == v.get(j + 1)) {
                        // insert only one
                        // element as sum
                        // of two same element.
                        w.add(2 * v.get(j));
                        j++;
                    }
                    else
                        w.add(v.get(j));
                }
 
                // filling the each
                // row element to 0.
                for (j = 0; j < n; j++)
                    a[i][j] = 0;
 
                j = 0;
 
                for (int it = 0; it < w.size(); it++)
                    a[i][j++] = w.get(it);
            }
        }
 
        // for down shift move.
        else if (d == 'd') {
            // for each column
            for (int i = 0; i < n; i++) {
                ArrayList<Integer> v = new ArrayList<Integer>();
                ArrayList<Integer> w = new ArrayList<Integer>();
                int j;
 
                // for each element of
                // column from bottom to top
                for (j = n - 1; j >= 0; j--) {
                    // if not 0
                    if (a[j][i] != 0)
                        v.add(a[j][i]);
                }
 
                // for each temporary array
                for (j = 0; j < v.size(); j++) {
 
                    // if two element have
                    // same value at consecutive
                    // position.
                    if (j < v.size() - 1 && v.get(j) == v.get(j + 1)) {
                        // insert only one element
                        // as sum of two same element.
                        w.add(2 * v.get(j));
                        j++;
                    }
                    else
                        w.add(v.get(j));
                }
 
                // filling the each
                // column element to 0.
                for (j = 0; j < n; j++)
                    a[j][i] = 0;
 
                j = n - 1;
 
                // Copying the temporary array
                // to the current column
                for (int it = 0; it < w.size(); it++)
                    a[j--][i] = w.get(it);
            }
        }
 
        // for up shift move
        else if (d == 'u') {
            // for each column
            for (int i = 0; i < n; i++) {
                ArrayList<Integer> v = new ArrayList<Integer>();
                ArrayList<Integer> w = new ArrayList<Integer>();
                int j;
 
                // for each element of column
                // from top to bottom
                for (j = 0; j < n; j++) {
                    // if not 0
                    if (a[j][i] != 0)
                        v.add(a[j][i]);
                }
 
                // for each temporary array
                for (j = 0; j < v.size(); j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.size() - 1 && v.get(j) == v.get(j + 1)) {
                        // insert only one element
                        // as sum of two same element.
                        w.add(2 * v.get(j));
                        j++;
                    }
                    else
                        w.add(v.get(j));
                }
 
                // filling the each
                // column element to 0.
                for (j = 0; j < n; j++)
                    a[j][i] = 0;
 
                j = 0;
 
                // Copying the temporary
                // array to the current
                // column
                for (int it = 0; it < w.size(); it++)
                    a[j++][i] = w.get(it);
            }
        }
    }
 
    // Driver Code
    public static void main(String args[])
    {
        char d = 'l';
        int n = 5;
        int a[][] = { { 32, 3, 3, 3, 3 },
                      { 0, 0, 1, 0, 0 },
                      { 10, 10, 8, 1, 2 },
                      { 0, 0, 0, 0, 1 },
                      { 4, 5, 6, 7, 8 } };
 
        moveMatrix(d, n, a);
 
        // Printing the
        // final array
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++)
                System.out.print(a[i][j] + " ");
 
            System.out.println();
        }
    }
}
 
// This code is contributed by
// Manish Shaw(manishshaw1)
Python3



# Python3 code to move matrix elements
# in given direction with add
# element with same value
MAX = 50
 
# Function to shift the matrix
# in the given direction
def moveMatrix(d, n, a):
 
    # For right shift move.
    if (d[0] == 'r'):
 
        # For each row from
        # top to bottom
        for i in range(n):
            v = []
            w = []
 
            # For each element of
            # row from right to left
            for j in range(n - 1, -1, -1):
                 
                # if not 0
                if (a[i][j]):
                    v.append(a[i][j])
 
            # For each temporary array
            j = 0
            while (j < len(v)):
                 
                # If two element have same
                # value at consecutive position.
                if (j < len(v) - 1 and
                   v[j] == v[j + 1]):
                     
                    # Insert only one element
                    # as sum of two same element.
                    w.append(2 * v[j])
                    j += 1
                 
                else:
                    w.append(v[j])
                     
                j += 1
 
            # Filling the each row element to 0.
            for j in range(n):
                a[i][j] = 0
 
            j = n - 1
 
            # Copying the temporary
            # array to the current row.
            for it in w:
                a[i][j] = it
                j -= 1
 
    # For left shift move
    elif (d[0] == 'l'):
 
        # For each row
        for i in range(n):
            v = []
            w = []
 
            # For each element of the
            # row from left to right
            for j in range(n):
                 
                # If not 0
                if (a[i][j]):
                    v.append(a[i][j])
 
            # For each temporary array
            j = 0
            while(j < len(v)):
                 
                # If two element have same
                # value at consecutive position.
                if (j < len(v) - 1 and
                   v[j] == v[j + 1]):
                     
                    # Insert only one element
                    # as sum of two same element.
                    w.append(2 * v[j])
                    j += 1
                 
                else:
                    w.append(v[j])
                     
                j += 1
 
            # Filling the each row element to 0.
            for j in range(n):
                a[i][j] = 0
 
            j = 0
 
            for it in w:
                a[i][j] = it
                j += 1
 
    # For down shift move.
    elif (d[0] == 'd'):
         
        # For each column
        for i in range(n):
            v = []
            w = []
 
            # For each element of
            # column from bottom to top
            for j in range(n - 1, -1, -1):
                 
                # If not 0
                if (a[j][i]):
                    v.append(a[j][i])
 
            # For each temporary array
            j = 0
            while(j < len(v)):
 
                # If two element have same
                # value at consecutive position.
                if (j <len( v) - 1 and
                   v[j] == v[j + 1]):
                     
                    # Insert only one element
                    # as sum of two same element.
                    w.append(2 * v[j])
                    j += 1
                 
                else:
                    w.append(v[j])
                     
                j += 1
                     
            # Filling the each column element to 0.
            for j in range(n):
                a[j][i] = 0
 
            j = n - 1
 
            # Copying the temporary array
            # to the current column
            for it in w:
                a[j][i] = it
                j -= 1
                 
    # For up shift move
    elif (d[0] == 'u'):
         
        # For each column
        for i in range(n):
            v = []
            w = []
 
            # For each element of column
            # from top to bottom
            for j in range(n):
                 
                # If not 0
                if (a[j][i]):
                    v.append(a[j][i])
 
            # For each temporary array
            j = 0
            while(j < len(v)):
                 
                # If two element have same
                # value at consecutive position.
                if (j < len(v) - 1 and
                   v[j] == v[j + 1]):
                     
                    # Insert only one element
                    # as sum of two same element.
                    w.append(2 * v[j])
                    j += 1
                 
                else:
                    w.append(v[j])
                j += 1
 
            # Filling the each column element to 0.
            for j in range(n):
                a[j][i] = 0
 
            j = 0
 
            # Copying the temporary array
            # to the current column
            for it in w:
                a[j][i] = it
                j += 1
 
# Driver Code
if __name__ == "__main__":
 
    d = ["l"] * 2
    n = 5
    a = [ [ 32, 3, 3, 3, 3 ],
          [ 0, 0, 1, 0, 0 ],
          [ 10, 10, 8, 1, 2 ],
          [ 0, 0, 0, 0, 1 ],
          [ 4, 5, 6, 7, 8 ] ]
 
    moveMatrix(d, n, a)
 
    # Printing the final array
    for i in range(n):
        for j in range(n):
            print(a[i][j], end = " ")
 
        print()
 
# This code is contributed by chitranayal
C#



// C# code to move matrix elements
// in given direction with add
// element with same value
using System;
using System.Collections.Generic;
 
class GFG {
    // Function to shift the matrix
    // in the given direction
    static void moveMatrix(char d, int n,
                           int[, ] a)
    {
 
        // For right shift move.
        if (d == 'r') {
 
            // for each row from
            // top to bottom
            for (int i = 0; i < n; i++) {
                List<int> v = new List<int>();
                List<int> w = new List<int>();
                int j;
 
                // for each element of
                // row from right to left
                for (j = n - 1; j >= 0; j--) {
                    // if not 0
                    if (a[i, j] != 0)
                        v.Add(a[i, j]);
                }
 
                // for each temporary array
                for (j = 0; j < v.Count; j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.Count - 1 && v[j] == v[j + 1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.Add(2 * v[j]);
                        j++;
                    }
                    else
                        w.Add(v[j]);
                }
 
                // filling the each
                // row element to 0.
                for (j = 0; j < n; j++)
                    a[i, j] = 0;
 
                j = n - 1;
 
                // Copying the temporary
                // array to the current row.
                for (int it = 0; it < w.Count; it++)
                    a[i, j--] = w[it];
            }
        }
 
        // for left shift move
        else if (d == 'l') {
 
            // for each row
            for (int i = 0; i < n; i++) {
                List<int> v = new List<int>();
                List<int> w = new List<int>();
                int j;
 
                // for each element of the
                // row from left to right
                for (j = 0; j < n; j++) {
                    // if not 0
                    if (a[i, j] != 0)
                        v.Add(a[i, j]);
                }
 
                // for each temporary array
                for (j = 0; j < v.Count; j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.Count - 1 && v[j] == v[j + 1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.Add(2 * v[j]);
                        j++;
                    }
                    else
                        w.Add(v[j]);
                }
 
                // filling the each
                // row element to 0.
                for (j = 0; j < n; j++)
                    a[i, j] = 0;
 
                j = 0;
 
                for (int it = 0; it < w.Count; it++)
                    a[i, j++] = w[it];
            }
        }
 
        // for down shift move.
        else if (d == 'd') {
            // for each column
            for (int i = 0; i < n; i++) {
                List<int> v = new List<int>();
                List<int> w = new List<int>();
                int j;
 
                // for each element of
                // column from bottom to top
                for (j = n - 1; j >= 0; j--) {
                    // if not 0
                    if (a[j, i] != 0)
                        v.Add(a[j, i]);
                }
 
                // for each temporary array
                for (j = 0; j < v.Count; j++) {
 
                    // if two element have same
                    // value at consecutive position.
                    if (j < v.Count - 1 && v[j] == v[j + 1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.Add(2 * v[j]);
                        j++;
                    }
                    else
                        w.Add(v[j]);
                }
 
                // filling the each
                // column element to 0.
                for (j = 0; j < n; j++)
                    a[j, i] = 0;
 
                j = n - 1;
 
                // Copying the temporary array
                // to the current column
                for (int it = 0; it < w.Count; it++)
                    a[j--, i] = w[it];
            }
        }
 
        // for up shift move
        else if (d == 'u') {
            // for each column
            for (int i = 0; i < n; i++) {
                List<int> v = new List<int>();
                List<int> w = new List<int>();
                int j;
 
                // for each element of column
                // from top to bottom
                for (j = 0; j < n; j++) {
                    // if not 0
                    if (a[j, i] != 0)
                        v.Add(a[j, i]);
                }
 
                // for each temporary array
                for (j = 0; j < v.Count; j++) {
                    // if two element have same
                    // value at consecutive position.
                    if (j < v.Count - 1 && v[j] == v[j + 1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.Add(2 * v[j]);
                        j++;
                    }
                    else
                        w.Add(v[j]);
                }
 
                // filling the each
                // column element to 0.
                for (j = 0; j < n; j++)
                    a[j, i] = 0;
 
                j = 0;
 
                // Copying the temporary array
                // to the current column
 
                for (int it = 0; it < w.Count; it++)
                    a[j++, i] = w[it];
            }
        }
    }
 
    // Driven Code
    static void Main()
    {
        char d = 'l';
        int n = 5;
        int[, ] a = new int[, ] { { 32, 3, 3, 3, 3 },
                                  { 0, 0, 1, 0, 0 },
                                  { 10, 10, 8, 1, 2 },
                                  { 0, 0, 0, 0, 1 },
                                  { 4, 5, 6, 7, 8 } };
 
        moveMatrix(d, n, a);
 
        // Printing the final array
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++)
                Console.Write(a[i, j] + " ");
 
            Console.WriteLine();
        }
    }
}
// This code is contributed by
// Manish Shaw(manishshaw1)
PHP



<?php
// PHP code to move matrix
// elements in given
// direction with add element
// with same value
$MAX = 50;
 
// Function to shift the matrix
// in the given direction
function moveMatrix($d, $n, &$a)
{
    global $MAX;
     
    // For right shift move.
    if ($d[0] == 'r')
    {
         
        // for each row from
        // top to bottom
        for ($i = 0; $i < $n; $i++)
        {
            $v = array();
            $w = array();
            $j = 0;
 
            // for each element of
            // row from right to left
            for ($j = $n - 1; $j >= 0; $j--)
            {
                // if not 0
                if ($a[$i][$j])
                    array_push($v, $a[$i][$j]);
            }
 
            // for each temporary array
            for ($j = 0; $j < count($v); $j++)
            {
                // if two element have same
                // value at consecutive position.
                if ($j < count($v) - 1 &&
                    $v[$j] == $v[$j + 1])
                {
                    // insert only one element
                    // as sum of two same element.
                    array_push($w, 2 * $v[$j]);
                    $j++;
                }
                else
                    array_push($w, $v[$j]);
            }
 
            // filling the each
            // row element to 0.
            for ($j = 0; $j < $n; $j++)
                $a[$i][$j] = 0;
 
            $j = $n - 1;
 
            // Copying the temporary
            // array to the current row.
            for ($it = 0; $it != count($w); $it++)
                    $a[$i][$j--] = $w[$it];
        }
    }
 
    // for left shift move
    else if ($d[0] == 'l')
    {
        // for each row
        for ($i = 0; $i < $n; $i++)
        {
            $v = array(); $w = array();
            $j = 0;
 
            // for each element of the
            // row from left to right
            for ($j = 0; $j < $n; $j++)
            {
                // if not 0
                if ($a[$i][$j])
                    array_push($v,
                               $a[$i][$j]);
            }
 
            // for each temporary array
            for ($j = 0; $j < count($v); $j++)
            {
                // if two element have
                // same value at consecutive
                // position.
                if ($j < count($v) - 1 &&
                    $v[$j] == $v[$j + 1])
                {
                    // insert only one element
                    // as sum of two same element.
                    array_push($w, 2 * $v[$j]);
                    $j++;
                }
                else
                    array_push($w, $v[$j]);
            }
 
            // filling the each
            // row element to 0.
            for ($j = 0; $j < $n; $j++)
                $a[$i][$j] = 0;
 
            $j = 0;
 
            for ($it = 0; $it != count($w); $it++)
                    $a[$i][$j++] = $w[$it];
        }
    }
 
    // for down shift move.
    else if ($d[0] == 'd')
    {
        // for each column
        for ($i = 0; $i < $n; $i++)
        {
            $v = array(); $w = array();
            $j = 0;
 
            // for each element
            // of column from
            // bottom to top
            for ($j = $n - 1; $j >= 0; $j--)
            {
                // if not 0
                if ($a[$j][$i])
                    array_push($v, $a[$j][$i]);
            }
 
            // for each temporary array
            for ($j = 0; $j < count($v); $j++)
            {
                 
                // if two element have
                // same value at
                // consecutive position.
                if ($j < count($v) - 1 &&
                    $v[$j] == $v[$j + 1])
                {
                    // insert only one element
                    // as sum of two same element.
                    array_push($w, 2 * $v[$j]);
                    $j++;
                }
                else
                    array_push($w, $v[$j]);
            }
 
            // filling the each
            // column element to 0.
            for ($j = 0; $j < $n; $j++)
                $a[$j][$i] = 0;
 
            $j = $n - 1;
 
            // Copying the temporary array
            // to the current column
            for ($it = 0; $it != count($w); $it++)
                    $a[$j--][$i] = $w[$it];
        }
    }
 
    // for up shift move
    else if ($d[0] == 'u')
    {
        // for each column
        for ($i = 0; $i < $n; $i++)
        {
            $v = array(); $w = array();
            $j = 0;
 
            // for each element of column
            // from top to bottom
            for ($j = 0; $j < $n; $j++)
            {
                // if not 0
                if ($a[$j][$i])
                    array_push($v,
                               $a[$j][$i]);
            }
 
            // for each temporary array
            for ($j = 0; $j < count($v); $j++)
            {
                // if two element have same
                // value at consecutive position.
                if ($j < count($v) - 1 &&
                    $v[$j] == $v[$j + 1])
                {
                    // insert only one element
                    // as sum of two same element.
                    array_push($w, 2 * $v[$j]);
                    $j++;
                }
                else
                    array_push($w, $v[$j]);
            }
 
            // filling the each
            // column element to 0.
            for ($j = 0; $j < $n; $j++)
                $a[$j][$i] = 0;
 
            $j = 0;
 
            // Copying the temporary array
            // to the current column
            for ($it = 0; $it != count($w); $it++)
                    $a[$j++][$i] = $w[$it];
        }
    }
}
 
// Driven Code
$d = array("l");
$n = 5;
$a = array( array(32, 3, 3, 3, 3),
            array(0, 0, 1, 0, 0),
            array(10, 10, 8, 1, 2),
            array(0, 0, 0, 0, 1),
            array(4, 5, 6, 7, 8));
 
moveMatrix($d, $n, $a);
 
// Printing the final array
for ($i = 0; $i < $n; $i++)
{
    for ($j = 0; $j < $n; $j++)
        echo ($a[$i][$j]." ");
 
    echo ("\n");
}
 
// This code is contributed
// by Manish Shaw(manishshaw1)
?>
Javascript



<script>
// Javascript code to move matrix
// elements in given direction
// with add element with same value
     
    // Function to shift the matrix
    // in the given direction
    function moveMatrix(d,n,a)
    {
        // For right shift move.
        if (d == 'r') {
   
            // for each row from
            // top to bottom
            for (let i = 0; i < n; i++) {
                let v = [] ;
                let w = [] ;
                let j;
   
                // for each element of
                // row from right to left
                for (j = n - 1; j >= 0; j--) {
                    // if not 0
                    if (a[i][j] != 0)
                        v.push(a[i][j]);
                }
   
                // for each temporary array
                for (j = 0; j < v.length; j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.length - 1 && v[j] == v[j+1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.push(2 * v[j]);
                        j++;
                    }
                    else
                        w.push(v[j]);
                }
   
                // filling the each
                // row element to 0.
                for (j = 0; j < n; j++)
                    a[i][j] = 0;
   
                j = n - 1;
   
                // Copying the temporary
                // array to the current row.
                for (let it = 0; it < w.length; it++)
                    a[i][j--] = w[it];
            }
        }
   
        // for left shift move
        else if (d == 'l') {
   
            // for each row
            for (let i = 0; i < n; i++) {
                let v = [] ;
                let w = [] ;
                let j;
   
                // for each element of the
                // row from left to right
                for (j = 0; j < n; j++) {
                    // if not 0
                    if (a[i][j] != 0)
                        v.push(a[i][j]);
                }
   
                // for each temporary array
                for (j = 0; j < v.length; j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.length - 1 && v[j] == v[j+1]) {
                        // insert only one
                        // element as sum
                        // of two same element.
                        w.push(2 * v[j]);
                        j++;
                    }
                    else
                        w.push(v[j]);
                }
   
                // filling the each
                // row element to 0.
                for (j = 0; j < n; j++)
                    a[i][j] = 0;
   
                j = 0;
   
                for (let it = 0; it < w.length; it++)
                    a[i][j++] = w[it];
            }
        }
   
        // for down shift move.
        else if (d == 'd') {
            // for each column
            for (let i = 0; i < n; i++) {
                let v = [];
                let w = [];
                let j;
   
                // for each element of
                // column from bottom to top
                for (j = n - 1; j >= 0; j--) {
                    // if not 0
                    if (a[j][i] != 0)
                        v.push(a[j][i]);
                }
   
                // for each temporary array
                for (j = 0; j < v.length; j++) {
   
                    // if two element have
                    // same value at consecutive
                    // position.
                    if (j < v.length - 1 && v[j] == v[j+1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.push(2 * v[j]);
                        j++;
                    }
                    else
                        w.push(v[j]);
                }
   
                // filling the each
                // column element to 0.
                for (j = 0; j < n; j++)
                    a[j][i] = 0;
   
                j = n - 1;
   
                // Copying the temporary array
                // to the current column
                for (let it = 0; it < w.length; it++)
                    a[j--][i] = w[it];
            }
        }
   
        // for up shift move
        else if (d == 'u') {
            // for each column
            for (let i = 0; i < n; i++) {
                let v = [];
                let w = [];
                let j;
   
                // for each element of column
                // from top to bottom
                for (j = 0; j < n; j++) {
                    // if not 0
                    if (a[j][i] != 0)
                        v.push(a[j][i]);
                }
   
                // for each temporary array
                for (j = 0; j < v.length; j++) {
                    // if two element have
                    // same value at
                    // consecutive position.
                    if (j < v.length - 1 && v[j] == v[j+1]) {
                        // insert only one element
                        // as sum of two same element.
                        w.push(2 * v[j]);
                        j++;
                    }
                    else
                        w.push(v[j]);
                }
   
                // filling the each
                // column element to 0.
                for (j = 0; j < n; j++)
                    a[j][i] = 0;
   
                j = 0;
   
                // Copying the temporary
                // array to the current
                // column
                for (let it = 0; it < w.length; it++)
                    a[j++][i] = w[it];
            }
        }
    }
      
    // Driver Code
    let d = 'l';
    let n = 5;
     
    let a = [ [ 32, 3, 3, 3, 3 ],
          [ 0, 0, 1, 0, 0 ],
          [ 10, 10, 8, 1, 2 ],
          [ 0, 0, 0, 0, 1 ],
          [ 4, 5, 6, 7, 8 ] ]
     
    moveMatrix(d, n, a);
   
        // Printing the
        // final array
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++)
            document.write(a[i][j] + " ");
   
        document.write("<br>");
    }
     
    // This code is contributed by rag2127
</script>
Output: 
32 6 6 0 0 
1 0 0 0 0 
20 8 1 2 0 
1 0 0 0 0 
4 5 6 7 8
 
Time Complexity: O(n2)
Auxiliary Space: O(n), since n extra space has been taken.

My Personal Notes
arrow_drop_up
Previous
Shift matrix elements row-wise by k
Next

Check if all rows of a matrix are circular rotations of each other
Recommended Articles
Page :
Check if a king can move a valid move or not when N nights are there in a modified chessboard
29, Oct 18
Count elements of same value placed at same indices of two given arrays
03, Jan 21
Distance Traveled by Two Trains together in the same Direction
06, Aug 20
Flip the given Matrix along both diagonals in clockwise direction
27, Dec 21
Print a given matrix in spiral form using direction tracking method
17, Jul 19
C++ Program to Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction
30, Dec 21
Python3 Program to Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction
30, Nov 21
Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction
30, Apr 21
Java Program to Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction
30, Dec 21
Minimum cost required to move all elements to the same position
23, Nov 20
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Final direction after visiting every cell of Matrix starting from (0, 0)
02, Jul 20
Javascript Program to Modify a matrix by rotating ith row exactly i times in clockwise direction
10, Dec 21
Python3 Program to Modify a matrix by rotating ith row exactly i times in clockwise direction
10, Dec 21
Java Program to Modify a matrix by rotating ith row exactly i times in clockwise direction
10, Nov 21
C++ Program to Modify a matrix by rotating ith row exactly i times in clockwise direction
10, Dec 21
Modify a matrix by rotating ith row exactly i times in clockwise direction
10, Mar 21
Rotate a matrix by 90 degree in clockwise direction without using any extra space
17, Sep 18
Minimum steps to move all 1 to a single cell of given square Matrix
10, Mar 22
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Minimize steps required to move all 1's in a matrix to a given index
24, Jun 20
Find the positions of given people after T time using their starting time and direction
27, Sep 21
Minimum and maximum count of elements at D distance from arr[i] in either direction
15, Oct 21
Find trace of matrix formed by adding Row-major and Column-major order of same matrix
04, Dec 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
anuj0503
@anuj0503
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!