Invertir una matriz en grupos de un tamaño determinado
Dada una matriz llegar[] y un numero entero k encuentre la matriz después de invertir cada submatriz de k elementos consecutivos en su lugar. Si el último subarreglo tiene menos de k elementos, inviértalo tal como está. Modificar la matriz en su lugar no devuelve nada.
Ejemplos:
Aporte: arreglo[] = [1 2 3 4 5 6 7 8] k = 3
Producción: [3 2 1 6 5 4 8 7]
Explicación: Los elementos se invierten: [1 2 3] → [3 2 1] [4 5 6] → [6 5 4] y el último grupo [7 8](tamaño < 3) is reversed as [8 7].Aporte: arreglo[] = [1 2 3 4 5] k = 3
Salida: [3 2 1 5 4]
Explicación: El primer grupo consta de los elementos 1 2 3. El segundo grupo consta de 4 5.I entrada: arreglo[] = [5 6 8 9] k = 5
Producción: [9 8 6 5]
Explicación: Dado que k es mayor que el tamaño de la matriz, se invierte toda la matriz.
[Acercarse ] Inversión de grupo de tamaño fijo
La idea es considerar cada submatriz de tamaño k comenzando desde el principio de la matriz e invertirla. Necesitamos manejar algunos casos especiales.
=> Si k no es un múltiplo de n, donde n es el tamaño de la matriz para el último grupo, nos quedarán menos de k elementos, necesitamos invertir todos los elementos restantes.
=> Si k = 1 la matriz debe permanecer sin cambios. Si k >= n invertimos todos los elementos presentes en la matriz.Para invertir un subarreglo, mantenga dos punteros: izquierdo y derecho. Ahora intercambie los elementos en los punteros izquierdo y derecho e incremente a la izquierda en 1 y disminuya a la derecha en 1. Repita hasta que los punteros izquierdo y derecho no se crucen.
Laboral:
C++ #include #include using namespace std ; void reverseInGroups ( vector < int >& arr int k ){ // Get the size of the array int n = arr . size (); for ( int i = 0 ; i < n ; i += k ) { int left = i ; // to handle case when k is not multiple of n int right = min ( i + k - 1 n - 1 ); // reverse the sub-array [left right] while ( left < right ) { swap ( arr [ left ++ ] arr [ right -- ]); } } } int main () { vector < int > arr = { 1 2 3 4 5 6 7 8 }; int k = 3 ; reverseInGroups ( arr k ); for ( int num : arr ) cout < < num < < ' ' ; return 0 ; }
C #include void reverseInGroups ( int arr [] int n int k ){ for ( int i = 0 ; i < n ; i += k ) { int left = i ; int right ; // to handle case when k is not multiple // of n if ( i + k -1 < n -1 ) right = i + k -1 ; else right = n -1 ; // reverse the sub-array [left right] while ( left < right ) { // swap int temp = arr [ left ]; arr [ left ] = arr [ right ]; arr [ right ] = temp ; left ++ ; right -- ; } } } int main () { int arr [] = { 1 2 3 4 5 6 7 8 }; int k = 3 ; int n = sizeof ( arr ) / sizeof ( arr [ 0 ]); reverseInGroups ( arr n k ); for ( int i = 0 ; i < n ; i ++ ) printf ( '%d ' arr [ i ]); return 0 ; }
Java class GfG { static void reverseInGroups ( int [] arr int k ){ int n = arr . length ; for ( int i = 0 ; i < n ; i += k ) { int left = i ; int right = Math . min ( i + k - 1 n - 1 ); // reverse the sub-array while ( left < right ) { int temp = arr [ left ] ; arr [ left ] = arr [ right ] ; arr [ right ] = temp ; left ++ ; right -- ; } } } public static void main ( String [] args ) { int [] arr = { 1 2 3 4 5 6 7 8 }; int k = 3 ; reverseInGroups ( arr k ); for ( int num : arr ) { System . out . print ( num + ' ' ); } } }
Python def reverseInGroups ( arr k ): i = 0 # get the size of the array n = len ( arr ) while i < n : left = i # To handle case when k is not # multiple of n right = min ( i + k - 1 n - 1 ) # reverse the sub-array [left right] while left < right : arr [ left ] arr [ right ] = arr [ right ] arr [ left ] left += 1 right -= 1 i += k if __name__ == '__main__' : arr = [ 1 2 3 4 5 6 7 8 ] k = 3 reverseInGroups ( arr k ) print ( ' ' . join ( map ( str arr )))
C# using System ; class GfG { public static void reverseInGroups ( int [] arr int k ){ int n = arr . Length ; for ( int i = 0 ; i < n ; i += k ) { int left = i ; // to handle case when k is // not multiple of n int right = Math . Min ( i + k - 1 n - 1 ); int temp ; // reverse the sub-array [left right] while ( left < right ) { temp = arr [ left ]; arr [ left ] = arr [ right ]; arr [ right ] = temp ; left += 1 ; right -= 1 ; } } } public static void Main ( string [] args ){ int [] arr = new int [] { 1 2 3 4 5 6 7 8 }; int k = 3 ; int n = arr . Length ; reverseInGroups ( arr k ); for ( int i = 0 ; i < n ; i ++ ) { Console . Write ( arr [ i ] + ' ' ); } } }
JavaScript function reverseInGroups ( arr k ) { let n = arr . length ; for ( let i = 0 ; i < n ; i += k ) { let left = i ; // to handle case when k is not // multiple of n let right = Math . min ( i + k - 1 n - 1 ); // reverse the sub-array [left right] while ( left < right ) { // Swap elements [ arr [ left ] arr [ right ]] = [ arr [ right ] arr [ left ]]; left += 1 ; right -= 1 ; } } return arr ; } // Driver Code let arr = [ 1 2 3 4 5 6 7 8 ]; let k = 3 ; let arr1 = reverseInGroups ( arr k ); console . log ( arr1 . join ( ' ' ));
Producción
3 2 1 6 5 4 8 7
Complejidad del tiempo: O(n) recorremos toda la matriz una sola vez invirtiendo elementos en grupos de tamaño k. Como no revisamos ningún elemento, el trabajo total realizado crece linealmente con el tamaño de la matriz. Entonces, si la matriz tiene n elementos, se necesitan aproximadamente n pasos.
Espacio Auxiliar: O(1) la reversión se realiza directamente dentro de la matriz original usando solo unas pocas variables adicionales.
![Las 10 ciudades más grandes de los Estados Unidos por población clasificadas [Lista actualizada en 2024]](https://techcodeview.com/img/us-gk/09/top-10-largest-cities-united-states-population-ranked.webp)
