Programa para invertir las filas en una array 2d

Dada una array 2D arr[][] de tamaño M x N enteros donde M es el número de filas y N es el número de columnas. La tarea es invertir cada fila de la array 2D dada.
Ejemplo: 
 

Input: arr[][] = 
{ {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9} }
Output:
3 2 1
6 5 4
9 8 7

Input: arr[][] = 
{ {1, 2}, 
  {4, 5}, 
  {7, 8}, 
  {9, 10} }
Output:
2 1
5 4
8 7
10 9

Acercarse: 
 

  1. Para cada fila en la array 2D dada, haga lo siguiente: 
    • Inicialice el índice de inicio como 0 y el índice final como N-1.
    • Iterar el ciclo hasta que el índice de inicio sea menor que el índice final, intercambiar el valor en estos índices y actualizar el índice como: 
       
swap(arr[i][start], arr[i][end])
start++;
end--;
  •  
  1. Realice la operación anterior para todas las filas de la array 2D.

A continuación se muestra la implementación del enfoque anterior: 
 

C++

// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
const int M = 3;
const int N = 3;
 
// A utility function
// to swap the two element
void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
 
// Function to reverse
// the given 2D arr[][]
void reverseArray(int arr[M][N])
{
 
    // Traverse each row of arr[][]
    for (int i = 0; i < M; i++) {
 
        // Initialise start and end index
        int start = 0;
        int end = N - 1;
 
        // Till start < end, swap the element
        // at start and end index
        while (start < end) {
 
            // Swap the element
            swap(&arr[i][start],
                 &arr[i][end]);
 
            // Increment start and decrement
            // end for next pair of swapping
            start++;
            end--;
        }
    }
 
    // Print the arr[][] after
    // reversing every row
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            cout << arr[i][j] << ' ';
        }
        cout << endl;
    }
}
 
// Driver Code
int main()
{
    int arr[][3] = { { 1, 2, 3 },
                     { 4, 5, 6 },
                     { 7, 8, 9 } };
 
    // Function call
    reverseArray(arr);
    return 0;
}

Java

// Java implementation of the above approach
class GFG{
  
static int M = 3;
static int N = 3;
  
 
// Function to reverse
// the given 2D arr[][]
static void reverseArray(int arr[][])
{
  
    // Traverse each row of arr[][]
    for (int i = 0; i < M; i++) {
  
        // Initialise start and end index
        int start = 0;
        int end = N - 1;
  
        // Till start < end, swap the element
        // at start and end index
        while (start < end) {
  
            // Swap the element
            int temp = arr[i][start];
            arr[i][start] = arr[i][end];
            arr[i][end] = temp;
  
            // Increment start and decrement
            // end for next pair of swapping
            start++;
            end--;
        }
    }
  
    // Print the arr[][] after
    // reversing every row
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println();
    }
}
  
// Driver Code
public static void main(String[] args)
{
    int arr[][] = { { 1, 2, 3 },
                     { 4, 5, 6 },
                     { 7, 8, 9 } };
  
    // Function call
    reverseArray(arr);
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python3 implementation of the above approach
M = 3;N = 3;
 
# Function to reverse
# the given 2D arr[][]
def reverseArray(arr) :
 
    # Traverse each row of arr[][]
    for i in range(M) :
 
        # Initialise start and end index
        start = 0;
        end = N - 1;
 
        # Till start < end, swap the element
        # at start and end index
        while (start < end) :
 
            # Swap the element
            arr[i][start], arr[i][end] = arr[i][end], arr[i][start];
 
            # Increment start and decrement
            # end for next pair of swapping
            start += 1;
            end -= 1;
 
    # Print the arr[][] after
    # reversing every row
    for i in  range(M) :
        for j in range(N) :
            print(arr[i][j],end= ' ');
     
        print();
  
# Driver Code
if __name__ ==  "__main__" :
 
    arr = [ [ 1, 2, 3 ],
            [ 4, 5, 6 ],
            [ 7, 8, 9 ] ];
 
    # Function call
    reverseArray(arr);
    
# This code is contributed by AnkitRai01

C#

// C# implementation of the above approach
using System;
 
class GFG{
   
static int M = 3;
static int N = 3;
   
// Function to reverse
// the given 2D [,]arr
static void reverseArray(int [,]arr)
{
   
    // Traverse each row of [,]arr
    for (int i = 0; i < M; i++) {
   
        // Initialise start and end index
        int start = 0;
        int end = N - 1;
   
        // Till start < end, swap the element
        // at start and end index
        while (start < end) {
   
            // Swap the element
            int temp = arr[i,start];
            arr[i, start] = arr[i, end];
            arr[i, end] = temp;
   
            // Increment start and decrement
            // end for next pair of swapping
            start++;
            end--;
        }
    }
   
    // Print the [,]arr after
    // reversing every row
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            Console.Write(arr[i, j] + " ");
        }
        Console.WriteLine();
    }
}
   
// Driver Code
public static void Main(String[] args)
{
    int [,]arr = { { 1, 2, 3 },
                     { 4, 5, 6 },
                     { 7, 8, 9 } };
   
    // Function call
    reverseArray(arr);
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

<script>
 
// JavaScript implementation of the above approach   
const M = 3;
    const N = 3;
 
    // Function to reverse
    // the given 2D arr
    function reverseArray(arr) {
 
        // Traverse each row of arr
        for (i = 0; i < M; i++) {
 
            // Initialise start and end index
            var start = 0;
            var end = N - 1;
 
            // Till start < end, swap the element
            // at start and end index
            while (start < end) {
 
                // Swap the element
                var temp = arr[i][start];
                arr[i][start] = arr[i][end];
                arr[i][end] = temp;
 
                // Increment start and decrement
                // end for next pair of swapping
                start++;
                end--;
            }
        }
 
        // Print the arr after
        // reversing every row
        for (i = 0; i < M; i++) {
            for (j = 0; j < N; j++) {
                document.write(arr[i][j] + " ");
            }
            document.write("<br/>");
        }
    }
 
    // Driver Code
     
        var arr = [ [ 1, 2, 3 ],
        [ 4, 5, 6 ],
        [ 7, 8, 9 ] ];
 
        // Function call
        reverseArray(arr);
 
// This code is contributed by todaysgaurav
 
</script>
Producción: 

3 2 1 
6 5 4 
9 8 7

 

Publicación traducida automáticamente

Artículo escrito por ritikadhamija y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *