VECTORES: // Solicita al usuario el tamaño de los

Dados dos vectores A y B ordenados vectores

ascendentemente llevar todos sus elementos a [Link]("Ingrese el tamaño del
un nuevo vector C que también deberá estar vector A: ");
int sizeA = [Link]();
ordenado ascendentemente
int[] A = new int[sizeA];
Analisis.-
[Link]("Ingrese el tamaño del
Definir tamañoA, tamañoB como enteros
vector B: ");
Definir A como arreglo de enteros int sizeB = [Link]();
Definir B como arreglo de enteros int[] B = new int[sizeB];
Definir C como arreglo de enteros // Solicita al usuario los elementos de cada
Imprimir "Ingrese el tamaño del vector A: " vector
Leer tamañoA [Link]("Ingrese los elementos
Establecer A con tamaño tamañoA del vector A ordenados ascendentemente:");
Imprimir "Ingrese el tamaño del vector B: " for (int i = 0; i < sizeA; i++) {
Leer tamañoB A[i] = [Link]();
Establecer B con tamaño tamaño }
[Link]("Ingrese los elementos
del vector B ordenados ascendentemente:");
Diagrama de flujo.-
for (int i = 0; i < sizeB; i++) {
B[i] = [Link]();
}
// Cierra el scanner
[Link]();
// Fusiona los vectores A y B en C
int[] C = new int[sizeA + sizeB];
int i = 0, j = 0, k = 0;
while (i < sizeA && j < sizeB) {
C[k++] = A[i] < B[j] ? A[i++] : B[j++];
}
while (i < sizeA) {
C[k++] = A[i++];
}
while (j < sizeB) {
C[k++] = B[j++];
}
// Imprime el vector C
[Link]("Vector C resultante:");
for (int num : C) {
[Link](num + " ");
}
}
}

Codificación.-
Scanner scanner = new Scanner([Link]);
Dado un vector A de N elementos hacer rotar [Link]("Arreglo original: ");
hacia la derecha en K elementos imprimirArreglo(A);
// Realizar la rotación
Análisis.- rotarDerecha(A, K);
Definir N como entero // Mostrar el arreglo rotado
Definir A como arreglo de enteros [Link]("Arreglo después de rotar
Definir K como entero
" + K + " veces a la derecha: ");
Establecer A con tamaño N
imprimirArreglo(A);
Para i desde 0 hasta N-1 hacer
// Cerrar el scanner
Diagrama de flujo.- [Link]();
}
public static void rotarDerecha(int[] arreglo, int
K) {
if (arreglo == null || K < 0) {
throw new IllegalArgumentException("El
arreglo no puede ser nulo y K no puede ser
negativo");
}
int N = [Link];
// Normalizar K en caso de que sea mayor
que N
K = K % N;
if (K == 0) {
return; // No es necesario rotar
}
// Rotar el arreglo K veces
for (int i = 0; i < K; i++) {
int ultimo = arreglo[N - 1];
for (int j = N - 1; j > 0; j--) {
arreglo[j] = arreglo[j - 1];
}
arreglo[0] = ultimo;
Codificación.-
}
Scanner scanner = new Scanner([Link]);
}
// Solicitar al usuario el tamaño del arreglo
public static void imprimirArreglo(int[] arreglo)
[Link]("Ingrese el tamaño del
{
arreglo: ");
for (int i = 0; i < [Link]; i++) {
int N = [Link]();
[Link](arreglo[i] + " ");
// Crear el arreglo con el tamaño
}
especificado
[Link]();
int[] A = new int[N];
}
// Solicitar al usuario los elementos del
}
arreglo
[Link]("Ingrese los elementos
del arreglo:");
for (int i = 0; i < N; i++) {
A[i] = [Link]();
}
[Link]("Ingrese el número de
rotaciones a la derecha: ");
int K = [Link]();
// Mostrar el arreglo original
 Realizar el producto de dos vectores for (int i = 0; i < sizeA; i++) {
considerando que son de distinta longitud A[i] = [Link]();
Analisis.- }
poducto escalar de 2 vectores A y B [Link]("Ingresa los elementos
donde M,N son como longitud del vector del segundo vector:");
A*B=a1*b1+a2*b2+an*bn..... for (int i = 0; i < sizeB; i++) {
A=[a1,a2,a3] B[i] = [Link]();
B=[b1,b2,0] }
A*B=a1*b1+a2*b2+a3*0 int producto = 0;
fin for (int i = 0; i < [Link](sizeA, sizeB); i++) {
diagrama de flujo.- producto += A[i] * B[i];
}
[Link]("El producto de los
vectores es: " + producto);
[Link]();
}}
Inicio
Definir tamañoA, tamañoB como enteros
Definir A, B como arreglos de enteros
Definir producto como entero y establecerlo en
0
Imprimir "Ingresa el tamaño del primer vector:
"
Leer tamañoA
Establecer A con tamaño tamañoA
Imprimir "Ingresa el tamaño del segundo
vector: "
Leer tamañoB
Establecer B con tamaño tamañoB
Imprimir "Ingresa los elementos del primer
vector:"
Para i desde 0 hasta tamañoA-1 hacer
Leer A[i]
Fin Para
Imprimir "Ingresa los elementos del segundo
vector:"
Para i desde 0 hasta tamañoB-1 hacer
Leer B[i]
Fin Para
Para i desde 0 hasta el mínimo entre tamañoA
codificacion.- y tamañoB hacer
import [Link]; producto = producto + (A[i] * B[i])
public class ProductoVectores { Fin Para
public static void main(String[] args) { Imprimir "El producto de los vectores es: " +
Scanner scanner = new Scanner([Link]); producto
Fin
[Link]("Ingresa el tamaño del Prueba de Escritorio:
primer vector: "); ingrese los vectores:
int sizeA = [Link](); *A = [1,2,3]
[Link]("Ingresa el tamaño del *B =[4,5 ]
segundo vector: "); *B extendido= [4,5,0]
int sizeB = [Link](); PRODUCTO PUNTO=(1/times 4+2 /times 5 +
int[] A = new int[sizeA]; 3/times0)
int[] B = new int[sizeB]; PP=(4+10+0)
[Link]("Ingresa los elementos pp=14.
del primer vector:");
Generar los primeros N números primos y Definir count como entero y establecerlo en 0
almacenarlos en un vector P Definir num como entero y establecerlo en 2
Analisis.- Imprimir "Ingrese el valor de N: "
P. vector almacenaje Leer n
verificacion de primos Establecer vectorPrimos con tamaño n
K=2 ; /K2
n=2 p<N(n)=p Mientras count < n hacer
n=n+1/p Si esPrimo(num) entonces
si k mod i==0; vectorPrimos[count] = num
falso/verdadero Incrementar count
Codificacion.- Fin Si
import [Link]; Incrementar num
public class NumerosPrimos { Fin Mientras
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]); Imprimir "Los primeros " + n + " números
[Link]("Ingrese el valor de N: "); primos son:"
int n = [Link](); Para i desde 0 hasta n-1 hacer
Imprimir vectorPrimos[i] + " "
int[] vectorPrimos = new int[n]; Fin Para
int count = 0; Fin
int num = 2; // Comenzamos con el primer
número primo Función esPrimo(num)
Si num <= 1 entonces
while (count < n) { Retornar falso
if (esPrimo(num)) { Fin Si
vectorPrimos[count] = num;
count++; Para i desde 2 hasta la raíz cuadrada de num
} hacer
num++; Si num módulo i es 0 entonces
} Retornar falso
Fin Si
[Link]("Los primeros " + n + " Fin Para
números primos son:");
for (int i = 0; i < n; i++) { Retornar verdadero
[Link](vectorPrimos[i] + " "); Fin Función
}
} Prueba de escritorio:
P=0
// Función para verificar si un número es primo 2=p ; P=[2]
public static boolean esPrimo(int num) { p= [2,3,5]
if (num <= 1) { los tres primeros primos.
return false;
}
for (int i = 2; i <= [Link](num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
}

Inicio
Definir n como entero
Definir vectorPrimos como arreglo de enteros
MATRIZES: [Link]("Ingrese el número de
Leer una matriz A de orden MxN y un número k. filas de la matriz (M):");
Multiplicar todos los elementos de la matriz por int m = [Link]();
el número k. Mostrar la matriz resultante [Link]("Ingrese el número de
Análisis.- columnas de la matriz (N):");
Pedir al usuario el número de filas M int n = [Link]();
Pedir al usuario el número de columnas N int[][] matrixA = new int[m][n];
Declarar matrixA como una matriz de enteros de [Link]("Ingrese los elementos de
tamaño MxN la matriz A:");
Para i desde 0 hasta M-1 hacer: for (int i = 0; i < m; i++) {
Para j desde 0 hasta N-1 hacer for (int j = 0; j < n; j++) {
Pedir al usuario que ingrese el elemento [i][j] matrixA[i][j] = [Link]();
de matrixA }
}
Diagrama de flujo.- [Link]("Ingrese el número k para
multiplicar la matriz:");
int k = [Link]();
// Multiplicar cada elemento por k
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
matrixA[i][j] *= k;
}
}
// Mostrar la matriz resultante
[Link]("La matriz resultante
es:");
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
[Link](matrixA[i][j] + " ");
}
[Link]();
}
}
}

Codificación:
import [Link];
public class MatrixMultiplier {
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
Leer una matriz C de orden P (matriz cuadrada). for (int i = 0; i < p; i++) {
Mostrar los elementos de la diagonal principal, for (int j = 0; j < p; j++) {
secundaria, de la matriz triangular superior y de matrizC[i][j] = [Link]();
la matriz triangular inferior }
}
Analisis.- [Link]("Diagonal Principal:");
Imprimir "Ingrese el orden P de la matriz for (int i = 0; i < p; i++) {
cuadrada: " [Link](matrizC[i][i] + " ");
Leer p }
Declarar matrizC[p][p] [Link]();
Imprimir "Ingrese los elementos de la matriz C:" [Link]("Diagonal Secundaria:");
Para i desde 0 hasta p-1 hacer for (int i = 0; i < p; i++) {
Para j desde 0 hasta p-1 hacer [Link](matrizC[i][p - 1 - i] + " ");
Leer matrizC[i][j }
[Link]();
Diagrama de flujo.- [Link]("Matriz Triangular
Superior:");
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (i <= j) {
[Link](matrizC[i][j] + " ");
} else {
[Link](" ");
}
}
[Link]();
}
[Link]("Matriz Triangular
Inferior:");
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (i >= j) {
[Link](matrizC[i][j] + " ");
} else {
[Link](" ");
}
}
[Link]();
}
[Link]();
}
}

Codificacion.-
Scanner scanner = new Scanner([Link]);
[Link]("Ingrese el orden P de la
matriz cuadrada: ");
int p = [Link]();
int[][] matrizC = new int[p][p];
[Link]("Ingrese los elementos de
la matriz C:");
 d) CODIFICACION EN JAVA.
package matriz;
import [Link];
public class JavaApplication104 {
public static void main(String[] args) {
[Link]("introducir el tamaño de
a) ANALISIS. la matriz: ");
matriz[i][j] = 4 se asigna cuando: Scanner k=new Scanner([Link]);
j == i (diagonal principal), int n=[Link]();
i + j == n - 1 (diagonal secundaria), if (n % 2 != 0 && n > 3) {
(j < i && i + j < n - 1) (triángulo superior int[][] matriz = generar(n);
izquierdo), [Link]("la matriz es : ");
(j > i && i + j > n - 1) (triángulo inferior derecho). imprimir(matriz);
} else {
b) DIAGRAMA DE FLUJO. [Link]("n debe ser un número
impar mayor que 3.");
}
}

public static int[][] generar(int n) {

int[][] matriz = new int[n][n];
// Llenar la matriz con 1s
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
matriz[i][j] = 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j == i || i + j == n - 1 || (j < i && i + j <
n - 1) || (j > i && i + j > n - 1)) {
matriz[i][j] = 4;
}
}
}
return matriz;
}
public static void imprimir(int[][] matrix) {
c) PRUEBA DE ESCRITORIO. for (int[] row : matrix) {
for (int value : row) {
[Link](value + " ");
}
[Link]();
}
}
}
 d. CODIFICACION JAVA.
a. ANALISIS. Package espiral;
• Este método recibe como parámetro n, que es el import [Link];
tamaño de la matriz. public class espiral {
• Crea una matriz cuadrada de tamaño n x n. public static void main(String[] args) {
• Utiliza cuatro variables (rowStart, rowEnd, colStart,
colEnd) para rastrear los límites actuales de la
[Link]("introducir el tamaño de
espiral dentro de la matriz. la matriz: ");
• Utiliza un bucle while para llenar la matriz en Scanner k=new Scanner([Link]);
espiral: int n=[Link]();
if (n % 2 != 0 && n > 3) {
a) Llena los elementos de la fila superior de derecha a int[][] matrix = espiral(n);
izquierda.
[Link]("la matriz es : ");
b) Llena los elementos de la columna derecha de
arriba hacia abajo. printMatrix(matrix);
c) Llena los elementos de la fila inferior de izquierda a } else {
derecha. [Link]("n debe ser un número
d) Llena los elementos de la columna izquierda de
impar mayor que 3.");
abajo hacia arriba.
• Incrementa o decrementa las variables de límite
}
(rowStart, rowEnd, colStart, colEnd) para ajustar el }
borde de la espiral después de cada ciclo de public static int[][] espiral(int n) {
llenado. int[][] matrix = new int[n][n];
• Continúa este proceso hasta que todos los int num = 1; // Iniciar con el número 1
elementos de la matriz estén llenos.
int rowStart = 0, rowEnd = n - 1;
b. DIAGRAMA DE FLUJO. int colStart = 0, colEnd = n - 1;
while (num <= n * n) {
for (int i = colEnd; i >= colStart; i--) {
matrix[rowStart][i] = num++;
}
rowStart++;
for (int i = rowStart; i <= rowEnd; i++) {
matrix[i][colStart] = num++;
}
colStart++;
for (int i = colStart; i <= colEnd; i++) {
matrix[rowEnd][i] = num++;
}
rowEnd--;
for (int i = rowEnd; i >= rowStart; i--) {
matrix[i][colEnd] = num++;
}
colEnd--;
}
return matrix;
}
public static void printMatrix(int[][] matrix) {
c. PRUEBA DE ESCRITORIO. for (int[] row : matrix) {
 for (int num : row) {
[Link]("%-3d", num); //
Ajustar formato para impresión
}
[Link]();
}
}
}

a) ANALISIS
• Crea una matriz cuadrada de tamaño n x
n.
c) PRUEBA DE ESCRITORIO.
• Utiliza la variable num para rastrear el
número actual que se está colocando en
la matriz, comenzando desde 1.
• Utiliza la variable goingDown para
controlar la dirección de llenado (hacia
abajo o hacia arriba en el patrón en
zigzag).
• Utiliza variables row y col para seguir la
posición actual en la matriz.
• Utiliza un bucle while que se ejecuta d) CODIFICACION EN JAVA
mientras num es menor o igual a n*n package zigzag;
para llenar la matriz en zigzag: import [Link];
✓ Si goingDown es verdadero, verifica si se public class zigzag {
ha alcanzado el borde inferior de la public static void main(String[] args) {
matriz o si se debe cambiar de dirección. [Link]("introducir el tamaño de
✓ Si goingDown es falso, verifica si se ha la matriz: ");
alcanzado el borde derecho de la matriz Scanner k=new Scanner([Link]);
o si se debe cambiar de dirección. int n=[Link]();
• Ajusta las variables row y col según la if (n % 2 != 0 && n > 3) {
dirección actual (goingDown o no) para int[][] matrix = generateZigzagMatrix(n);
avanzar en zigzag. [Link]("la matriz es : ");
• Incrementa num después de colocar printMatrix(matrix);
cada número en la matriz. } else {
[Link]("n debe ser un número
b) DIAGRAMA DE FLUJO impar mayor que 3.");
}
}
public static int[][] generateZigzagMatrix(int n)
{
int[][] matrix = new int[n][n];
int num = 1; // Iniciar con el número 1
boolean goingDown = true;
 int row = 0, col = 0; Para ilustrar el proceso, consideremos n = 5:
while (num <= n * n) {
matrix[row][col] = num++; • En la primera iteración (i = 0):
límites o a una celda ya ocupada o j varía de 0 a 4, y se asignan
if (goingDown) { valores en las posiciones [0][0],
if (row == n - 1) { [1][1], [2][2], [3][3], [4][4].
goingDown = false; • En la segunda iteración (i = 1):
col++; o j varía de 1 a 4, y se asignan
} else if (col == 0) { valores en las posiciones [0][1],
[1][2], [2][3], [3][4].
goingDown = false;
• Y así sucesivamente, completando el
row++;
patrón en diagonal y arriba de ella.
} else {
row++;
col--; b) DIAGRAMA DE FLUJO.
}
} else {
if (col == n - 1) {
goingDown = true;
row++;
} else if (row == 0) {
goingDown = true;
col++;
} else {
row--;
col++;
}
}
}

return matrix;
} c) PRUEBA DE ESCRITORIO

public static void printMatrix(int[][] matrix) {

for (int[] row : matrix) {
for (int num : row) {
[Link]("%-3d", num); //
Ajustar formato para impresión
}
[Link]();
}
}
}

d) CODIFICACION JAVA
package diagonalsuperior;
import [Link];
public class diagonalsuperior {
public static void main(String[] args) {
[Link]("introducir el tamaño de
la matriz: ");
Scanner k=new Scanner([Link]);
a) ANALISIS. int n=[Link]();
 if (n % 2 != 0 && n > 3) {
int[][] matrix =
generateCustomPatternMatrix(n);
printMatrix(matrix);
} else {
[Link]("n debe ser un número
impar mayor que 3.");
}
}
public static int[][]
generateCustomPatternMatrix(int n) {
int[][] matrix = new int[n][n];
int num = 1; // Iniciar con el número 1
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
matrix[j - i][j] = num++; // Llenar en la
diagonal y arriba
}
}

return matrix;
}

public static void printMatrix(int[][] matrix) {

for (int[] row : matrix) {
for (int num : row) {
[Link]("%02d ", num);
}
[Link]();
}
}
}