Search code snippets, questions, articles...

java code snippets

hamming
ñ
traducción a piglatin
import java.util.Scanner;
import java.util.ArrayList;

public class App {

    public static String vocales(String str) {

        str = str + " ";
        String otra = "";
        String traducida = "";
        String nuevafrase = "";
        for (int i = 0; i < str.length() - 1; i++) {
            otra += str.charAt(i);
            if (str.charAt(i) == ' ') {
                traducida += otra;
                otra = "";
                continue;
            } // if espacio
            if (str.charAt(i + 1) == ' ') {
                if (otra.charAt(0) == 'a' || otra.charAt(0) == 'e' || otra.charAt(0) == 'i' || otra.charAt(0) == 'o'
                        || otra.charAt(0) == 'u' || otra.charAt(0) == 'h') {

                    traducida += otra;
                    traducida += "ay";
                } // if es vocal
                else {
                    traducida += otra;
                } // if no es vocal

                otra = "";
            } // if la siguiente es un espacio

            nuevafrase += traducida;
            traducida = "";

        } // for i

        return nuevafrase;
    }
    // metodo vocales

    public static String consonantes(String str) {

        String otra = "";
        String traducida = "";
        String nuevafrase = "";
        String consonantes = "";
        int cont = 0;
        for (int i = 0; i < str.length() - 1; i++) {
            otra += str.charAt(i);
            if (str.charAt(i + 1) == ' ') {
                for (int k = 0; k < otra.length(); k++) {
                    if (otra.charAt(k) == ' ') {
                        traducida += otra.charAt(k);
                        continue;
                    } // if es espacio
                    if (cont > 0) {
                        traducida += otra.charAt(k);
                    } // if ha encontrado alguna vocal
                    else {
                        if (otra.charAt(k) == 'a' || otra.charAt(k) == 'e' || otra.charAt(k) == 'i'
                                || otra.charAt(k) == 'o'
                                || otra.charAt(k) == 'u') {
                            traducida += otra.charAt(k);
                            cont++;
                        } // if es vocal
                        else {
                            consonantes += otra.charAt(k);
                        } // if no es vocal
                    } // else aun no hay vocales
                } // for k

                otra = "";
                traducida += consonantes;
                consonantes = "";
                cont = 0;

            } // for i

            nuevafrase += traducida;
            traducida = "";

        }

        return nuevafrase;

    }
    // metodo consonantes

    public static String traducir(String str) {
        String consonantes = consonantes(str);
        String traducida = vocales(consonantes);
        return traducida;
    }
    // metodo para traducir

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        System.out.print("Introduzca el texto a ser traducido: ");
        String str = read.nextLine() + " ";

        System.out.println("Texto traducido: " + traducir(str));

    } // main

}
Pedir números hasta que se meta uno negativo. Calcular media.
import java.util.Scanner;
import java.util.ArrayList;

public class App {

    public static double media(ArrayList<Integer> nums) {
        double suma = 0;
        for (int i = 0; i < nums.size(); i++) {
            suma = suma + nums.get(i);
        } // for i
        double media = suma / nums.size();
        return media;
    } // media del arraylist

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        int num = 1;
        ArrayList<Integer> nums = new ArrayList<Integer>();

        while (num >= 0) {

            System.out.print("Introduce el número: ");
            num = read.nextInt(); // read num
            if (num < 0) {
                break;
            } // if es menor que cero

            nums.add(num);

        } // while no es cero
        System.out.println("La media de los números es " + media(nums));

    } // main

}
pedir números hasta que metan un 0. Mostrar suma de todos.
import java.util.Scanner;
import java.util.ArrayList;

public class App {

    public static int suma(ArrayList<Integer> nums) {
        int suma = 0;
        for (int i = 0; i < nums.size(); i++) {
            suma = suma + nums.get(i);
        } // for i
        return suma;
    } // suma del arraylist

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        int num = 1;
        ArrayList<Integer> nums = new ArrayList<Integer>();

        while (num != 0) {

            System.out.print("Introduce el número: ");
            num = read.nextInt(); // read num
            nums.add(num);

        } // while no es cero

        System.out.println("La suma de todos los números es: " + suma(nums));

    } // main

}
Hacer un juego de adivinar un N. El juego va diciendo "mayor" "menor" hasta que se acierta.
import java.util.Random;
import java.util.Scanner;

public class App {

    public static void resultados(int guess, int num) {

        if (guess < num) {
            System.out.println("El número es mayor.");
        } // if es menor
        if (guess > num) {
            System.out.println("El número es menor.");
        } // if es mayor
        if (guess == num) {
            System.out.println("Felicidades! Has acertado. El número era " + num);
        } // if es num

    } // metodo resultados

    public static void main(String[] args) {

        Scanner read = new Scanner(System.in);
        Random rnd = new Random();
        int num = rnd.nextInt(1000);
        int guess = 0;

        while (guess != num) {

            System.out.print("Introduce el número: ");
            guess = read.nextInt();

            resultados(guess, num);

        } // while

    } // main

}
metodo que le metes numero hasta que metas uno negativo y al final te dice cuantos has metido
import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        int num = 1;
        int count = 0;
        while (num >= 0) {
            System.out.print("Introduce el número: ");
            num = read.nextInt(); // read num
            if (num < 0) {
                System.out.println("Fin del programa.");
                break;
            } // if es menor que cero

            count++;

        } // while es mayor que cero

        System.out.println("Se han leído " + count + " numeros.");

    } // main

}
metodo que te dice si un numero es par
import java.util.Scanner;

public class App {

    public static void par(int num) {
        if (num % 2 == 0) {
            System.out.println(num + " es par.");
        } // if
        else {
            System.out.println(num + " no es par.");
        } // else
    } // metodo mayor o menor que cero

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        int num = 1;
        while (num != 0) {
            System.out.print("Introduce el número: ");
            num = read.nextInt(); // read num
            if (num == 0) {
                System.out.println("Fin del programa.");
                break;
            } // if es cero
            par(num);
        } // while no es cerof

    } // main

}
metodo que te dice si un número es mayor o menor que cero
import java.util.Scanner;

public class App {

    public static void mayor_que_cero(int num) {
        if (num < 0) {
            System.out.println(num + " es menor que 0.");
        } // if
        else {
            System.out.println(num + " es mayor que 0.");
        } // else
    } // metodo mayor o menor que cero

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        int num = 1;
        while (num != 0) {
            System.out.print("Introduce el número: ");
            num = read.nextInt(); // read dimensiones
            if (num == 0) {
                System.out.println("Fin del programa.");
                break;
            } // if es cero
            mayor_que_cero(num);
        } // while no es cerof

    } // main

}
dibujar un cuadrado de nxn dimensiones
import java.util.Scanner;

public class App {

    public static void imprimir_cuadrado(int dimensiones) {

        for (int vertical = 0; vertical < dimensiones; vertical++) {
            System.out.println("");
            for (int horizontal = 0; horizontal < dimensiones; horizontal++) {
                System.out.print("* ");
            } // for horizontal

        } // for vertical

    } // metodo para imprimir el cuadrado

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);

        System.out.print("Introduce las dimensiones del cuadrado: ");
        int dimensiones = read.nextInt(); // read dimensiones

        imprimir_cuadrado(dimensiones);

    } // main

}
tabla de multiplicar de numeros
public class App {

    public static void printear_resultado(int a, int b, int resultado) {

        System.out.println(a + " x " + b + " = " + resultado);

    } // metodo para printear el resultado

    public static void tabla(int[] nums) {

        for (int i = 0; i < nums.length; i++) {
            System.out.println("Tabla de multiplicar del " + nums[i]);
            System.out.println("");
            for (int numero = 0; numero <= 10; numero++) {
                int resultado = nums[i] * numero;
                printear_resultado(nums[i], numero, resultado);
            } // for numero
        } // for i

    } // metodo para la tabla

    public static void main(String[] args) {

        int[] nums = { 1, 4, 6 };

        tabla(nums);

    } // main

}
calcular GCD de dos números recursivo
public class App {

    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        } // if 
        else {
            return gcd(b, a % b);
        } // else
    } // metodo gcd

    public static void main(String[] args) {

        int a = 12;
        int b = 4;

        System.out.println("El maximo comun multiplo de " + a + " y " + b + " es " + gcd(a, b));

    } // main

}
contador que va de 0 a 5 factorizado
import java.util.Arrays;
public class App {

    public static boolean todo10(int[] digito) {

        final int DUR = 10;

        if (digito[0] < DUR && digito[1] < DUR && digito[2] < DUR && digito[3] < DUR && digito[4] < DUR) {
            return true;
        } else {
            return false;
        }

    }

    public static boolean es10(int digito) {

        if (digito == 10){
            return true;
        }
        else{
            return false;
        }

    }

    public static void print_digitos(int[] digito) {

        System.out.println(Arrays.toString(digito));

    }

    public static void main(String[] args) {

        final int TAM = 5;
        int[] digito = new int[TAM];
        System.out.println(digito[1]);

        while (todo10(digito)) {

            print_digitos(digito);
            digito[4]++;
            for (int i = digito.length - 1; i > 0; i--) {
                if(es10(digito[i])){
                    digito[i-1]++;
                    digito[i]=0;
                }

            }

        }

    }
}
metodo recursivo para sacar factorial de n
public class App {
    public static int factorial(int n) {
        if (n == 0) {
            return 1;
        } // if n es 0 devuelve 1
        else {
            return n * (factorial(n - 1)); // devuelve n multiplicado por el factorial de n-1 hasta llegar a 0
        } // else
    } // metodo para sacar el factorial de n

    public static void main(String[] args) {

        System.out.println(factorial(5));

    } // main
}
calcular GCD de todos los números que quieras
public class App {
    public static int gcd(int[] a) {
        int c = 0; // variable de maximo comun divisor
        for (int i = 1; i <= a[0]; i++) {
            int x = 0;
            for (int k = 0; k < a.length; k++) {
                if (a[k] % i == 0) {
                    x++;

                    if (x == a.length) {
                        c = i;
                    } // if todos los números tienen a ese número como divisor se le asigna ese número
                      // a c

                } // if es divisor se suma
            } // for k
        } // for i
        return c;
    } // metodo para sacar el maximo comun divisor de x numeros

    public static void main(String[] args) {

        int[] a = { 30, 60, 120, 700 }; // numeros a los que se le saca el maximo comun divisor

        System.out.println(gcd(a));

    } // main
}
metodo que de la vuelta a una string
public class App {
    public static void main(String[] args) {

        String str = "hola hola hola";
        String rts = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            rts += str.charAt(i); // se añade el caracter a la nueva string
        } // for que recorre todos los caracteres de la string

        System.out.println(rts);
    } // main
}
método que diga si todos los caracteres de una string son vocalees (REGEX) / que cuente cuantas vocales hay
public class App {

    public static int vocales(String str){
        int i = 0;

        for(int x = 0; x<str.length();x++){
            if(str.charAt(x) == 'a' || str.charAt(x) == 'e' || str.charAt(x) == 'i' || str.charAt(x) == 'o' || str.charAt(x) == 'u'){
                i++;
            } // if coincide con las vocales se suma
        } // for x 
        return i; // numero de vocales

    } // método que cuenta las vocales


    public static void main(String[] args) {

        String str = "aabaa";

        if (!str.matches("[aeiou]*")){
            System.out.println("No todas son vocales y tiene "+vocales(str)+" vocales.");
        } // if son solo vocales
        else{
            System.out.println("Son todas vocales y tiene "+vocales(str)+" vocales.");
        } // if no son solo vocales

    } // main
}
método que calcule el área de un triángulo dados los lados
import java.util.Scanner;

public class App {

    public static double area(double base, double altura) {

        double area = base * altura / 2; // fórmula del área

        return area;
    } // clase para calcular el área

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);

        System.out.print("Introduce la base: ");
        String bas = read.nextLine(); // se introduce la base

        System.out.print("Introduce la altura: ");
        String altur = read.nextLine(); // se introduce la altura

        Double base = Double.valueOf(bas);
        Double altura = Double.valueOf(altur);
        // se transforman las strings en int

        System.out.println("");
        System.out.println(area(base, altura));

    }
}
método que diga si todos los dígitos de un número son pares
public class App {

    public static boolean par (int n){
        String str = Integer.toString(n); // convierte el int a string
        int dur = str.length(); // se crea una int con la duracion de la string
        int[] nums = new int[str.length()]; // se crea un array con la duración de la string

        for (int i = 0; i < dur; i++) {
            nums[i] = str.charAt(i) - '0';
            if (nums[i] % 2 != 0) {
                return false;
            } // if par

        } // for
        return true;
    } // clase para saber si todos las cifras de un número son pares
    public static void main(String[] args) {

        if (par(22224)) {
            System.out.println("Todos los números son pares.");
        } // if par
        else {
            System.out.println("No todos los números son pares.");
        } // if no es par

    }
}
método que calcule cuantas veces tiene un númeor a otro como factor (descomposicion tipo 81 = 3^4 = 9^2)
public class App {
    public static void main(String[] args) {

        int n = 100;

        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
                if (Math.pow(i , j) == n){
                    System.out.println(n+" = "+i+"^"+j);
                }
            }
        }

    }
}
método que le metes N númeors y te dice si son consecutivos o no
public class App {

    public static boolean consecutivos(int[] numeros) {

        for (int i = 0; i < numeros.length - 1; i++) {
            if (numeros[i] + 1 != numeros[i + 1]) {
                return false;
            } // if no son consecutivos
        } // for

        return true;
    } // metodo para saber si son consecutivos

    public static void main(String[] args) {

        int[] n = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // números

        if (consecutivos(n)) {
            System.out.println("Los números son consecutivos.");
        } // if son consecutivos
        else {
            System.out.println("Los números no son consecutivos.");
        } // if no son consecutivos

    }
}
Método que calcule todos los dígitos "X" que aparecen en un núemro dado
public class App {
    public static void main(String[] args) {

        int n = 124123321;
        String str = Integer.toString(n);// convierte el int a string
        int x = 0;
        int nu = 3; // número a contar en la string
        int dur = str.length(); // int con la duración de la string
        int[] nums = new int[str.length()]; // se crea una int con la duracion de la string

        for (int i = 0; i < dur; i++) {
            nums[i] = str.charAt(i) - '0';
            if (nums[i] == nu) {
                x++;
            }
        }

        System.out.println("El número " + nu + " aparece " + x + " veces en " + n);

    }
}
Todos los numeros primos gemelos hasta N numero
public class App {

    public static boolean primo(int N) {
        for (int i = 2; i < N; i++) {
            if (N % i == 0) {
                return false;
            } // if el resto da cero se suma

        } // forint y;
        return true;
    }
    
    // clase que saca si un número es primo o no

    public static void primos_gemelos(int N) {
        for (int i = 2; i < N; i++) {
            if (primo(i) && primo((i+2))) {
                System.out.println(i + " y " + (i+2) + " son números primos gemelos.");
            } // if

        } // for recorre los números
    }
    public static void main(String[] args) throws Exception {

        primos_gemelos(100);

    }
}
Java Contraseña con requisitos e input
import java.util.Scanner;

public class App {
    public static void main(String[] args) {

        Scanner read = new Scanner(System.in); // Crea el objeto scanner system in, es decir, un objeto que lee la input.
        System.out.print("Introduce el nombre de usuario: ");
        String user = read.nextLine(); // Lee la input de la siguiente linea.
        System.out.print("Introduce la contraseña: ");
        String pass = read.nextLine();

        boolean p = true;

        if (pass.length() < 10) {
            p = false;
        }
        if (!pass.matches("[a-zA-Z0-9]*")) {
            p = false;
        } // Si la contraseña no tiene los requisitos, la boolean es false.

        if (p) {
            System.out.println("Tu cuenta se ha creado correctamente. El nombre de usuario es " + user
                    + " y la contraseña es " + pass); // Muestra por pantalla el resultado correcto
        } else {
            System.out.println("La password no cumple con los requisitos mínimos.");
        }

    }
}
Recursive Sum of Digits
static int digitsSum(int n) {
        if (n < 0) {
            return -1;
        }
        if (n < 10) {
            return n;
        } else {
            return n % 10 + digitsSum(n / 10);
        }
    }
Java program to split a String using a seperator
String str = "Java~programming~is~cool";
String[] result = str.split("~");
String p1 = result[0];
String p2 = result[1];
String p3 = result[2];
String p4 = result[3];

System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
String to int conversion using Java
String mystr = "100";
int intVal = Integer.parseInt(mystr);
      
System.out.println(intVal);
helloj
azdd
Java 8 Stream
List<String> myList =
    Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList
    .stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);
Pascal Matrix
public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> pascalMatris = new ArrayList<>();
        for (int numRow=0; numRow<numRows; numRow++){
            pascalMatris.add(generatePascalRow(getTheLastMatrisRow(pascalMatris)));
        }
        return  pascalMatris;
    }

    private List<Integer> getTheLastMatrisRow(List<List<Integer>> pascalMatris) {
        return pascalMatris.isEmpty()? new ArrayList<>(): pascalMatris.get(pascalMatris.size()-1);
    }

    private List<Integer> generatePascalRow(List<Integer> theLastPascalRow) {
        List<Integer> pascalRow= new ArrayList<>();
        // adds the lead element '1' in the row
        pascalRow.add(1);
        pascalRow.addAll(calculateTheLastPacalRow(theLastPascalRow));
        if (theLastPascalRow.size()>0) {
            // adds the last element '1' in the row
            pascalRow.add(1);
        }
        return pascalRow;
    }

    private List<Integer> calculateTheLastPacalRow(List<Integer> theLastPascalRow) {
        List<Integer> pascalRowCalculated = new ArrayList<>();
        for (int i=0; i<theLastPascalRow.size()-1; i++){
            pascalRowCalculated.add(theLastPascalRow.get(i)+ theLastPascalRow.get(i+1));
        }
        return pascalRowCalculated;
    }
spiralOrder
/**
     * Input:
     [
     [ 1, 2, 3 ],
     [ 4, 5, 6 ],
     [ 7, 8, 9 ]
     ]

     Output: [1,2,3,6,9,8,7,4,5]


     * @param matrix
     * @return
     */
    public List<Integer> spiralOrder(int[][] matrix) {
        String spiralDirection="RIGHT";
        int startRow=0;
        int startColumn=0;
        int k=0;
        if (matrix==null || matrix.length==0)
            return new ArrayList<>();
        int row = matrix.length;
        int lastRow= row-1;
        int column = matrix[0].length;
        int lastColumn = column-1;
        List<Integer> spiralOrder= new ArrayList<>();

        while (k<row*column) {
            switch (spiralDirection){
                case "RIGHT":
                    for (int i = startRow, j = startColumn; j <= lastColumn; j++) {
                        spiralOrder.add(matrix[i][j]);
                        k++;
                    }
                    startRow++;
                    spiralDirection = "DOWN";
                    break;

                case "DOWN":
                    for (int i = startRow, j = lastColumn; i <= lastRow; i++) {
                        spiralOrder.add(matrix[i][j]);
                        k++;
                    }
                    lastColumn--;
                    spiralDirection = "LEFT";
                    break;

                case "LEFT":
                    for (int i = lastRow, j = lastColumn; j >= startColumn; j--) {
                        spiralOrder.add(matrix[i][j]);
                        k++;
                    }
                    lastRow--;
                    spiralDirection = "UP";
                    break;

                case "UP":
                    for (int i = lastRow, j = startColumn; i >= startRow; i--) {
                        spiralOrder.add(matrix[i][j]);
                        k++;
                    }
                    startColumn++;
                    spiralDirection = "RIGHT";
                    break;

                    default:
                        break;
            }
        }
        return spiralOrder;
    }
Index of maximum in an array
class Solution {
    public int dominantIndex(int[] nums) {
        int maxIndex = 0;
        for (int i = 0; i < nums.length; ++i) {
            if (nums[i] > nums[maxIndex])
                maxIndex = i;
        }
        return maxIndex;
    }
}
Pivot index
class Solution {
    public int pivotIndex(int[] nums) {
        int sum = 0, leftsum = 0;
        for (int x: nums) sum += x;
        for (int i = 0; i < nums.length; ++i) {
            if (leftsum == sum - leftsum - nums[i]) return i;
            leftsum += nums[i];
        }
        return -1;
    }
}