import java.util.

Scanner;
class Main {
public static void main (String[] args) {

System.out.println("Hello World");
Scanner leer = new Scanner(System.in);
int C=0;
int A = leer.nextInt();
int B = leer.nextInt();
C = A+B;
System.out.println(C);

}
}

public class Suma3 {

public static void main(String[] args) {
int numero = 10;
int suma = calcularSuma3(numero);
System.out.println("La suma3 de los n�meros inferiores a " + numero + " es:
" + suma);
}

public static int calcularSuma3(int numero) {

int suma = 0;
for (int i = 1; i < numero; i++) {
if (i % 3 == 0) {
suma += i;
}
}
return suma;
}
}

import java.util.Scanner;

public class RestasSucesivasEspeciales {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ingrese N: ");
int N = scanner.nextInt();
System.out.print("Ingrese K: ");
int K = scanner.nextInt();

int resultado = realizarRestasSucesivasEspeciales(N, K);

System.out.println("El resultado final es: " + resultado);
}

public static int realizarRestasSucesivasEspeciales(int N, int K) {

for (int i = 0; i < K; i++) {
if (N % 10 != 0) {
N--;
} else {
N /= 10;
}
}
return N;
}
}
En este programa, se utiliza la clase Scanner para leer los valores de N y K desde
la entrada est�ndar. Luego, se llama a la funci�n realizarRestasSucesivasEspeciales
pasando los valores de N y K como argumentos.

Dentro de la funci�n realizarRestasSucesivasEspeciales, se realiza un bucle que se

ejecuta K veces. En cada iteraci�n, se verifica si el �ltimo d�gito de N es
diferente de cero. Si es as�, se le resta uno a N. De lo contrario, se divide N
entre 10. Al final del bucle, se devuelve el valor de N como resultado.

Espero que esto te sea �til. Si tienes alguna otra pregunta, no dudes en preguntar.

import java.util.Scanner;

public class CalculoPagoTrabajador {

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

System.out.print("Ingrese el salario por hora: ");

double salarioPorHora = sc.nextDouble();

System.out.print("Ingrese el n�mero de horas trabajadas en la semana: ");

int horasTrabajadas = sc.nextInt();

double pagoTotal = calcularPago(salarioPorHora, horasTrabajadas);

System.out.println("El pago total al trabajador es: $" + pagoTotal);

sc.close();
}

public static double calcularPago(double salarioPorHora, int horasTrabajadas) {

double pagoTotal;

if (horasTrabajadas <= 40) {

pagoTotal = salarioPorHora * horasTrabajadas;
} else {
int horasExtras = horasTrabajadas - 40;
pagoTotal = (salarioPorHora * 40) + (salarioPorHora * 1.5 *
horasExtras);
}

return pagoTotal;
}
}
-------------------------
public class PagoTrabajador {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

// Leer el n�mero de casos de prueba

int t = scanner.nextInt();

// Procesar cada caso de prueba

for (int i = 0; i < t; i++) {
 // Leer el n�mero de horas trabajadas y el salario por hora
int horasTrabajadas = scanner.nextInt();
int salarioPorHora = scanner.nextInt();

// Calcular el pago al trabajador

int pago = calcularPago(horasTrabajadas, salarioPorHora);

// Imprimir el resultado
System.out.println("El pago al trabajador es: " + pago);
}

scanner.close();
}

public static int calcularPago(int horasTrabajadas, int salarioPorHora) {

int horasNormales = Math.min(horasTrabajadas, 40);
int horasExtras = Math.max(horasTrabajadas - 40, 0);

// Calcular el pago por horas normales y extras

int pagoHorasNormales = horasNormales * salarioPorHora;
int pagoHorasExtras = (int) (horasExtras * salarioPorHora * 1.5); //
Incremento del 50%

// Calcular el pago total

int pagoTotal = pagoHorasNormales + pagoHorasExtras;

return pagoTotal;
}
}
----------------------------------------------
public class CalculadoraSalario {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

int t = scanner.nextInt(); // N�mero de casos de prueba

for (int i = 0; i < t; i++) {

int horasTrabajadas = scanner.nextInt();
int salarioPorHora = scanner.nextInt();

double salarioTotal = calcularSalarioTotal(horasTrabajadas,

salarioPorHora);
System.out.printf("%.2f%n", salarioTotal);
}

scanner.close();
}

public static double calcularSalarioTotal(int horasTrabajadas, int

salarioPorHora) {
int horasNormales = Math.min(horasTrabajadas, 40); // Obtener las horas
normales (hasta 40 horas)
int horasExtra = Math.max(horasTrabajadas - 40, 0); // Obtener las horas
extra (m�s de 40 horas)

double salarioNormal = horasNormales * salarioPorHora;

double salarioExtra = horasExtra * salarioPorHora * 1.5;

return salarioNormal + salarioExtra;

 }
}
------------------------------

import java.util.HashMap;
import java.util.Map;

public class MurcielagoCoder {

private static final Map<Character, Integer> conversionTable = new HashMap<>();

static {
conversionTable.put('M', 0);
conversionTable.put('U', 1);
conversionTable.put('R', 2);
conversionTable.put('C', 3);
conversionTable.put('I', 4);
conversionTable.put('E', 5);
conversionTable.put('L', 6);
conversionTable.put('A', 7);
conversionTable.put('G', 8);
conversionTable.put('O', 9);
}

public static String codificar(String texto) {

StringBuilder resultado = new StringBuilder();

for (char c : texto.toCharArray()) {

Integer valor = conversionTable.get(Character.toUpperCase(c));
if (valor != null) {
resultado.append(valor);
} else {
resultado.append(c);
}
}

return resultado.toString();
}

public static void main(String[] args) {

String textoOriginal = "BOLIVIA";
String textoCodificado = codificar(textoOriginal);
System.out.println("Texto original: " + textoOriginal);
System.out.println("Texto codificado: " + textoCodificado);
}
}

import java.util.HashMap;
import java.util.Map;

public class DecodificadorMurcielago {

public static void main(String[] args) {
String textoCodificado = "B964V47";
String textoDecodificado = decodificarTexto(textoCodificado);
System.out.println("Texto decodificado: " + textoDecodificado);
}

public static String decodificarTexto(String textoCodificado) {

Map<Character, Character> tablaConversion = crearTablaConversion();
StringBuilder sb = new StringBuilder();
 for (char c : textoCodificado.toCharArray()) {
if (Character.isDigit(c)) {
char letra = tablaConversion.get(c);
sb.append(letra);
} else {
sb.append(c);
}
}

return sb.toString();
}

public static Map<Character, Character> crearTablaConversion() {

Map<Character, Character> tablaConversion = new HashMap<>();
tablaConversion.put('0', 'M');
tablaConversion.put('1', 'U');
tablaConversion.put('2', 'R');
tablaConversion.put('3', 'C');
tablaConversion.put('4', 'I');
tablaConversion.put('5', 'E');
tablaConversion.put('6', 'L');
tablaConversion.put('7', 'A');
tablaConversion.put('8', 'G');
tablaConversion.put('9', 'O');
return tablaConversion;
}
}

---------------
import java.util.HashMap;
import java.util.Map;

public class CesarCipher {

public static void main(String[] args) {
String palabraOriginal = "ANA";
String palabraCifrada = cifrar(palabraOriginal);
System.out.println("Palabra original: " + palabraOriginal);
System.out.println("Palabra cifrada: " + palabraCifrada);
}

public static String cifrar(String palabra) {

// Obtener el desplazamiento
int desplazamiento = obtenerDesplazamiento(palabra);

// Crear la tabla de conversi�n

Map<Character, Character> tablaConversion =
crearTablaConversion(desplazamiento);

// Cifrar la palabra
StringBuilder palabraCifrada = new StringBuilder();
for (int i = 0; i < palabra.length(); i++) {
char caracter = palabra.charAt(i);
if (tablaConversion.containsKey(caracter)) {
palabraCifrada.append(tablaConversion.get(caracter));
} else {
palabraCifrada.append(caracter);
}
}
 return palabraCifrada.toString();
}

public static int obtenerDesplazamiento(String palabra) {

Map<Character, Integer> contador = new HashMap<>();

// Contar la frecuencia de cada letra en la palabra

for (int i = 0; i < palabra.length(); i++) {
char caracter = palabra.charAt(i);
contador.put(caracter, contador.getOrDefault(caracter, 0) + 1);
}

// Obtener el m�ximo valor de frecuencia

int maxFrecuencia = 0;
for (int frecuencia : contador.values()) {
if (frecuencia > maxFrecuencia) {
maxFrecuencia = frecuencia;
}
}

// El desplazamiento es el m�ximo valor de frecuencia

return maxFrecuencia;
}

public static Map<Character, Character> crearTablaConversion(int

desplazamiento) {
Map<Character, Character> tablaConversion = new HashMap<>();
String alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int longitudAlfabeto = alfabeto.length();

// Crear la tabla de conversi�n

for (int i = 0; i < longitudAlfabeto; i++) {
char caracterOriginal = alfabeto.charAt(i);
int posicionOriginal = i + 1;
int posicionCifrada = (posicionOriginal + desplazamiento - 1) %
longitudAlfabeto;
char caracterCifrado = alfabeto.charAt(posicionCifrada);
tablaConversion.put(caracterOriginal, caracterCifrado);
}

return tablaConversion;
}
}
--------------
import java.util.Scanner;

public class CifradoCesar {

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

System.out.print("Ingrese el texto cifrado: ");

String textoCifrado = scanner.nextLine();

char factorDesplazamiento = textoCifrado.charAt(0);

int desplazamiento = factorDesplazamiento - 'A';

String textoDescifrado = descifrarTexto(textoCifrado.substring(1),

desplazamiento);
 System.out.println("Texto original: " + textoDescifrado);
}

public static String descifrarTexto(String textoCifrado, int desplazamiento) {

StringBuilder textoDescifrado = new StringBuilder();

for (int i = 0; i < textoCifrado.length(); i++) {

char caracterCifrado = textoCifrado.charAt(i);
char caracterDescifrado = (char) (caracterCifrado - desplazamiento);

if (caracterDescifrado < 'A') {

caracterDescifrado = (char) ('Z' - ('A' - caracterDescifrado - 1));
}

textoDescifrado.append(caracterDescifrado);
}

return textoDescifrado.toString();
}
}
----------------
import java.util.Scanner;

public class DeterminarGanador {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("Ingrese el n�mero de juegos: ");

int numJuegos = scanner.nextInt();

int ganadosPorDereck = 0;
int ganadosPorMarco = 0;

for (int i = 1; i <= numJuegos; i++) {

System.out.print("Ingrese el ganador del juego " + i + "
(Dereck/Marco/Empate): ");
String ganador = scanner.next();

if (ganador.equalsIgnoreCase("Dereck")) {
ganadosPorDereck++;
} else if (ganador.equalsIgnoreCase("Marco")) {
ganadosPorMarco++;
}
}

System.out.println("Resultados:");
System.out.println("Dereck gan� " + ganadosPorDereck + " juegos.");
System.out.println("Marco gan� " + ganadosPorMarco + " juegos.");

if (ganadosPorDereck > ganadosPorMarco) {

System.out.println("�Dereck gan� m�s juegos!");
} else if (ganadosPorMarco > ganadosPorDereck) {
System.out.println("�Marco gan� m�s juegos!");
} else {
System.out.println("Hubo un empate en juegos.");
}
}
}
-------------------
import java.util.Scanner;

public class ContarPiedras {

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

System.out.print("Ingrese la secuencia de colores de las piedras (por

ejemplo, RRVVBRR): ");
String secuencia = scanner.nextLine();

int contador = 1;
for (int i = 1; i < secuencia.length(); i++) {
if (secuencia.charAt(i) == secuencia.charAt(i - 1)) {
contador++;
} else {
System.out.println("Color: " + secuencia.charAt(i - 1) + " -
Cantidad: " + contador);
contador = 1;
}
}

// Imprimir el �ltimo color y su cantidad

System.out.println("Color: " + secuencia.charAt(secuencia.length() - 1) + "
- Cantidad: " + contador);
}
}

import java.util.Scanner;

public class ContarPiedras {

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

System.out.print("Ingrese la secuencia de colores de las piedras (por

ejemplo, RRVVBRR): ");
String secuencia = scanner.nextLine();

int contador = 1;
for (int i = 1; i < secuencia.length(); i++) {
if (secuencia.charAt(i) == secuencia.charAt(i - 1)) {
contador++;
} else {
System.out.println("Color: " + secuencia.charAt(i - 1) + " -
Cantidad: " + contador);
contador = 1;
}
}

// Imprimir el �ltimo color y su cantidad

System.out.println("Color: " + secuencia.charAt(secuencia.length() - 1) + "
- Cantidad: " + contador);
}
}
---------
import java.util.Scanner;

public class ContadorPiedras {

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

// Leer el n�mero de piedras

int N = scanner.nextInt();

// Leer la cadena de colores de las piedras

String colors = scanner.next();

// Inicializar variables
int count = 1; // Inicialmente, hay al menos una piedra contigua del mismo
color
int maxCount = 1; // Contador m�ximo

// Iterar a trav�s de las piedras a partir de la segunda

for (int i = 1; i < N; i++) {
// Si el color de la piedra actual es igual al color de la piedra
anterior, incrementar el contador
if (colors.charAt(i) == colors.charAt(i - 1)) {
count++;
} else {
// Si el color es diferente, reiniciar el contador
count = 1;
}

// Actualizar el contador m�ximo si el contador actual es mayor

if (count > maxCount) {
maxCount = count;
}
}

// Imprimir el resultado
System.out.println(maxCount);
}
}
-------------

import java.util.Scanner;

public class ContarPiedras {

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

// Leer el n�mero de piedras

int n = scanner.nextInt();
scanner.nextLine(); // Consumir el salto de l�nea

// Leer la cadena de colores

String colors = scanner.nextLine();

// Inicializar variables
int count = 1; // Contador inicializado en 1, ya que siempre hay al menos
una piedra

// Recorrer la cadena de colores y contar las piedras del mismo color que
est�n juntas
for (int i = 1; i < n; i++) {
if (colors.charAt(i) == colors.charAt(i - 1)) {
count++;
}
 }

// Imprimir el resultado
System.out.println(count);
}
}
-----------------------
import java.util.Scanner;

public class PiedrasEnLaMesa {

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

// Leer el n�mero de piedras

int N = sc.nextInt();
sc.nextLine(); // Consumir el salto de l�nea

// Leer la cadena de colores

String colors = sc.nextLine();

// Inicializar variables
int count = 1; // Contador para contar las piedras del mismo color que
est�n juntas
int maxCount = 1; // Variable para almacenar la cantidad m�xima de piedras
contadas

// Recorrer la cadena de colores

for (int i = 1; i < N; i++) {
// Verificar si la piedra actual tiene el mismo color que la anterior
if (colors.charAt(i) == colors.charAt(i - 1)) {
count++; // Incrementar el contador
} else {
// El color ha cambiado, reiniciar el contador
count = 1;
}

// Actualizar la cantidad m�xima de piedras contadas

if (count > maxCount) {
maxCount = count;
}
}

// Imprimir la cantidad m�xima de piedras contadas

System.out.println(maxCount);
}
}
--------------
package javaapplication60;
import java.util.Scanner;
public class JavaApplication60 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
sc.nextLine(); // Leer el salto de l�nea despu�s del entero N
String colors = sc.nextLine();

int count = 0;
for (int i = 0; i < N - 1; i++) {
 if (colors.charAt(i) == colors.charAt(i + 1)) {
count++;
}
}

System.out.println(count);
}
}
---------

import java.util.Scanner;

public class LaCaseraDeLasPaltas {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int k = sc.nextInt(); // Costo de la primera palta
int n = sc.nextInt(); // Cantidad de bolivianos del cliente
int w = sc.nextInt(); // Cantidad de paltas que quiere

int totalCost = 0;

for (int i = 1; i <= w; i++) {

totalCost += i * k;
}

int borrowedMoney = Math.max(totalCost - n, 0);

System.out.println(borrowedMoney);
}
}