Java és un llenguatge de programació popular conegut per la seva versatilitat i potència. Des de la manipulació de cadenes fins a la manipulació de matrius, Java ofereix una àmplia gamma d'eines per a abordar una varietat de desafiaments de programació. En aquest blog, explorarem algunes solucions a problemes comuns a Java, des d'invertir una cadena fins a trobar el segon major número en una matriu d'enters.
cta:domains
Invertir una cadena és una tasca comuna en la programació, i en Java, es pot aconseguir fàcilment utilitzant la classe StringBuilder o mitjançant un enfocament recursivo. Aquí, presentem una solució utilitzant StringBuilder:
public class ReverseString {
public static String reverse(String str) {
return new StringBuilder(str).reverse().toString();
}
public static void main(String[] args) {
String example = "Hola Mundo";
System.out.println("Cadena original: " + example);
System.out.println("Cadena invertida: " + reverse(example));
}
}
Resultat de l'exemple:
Cadena original: Hola Món
Cadena invertida: nòM aloH
Crear una piràmide de números és un exercici interessant que implica bucles niats. Aquí hi ha un exemple de com fer-lo a Java:
public class NumberPyramid {
public static void main(String[] args) {
int rows = 5;
for (int i = 1; i <= rows; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " ");
}
System.out.println();
}
}
}
Resultat del'exemple:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
A vegades, és necessari eliminar els espais en blanc d'una cadena per a realitzar operacions més netes. Aquí està com fer-ho a Java:
public class RemoveSpaces {
public static String remove(String str) {
return str.replaceAll("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\s", "");
}
public static void main(String[] args) {
String example = "Hola Mundo Feliz";
System.out.println("Cadena original: " + example);
System.out.println("Cadena sin espacios: " + remove(example));
}
}
Resultat de l'exemple:
Cadena original: Hola Món Feliç
Cadena sin espacios: HolaMónFeliç
cta:hosting
Per a trobar caràcters duplicats en una cadena a Java, podem usar un HashMap per a realitzar un seguiment de la freqüència de cada caràcter. Aquí està la implementació:
import java.util.HashMap;
import java.util.Map;
public class DuplicateCharacters {
public static void findDuplicates(String str) {
Map<Character, Integer> charCountMap = new HashMap<>();
for (char c : str.toCharArray()) {
if (charCountMap.containsKey(c)) {
charCountMap.put(c, charCountMap.get(c) + 1);
} else {
charCountMap.put(c, 1);
}
}
System.out.println("Caracteres duplicados en la cadena '" + str + "': ");
for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
if (entry.getValue() > 1) {
System.out.println(entry.getKey() + " - " + entry.getValue() + " veces");
}
}
}
public static void main(String[] args) {
String example = "programación en Java";
findDuplicates(example);
}
}
Resultat de l'exemple:
Caràcters duplicats en la cadena 'programació en Java':
- 2 vegades
a - 4 vegades
n - 2 vegades
r - 2 vegades
Per a verificar la igualtat de dues matrius a Java, necessitem comparar element per element. Aquí hi ha un exemple de com fer-lo:
public class MatrixEquality {
public static boolean areEqual(int[][] matrix1, int[][] matrix2) {
if (matrix1.length != matrix2.length || matrix1[0].length != matrix2[0].length) {
return false;
}
for (int i = 0; i < matrix1.length; i++) {
for (int j = 0; j < matrix1[0].length; j++) {
if (matrix1[i][j] != matrix2[i][j]) {
return false;
}
}
}
return true;
}
public static void main(String[] args) {
int[][] matrix1 = {{1, 2}, {3, 5}};
int[][] matrix2 = {{1, 2}, {3, 4}};
System.out.println("¿Las matrices son iguales? " + areEqual(matrix1, matrix2));
}
}
Resultat de l'exemple:
Les matrius són iguals? false
Un anagrama és una paraula o frase formada reorganitzant les lletres d'una altra. Aquí hi ha una implementació a Java per a verificar si dues cadenes són anagrames:
import java.util.Arrays;
public class Anagram {
public static boolean areAnagrams(String str1, String str2) {
if (str1.length() != str2.length()) {
return false;
}
char[] chars1 = str1.toCharArray();
char[] chars2 = str2.toCharArray();
Arrays.sort(chars1);
Arrays.sort(chars2);
return Arrays.equals(chars1, chars2);
}
public static void main(String[] args) {
String word1 = "listen";
String word2 = "silent";
System.out.println("¿Son anagramas? " + areAnagrams(word1, word2));
}
}
Resultat de l'exemple:
¿Són anagrames? true
Un número d'Armstrong (també conegut com a número narcisista) és un número que és igual a la suma dels seus propis dígits elevats a la potència del nombre de dígits. Aquí està la implementació a Java per a verificar si un número és un número d'Armstrong:
public class ArmstrongNumber {
public static boolean isArmstrong(int number) {
int originalNumber = number;
int digits = String.valueOf(number).length();
int sum = 0;
while (number != 0) {
int digit = number % 10;
sum += Math.pow(digit, digits);
number /= 10;
}
return sum == originalNumber;
}
public static void main(String[] args) {
int num = 153;
System.out.println(num + " es un número de Armstrong: " + isArmstrong(num));
}
}
Resultat de l'exemple:
153 és un número d'Armstrong: true
Per a trobar elements duplicats en un array a Java, podem utilitzar un HashSet per a mantenir un registre dels elements únics i comparar-los amb els elements del array. Aquí està la implementació:
import java.util.HashSet;
import java.util.Set;
public class DuplicateElements {
public static void findDuplicates(int[] array) {
Set<Integer> uniqueElements = new HashSet<>();
Set<Integer> duplicateElements = new HashSet<>();
for (int num : array) {
if (!uniqueElements.add(num)) {
duplicateElements.add(num);
}
}
System.out.println("Elementos duplicados en el array:");
System.out.println(duplicateElements);
}
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 2, 5, 6, 7, 3};
findDuplicates(numbers);
}
}
Resultat d'Exemple::
Elements duplicats en el array:
[2, 3]
Per a trobar la suma de tots els dígits d'un número a Java, podem usar un bucle while per a iterar sobre cada dígit i sumar-los. Aquí està la implementació:
public class SumOfDigits {
public static int sum(int number) {
int sum = 0;
while (number != 0) {
sum += number % 10;
number /= 10;
}
return sum;
}
public static void main(String[] args) {
int num = 12345;
System.out.println("Suma de los dígitos de " + num + ": " + sum(num));
}
}
Resultat de l'exemple:
Suma dels dígits de 12345: 15
Per a trobar el segon major número en una matriu d'enters a Java, podem seguir un enfocament on inicialment trobem el major número i després l'eliminem per a trobar el següent major. Aquí està la implementació:
public class SecondLargest {
public static int findSecondLargest(int[][] matrix) {
int max = Integer.MIN_VALUE;
int secondMax = Integer.MIN_VALUE;
for (int[] row : matrix) {
for (int num : row) {
if (num > max) {
secondMax = max;
max = num;
} else if (num > secondMax && num < max) {
secondMax = num;
}
}
}
return secondMax;
}
public static void main(String[] args) {
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
System.out.println("El segundo mayor número en la matriz es: " + findSecondLargest(matrix));
}
}
Resultat de l'exemple:
El segon major número en la matriu és: 8
En conclusió, Java ofereix una àmplia gamma d'eines i funcionalitats per a abordar una varietat de desafiaments de programació, des de manipulació de cadenes fins a manipulació de matrius i més enllà. Amb les solucions proporcionades aquí, pots resoldre problemes comuns de manera eficient i efectiva a Java. Explora, experimenta i gaudeix programant amb Java!
cta:cloud_so
