48. Programación en Java || Arreglos || Ejercicio - Desplazar una posición en un arreglo
Vložit
- čas přidán 27. 04. 2017
- Puedes apuntarte al curso completo en la siguiente plataforma:
Hotmart: go.hotmart.com/W79402623G?dp=1
En este vídeo vamos a resolver el siguiente ejercicio:
Ejercicio 9: Crear un programa que lea por teclado una tabla de 10 números enteros y la desplace una posición hacia abajo: el primero pasa a ser el segundo, el segundo pasa a ser el tercero y así sucesivamente. El último pasa a ser el primero.
Visita mi sitio web para más cursos:
programacionats.zenler.com
Sigueme por las redes sociales:
Facebook ProgramacionATS: goo.gl/sqmEE1
Twiter: goo.gl/WE4oaP
Hotmail: alejandro.acb@hotmail.com
Facebook personal: goo.gl/xL9qLl
instagram: @alejandroats
Cuenta paypal para donaciones: migueltaboadas@hotmail.com - Věda a technologie
No te desanimes amigo, si aveces sientes que no estas cogiedo logica, sigue practicando, asi se aprende. "Publico"
de verdad che? intento resolver esos ejercicios pero se me complica un poco y le hago a mano para ver si le entiendo mejor la lógica de esos
A mí me tocó ver varios días el tema de arreglos, porque no lo estaba cogiendo y de nada sirve, engañarse y avanzar si entender nada..
jeje es cierto, me costo mis horas pero al final lo comprendi. con un poco de ayuda de cha gpt pregunandole mis dudas y analisis en un bloc de notas lo entendi
Algún tip para poder entender la lógica de Java
Desde mi experiencia aprendiendo, recomiendo empezar con diagramas de flujo, así vez gráficamente la lógica de la programación, hay un curso buenísimo de la Geekepedia de Ernesto, así se llama el canal, que te enseña con un lenguaje de diagramas de flujo llamado Raptor, a mi me ayudó bastante para entender la lógica de la programación, lo mejor de todo es que te enseña desde cero.
Muy buen vídeo tío, podrías dejar el código en la descripción del vídeo, así puedo ir paso a paso mientras te oigo explicándolo, sigue así!!!!!
NUNCA HUBIESE IMAGINADO QUE IBA A PODER RESOLVER EL EJERCICIO EN 5 MIN!!!
SEGURO VOY POR EL CURSO COMPLETO, LUEGO!!
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int arreglo[] = new int[10];
int aux,desplaza;
System.out.println("Llene el arreglo");
for (int i = 0; i < 10; i++) {
System.out.print("Ingrese un numero: ");
arreglo[i] = entrada.nextInt();
}
aux = arreglo[9];
System.out.println("
Ingrese posiciones a dezplazar");
desplaza = entrada.nextInt();
for (int i = desplaza; i > 0; i--) {
for (int j = 8; j >= 0; j--) {
arreglo[j+1] = arreglo[j];
}
arreglo[0] = aux;
aux = arreglo[9];
}
System.out.println("
El arreglo es: ");
for (int i:arreglo) {
System.out.print(i+" ");
}
}
Nah pues que loco, gracias por compartir tu solución, yo la verdad me había atorado aqui en este ejercicio Xd, pensaba en un buen de cosas y soluciones, ya me había "atorado" aqui jaja
Pero tu lo hiciste sencillo y funcional como debe ser 👍
Brutal tu respuesta, tan simple como repetir la cantidad de posiciones el mismo proceso. Lo que si no comprendí es porqué en el primer bucle le metes "i--" a mi me funcionó "i++".. porque al final es lo mismo pero bueno, me hizo ruido y me hiciste pensar jajaja.
*EXPLICACIÓN EJERCICIO 10*
No soy de comentar pero en este caso lo veo necesario ya que a mí se me dificultó un poco el razonamiento y la lógica del ejercicio, por lo tanto me ayuda explicar las cosas así que si es de la ayuda de alguien aquí va la explicación del ejercicio 10.
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in); //Declaramos el scanner.
int arreglo[] = new int[10]; //Declaramos las variables.
int ultimo (Para guardar el valor de la última casilla del arreglo), posiciones (La cantidad de posiciones que se va a correr el arreglo);
System.out.println("Llenando el arreglo"); //Llenamos el arreglo inicial.
for (int i = 0; i < 10; i++) {
System.out.print(i + ". Digite el primer número:");
arreglo[i] = entrada.nextInt();
}
System.out.println("
Digite el número de espacios que quiere mover el arreglo: "); //Pedimos la cantidad de espacios que se va a mover el arreglo.
posiciones = entrada.nextInt();
for (int i = 1; i = 0; j--) { //Entra al segundo bucle for y se corre el arreglo una posición hacia abajo.
arreglo[j + 1] = arreglo[j]; //La posición j + 1 toma el valor de la posición j . Por ejemplo, Arreglo [7+1 = (8)] = Arreglo [7],
//Es decir, el valor que está en Arreglo [7] va a ser ahora el valor de la posición Arreglo [8]. Y así se va corriendo el arreglo de posición.
}
arreglo[0] = ultimo; //El valor de la última posición se va a la primera posición.
//Y regresa nuevamente al primer bucle for (hasta acabar con el número N que nos piden inicialmente) y el valor de la última posición cambia al valor que se corrió a la última casilla.
}
for(int z:arreglo ){
System.out.print("["+z+"] "); //Se imprime.
}
}
Espero les ayude la explicación y que haya sido de su entendimiento! :D.
amigo mira este es mi codigo, pero yo tenia un problema, el bucle donde controlo el numero de veces que de va a desplazar el array yo tenia el iterador "i" en vez de el "j" que tengo ahora por que si lo dejaba con el iterador i , el programa no hacia nada literalmente no entraba ninguna vez al bucle, se soluciono como te digo hasta que cambie la "i" por la "j"
tu sabrias explicarme por que pasa esto, por que es la unica duda que me surgio de este programa
package Arreglos;
import javax.swing.JOptionPane;
import javax.swing.JLabel;
public class Ejercicio_10_Ats {
public static void main(String[] args) {
int numeros[] = new int[10];
int guardar = 0, N, i = 0;
JOptionPane.showMessageDialog(null, new JLabel("DESPLAZAR ARRAY N POSICIONES" ,JLabel.CENTER) ,"Message" ,JOptionPane.PLAIN_MESSAGE);
for(i=0;i
@@josejulianferrerperez8749 Si no estoy mal y por lo que puedo observar en tu código... El problema viene de que estás inicializando la variable " i ", al principio, como int i = 0, por eso al entrar al bucle toma este valor como " 0 ", porque esta inicializada con ese valor y en el bucle dice que ejecute la acción hasta que el valor de i sea mayor o igual que cero entonces por eso no te ejecuta la acción del bucle. Prueba quitando la inicialización de la variable al inicio y en el ciclo for iniciala correctamente "int i = 8; i >= 0; i--". Por eso al momento de poner el iterador J sí te funciona porque empieza con valores distintos de 0.
Alguien me explica porque es arreglo[j+1] = arreglo[j]; y no es arreglo[j] = arreglo[j+1]; para mi el segundo tiene mucho más sentido porque si tenemos un arreglo en la posicion 8 y hacemos que este sea igual al arreglo 8+1 es decir 9 pues estaríamos recorriendo un espacio a la derecha que es lo que nos pide. Pero eso no ocurre alguien me explica por que?
por favor, podrías explicar como haces tus videos? osea que se grave solo una ventana mientras en un cuadro flotante apareces tu explicando?
gracias de antemano.
buen video ;D aqui les dejo otra forma del ejercicio 9: al pedir los primeros 9 numeros los guarde defrente en una posicion contigua ,y asi pude ahorrar un for; luego pedi aparte el utimo numero y lo guarde en la primera posicion.......suerteeeeee
package javaapplication1111;
import java.util.Scanner;
public class JavaApplication1111 {
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
int numeros[]=new int[10];
for(int i=0;i
DE TOQUE PERRO...NO SE PORQUE SE COMPLICO TANTO EL PROFE, IGUAL FUE UN TITAN
@Gino Calderato, no pensé que se pudiera hacer en tan pocas líneas! Yo hice el ejercicio 9, pero además de que me tomó un resto de horas, también me tomó una cantidad absurda de líneas! Jajaja...!!
¡Gracias por compatir!
Slaudos!
wow la vrd esta entendible el codigo ami se me complica los arreglos
que buenos vídeos amigo! estudio ingeniería de sistemas me serán útiles
sabes utilizar interfaz grafica?
Un poco haha
no le entendi al ejercicio 10 xD
exelente vídeo :)
Excelente*
Aca les dejo mi solucion al ejercicio 10, hay varias formas de resolverlo y gracias Alejandro por todo, sos un grande.
import java.util.Scanner;
public class ArrayEj10
{
public static void main (String[] args){
Scanner entrada=new Scanner(System.in);
int arreglo[]=new int [10];
int j=9;
System.out.println("Ingrese una tabla de 10 numeros: ");
for(int i=0;i
ya pero solo era crear un solo arreglo
este bloque de arreglos esta dificil jaja
Por otro lado quiza habra alguien que sepa como contactar a la familia al menos para saber si de alguna manera habra un recurso pago que le ayude en concepto de los cursos que Alejandro dejo en vida? y si aun estan disponibles ? me refiero al caso de hotmart mas especificamente no se si hoy dia se pueda pagar en linea y recibir el curso completo de java si alguien sabe por fa les recomiendo
Me gustaría hacer esto pero en vez de usando números, usando palabras. Es decir, al introducir la palabra "hola" pedir un número de desplazamiento 1, que los caracteres de la palabra se muevan N desplazamientos, es decir, "ahol" (donde la última palabra pasa a la posición inicial). He intentado hacerlo haciendo uso del método substring pero no soy capaz. Alguna ayuda?
Jajajaja estupendo. Explicas muy bien las cosas y das alegría al hacerlo. mucho éxito.
siempre transmitía una energía y dinamismo en todos sus vídeos, es una lastima que ya no este con nosotros. Descanse en paz un excelente maestro se nos fue.
Buen video Like
Y si quiera desplazar mas de una posicion?
puedes hacer videos sobre POO
cool! pero me gusta mas desplazar hacia la derecha!! gracias genio!!
Buenas, dejo resolucion ejercicio 10 por si a alguien le interesa:
*me costo como 3 horas el ejercicio 10 pero finalmente lo logre :,) , descanza en paz ats*
public static void main(String[] args) {
int arreglo[] = new int[10];
int posiciones;
int numero;
int contador = 0;
for (int i = 0; i < 10; i++) {
arreglo[i] = Integer.parseInt(JOptionPane.showInputDialog(null, (i + 1) + ". Ingrese un numero"));
}
posiciones = Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese el numero de posiciones que quiere desplazar"));
numero = 10 - posiciones;
int arreglo2[] = new int[posiciones];
//rescato los numeros
for (int i = numero; i < 10; i++) {
arreglo2[contador] = arreglo[i];
contador++;
}
//muevo los numeros
for (int i = 0; i < posiciones; i++) {
for (int e = 8; e >= 0; e--) {
arreglo[e + 1] = arreglo[e];
}
}
//alojo los numeros rescatados
for (int i = 0; i < posiciones; i++) {
arreglo[i] = arreglo2[i];
}
//Imprimo el arreglo ya terminado
for (int i = 0; i < 10; i++) {
System.out.println(arreglo[i]);
}
}
Me pego un tiro al final afane el primer valor del arreglo y lo pegue manualmente en el arreglo final porque no podia hacerlo funcionar de otro modo.
Después de varios días resolví el ejercicio 10:
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int tabla[] = new int[10];
//se piden los primeros valores para el arreglo
System.out.println("Ingrese 10 valores para la tabla:");
for (int i = 0; i < 10; i++) {
System.out.print((i+1)+"º Valor: ");
tabla[i] = entrada.nextInt();
}
//se pide el valor de veces que se desplaza la tabla
System.out.print("Ingrese un valor que vaya a desplazar la tabla: ");
int numero = entrada.nextInt();
int aux[] = new int[numero];//crea un arreglo auxiliar para guardar los numeros desplazados
int j = 9;
for (int i = 0; i < aux.length; i++) {//el ultimo valor de la tabla se guarda primero en el aux
aux[i] = tabla[j];
j--;
}
//se desplazan los numero de la tabla las veces indicadas
for (int i = 9; i >= numero; i--) {
tabla[i] = tabla[i-numero];
}
//se agregan los valores de aux a la tabla
j = numero-1;//menos 1 para recorrer desde el final el arreglo aux e invertir el orden en que se ingreso
for (int i = 0; i < aux.length; i++) {
tabla[i] = aux[j];
j--;
}
//se recorre el arreglo final
System.out.println("La tabla desplazada es:");
for(int a: tabla){
System.out.print("["+a+"]");
}
}
Seguro hay mejor soluciones mas eficientes, pero esa funciona jaja.
Cuando se resuelve da una sensación de tranquilidad! Jajaja
me gusta tu resolucion muy entendible
yo tarde dos dias jaja literal estaba comiendo y me llego la solucion de la parte que me faltaba, luego fui a encender mi lap, la probe y funciono jajaja a veces tu cerebro ya tiene la solución solo que se hace del rogar jaja
Gracias bro, entendí paso a paso tu código
Era mucho mas simple para mi, primero desplace una posicion todo el array, luego eso lo meti dentro de un while que da las vueltas que ingreso la persona
import java.util.*;
public class Array{
public static void main(String args[]){
Scanner entrada= new Scanner(System.in);
int [] matriz = new int[10];
int desp =0;
int mem =0;
for(int i =0;i0){
mem= matriz[9];
for(int i =9;i>0;i--){
matriz[i]=matriz[i-1];
}
matriz[0]=mem;
desp--;
}
for(int i:matriz){
System.out.print(i+", ");
}
}
}
busco el ejercicio 8 de Arreglos
alguien me ayuda
y como la harías para que se desplace de acuerdo a lo que pone el usuario, por ejemplo: que haga un desplazamiento de 5 o 4 o 10,etc
esa es la tarea del ejercico 10 !!!
Hola Alejandro para felicitarlo por sus buenos videos, me gustaria saber en que editor de texto hace las explicaciones y ademas que le quedan un poco animadas se ve interesante
NetBeans lo dijo en su primer video y hasta enseño a descargarlo
Ejercicio 10
public static void main(String[] args) {
Scanner entrada= new Scanner(System.in);
int arreglo[]= new int [10];
int p, d=0;
for(int i=0; i
podrias colocarle comentarios? no se entiende tu codigo...
@@ileanr.progra-lw9ho Hola, no se si aún te sirva pero aquí te lo pongo mas entendible
int arreglo[]= new int [10];
int posicion, ultimo=0;
for(int i=0; i
El tema de arreglos es super dificil
me pone sad cuando dice: "como ven es un ejemplo muy sencillo" :'(
No le entiendo ni un carajo ahhh
@pollito cocinao si ya lo se xD paso mucho desde ese comentario, es facil la tendencia actual es estudiar calculo y algebra lineal para poder estar en data science o participar en desarrollo de redes neuronales para inteligencia artificial xd
Está fácil si te lo enseña papi Chema
@@antuanortega2214 fue hace 5 años xD pero si esta facil :vv
Este es mi aporte para el ejercicio 10:
Scanner entrada = new Scanner (System.in);
//Definimos las variables
int TABLA[]=new int [10];
int posicion,H=0;
//Pedimos al usuario que rellene el arreglo
System.out.println("Llenando tabla.");
for(int i=0;i
Sin dudas puedo decir que eres el mejor maestro... te extrañare :(
dejo mi solucion...
import java.util.Scanner;
public class Ej10 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int arre1[]=new int[10];
System.out.println("Introduce los 10 elementos de tu array...");
for(int i=0;i
No deberías usar abreviaciones...
Cuando tú programas, tú lo entientes en el momento de hacerlo pero pasado un tiempo puedes no entenderlo. Además, si trabajas con otros programadores, ellos no entendería ntu codigo por muy sencillo que a ti te parezca...
alguien me ayuda que el primer numero este en todas las posiciones como lo haria
Scanner entrada = new Scanner(System.in);
int arreglo[]=new int[10];
System.out.println("Procedemos al ingreso de los 10 numeros enteros en el arreglo");
for(int i=0;i
Me he gastado una buena cantidad de horas tratando de solucionar el ejercicio Nº 9, hasta que PORFIN PUDE HACERLO!
Scanner entrada = new Scanner(System.in);
int arreglo[] = new int[10];
System.out.println("Ingresando los números en el arreglo: ");
for (int i = 0; i < 10; i++) {
System.out.print((i + 1) + ".Digite un número: ");
arreglo[i] = entrada.nextInt();
}
System.out.println("");
// Imprimiendo el arreglo inicial
System.out.println("Imprimiendo el arreglo inicial.");
for (int i = 0; i < arreglo.length; i++) { // En cambio de poner 10 en la condicional, se pone "arreglo.length" para cuando el arreglo sea demasiado largo.
System.out.print(arreglo[i] + ", ");
}
System.out.print("\b\b.");
System.out.println("");
// Deslazando las posiciones del arreglo.
int paso = arreglo[9], k = 8;
for (int j = 9; j > 0; j--) {
arreglo[j] = arreglo[k]; // revisar esta declaración!!
k--;
}
arreglo[0] = paso;
System.out.println("");
// Imprimiendo el segundo arreglo.
System.out.println("Imprimiendo el segundo arreglo.");
for (int i = 0; i < 10; i++) {
System.out.print(arreglo[i] + ", ");
}
System.out.print("\b\b.");
System.out.println("");
¡Saludos!
te puedo sugerir esto: Realizar un programa que lea tantos números enteros como desee el usuario y los introduzca en una lista.
Muestras la lista, intercambias los números que se encuentren en la 2ª y 4ª posición, y muestras el nuevo la lista por antalla
chale bro el ya murió :(
te pued sugerir que hagas tu canal y realizes tu videos
a mi me sucede que cuando muestra la tabla terminada el numero 2 se repite dos veces. queda asi: 10,2,2,3,4,5,6,7,8,9. alguien sabe por que?
ya lo solucioné. me había comido un identificador.
Es media noche, pero me dormiré feliz porque lo logre hacer, dejo mi manera de solucionarlo
import java.util.Scanner;
public class Ejercicio10 {
public static void main(String[] args) {
Scanner entrada = new Scanner (System.in);
int [] array = new int[10];
for(int i=0; i0; j--){
array[j]=array[j-1];
}
array[0]=ultimoNumero;
for(int i=0; i
del ejercicio del vídeo no había necesidad de colocar abajo la posición de ultimo, dentro del mismo arreglo podía haberse hecho
package sustitucionarreglo;
import java.util.Scanner;
/**
*
* @author JALZ
*/
public class SustitucionArreglo {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int []arreglo= new int[10];
int ultimo;
Scanner scan = new Scanner(System.in);
for (int i = 0; i < 10; i++) {
System.out.println("ingrese el "+(i+1)+"° numero: ");
arreglo[i]=scan.nextInt();
}
ultimo=arreglo[9];//guardamos el ultimo elemento
for (int i = 8; i >=0; i--) {
arreglo[i+1]=arreglo[i];
arreglo[i]=ultimo;
}
for (int i = 0; i < 10; i++) {
System.out.println(arreglo[i]);
}
}
}
como puedo, desplazar un espacio, hacia arriba, para que mi primer elemento del arreglo, se elimine, no el ultimo.
El ya esta muerto, por cáncer en su rodilla.
Me encuentro en dificultà con el tema de arreglos, antes hacia sin problemas los ejercicios!! A seguir intentandolo..voy por el ejercicio 10.
/*
Ejercicio 9: Crear un programa que lea por teclado una tabla de 10 números
enteros y la desplace una posición hacia abajo: el primero pasa a ser el
segundo, el segundo pasa a ser el tercero y así sucesivamente.
El último pasa a ser el primero.
*/
package Ejercicios;
import java.util.Scanner;
public class Ejercicio09 {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int[] num = new int[10];
System.out.println("Ingreso de números");
for (int i = 0; i < 10; i++) {
System.out.print((i + 1) + ".- Ingrese un número: ");
num[i] = scn.nextInt();
}
System.out.println("
Orden original del arreglo");
for (int j : num) {
System.out.print(j + " ");
}
System.out.println("
Orden modificado");
//Almacenamos el ultimo valor a x, para que no se pierda en el bucle
int x = num[9];
//Desplazamiento de i -> i+1
for (int i = 8; i >= 0; i--) {
num[i + 1] = num[i];
}
//Asignamos el ultimo valor a la primera posición del arreglo
num[0] = x;
for (int j : num) {
System.out.print(j + " ");
}
System.out.println("");//espacio en blanco, netamente estetico
}
}
Ejercicio10: jala....
Scanner a = new Scanner(System.in);
int array[] = new int[10];
int n,c,ultimo,l;
System.out.println("Digite los 10 números a continuación");
for(int i=0;i
Me salvaste el culo, muchas gracias xD
Estaba desesperado porque no me funcionaba lo había echo igual que tú solo que con variables distintas hasta que vi que a mí for (int j =8; j>0; j--) le faltaba el = osea (int j=8;j>=0;j--) con eso cambiaba totalmente.
que elegante.
Hola, está piola
Amigo que estas haciendo con el array [p], no entiendo porque lo creaste de la nada, alguien me puede explicar por favor
Tengo una duda: ¿Por qué en el ciclo for(int i=8; i >= 0; i- -) la seuencia es descendente? Es decir, con el i - -
Como lo que se busca es desplazar el vector hacia la derecha se necesita hacer el recorrido hacia la derecha para no ir sobrescribiendo los demas numeros lo que si pasaria si haces el ciclo ascendente. Es un poco complejo verlo así pero trata de hacerlo en papel y de seguro lo entenderas :)
Yo tengo la misma duda que él, y traté de hacerlo en papel y entenderlo y no pude, desde los videos de arreglos no llevo entendido nada
Tiene sentido lo que dice Juan, si bien la secuencia esta en forma descente, en ese bucle los datos se van guardando en la casilla superior debido al i+1, por Ejemplo si dice 8, la posicion de ese arreglo aumentara en 1, osea yendo a la posicion 9, cuando vuelva a realizar el bucle, este pasara a ser 7(7>=0;i- -) repitiendo el proceso anterior. La posicion 7 se guardara en la posicion 8, todo se debe al i+1 en donde se almacena lo que contenia la posicion anterior
Para cuando POO papi..
porque i=8 ? . No se supone que el arreglo [i] empieza en posicion cero? y va hacia abajo ? . si alguien me aclara esa duda le agradeceria.
llego dos a;os tarde, pero bueno para desplazar elementos de atras para alante, debes empezar en el final del arreglo, y como la posicion 8 es realmente la 9 en el arreglo, ya que se empieza desde 0 entonces debes empezar agarrando i=8 para poder hacer el tabla[i+1] = tabla[i]
aso solo el 60 % del ejerciocio puedo hacerlo bien pero lo demas mal estoy que explota mi mente con estos ejercicios
Menor, estoy explotando con el maldito ejercicio 10....
Hola, aquí dejo una propuesta distinta. En vez de usar un entero temporal para almacenar el ultimo carácter y ponerlo el primero, he usado dos arrays uno principal y otro auxiliar para guardar temporalmente los números a desplazar. public static void main(String[] args) {
int arreglo_1[] = new int[10];
int arreglo_2[] = new int[10];
int desplaza, ordenInverso, k=0, j=9;
Scanner entrada = new Scanner (System.in);
System.out.println("Introduce 10 numeros:");
for (int i=0;iordenInverso;i--){
arreglo_2[k]=arreglo_1[i];
k--;
}
for (int i=ordenInverso;i>=0;i--){
arreglo_1[j]=arreglo_1[i];
j--;
}
for (int i=0;i
el ejercicio en html alguien lo tiene
Como haria si necesito Un método privado ampliarArreglo que extienda el arreglo en diez espacios más. cuando ya tengo el arreglo
public ArregloCodigos(){
codigo =new int[10];
indice = 0;
}
private int[] edad;
private void ampliararreglo(){
int[] aux = edad;
edad = new int[indice + 10];
for (int i=0; i
esta yuca. pasa la solucion por mega
entendí todo hasta cuando dijo chancar...🤔
Aporte al ejercicio resuelto: Ejercicio10 arreglos
Scanner entrada = new Scanner (System.in);
int arreglo[] = new int[10];//arreglo de 10 ents
int ultimo, posiciones, j=1;
System.out.println("Llenemos el arreglo");
for (int i=0; i=0;i--){
arreglo[i+1]=arreglo[i];
}
j++;
arreglo [0]= ultimo;
}
while (j
de esa manera 1 ves va a entrar en la tabla. osea que si pongo 0. 1 ves me va a correr los numeros del arreglo.
es solo con un while(posiciones>=1&&j
wow no entendi xddd xk solo con un do while hacia todo eso
Scanner entrada = new Scanner(System.in);
int tabla[] = new int[10];
int nPosiciones = 0;
int ElementoFinal;
System.out.println("\tLLENADO DEL ARREGLO");
for (int i = 0; i < 10; i++) {
System.out.print((i + 1) + ".- Digite un numero: ");
tabla[i] = entrada.nextInt();
}
ElementoFinal = tabla[9]; //Guarda el ultimo elemento de la tabla
System.out.print("
Digite la cantidad de posiciones a desplazar: ");
nPosiciones = entrada.nextInt();
for (int i = 0; i < nPosiciones; i++) { //Desplaza las posiciones indicadas
for (int j = 8; j >= 0; j--) {
tabla[j + 1] = tabla[j];
}
tabla[0] = ElementoFinal;
ElementoFinal = tabla[9];
}
System.out.println("
EL NUEVO ARREGLO ES ");
for (int i = 0; i < 10; i++) {
System.out.println((i + 1) + ".- Numero: " + tabla[i]);
}
disculpame pero para MI al menos, una posicion hacia abajo seria pasar de la posicion 2 a la 1 (a la izquierda) y no al reves como explicas en el video... solo eso me carcome la cabeza XD
por el resto perfecto como siempre, muy buenos videos
se supone que es hacia abajo porque un arreglo se ve como una columna, osea en forma vertical. Haciendo que la posicion 0 sea la de arriba y a medida que aumente 1,2,3 ,etc , va bajando. No se si entendiste
@@n1k0t1n4_ también me parecía raro. Porque al inicio lo hace en horizontal.
Igual, gracias por explicar!
Añado mi codigo para el ejercicio 10, espero y le sirva a alguien. : )
public static void main(String[] args){
int[] tabla = new int[10];
int[] save = new int[10];
int despla;
for(int i=0;i=despla;i--){
tabla[i] = tabla[i-despla];
}
int c=0;
for(int i = 10-despla;i
ejercicio 10:
Scanner entrada = new Scanner (System.in);
int [] numeros = new int [10];
int posiciones, ultima_cifra;
System.out.println("INGRESE VALORES AL ARREGLO: ");
for (int i = 0; i < 10; i++) {
System.out.print((i+1)+".Número: ");
numeros[i] = entrada.nextInt();
}
System.out.println("
Cuantas posiciones desea avanzar el arreglo: ");
posiciones = entrada.nextInt();
for (int i = 0; i < posiciones; i++) {
ultima_cifra = numeros[9];
for (int j = 8; j >= 0; j--) {
numeros[j+1] = numeros[j];
}
numeros[0] = ultima_cifra;
}
System.out.print("
El nuevo arreglo es: ");
for (int i = 0; i < 10; i++) {
System.out.print(" "+numeros[i]);
}
System.out.println("
"); // ESTETICA NO IMPORTA
está bien. pero en ningun momento dice que los que están detras de las n posiciones deben acomodarse delante.
@@andresxever Los que estan detras de las n posiciones se acomodan adeltante por que tambien se movieron n posiciones
Realizar un programa que lea tantos numeros enteros como desee el usuario y los introduzca en una lista.
Muestras la lista, intercambiar los numeros que se encuentren en la 2° y 4° posicion, y volver a mostrar la lista por pantalla.
Utilizar al menos 3 metodos:
- uno para introducir los datos
- uno para mostrar los datos
- por ultimo uno para intercambiar los datos.
que me dices amigo me da un apoyo en java.
Es mas facil que este lo que debes hacer es introducir los datos imprimir una lista de posicion de los mismo
luego creas 2 variables
en una guardas la posicion 2 y en otra la cuatro luego haces el cambio
ejemplo
arreglo[2] = la variable con el dato de la posicion 4
arreglo[4] = la variable con el dato de la posicion 2
luego imprimes todo es mas facil que los que ves en videos
*EJERCICIO 10*
public static void main (String[] args) {
// --- VARIABLES ---
Scanner guardar = new Scanner (System.in);
int desplazarse, copia;
int[] vector = new int[10];
// --- PEDIR DATOS AL USUARIO ---
for (int c1 = 0; c1 < 10; c1++){
System.out.print("INGRESE UN VALOR A LA CASILLA N.-" + c1 + ": ");
vector[c1] = guardar.nextInt();
}
// --- PRESENTAR SU ARREGLO ---
System.out.print("SU ARREGLO: ");
for (int c1 = 0; c1 < 10; c1++){
System.out.print(vector[c1] + " ");
}
// --- PEDIR LA CANTIDAD DE VECES A DESPLAZARSE HACIA ADELANTE ---
System.out.print("
INGRESE LA CANTIDAD DE VECES A DESPLAZARSE HACIA ADELANTE: ");
desplazarse = guardar.nextInt();
// --- BUCLE DE DESPLAZAMIENTOS ---
for(int c1 = 0; c1 < desplazarse; c1++){
copia = vector[9]; // PRIMERO, COPIO EL ULTIMO VALOR
// LUEGO HAGO EL BULCE PARA DESPLAZARSE HACIA ADELANTE
for(int c2 = 9; c2 > 0; c2--){
vector[c2] = vector[c2 - 1]; // EL ULTIMO = AL PENULTIMO; EL PENULTIMO = AL ANTEPENULTIMO; EL ANTEPENULTIMO = AL ANTESANTEPENULTIMO etc...
}
// POR ULTIMO, LO QUE COPIE, LO PONGO EN LA PRIMERA POSICION
vector[0] = copia;
} // Y ASI SE REPITE EL BUCLE, HASTA LLEGAR A LA VECES QUE EL USUARIO HAYA QUERIDO
// --- PRESENTAR SU NUEVO ARREGLO ---
System.out.println("SU NUEVO ARREGLO :D");
for (int c1 = 0; c1 < 10; c1++){
System.out.print(vector[c1] + " ");
}
// COPIA, LEE Y APRENDE, PERO NUNCA TE RINDAS,
// RECUERDA QUE, SI PUEDES IMAGINARLO, PUEDES PROGRAMARLO
// ;D
}
ejercicio #9
System.out.println("Los numeros de su arreglo son");
System.out.print(Arreglo[9]+" ");
for(int i=0;i
Exercise_10
Scanner entrada = new Scanner(System.in);
System.out.print("digite la dimension del arreglo: ");
final int Nelementos = entrada.nextInt();
int table[];
table = new int[Nelementos];
System.out.println("digite " + Nelementos + " numeros");
for (int i = 0; i < table.length; i++) {
System.out.print((i + 1) + ".- digite un numero: ");
table[i] = entrada.nextInt();
}
System.out.println("digite cuantas posiciones desea desplazar: ");
int n = entrada.nextInt();
for (int j = 0; j < n; j++) {
int ultimo = table[table.length - 1];
for (int i = table.length - 2; i >= 0; i--) {
table[i + 1] = table[i];
}
table[0] = ultimo;
}
// print
int k = 0;
for (int i : table) {
if (k < table.length - 1) {
System.out.print(i + ", ");
} else {
System.out.print(i);
}
k++;
}
Ejercicio 10 super que facil
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package pasando_posicion;
import java.util.Scanner;
/**
*
* @author Angel
*/
public class Pasando_Posicion {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner entrada= new Scanner (System.in);
int num[],pos,cambio;
num= new int[10];
for(int i=0; i
Wey yo sigo intentando hacerlo y no se como jajaj
@@dennysfabianfalconlainez4932 Alguien me explica porque es arreglo[j+1] = arreglo[j]; y no es arreglo[j] = arreglo[j+1]; para mi el segundo tiene mucho más sentido porque si tenemos un arreglo en la posicion 8 y hacemos que este sea igual al arreglo 8+1 es decir 9 pues estaríamos recorriendo un espacio a la derecha que es lo que nos pide. Pero eso no ocurre alguien me explica por que?
Este tema de arreglos es difícil de comprender u.u me tomó varias horas completar el ejercicio.
public static void main(String[] args) {
int[] serie = new int[10];
Scanner leer = new Scanner(System.in);
int n;
System.out.println("Por favor ingrese 10 números enteros:");
for (int i=0;i0){
for (int c=1,i=8;c
Ejercicio 9(a mi manera):
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int arreglo[] = new int[10];
int aux;
for(int i=0; i=0;i--){
arreglo[i+1] = arreglo[i];
}
arreglo[0] = aux;
System.out.println("Imprimiendo ne la posicion indicada: ");
for(int i=0; i
Ejercicio 10.- Con JOptionPane (1-10)
package arreglos;
import javax.swing.JOptionPane;
public class Arreglos {
public static void main(String[] args) {
int [] teclado = new int [10];
int ultimo,posicion,c;
String cadena="";
for(int i=0; i
//una solución más genérica para el ejercicio 10, dado un arreglo de n elementos recorrer n posiciones.
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner lee = new Scanner(System.in);
while(lee.hasNext()) {
int n = lee.nextInt();
int arr[]=new int[n];
for(int i=0;i=desp)
arr[j]=arr[j-desp];
else
break;
}
//unir arreglo rezagado con original
int count=0;
for(int h=arraux.length-1; h>=0;h--) {
arr[h]=arraux[count];
count++;
}
for(int k:arr) {
System.out.print(k+" ");
}
}
}
}
package ciclos;
import javax.swing.JOptionPane;
import jdk.nashorn.internal.objects.NativeArray;
public class Cap_48_ejer_9_arreglos_desplazar_posicion
{
public static void main(String args[])
{
/*
Ejercicio 10: Crear un programa que lea una tabla
de 10 numeros enteros y despace N posiciones en el arreglo
(N es ingresado por el usuario)
*/
int arreglo[] = new int[10];
int posiciones, entrada, numero,aux;
JOptionPane.showMessageDialog(null, "Ingrese los 10 elementos del vector..");
for (int i = 0; i
EJER 10:
Scanner input = new Scanner(System.in);
int numbers[] = new int[10];
int posiciones,j=0;
for(int i = 0; i < numbers.length; i++){
System.out.print("Ingrese el valor #"+i+": ");
numbers[i] = input.nextInt();
}
System.out.println("");
System.out.print("Digite la cantidad de posiciones a desplazar: ");
posiciones = input.nextInt();
// Arreglo para salvar los numeros perdidos
int save[] = new int[posiciones];
// Hago la logica de salvar los valores que se van a perder al momento de avanzar N posiciones
int mlapela =(numbers.length-(1+posiciones))+1;
for(int i = mlapela ; i < numbers.length; i++){
for(; j < save.length;){
save[j] = numbers[i];
break;
}
j++;
}
// hago la logica de avanzar N posisciones (La cantidad e posiciones que el usuario me ingresa)
for(int i = numbers.length-(1+posiciones); i >=0; i--){
numbers[i+posiciones] = numbers[i];
}
// Integro los valores perdidos en al avanzar N posiciones al arreglo al cual se le hizo el movimiento
for(int i = 0; i < posiciones; i++){
numbers[i] = save[i];
}
for(int i = 0; i < numbers.length; i++){
System.out.println("["+i+"]"+"="+numbers[i]);
}
como vergas hiciste eso loco no entendi un culo
ejercicio 10 lo resolvi solo pero no se si esta bien por que lo hize dela manera menos logica pero si salio xddd
Scanner s= new Scanner(System.in);
int arreglo[]=new int[10];
System.out.println("digitando 10 numeros ");
for (int i = 0; i < 10; i++) {
System.out.printf("digite un numero : ");
arreglo[i]=s.nextInt();
}
System.out.println("digite las posiciones que queres desplazar");
int desplazar=s.nextInt();
for (int i = desplazar; i < 10; i++) {
System.out.println(arreglo[i]);
if (i==9) {
for (int j = 0; j < desplazar; j++) {
System.out.println(arreglo[j]);
}
}
}
Les dejo mi resolución que creo está bastante simplificada:
import java.util.Scanner; //Para entrada de datos por pantalla
public class Ejercicio10{
public static void main(String[] args){
Scanner entrada = new Scanner(System.in);
//Variables
int a[] = new int[10],n,ultimo;
//Ingreso los 10 numeros del arreglo
for(int i=0;i
Brother, de esta manera yo me lo imaginaba sólo que no pude llevarlo a netbeans, muy bien hecho👏
acá les dejo mi solución, si desean preguntar me escriben a continuación
public static void main(String[] args){
int num[] =new int[10];
int x,ul;
Scanner numeros= new Scanner(System.in);
for(int i=0;i=0;i--){
System.out.println((x-i-1)+" "+(a[i])+" ");
}
//imprimiendo ultimos numeros con arreglo num
for(int i=x;i
Yo lo hice un poco mas sencillo, solo agregue un while y ya:
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int arreglo[] = new int[10];
int posiciones;
int ultimo;
System.out.println("Llena el arreglo.");
for(int i = 0; i < 10; i++){
System.out.print((i+1)+".Digite un numero: ");
arreglo[i] = scanner.nextInt();
}
System.out.println("
Coloque la cantidad de posiciones a desplazar: ");
posiciones = scanner.nextInt();
int cont = 0;
while(cont < posiciones){
ultimo = arreglo[9];
for (int i = 8; i >= 0; i--){
arreglo[i+1] = arreglo[i];
}
arreglo[0] = ultimo;
cont++;
}
System.out.println("
El nuevo arreglo es: ");
for (int i = 0; i < 10; i++){
System.out.println(i+" Numero: "+ arreglo[i]);
}
scanner.close();
}
Resolucion del Ejercicio 10;
//Dezplazamiento de posiciones en una matriz
package psint;
import java.util.*;
public class EjerArraytres {
public static void main(String[] args) {
Scanner entrada= new Scanner(System.in);
int a[] = new int [10];
int posiciones =0;
int numerofinal=0;
for(int i =0; i
int cantidadElm=10;//opcional
Scanner entrada = new Scanner(System.in);
int[] numeros=new int[cantidadElm];
//agregar elementos
for(int i=0;i
QUE PIDA AL USUARIO CUANTOS NUMEROS DESEA INGRESAR, CUANTAS VECES DESPLAZAR Y HACIA LA DERECHA O IZQUIERDA.
import java.util.Scanner;
public class Ejercicios {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Cuantos numeros deseas ingresar. ");
int num = entrada.nextInt();
System.out.print("Cuantas veces deseas desplazarlos: ");
int num2 = entrada.nextInt();
int num3 = 0;
try {
while (num3 != 1 && num3 != 2) {
System.out.print("Hacia que lado deseas desplazarlos:
Oprime 1 DERECHA.
Oprime 2 IZQUIERDA.
");
num3 = entrada.nextInt();
}
} catch (Exception e) {
System.out.println("error ingresa de nuevo" + e);
}
int arreglo1[] = new int[num];
for (int i = 0; i < arreglo1.length; i++) {
System.out.print("Ingresa número " + (i + 1) + ": ");
int guarda = entrada.nextInt();
arreglo1[i] = guarda;
}
//
System.out.println("
Números ingresados: ");
for (int i = 0; i < arreglo1.length; i++) {
if (i < arreglo1.length - 1) {
System.out.print(arreglo1[i] + ",");
} else {
System.out.println(arreglo1[i] + " ");
}
}
if (num3 == 1) {
//aqui se mueven los valores derecha
for (int j = 0; j < num2; j++) {
int ultimo = arreglo1[arreglo1.length - 1];
for (int i = arreglo1.length - 2; i >= 0; i--) {
arreglo1[i + 1] = arreglo1[i];
}
arreglo1[0] = ultimo;
}
} else {
// izquierda:
for (int j = 0; j < num2; j++) {
int primero = arreglo1[0];
for (int i = 0; i < arreglo1.length - 1; i++) {
arreglo1[i] = arreglo1[i + 1];
}
arreglo1[arreglo1.length - 1] = primero;
}
}
//
System.out.println("Numeros desplazados:");
for (int i = 0; i < arreglo1.length; i++) {
if (i < arreglo1.length - 1) {
System.out.print(arreglo1[i] + ",");
} else {
System.out.println(arreglo1[i] + "");
}
}
}
}
EJERCICIO 10:
Scanner entrada = new Scanner (System.in);
int arreglo [] = new int [10];
int a [] = new int [10];
int posiciones,resta;
for (int i = 0; i < 10; i++) {
System.out.print(i+ ". Ingrese Numero: ");
arreglo[i] = entrada.nextInt();
}
System.out.println("Cuantas posiciones desea recorrer: ");
posiciones = entrada.nextInt();
resta = 10-posiciones;
for (int i = resta,j = 0; i = 0; i--) {
arreglo[i+posiciones] = arreglo[i]; // MOVEMOS TODO EL ARREGLO LAS POSICONES INDICADAS
}
for (int i = 0; i
Quien en java en el 2022
/*Ejercicio 10: Crear un programa que lea por teclado una tabla de N numeros enteros y desplace X posiciones en el arreglo (X es digitado
por el usuarios)
*/
package arreglo_ejercicio_10;
import javax.swing.JOptionPane;
public class Arreglo_Ejercicio_10 {
public static void main(String[] args) {
int cant = Integer.parseInt(JOptionPane.showInputDialog("Ingresa la cantidad del arreglo :"));
int[] numeritos = new int[cant];
for (int i = 0; i < cant; i++) {
numeritos[i] = Integer.parseInt(JOptionPane.showInputDialog("Ingresa el valor [" + (i + 1) + "] :"));
}
int salto = Integer.parseInt(JOptionPane.showInputDialog("INGRESA EL SALTO:"));
System.out.println("**********ARRAY PRINCIPAL***********");
for (int i = 0; i < numeritos.length; i++) {
System.out.print(numeritos[i] + " ");
}
System.out.println("
********************************");
int conta = 0;
int[] backup = new int[numeritos.length];
for (int i = 0; i < numeritos.length - salto; i++) {
backup[i + salto] = numeritos[conta];
conta++;
}
int conta2 = numeritos.length - 1;
System.out.println("***** primera forma*******");
for (int i = 0; i < salto; i++) {
backup[i] = numeritos[conta2];
conta2--;
}
for (int i = 0; i < backup.length; i++) {
System.out.print(backup[i] + " ");
}
System.out.println("
**** segunda *** forma *******");
int test = salto;
for (int i = 0; i < salto; i++) {
backup[i] = numeritos[numeritos.length - test];
test--;
}
for (int i = 0; i < backup.length; i++) {
System.out.print(backup[i] + " ");
}
System.out.println("");
}
}
Ejercicio 10 para ustedes hecho por mi UwU:
package arraysdesplazar10numerosnposiciones;
import javax.swing.JOptionPane;
public class ArraysDesplazar10NumerosNPosiciones {
public static void main(String[] args) {
int[] n = new int[10];
int[] arreglo = new int[10];
int posiciones;
for(int i = 0; i < 10; i++){
n[i] = Integer.parseInt(JOptionPane.showInputDialog("Digite el numero "+(i+1)+": "));
System.out.println("Numero "+(i+1)+": "+n[i]);
}
posiciones = Integer.parseInt(JOptionPane.showInputDialog("Digite el numero de posiciones a recorrer: "));
if(posiciones
Buena, yo intente hacerlo solo hice bastantes cosas y no me funciona... no se por que
@@martincoimbra2053 yo me guié de él. Aquí lo puse comentado paso a paso:
/*Ejercicio 10: Crear un programa que lea por teclado una tabla de 10 números
eneros y desplace posiciones posiciones en el arreglo (posiciones es digitado por el usuario) .*/
package pkg48.ejercicio10.desplazarnposicionelarreglo;
import java.util.Scanner;
public class Ejercicio10DesplazarNposicionElArreglo {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int n[]=new int[10]; //defino arreglo de 10 elementos enteros
int arreglo[]= new int[10];
int posiciones;
//--------------------------------------------
System.out.println("ingrese 10 elementos:");//pido elementos del arreglo "n"
for (int i = 0; i < 10; i++) {
System.out.print((i+1)+". Numero: ");
n[i]= entrada.nextInt();
}
//-------------------------------------------
System.out.println("cuantas posiciones deseas desplazar?: ");//pregunto cuantas "posiciones"
posiciones = entrada.nextInt();
//------------------------------------------desplazamiento de posiciones "N"-> ejemplo: 4
if(posicionesi=0 / j=5->i=1 / j=6->i=2 / j=7->i=3 / j=8->i=4 / j=9->i=5 //he guardado en "arreglo" desde posicion 4 -> 9
}
//------------------------------------------asigno los numeros finales por los del principio
j = 10-posiciones; //j=6
for (int i = 0; i < posiciones; i++) { //0-1-2-3-4-5
arreglo[i]=n[j];////guardando en nuevo "arreglo[j]" en las posiciones: 0-1-2-3 -> 6-7-8-9(ultimos numeros de la serie)
j++; //va iterar 4 veces porq empieza desde j=6
//i=0->j=6 / i=1->j=7 / i=2->j=8 / i=3->j=9 //he guardado en "arreglo" desde 0 -> 3
} //hasta aquí ya guardé todo en "arreglo[10]" 0->9
//------------------------------------------Imprimiendo resultado
System.out.println("El nuevo arreglo es: ");
for (int i = 0; i < 10; i++) {
System.out.println((i+1)+". Numero: "+arreglo[i]); //solo tengo q imprimir "arreglo"
}
}
else{
System.out.println("el numero de posiciones es excesivo.");
}
}
}
gracias comprendi mas ese jercicio
Scanner cin = new Scanner( System.in );
int[] a = new int[10];
int dato,pos,aux,aux2;
for(int x=0; x=0;x++,j--){
if(x
He aquí mi solución:
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
int arreglo[]=new int [10];
int n,contador=0, con2=9;
int arreglo2[]=new int[10];
System.out.println("Inicio");
System.out.println("Digite los 10 datos del arreglo");
for(int i=0; i
/*
Crear un programa que lea por teclado una tabla de 10 numeros
enteros y desplace N posiciones en el arreglo
(N posiciones digitado por el usuario)
*/
package ejercicio9_array;
import java.util.Scanner;
public class Ejercicio9_Array {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int[] Array = new int[10];
int pos;
System.out.println("Llenar el Array: ");
for (int i = 0; i < 10; i++) {
System.out.print((i+1)+". Dato:: ");
Array[i] = entrada.nextInt();
}
System.out.print("Cuantas posicionos desea desplazar: ");
pos = entrada.nextInt(); // numero de posiciones que rodaran los datos.
int[] Ultimos = new int[pos];
int j=0;
for (int i = (10 - pos); i < 10; i++) {
Ultimos[j] = Array[i]; // guardara los ultimos numeros de acuerdo al numero de posiciones.
j++;
}
// 1 2 3 4 5 6 7 8 9 10
// 1 2 1 2 3 4 5 6 7 8
for (int i = 8; i >=(pos-1); i--) {
Array[i+1] = Array[(i-pos)+1]; // Rodaran los datos el numero hacia adelante el numero de posiciones que digite el usuario
}
j=0;
for (int i = 0; i < pos; i++) {
Array[i] = Ultimos[j]; // ponemos los ultimos elementos de primeros
j++;
}
for (int i = 0; i < 10; i++) {
System.out.println(Array[i]);
}
}
}
Alguien que tenga alguna idea de por que no funciona? Scanner entrada = new Scanner(System.in);
int[] arreglo = new int[10];
int numdesplaza;
System.out.println("Ingresando numeros del arreglo.");
for(int i=0;i
Ejercicio 10.-
---------------------------------------------------------
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] listaOriginal = new int[10];
int[] listaDesplazada = new int[10];
System.out.println("Ingresar datos del array.
"); //ingresar array
for (int i = 0; i < 10; i++) {
System.out.print((i + 1) + ". ");
listaOriginal[i] = scanner.nextInt();
}
System.out.print("Pocisiones a desplazar: "); //ingresar pocisiones a desplazar
int desplazar = scanner.nextInt();
if (desplazar % 10 == 0){ //si desplazar = 0 o es multiplo de 10, el array queda igual
System.out.println("El array no se movio");
}else {
for (int i = 0; i < listaOriginal.length; i++) { // transferir listaOriginal a listaDesplazada
if ((i + desplazar) < 10){ //Mantener el desplazamiento dentro del array
listaDesplazada[i+desplazar] = listaOriginal[i]; // Mover array atras a adelante {a, x, x} => {x, x, a}
}else {
listaDesplazada[i+desplazar-10] = listaOriginal[i]; // Mover array adelante a atras {x, x, a} => {a, x, x}
}
}
for (int j : listaDesplazada) { //Imprimir array
System.out.println(j + " ");
}
}
}
}
Así hice yo el ejercicio 9:
import java.util.Scanner;
public class NewMain {
public static void main(String[] args) {
Scanner scan = new Scanner (System.in);
int vec []=new int [10];
System.out.println("Digite 10 numeros");
for (int i=0; i
Osea si, pero no
EJERCICIO #10:
package javaapplication6;
import java.util.*;
public class JavaApplication6 {
static Scanner imput = new Scanner(System.in);
public static void main(String[] args) {
int nElementos,ultimo,P;
System.out.print("Ingrese la cantidad de elementos que tendra su arreglo: ");
nElementos = imput.nextInt();
int [] Arreglo = new int[nElementos];
System.out.println("Ingrese los elementos del arreglo: ");
for(int i=0;i
Gracias, estaba pensando en dejar el curso, llevo 1 dia atrapado en este ejercicio y ahora puedo entender mas o menos como lo puedo hacer.
@@leandrogaston7943 de nada bro, me alegra que te sirviera 👍
La verdad, me quede aca. Estoy viendo si seguir el curso ya que el anterior no lo pude hacer el ejercicio y este menos. No se si es el video o soy yo... (Aclaracion, hablo de las tareas)
edit, gracias al comentario de abajo lo entendi un poco :)
Bueno, y así me quedó el código del ejercicio Nº 10 que, dicho sea de paso, lo resolví en muchísimo menos tiempo que el ejrcicio Nº 9:
Scanner entrada = new Scanner(System.in);
int arreglo[] = new int[10];
System.out.println("Llenando el arreglo.");
for (int i = 0; i < 10; i++) {
System.out.print((i+1)+". Digite un número: ");
arreglo[i] = entrada.nextInt();
}
// Imprimendo los números del arreglo.
System.out.println("
Imprimiendo los números del arreglo: ");
for (int i = 0; i < 10; i++) {
System.out.print(arreglo[i]+", ");
}
System.out.print("\b\b.");
System.out.println("");
// Introduciendo la cantidad de desplazamientos que el usuario quiera realizar.
int n, aux;
System.out.print("
Digite el número (1-9) de la cantidad de espacios que quieres desplazar: ");
n = entrada.nextInt();
for (int i = 0; i < n; i++) {
aux = arreglo[9];
for (int j = 8; j >= 0; j--) {
arreglo[j+1] = arreglo[j];
}
arreglo[0] = aux;
}
// Imprimiendo el nuevo arreglo
System.out.println("
El nuevo arreglo es: ");
for (int i : arreglo) {
System.out.print(i + ", ");
}
System.out.print("\b\b.");
System.out.println("");
¡Saludos!
Alguien me explica porque es arreglo[j+1] = arreglo[j]; y no es arreglo[j] = arreglo[j+1]; para mi el segundo tiene mucho más sentido porque si tenemos un arreglo en la posicion 8 y hacemos que este sea igual al arreglo 8+1 es decir 9 pues estaríamos recorriendo un espacio a la derecha que es lo que nos pide. Pero eso no ocurre alguien me explica por que?
La cuestión es que no es lo mismo, la expresión (arreglo[j+1] = arreglo[j];) que se leería de la siguiente forma "A la posición siguiente asígnale el valor de la posición actual" y la expresión (arreglo[j] = arreglo[j+1];) "A la posición actual asígnale el valor de la posición siguiente".
Si haces que el bucle recorra el arreglo organizándolo desde la penúltima posición hasta la posición 0 lo lógico es hacer que a la posición siguiente se le asigne el valor de la posición actual, de esta forma perderás el valor de la última posición por eso lo guardamos.
Pero si haces que el bucle recorra el arreglo organizándolo desde la posición 0 hasta la penúltima posición lo lógico es hacer que a la posición actual se le asigne el valor de la posición siguiente, de esta forma perderás el valor de la posición 0 sería el dato a guardar antes de organizarlo.
public static void main(String[] args) {
// TODO code application logic here
Scanner Sc=new Scanner(System.in);
int arreglo[]=new int[10];
int desplazar,ultimo;
for (int i = 0; i = 0; j--) {
arreglo[j+1]=arreglo[j];
}
arreglo[0]=ultimo;
}
System.out.println("
Resultado del arreglo es");
for (int i = 0; i
Tengo una solución al ejercicio 10, espero les sirva, quizá ya lo vieron en otro comentario pero lo hice usando mi lógica:):
import java.util.Scanner;
public class Arreglos333{
public static void main (String[]args){
Scanner entrada = new Scanner(System.in);
int numeros[] = new int [10];
int n;
//Pedir los números del arreglo
System.out.println("Escribe los 10 números");
for(int i = 0;i < 10;i++){
System.out.print((i + 1) + ". Escribe un número: ");
numeros[i] = entrada.nextInt();
}
System.out.println("¿Cuántas posiciones quieres desplazar los números del arreglo?");
n = entrada.nextInt();
//Recorrer las posiciones ingresadas
int recorrer[] = new int[n];
for(int i = 0;i < n;i++){
recorrer[n - (i+1)] = numeros[9 - i];
}
for(int i = (9 - n);i >= 0;i - -){
numeros[i + n] = numeros[i];
}
for(int i = 0;i < n;i++){
numeros[i] = recorrer[i];
}
for(int i = 0;i < 10;i++){
System.out.println("Numero " + numeros[i]);
}
entrada.close();
}
}
package ejercicio_10_arreglos;
import java.util.Scanner;
/**
*
* @author Luis Morales
*/
public class Ejercicio_10_arreglos {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner entrada = new Scanner (System.in);
int mover[] = new int[10];
int aux, pos;
System.out.println("Ingrese los 10 numeros del arreglo");
for (int i = 0; i < 10; i++) {
System.out.print((i+1)+ ".numero del arreglo: ");
mover[i] = entrada.nextInt();
}
System.out.print("Ingrese la cantidad de posiciones que quiere que se desplazen en el arreglo: ");
pos = entrada.nextInt();
for (int j = 1; j = 0; i--) {
mover[i+1] = mover[i];
}
mover[0] = aux;
}
System.out.println("El arreglo con "+pos+" posiciones desplazadas es: ");
for (int i = 0; i < 10; i++) {
System.out.println(mover[i]);
}
}
}
Scanner entrada=new Scanner(System.in);
int arreglo[]=new int[10];
int ultimo;
System.out.println("Llenar el arreglo");
for(int i=0;i
este es el mismo pero con while
int arreglo[] = new int[10];
int ultimo; // aqui vamos a guardar el ultimo valor del arreglo
int posiciones; // aqui vamos a ingresar la cantidad de posiciones que deseamos desplazar
int contador=0;
System.out.println("Ingrese los valores para llenar el arreglo");
Scanner entrada = new Scanner(System.in);
for (int i = 0; i < 10; i++) {
System.out.print(" [ " + i + " ] " + " = ");
arreglo[i] = entrada.nextInt();
}
System.out.println(" Cuantas posiciondes deseas desplazar la matriz ? = " );
posiciones = entrada.nextInt();
while (posiciones != contador){
ultimo = arreglo[9];
for (int j = 8; j >= 0; j--) {
arreglo[j+1] = arreglo[j];
}
arreglo[0] = ultimo;
contador++;
}
System.out.println("El resultado de la matriz final es : ");
for (int i = 0; i < 10; i++) {
System.out.println(" [ " + i + " ] " + " = " + arreglo[i] );
}
/*
Ejercicio 10: Crear un programna
que lea por teclado una tabla de 10
números enteros y desplace N
posiciones en el arreglo (N es
digitado por el usuario).
*/
package desplazar_n_veces_array;
import java.util.Scanner;
/**
*
* @author Daniel
*/
public class Desplazar_n_veces_array {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner in = new Scanner(System.in);
int A[], tmp[], desplazador;
A = new int[10];
System.out.println("Llene el array a continuación: ");
for(int i=0; i
posible solución ejercicio 2 video 48:
int arreglo[] = new int[10];
int ultimo; // aqui vamos a guardar el ultimo valor del arreglo
int posiciones; // aqui vamos a ingresar la cantidad de posiciones que deseamos desplazar
int contador=0;
System.out.println("Ingrese los valores para llenar el arreglo");
Scanner entrada = new Scanner(System.in);
for (int i = 0; i < 10; i++) {
System.out.print(" [ " + i + " ] " + " = ");
arreglo[i] = entrada.nextInt();
}
System.out.println(" Cuantas posiciondes deseas desplazar la matriz ? = " );
posiciones = entrada.nextInt();
while (posiciones != contador){
ultimo = arreglo[9];
for (int j = 8; j >= 0; j--) {
arreglo[j+1] = arreglo[j];
}
arreglo[0] = ultimo;
contador++;
}
System.out.println("El resultado de la matriz final es : ");
for (int i = 0; i < 10; i++) {
System.out.println(" [ " + i + " ] " + " = " + arreglo[i] );
}
Gracias! El programa se hace mucho mas simple usando un bucle While, no me había percatado :)
Ojala lleguemos a POO...
EJERCICIO 10
package vsrhtrjyf;
//AUTOR: KEVIN P.CAMAN
import java.util.Scanner;
public class Vsrhtrjyf {
public static void main(String[] args) {
// TODO code application logic here
Scanner input = new Scanner(System.in);
int [] n = new int [10];
//Guardamos elementos en nuestro vector
for(int i=0;i
package arreglos;
import java.util.Scanner;
public class Ejercicio10 {
public static void main(String[]args){
Scanner entrada = new Scanner(System.in);
int arreglo[] = new int[10]; //Se declara el arreglo
int posiciones, ultimo;
//Se pide el llenado del arreglo
System.out.println("Llenado del arreglo");
for(int i = 0;i0;i--){
for(int j=8;j>=0;j--){
arreglo[j+1] = arreglo[j];
}
arreglo[0] = ultimo; //Se tomará el número de la posición 0 para la variable ultimo
ultimo = arreglo[9]; // Ahora en la posición 9 del arreglo estará el valor de la variable último
}
//Se manda a imprimir el arreglo
System.out.println("
El nuevo arreglo es: ");
for(int i = 0;i
public static void main(String[] args) {
Scanner entrada=new Scanner(System.in);
int[] numeros=new int[10];
int[] numerosAux=new int[10];
int n;
System.out.println("Digite elementos del arreglo:");
for(int i=0;i
Me ha costado mucho este ejercicio, quisiera saber como puedo tener una resolución más rápida y efectiva para los arreglos.
@fanger 360 uff vaya que ahora la práctica a ayudado jajajjaa tu respuesta me hace ver cómo pasa el tiempo. Gracias siempre a este gran maestro .
Siempre va a haber frustración pero si se practica y se insiste en buscar la solución eventualmente se logra. Paciencia, dedicación y aceptar que tal ves un día no se pudo pero al siguiente puede que sí.
package nposicionesarreglo;
import java.util.Scanner;
public class NPosicionesArreglo {
public static void main(String[] args) {
Scanner entrada= new Scanner(System.in);
int arreglo[]=new int[10];
int aux[]=new int[10];
for (int i = 0; i < 10; i++) {
System.out.println("Ingrese los numeros: ");
arreglo[i]=entrada.nextInt();
}
System.out.println("Ingrese el numero de posicicones a trasladar: ");
int pasos=entrada.nextInt();
int j=pasos;
int u=pasos;
for (int k = 0; k < 10-u; k++) {
aux[pasos]=arreglo[k];
pasos++;
}
for (int i = 8;j>0; i--) {
aux[j-1]=arreglo[i+1];
j--;
}
for (int i = 0; i < 10; i++) {
System.out.print(aux[i]+" ");
}
}
}
package Arreglo;
import java.util.Scanner;
public class Ejercicio10 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int[] arreglo = new int[10];
System.out.println("Llenar arreglo:");
for (int i = 0; i < arreglo.length; i++) {
System.out.print((i + 1) + "Ingresar un dijito: ");
arreglo[i] = entrada.nextInt();
}
System.out.println("Ingrese el numero a desplazar:");
int n = entrada.nextInt();
int[] arregloDesplazado = desplazarArreglo(arreglo, n);
System.out.println("Arreglo desplazado: ");
for (int i = 0; i < arregloDesplazado.length; i++) {
System.out.println(arregloDesplazado[i]);
}
}
public static int[] desplazarArreglo(int[] arreglo, int n) {
// Crear un nuevo arreglo para almacenar el arreglo desplazado
int[] nuevoArreglo = new int[arreglo.length];
// Realizar el desplazamiento utilizando una operación de rebanado (slicing)
System.arraycopy(arreglo, n, nuevoArreglo, 0, arreglo.length - n);
System.arraycopy(arreglo, 0, nuevoArreglo, arreglo.length - n, n);
return nuevoArreglo;
}
}
Ejercicio 10:
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int arreglo[] = new int[10];
int ultimos[], N;
System.out.println("SOLICITANDO LOS ELEMENTOS DEL ARREGLO");
for (int i = 0; i < 10; i++) {
System.out.print("Digite un número: ");
arreglo[i] = entrada.nextInt();
}
System.out.print("
Ingrese la cantidad de posiciones a recorrer: ");
N = entrada.nextInt();
ultimos = new int[N];
int j = N - 1;
for (int i = 9; i > 9 - N; i--) {
ultimos[j] = arreglo[i];
j--;
}
for (int i = 9 - N; i >= 0; i--) {
arreglo[i + N] = arreglo[i];
}
for (int i = 0; i < N; i++) {
arreglo[i] = ultimos[i];
}
System.out.println("
ELEMENTOS REORDENADOS");
System.out.println("Los elementos del arreglo son: ");
for (int i = 0; i < arreglo.length; i++) {
System.out.print(arreglo[i] + " ");
}
}
Ej 10
package ejercicios.java;
import java.util.Scanner;
public class EjerciciosJava {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int a[] = new int[10];
int numpos, ultnum;
// obteniendo los 8 valores para el arreglo.
System.out.println("Digite los valores para el arreglo: ");
for(int i = 0; i < 10; i++){
System.out.print((i+1)+". Digite el valor: ");
a[i]= entrada.nextInt();}
System.out.print("Por favor ingrese la cantidad de veces que desea que se desplase el arreglo: ");
numpos = entrada.nextInt();
for(int j = 0; j < numpos;j++){
ultnum = a[9];
for(int i = 8; i >= 0; i--){
a[i + 1] = a[i];
}
a[0] = ultnum;
}
for(int i = 0; i
creo fue la respuesta a la que mas le pude entender