Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Hola.
Estas lineas que has escrito así:

writeln('tra[i].sum/tra:4:2');
Al ponerlo entre comillas simples, le estas diciendo a Pascal que muestre ese texto tal cual.
Es decir, eso de ahí es un literal, una cadena string, no es ningún tipo de operación aritmética porque está entre las comillas simples.

Supongo que lo pusiste entre esas comillas para evitar otros errores de compilación que tuviste. Y claro, ahora te compila, pero obviamente no va a hacer lo que esperabas.

Por eso además te salen esos warnings de "variables declaradas pero no usadas", porque los nombres de las variables como sum los pones dentro del literal, por lo tanto, en realidad no estás haciendo referencia a esas variables, así que no se están usando.

Otra cosa, para calcular las medias de los cases 7, 8 y 9.... no necesitas distintas variables para acumular, te basta con una.
Lo que si necesitarás, es otra variable para contar cuantos trabajadores has acumulado su media. O sea, un contador integer que se vaya incrementando de 1 en 1 cada vez que acumules un salario.

Por ejemplo, para la nomina menor, los que son menos de 1500.
Recorres trabajadores y preguntas si su salario es menor que 1500.
En caso afirmativo, acumulas su salario, y además, tienes que aumentar el contador en 1

Terminado el bucle, divides lo acumulado por el contador, y así obtendrás la media.

Otra cosa que no me queda clara es que para acumular, a unos les coges el atributo .sal_anual y a otros .sal_anu

Como no tengo el enunciado del ejercicio, no se si es por algún motivo. A mi me parece más lógico coger el salario tal cual..

Otra cosa que habría que cambiar, los bucles para calcular la media no deberían ir desde 1 hasta capacidad
Porque capacidad es una constante de valor 1000. Si usas este valor para el bucle ocurren dos cosas no deseadas:
1- El bucle se va a repetir siempre 1000 veces, aunque tengas solo 100 empleados, o 50,.. ¡¡o solo 1!!
No es demasiado importante realmente, pero son ciclos de computación inútiles, y no es una buena práctica de programación.

2- Esto si es más importante. En el case 8, buscamos salarios menores de 1500.
Como el bucle va desde 1 hasta 1000 (el valor de capacidad), las posiciones del array donde NO HAY trabajadores registrados, es decir, que en teoría están vacías... en realidad sí que hay datos. Hay variables tipoPersona creados automáticamente por el compilador con todos sus atributos con valor 0.
Entonces, esos tipoPersona que en realidad no ha registrado el usuario, el sistema los va a contar como empleados con salario < 1500 y va a provocar un error al calcular la media.
Ya que aunque registres un único trabajador y con sueldo < 1500, el programa va a considerar que en realidad hay 1000 trabajadores que cumplen esa condición . Cuando en realidad 999 trabajadores son "falsos" tipoPersona.

Para evitar estos problemas, los bucles tienen que ir hasta el valor de la variable cantidad, en lugar de capacidad.
Así el bucle solo recorre posiciones donde realmente hay trabajadores registrados.

Mira, he reescrito el código cambiando estas cosas que he dicho.
He cambiado las variables declaradas.
Y he cambiado los cases 7, 8 y 9 para que calcular la media según he explicado.
Y hacemos uso de la variable cantidad, en lugar de capacidad, para recorrer el array.
Además he hecho que cantidad decremente cuando borramos a un trabajador.

Si pruebas este código que pongo abajo, verás que compila y funciona.
Repasa línea a línea, comprueba que entiendes todo y comprueba que cumple con lo que se supone que debe hacer el programa según el enunciado.
No he revisado todo el código a fondo. El resto parece funcionar bien, aunque hay algo que me resulta un poco extraño.
Al añadir un trabajador, en la línea 119 se inicia un bucle que recorre a todos los trabajadores y altera sus atributos según el valor de su salario.
¿Por qué alterar TODOS los trabajadores cada vez que añadimos UN trabajador?

Revisa esa parte, a ver si realmente tiene sentido o no.

Un saludo.


program ACME;
 
type
 
    tipoPersona = record
 
        nombre: string;
 
        salario: real;
 
sal_anu: real;
 
sal_anual: real;
 
sal_men: real;
 
sal_mensual: real;
 
utili, utilidades, vaca, vacaciones: real;
 
bono: real;
 
cedula :integer;
 
    end;
 
const
 
capacidad = 1000;
 
var
 
tra: array[1..capacidad] of tipoPersona;
 
    cantidad: integer;
 
    opcion: integer;
 
    i: integer;
 
    textoBuscar: string;
 
    encontrado: boolean;
 
bono: real;
 
cesta: integer;
 
seBorro:boolean;
 
acumMedia :real;
 
contMedia: integer;
 
 
 
 
 
{Cuerpo del programa principal}
 
begin
 
cantidad := 0;
 
    repeat
 
        WriteLn('***BIENVENIDO A ACME***');
 
        WriteLn;
 
        WriteLn('1- Agregar Trabajador');
 
        WriteLn('2- Todos los trabajadores');
 
        WriteLn('3- Buscar a un trabajador');
 
        WriteLn('4- Reporte 1');
 
        WriteLn('5- Reporte 2');
 
WriteLn('6- Eliminar trabajador');
 
WriteLn('7- Promedio Nomina Mayor');
 
WriteLn('8- Promedio Nomina Menor');
 
WriteLn('9- Promedio General');
 
        WriteLn('0- Salir');
 
        Write('Escoja una opcion: ');
 
        ReadLn(opcion);
 
        WriteLn;
 
 
 
        case opcion of
 
1: { Agregar trabajador }
 
if (cantidad < capacidad) then
 
                begin
 
inc(cantidad);
 
                    WriteLn('Introduciendo al trabajador ', cantidad);
 
                    Write('Introduzca el nombre: ');
 
                    ReadLn(tra[cantidad].nombre);
 
                    Write('Introduzca Salario: ');
 
                    ReadLn(tra[cantidad].salario);
 
for i:=1 to cantidad do
 
begin
 
if tra[i].salario > 1500 then begin
 
with tra[i] do begin
 
bono:=tra[i].salario*0.1;
 
utilidades:=tra[i].salario*2;
 
vacaciones:=tra[i].salario;
 
sal_mensual:=tra[i].salario+tra[i].bono;
 
sal_anual:=tra[i].sal_mensual*12+tra[i].vacaciones+tra[i].utilidades;
 
end;
 
end;
 
if tra[i].salario <= 1500 then
 
begin
 
cesta:=20;
 
with tra[i] do begin
 
vaca:=salario;
 
utili:=salario*4;
 
sal_men:=salario+cesta;
 
sal_anu:=sal_men*12+tra[i].vaca;
 
end;
 
end;
 
end;
 
end;
 
            2: begin {Todos los trabajadores}
 
if cantidad = 0 then
 
WriteLn('No hay datos')
 
else
 
for i := 1 to cantidad do
 
WriteLn(i, ' ', tra[i].nombre, tra[i].salario:4:2);
 
WriteLn;
 
end;
 
            3:  {Buscar a un trabajador}
 
                begin
 
Write('Escriba el nombre del trabajador ');
 
ReadLn( textoBuscar );
 
encontrado := false;
 
for i := 1 to cantidad do
 
if pos (textoBuscar, tra[i].nombre) > 0 then
 
begin
 
encontrado := true;
 
WriteLn( i,' - Nombre: ', tra[i].nombre,', Salario: ', tra[i].salario:4:2);
 
end;
 
if not encontrado then
 
WriteLn('No se ha encontrado.');
 
WriteLn;
 
                end;
 
            4:  {Reporte 1 }
 
for i := 1 to cantidad do
 
                begin
 
if tra[i].salario > 1500 then
 
begin
 
writeln('Nombre del trabajador: ', tra[i].nombre);
 
WriteLn('Salario: ', tra[i].salario:4:2);
 
WriteLn('Bono: ', tra[i].bono:4:2);
 
WriteLn('Total: ', tra[i].sal_mensual:4:2);
 
end;
 
                end;
 
            5: { Reporte 2}
 
for i := 1 to cantidad do
 
                begin
 
if tra[i].salario <= 1500 then
 
begin
 
writeln('Nombre del trabajador: ', tra[i].nombre);
 
WriteLn('Salario: ', tra[i].salario:4:2);
 
WriteLn('Cestaticket: ', cesta);
 
WriteLn('Total: ', tra[i].sal_men:4:2);
 
end;
 
                end;
 
            6: {Borra un trabajador}
 
begin
 
write('Nombre a buscar: ');
 
readln(textoBuscar);
 
seBorro := false;
 
for i := 1 to cantidad do begin
 
{ReadLn(tra[cantidad].nombre);}
 
if (textoBuscar = tra[i].nombre) then
 
begin
 
seBorro := true;
dec(cantidad);
 
with tra[i] do begin
 
nombre:='';
 
salario:=0;
 
sal_anu:=0.0;
 
sal_anual:=0.0;
 
sal_men:=0.0;
 
sal_mensual:=0.0;
 
utili:=0;
 
utilidades:=0;
 
vaca:=0;
 
vacaciones:=0;
 
bono:=0;
 
end;
 
end;
 
end;
end;
 
            7: {Promedio Nomina Mayor}
 
begin

acumMedia:= 0;

contMedia:= 0;
 
for i := 1 to cantidad do
 
if tra[i].salario > 1500 then
 
begin
 
acumMedia := acumMedia + tra[i].salario;

inc(contMedia);
 
end;

if (contMedia = 0) then

writeln('No hay empleados con salario mayor de 1500')

else
 
writeln('Promedio Nomina Mayor es: ', acumMedia/contMedia:4:2);
end;
 
            8: {Promedio Nomina Menor}
 
begin

acumMedia:= 0;

contMedia:= 0;
 
for i := 1 to cantidad do
 
if tra[i].salario <= 1500 then
 
begin
 
acumMedia := acumMedia + tra[i].salario;

inc(contMedia);
 
end;

if (contMedia = 0) then

writeln('No hay empleados con salario menor o igual a 1500')

else

writeln('Promedio Nomina Menor es: ', acumMedia/contMedia:4:2);
end;
 
            9: {Promedio general}
 
begin

if (cantidad = 0) then

writeln('No hay trabajadores registrados')

else

begin

acumMedia:= 0;

contMedia:= 0;

for i := 1 to cantidad do

begin

acumMedia := acumMedia + tra[i].salario;

inc(contMedia);

end;

writeln('Promedio general es: ', acumMedia/contMedia:4:2);

end;
end;
 
           0: { salir}
 
begin
 
WriteLn;
 
WriteLn('Saliendo...');
 
WriteLn;
 
                end;
 
             else
 
                begin
 
WriteLn;
 
WriteLn('Opción incorrecta!');
 
WriteLn;
 
                end;
 
        end;  { Fin de "case" }
 
    until opcion = 0;
 
end.

Todo parece correcto, nada que objetar.           

Bienvenido Daniel.

Siente libre de compartir en el foro dudas, conocimientos, comentarios... estás en tu casa 

Un saludo.

Me alegra haber colaborado. 
Muy interesante lo que has montado.
De programación se algo, pero de electrónica nada de nada.

Un saludo.

Hola.
A ver si sirve lo que he hecho.
En el menú Fichero he añadido otra opción de configuración. Al clickarle se abre un formulario con 9 campos de texto para indicar las lineas que se quieren ir mostrando en el archivo de texto.
Estos campos están limitados a 8 caracteres ya que mencionaste que ese era un límite impuesto.

Además hay un selector de tiempo, en milisegundos, para escoger el lapso de tiempo que ha de transcurrir entre cambios en el fichero.
Si queremos 3 segundos, pues lo establecemos a 3000.
Si preferimos 2 segundos y medio, pues a 2500.
Etc..

Estos valores de configuración se guardan en un archivo llamado config.cfg. Así que el programa ejecutable JAR ha de ir acompañado siempre de los archivos config.cfg y ruta.cfg

Adjunto nuevo zip con el ejecutable y los archivos .java para quien quiera ver el código. Por prisas y falta de tiempo, el código está sin comentar y no todo lo bien estructurado que debiera. Pero bueno, si alguien tiene preguntas solo tiene que hacerlas.


Espero que te sea útil, muy interesante lo que muestras en tu vídeo Youtube. Un saludo.

Hola. He probado el programa y sí funciona. Sin embargo, he hecho unos ligeros cambios para que sea más legible al ojo humano y ahorrar también unas líneas.

Lo que he cambiado es que, para comparar cadenas String, no es necesario que uses variables a las que les asignas los String y luego comparas. No es necesario, puedes comparar directamente las cadenas String, no hace falta meterlas en variables.

Y para declarar la variable user, donde vas leyendo lo que teclea el usuario, no es necesario comenzar asignándole un valor mediante nextLine() si en ese momento no le estas preguntando nada el usuario. Lo declaras como

 String user;

 y ya está, nada más.

Por lo demás, insisto, el programa parece funcionar bien.

Sí sería bueno plantear las opciones al usuario de otra forma más sencilla para él.

Es decir, para que tu programa funcione, por ejemplo el usuario ha de ser capaz de escribir correctamente opciones como:

"Disco duro sólido"

No puede equivocarse en la D mayúscula, no puede equivocarse en los espacios en blanco y no puede fallar al ponerle tilde a la palabra sólido.

Eso es esperar demasiada eficiencia por parte del usuario je je..., es mejor facilitarle las cosas.

Por ejemplo, puedes pedirle que teclee números en lugar de palabras enteras.

En lugar de esperar que teclee bien estos términos y confiar que tus comparaciones tengan éxito:

System.out.println("indica tipo de disco duro: Disco duro mecánico(0€) o Disco duro sólido/ (300€)");
user= pc.nextLine();
if (user.equals("Disco duro mecánico")){
System.out.println("Ha escogido Disco duro mecánico");
}
if (user.equals("Disco duro sólido")){
System.out.println("Ha escogido Disco duro sólido");
precio+=300;
}
Se lo facilitas pidiendo opciones numeradas:

System.out.println("indica tipo de disco duro: (1)Disco duro mecánico(0€) o (2)Disco duro sólido/ (300€)");
System.out.print("Elija entre valores 1 y 2: ");
user= pc.nextLine();
if (user.equals("1")){
System.out.println("Ha escogido Disco duro mecánico");
}
if (user.equals("2")){
System.out.println("Ha escogido Disco duro sólido");
precio+=300;
}
Así reduces las posibilidades de que el usuario se equivoque. Aún así, no se está contemplando que ocurre si el usuario elige opciones no existentes.

Pero esto ya lo irás aprendiendo más adelante, cuando aprendas a usar bucles y la instrucción switch te serás más fácil pedirle opciones al usuario, comprobar si ha escogido opciones válidas y como reaccionar si no lo ha hecho.

Te dejo, el código tal cuál yo lo tengo tras esos ligeros cambios estéticos que mencioné al principio.

import java.util.Scanner;

public class JavaApplication4 {
public static void main(String[] args) {
Scanner pc= new Scanner(System.in);
String user;
int precio=0;

System.out.println("Indica tipo de ordenador: Sobremesa(500€) o Portatil(600€)");
user= pc.nextLine();

if (user.equals("Sobremesa")) {
System.out.println("Ha escogido ordenador de sobremesa");
precio+=500;
}

if (user.equals("Portatil")){
System.out.println("Ha escogido ordenador portatil");
precio+=600;
}

System.out.println("indica tipo de procesador: i3(0€) / i5(200€) / i7(300€)");
user= pc.nextLine();
if (user.equals("i3")){
System.out.println("Ha escogido procesador i3");
}
if (user.equals("i5")){
System.out.println("Ha escogido procesador i5");
precio+=200;
}
if (user.equals("i7")){
System.out.println("Ha escogido procesador i7");
precio+=300;
}

System.out.println("indica tipo de disco duro: Disco duro mecánico(0€) o Disco duro sólido/ (300€)");
user= pc.nextLine();
if (user.equals("Disco duro mecánico")){
System.out.println("Ha escogido Disco duro mecánico");
}
if (user.equals("Disco duro sólido")){
System.out.println("Ha escogido Disco duro sólido");
precio+=300;
}

System.out.println("indica capacidad del disco duro: 250gb(0€) / 500gb (200€) / 750gb (300€)");
user= pc.nextLine();
if (user.equals("250gb")){
System.out.println("Ha escogido usted disco duro de 250gb");
}
if (user.equals("500gb")){
System.out.println("Ha escogido usted disco duro de 500gb");
precio+=200;
}
if (user.equals("750gb")){
System.out.println("Ha escogido usted disco duro de 750gb");
precio+=300;
}

System.out.println("indica tipo memoria ram 8gb(0€): 16gb(200€)");
user= pc.nextLine();
if (user.equals("8gb")){
System.out.println("Ha escogido 8gb");
}
if (user.equals("16gb")){
System.out.println("Ha escogido 16gb");
precio+=200;
}

System.out.println("El precio final es "+precio+" EUROS");
pc.close();
}
}
Y este resultado me da en pantalla:

Indica tipo de ordenador: Sobremesa(500€) o Portatil(600€)
Sobremesa
Ha escogido ordenador de sobremesa
indica tipo de procesador: i3(0€) / i5(200€) / i7(300€)
i5
Ha escogido procesador i5
indica tipo de disco duro: Disco duro mecánico(0€) o Disco duro sólido/ (300€)
Disco duro sólido
Ha escogido Disco duro sólido
indica capacidad del disco duro: 250gb(0€) / 500gb (200€) / 750gb (300€)
500gb
Ha escogido usted disco duro de 500gb
indica tipo memoria ram 8gb(0€): 16(200€)
16gb
Ha escogido 16gb
El precio final es 1400 EUROS

No tengo ninguna experiencia con este tema, me sobrepasa por completo.

Investiga sobre la Java Communications API, debería permitirte comunicarte con la balanza por puerto serie.

Otra cosa distinta es "entender" lo que la balanza comunica, eso como decía el compañero, quizás sea cosa del fabricante quien explique cómo entenderse con la balanza.

Primero, solo puedes tener una etiqueta body.

Segundo, el atributo bgcolor solo se pone una vez en la apertura de la etiqueta.

Tercero, el valor para el atributo, el símbolo de la almohadilla --> # ... SOLO se usa para dar un valor hexadecimal, por ejemplo #ff0000
Si usas los nombre predefinidos: red, blue, green.... se pone el nombre tal cuál, sin almohadilla.

<!DOCTYPE html>
<html>
<head>
<title> Aguante la tuk </title>
</head>
<body bgcolor="red">
  la tuk es buena
</body>
</html>

Hola, creo que no lo estás enfocando bien.

El enunciado dice que ha de "retornar" la posición de la palabra en la frase.

Yo ahí interpreto dos cosas:
1) En realidad lo que hay que hace es un método/función que retorne un valor int.
2) Ese valor int, no es la posición del carácter de la palabra que buscamos, sino la posición de la palabra.

Supón esta frase:
"Esto es una frase para hacer pruebas"
Y esta palabra:
"para"

Esa palabra ocupa la posición 5 dentro de la frase:
1ª es "Esto"
2ª es "es"
3ª es "una"
4ª es "frase"
5ª es "para"
6ª es "hacer"
7ª es "pruebas"

Así que nuestro método/función ha de recibir la frase y la palabra. Y ha de retornar un int con la posición, en este caso, sería el valor 5.

Repito, eso es lo que yo creo entender.
Así que  tendríamos que escribir un programa que tenga y utilice dicha función.

El quid de la cuestión es como resolverá nuestra función esto que nos piden.
Bien, hay una forma muy sencilla si conocemos bien los métodos de la clase String

Uno de sus muchos métodos, es el método split(), quien permite dividir un String en varios String, según el valor que le pasemos entre paréntesis.
En nuestro caso, si le pasamos un espacio en blanco --> split(" "), lo que hará será separar String que contiene la frase, en varios String conteniendo cada uno una palabra de dicha frase.
Estos String nos los devuelve juntos y ordenados en un array de String.
Así que tan solo tendríamos que recorrer el array, comparar cada String con la palabra que buscamos y si alguno coincide, devolvemos su posición + 1.

Si no encontramos ninguna coincidencia, pues devolvemos el valor 0.

public class BuscaPalabra {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);
String insertaPalabra;
String insertaFrase;

System.out.println("Dime una frase");
insertaFrase = teclado.nextLine();

System.out.println("Dime una palabra");
insertaPalabra = teclado.nextLine();

System.out.println("Esa palabra está en la posición: " + posicionPalabra(insertaFrase, insertaPalabra));
teclado.close();
}

public static int posicionPalabra(String frase, String palabra) {

//Con split obtenemos un array con todas las palabras separadas
String[] palabras = frase.split(" ");

//Recorremos array, si alguna palabra coincide, esa será la posicion
for (int i = 0; i < palabras.length; i++) {
if (palabras[i].equals(palabra))
return i+1;
}

//si el bucle no ha hecho un return, es que no ha encontrado la palabra
return 0;
}

}
Esto es resolverlo apoyándonos en un método perteneciente a la API de Java.
Es correcto usarlos, pues para eso están.

Sin embargo, cuando estamos aprendiendo probablemente se espera que resolvemos los ejercicios por nuestros propios medios.

Se puede hacer sin usar split(). Es más complejo y engorroso.
Habría que recorrer la frase carácter a carácter, buscar uno que coincida con el primer carácter de nuestra palabra.
Cada vez que encontremos uno, tendremos que comprobar el resto de caracteres a ver si coinciden.
Si coinciden todos, hemos encontrado la palabra. Si no, pues hay que seguir buscando.
Pero, ¿y como sabemos en que número de palabra nos encontramos?
Podemos hacerlo contando los espacios en blanco que podamos ir encontrando.

Es decir, si durante la búsqueda no hemos encontrado ningún espacio en blanco --> (espaciosContados = 0) podemos suponer que estamos en la primera palabra.
Si espacios Contados = 1, seguramente es que estamos ya en la segunda palabra, etc...

Te dejo el mismo programa, pero esta vez con las dos funciones y mostrando en pantalla el resultado de ambas, a ver si coinciden.

public class BuscaPalabra {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);
String insertaPalabra;
String insertaFrase;

System.out.println("Dime una frase");
insertaFrase = teclado.nextLine();

System.out.println("Dime una palabra");
insertaPalabra = teclado.nextLine();

System.out.println("Solucion usando split()");
System.out.println("Esa palabra está en la posición: " + posicionPalabra(insertaFrase, insertaPalabra));
System.out.println("----");
System.out.println("Solucion buscando caracteres mediante bucles");
System.out.println("Esa palabra está en la posición: " + posicionPalabra2(insertaFrase, insertaPalabra));
teclado.close();
}

public static int posicionPalabra(String frase, String palabra) {

//Con split obtenemos un array con todas las palabras separadas
String[] palabras = frase.split(" ");

//Recorremos array, si alguna palabra coincide, esa será la posicion
for (int i = 0; i < palabras.length; i++) {
if (palabras[i].equals(palabra))
return i+1;
}

//si el bucle no ha hecho un return, es que no ha encontrado la palabra
return 0;
}

public static int posicionPalabra2(String frase, String palabra) {
//contando espacios en blanco en la frase, podemos suponer en que palabra nos encontramos
int espaciosContados = 0;

/*
* Recorremos cada caracter.
* Si es un espacio en blanco, lo contamos.
* Si es un caracter que coincide con el primer caracter de
* nuestra palabra, habrá que comprobar el resto de caracteres
* a ver si coinciden todos.
*/
for (int i = 0; i < frase.length(); i++) {
if (frase.charAt(i) == ' ') //Es un espacio en blanco
espaciosContados++;
else {
/*
* No es un espacio en blanco.
* Comprobamos si este caracter coincide con
* el primer caracter de nuestra palabra
*/
if (frase.charAt(i) == palabra.charAt(0)) {
//¡¡Coincide!!. Recorremos el resto de caracteres a ver si tenemos la palabra completa.
boolean coincide = true;
for (int j = 1; j < palabra.length(); j++) {
if (frase.charAt(i+j) != palabra.charAt(j))
coincide = false; //¡Oh! Un caracter no ha coincidido, no es nuestra palabra
}
//Si coincide == true, nuestra búsqueda ha finalizado
if (coincide)
return espaciosContados + 1;
//Si coincide == false, no hacemos nada, dejamos que el bucle siga buscando.
}
}
}

//Bucle no ha hecho return, porque no ha encontrado la palabra
return 0;
}

}
Esto nos da este resultado en pantalla:

Dime una frase
Esta frase es para hacer pruebas
Dime una palabra
hacer
Solucion usando split()
Esa palabra está en la posición: 5
----
Solucion buscando caracteres mediante bucles
Esa palabra está en la posición: 5

Parece que todo es correcto.
Sin embargo, nuestra segunda función es propensa a errores.
Fíjate lo que ocurre si usamos otra frase distinta:

Dime una frase
El paraguas se usa para la lluvia
Dime una palabra
para
Solucion usando split()
Esa palabra está en la posición: 5
----
Solucion buscando caracteres mediante bucles
Esa palabra está en la posición: 2

¡¡Oh no!!
La segunda función se equivoca, piensa que la palabra "para" está donde está la palabra "paraguas". Menudo error.

Este error se puede corregir, tan solo hay que pedirle a la función que haga una comprobación extra antes de dar por buena la palabra encontrada.
¿Se te ocurre cuál puede ser?

Intenta entender todo el ejercicio e intenta averiguar como corregir este fallo. Si no lo consigues, ya te lo diré.
Un saludo

Te propongo esta solución.

Hay comentarios explicando.
Para rellenar la matriz uso un while y un for anidado. Es lo más lioso del programa, de hecho, no me ha salido a la primera.
Yo empiezo a rellenar por abajo, desde 1 hasta n. Bueno, en realidad va desde 0 hasta n-1, pero le sumo 1 antes de guardar el valor en la matriz.

Tras rellenar la última columna, n se decrementa y así repetimos el proceso en la penúltima columna, solo que ahora va de 1 hasta n-1.
Luego de 1 hasta n-2....

Así hasta llegar a la primera fila, donde solo guardaremos un 1.

El resto de posiciones se quedan con valor 0. Al imprimir en pantalla la matriz, evitamos imprimir los valores 0, así da efecto de escalera.

public class Escalera {

public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
//Pedimos cantidad de valores
int n;
System.out.print("¿Cuántos valores?: ");
n = teclado.nextInt();

//Creamos matriz
int[][] escalera = new int[n][n];

/*
* Llenamos matriz. Podemos empezar desde abajo
* con un bucle hasta n.
* Cada iteracion n se reduce hasta llegar a 0
* para así recorrer todas las filas desde n-1 hasta 0.
* Para recorrer las columnas usaremos otro varaible
* de un bucle for, que habrá que aumentar en 1 el valor
* de n en cada iteración para que recorra correctamente
* todas las columnas.
*/

while (n >= 0) {
n--;

for (int j = 0; j < n+1; j++)
escalera[n][j] = j+1;
}

/*
* Mostramos la matriz.
* Evitaremos imprimir los valores 0
* que no han recibido valores.
* Esto dará sensación de escalera.
*/


for (int j = 0; j < escalera.length; j++) {
for (int z = 0; z < escalera[0].length; z++)
if (escalera[j][z] != 0)
System.out.print(escalera[j][z]);

System.out.println();
}

teclado.close();

}

}
En pantalla tenemos este resultado:
¿Cuántos valores?: 5
1
12
123
1234
12345