mover números de un arreglo n lugares

Problema

Un arreglo de números enteros de tamaño n tiene que recorrer la posición de los numeros K veces.

Solución:

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n;// Reducir k si es mayor que n
        
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }
    
    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
}

Explicación

Esta solución utiliza la técnica de inversión en tres partes. Es eficiente porque trabaja directamente sobre el arreglo original sin necesidad de crear uno nuevo.

Complejidad

• Tiempo: O(n)
• Espacio: O(1)

Artículo con fines educativos y de práctica personal.

Palindromo en java - formación de palindromos en subcadenas

Problema

el problema consiste en particionar la cadena en k partes y modificar el menor número posible de letras para que cada parte cumpla la propiedad de semipalíndromo.

Enfoque de la solución

Este es un problema de nivel Hard que combina dos técnicas importantes:

1. Precomputación del costo mínimo para convertir cada substring posible en semi-palindrome.
2. Dynamic Programming para encontrar la mejor forma de dividir el string en k partes.

Solución en Java

import java.util.*;

class Solution {
    public int minimumChanges(String s, int k) {
        int n = s.length();
        final int INF = 1_000_000_000;
        
        // g[i][j] = combios minimos para hacer un s[i..j-1] semi-palindrome
        int[][] g = new int[n + 1][n + 1];
        for (int i = 0; i <= n; i++) {
            Arrays.fill(g[i], INF);
        }
        
        // Precompute cost for every substring
        for (int i = 1; i <= n; i++) {           // start (1-based)
            for (int j = i; j <= n; j++) {       // end
                int len = j - i + 1;
                if (len == 1) continue; // longitud 1 no puede ser semi-palindrome
                
                for (int d = 1; d < len; d++) {
                    if (len % d != 0) continue;
                    
                    int changes = 0;
                    // For de este divisior d, checa cada grupo
                    for (int start = 0; start < d; start++) {
                        // Chaeca el grupo inicial 'start' con el paso d
                        int left = 0;
                        int right = (len / d) - 1;
                        while (left < right) {
                            char c1 = s.charAt(i - 1 + left * d + start);
                            char c2 = s.charAt(i - 1 + right * d + start);
                            if (c1 != c2) {
                                changes++;
                            }
                            left++;
                            right--;
                        }
                    }
                    g[i][j] = Math.min(g[i][j], changes);
                }
            }
        }
        
        // DP: dp[i][j] = consto minimo particionado primero i caracteres dentro de j partes
        int[][] dp = new int[n + 1][k + 1];
        for (int i = 0; i <= n; i++) {
            Arrays.fill(dp[i], INF);
        }
        dp[0][0] = 0;
        
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= Math.min(i, k); j++) {
                for (int prev = 0; prev < i; prev++) {
                    if (dp[prev][j - 1] != INF && g[prev + 1][i] != INF) {
                        dp[i][j] = Math.min(dp[i][j], dp[prev][j - 1] + g[prev + 1][i]);
                    }
                }
            }
        }
        
        return dp[n][k];
    }
}

Conceptos clave aprendidos

• Dynamic Programming de partición
• Precomputación de costos en substrings
• Divisores y patrones repetitivos en strings
• Optimización de soluciones complejas

Dificultad

Este tipo de problemas ayuda a fortalecer el razonamiento lógico y la capacidad de combinar múltiples técnicas algorítmicas.

Combinación de dos arreglos ya ordenado en uno solo.

Problema

El problema es combinar dos arrays que ya están ordenados en uno solo, sin utilizar memoria adicional. El primer array tiene espacio suficiente para contener ambos.

Solución en Java

Esta es una de las soluciones que llegan a pedir en las entrevistas técnicas:

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1;
        int j = n - 1;
        int k = m + n - 1;
        
        while (j >= 0) {
            if (i >= 0 && nums1[i] > nums2[j]) {
                nums1[k] = nums1[i];
                i--;
            } else {
                nums1[k] = nums2[j];
                j--;
            }
            k--;
        }
    }
}

Explicación

La clave está en recorrer los arrays **desde el final**. De esta forma evitamos tener que desplazar elementos y logramos una solución muy eficiente.

Complejidad

• Tiempo: O(m + n)
• Espacio: O(1)

Conceptos aprendidos

Two Pointers, manipulación eficiente de arrays y resolución in-place.

Hola mundo en C-shrap

Hola mundo en C#.

Versión del lenguaje:

.net C# 10

Las primeras lineas de código que aprendes a hacer en .Net C#, no encontre mucha diferencia entre los lenguajes java y c# pero aquí les comparto mi experiencia.

using System; public class Program { public static void Main() { Console.Write("Hola mundo!!"); } }

Conectar MySql con Java

Conectar con MySql desde JAVA 8.

Ejemplo con:

• Java 8
• MySql 8.0.36
• Driver JDBC - controlador - 

las librerias que se ocupan en esta entrada son las siguientes:

• java.sql.DriverManager
• java.sql.*
• java.util.logging.Level
• java.util.logging.Logger

La dirección para conectarse a la DB puede ser tanto en local como en LAN lo cual en este debe de ser la dirección IP de la computadora en donde se aloje la DB.

Los datos después de la dirección ip son el esquema de la DB con la que se va a trabajar, el usuario junto con su password el cual nos permitira realizar las consultas correspondientes, para el ejemplo de esta prublicación solo es para permitirnos conectar a la DB.

public class Think_Java_ConnectionDB {     public static void main(String[] args) { Connection conn = null; //Declaramos la variable. try{ Class.forName("com.mysql.cj.jdbc.Driver"); //Declaramos la clase del controlador. conn = DriverManager.getConnection("jdbc:mysql://localhost:puerto/esquema","usuario","password"); if(conn != null){ System.out.println("****Conexión existosa****"); } conn.close();//Cerramos conexión }catch(ClassNotFoundException cnfe){ //Excepción cuando no se encuentra la clase del controlador. Logger.getLogger(Think_Java_Cap1.class.getName()).log(Level.SEVERE,null, cnfe); }catch(SQLException sqles){ //Excepción de error en SQL Logger.getLogger(Think_Java_Cap1.class.getName()).log(Level.SEVERE,null, sqles); }catch(Exception ex){ //Excepción general. System.err.println(ex.getCause()); }finally{ //Lo colocamos para que se ejecute al final de cada excepción o cuando se termine de ejecutar el bloque. try{ if(conn != null) conn.close(); }catch(SQLException sqlex){ System.err.println(sqlex.getErrorCode()); } } }

El manejo de las excepciones los estaremos practicando con calma y tiempo.

Permitir conectarse a MySQL en Red LAN

Buen día. Esta vez les mostrare como permitir conectarse a una base de datos de MySQL WorkBench en la red LAN. Lo que vamos a necesitar es:

• MySQL 8.0.36 - Es la versión mas reciente al momento que se esta haciendo esta publicación -

la podemos descargar en el sitio oficial de MySQL MySQL Download una vez que se instale y se tenga creada la base de datos.

Se conecta con el usuario deseado, para esta muestra se coloca en root.

Conectar con usuario raíz de la DB

Una vez conectado buscamos el navegador que se encuentra en la parte izquierda de la pantalla y seleccionamos Usuarios y privilegios - Users and Privileges - 

Navegador de administración

Lo que mostrara el listado de usuarios creados y sus privilegios de cada uno, se selecciona al usuario al que se le va a cambiar el limite de conexión por default se encuentra en localhost entonces se cambiara a una propiedad de %.

Detalles del usuario seleccionado.

En la opción de limit to hosts matching se cambia el localhost por el % lo cual esto permitirá conectarse desde otra computadora a la base de datos a la que este asignado el usuario.

Hola Mundo en Java

Hola mundo.

Versión del lenguaje:

Java 8

Las primeras lineas de código que aprendes a hacer en JAVA.

public class Think_Java_Cap1 {     public static void main(String[] args) {         // TODO code application logic here         System.out.println("Hola mundo");     } }