Upload
christianulises
View
81
Download
0
Embed Size (px)
Citation preview
COLEGIO DE ESTUDIOS CIENTÍFICOS Y TECNOLÓGICOS DEL ESTADO
DE MÉXICO
TÉCNICO EN PROGRAMACIÓN
DESARROLLA APLICACIONES MÓVILES
Alumno: Christian Ulises Pérez Espinosa
Grupo: 403
PRACTICAS
INDICE
FIGURAS RECTANGULARES………………………………………………………………………...3
SUMANDO………………………………………………………………………………………………..5
FRECUENCIAS………………………………………………………………………………………….8
CUADRADO...…………………………………………………………………………………………...10
BARDEANDO…………………………………………………………………………………………...13
MATRIZ CUADRADA…………………………………………………………………………………15
SUMA TRIPLE………………………………………………………………………………………….17
TRIANGULO……………………………………………………………………………………………19
ROMANOS………………………………………………………………………………………………21
TABLERO DE AJEDREZ……………………………………………………………………………...23
INTERVALOS…………………………………………………………………………………………..25
SEDES……………………………………………………………………………………………………27
NO.FIBONACCI………………………………………………………………………………………...29
Figuras Rectangulares Descripción
Tenemos un conjunto de cuadrados y rectángulos cuyos medidas de sus diferentes lados son cantidades
enteras y mayores a 1 y , si tenemos el área de la figura, es posible que sea un cuadrado o un rectángulo. Problema
Construye un programa que nos ayude a resolver este problema (dada el área de una figura determinar si es
cuadrado o rectángulo), la lectura la debes hacer de la entrada estándar (teclado) y la escritura se debe hacer a
la salida estándar (pantalla). Entrada
La primera línea contendrá un número "N" entre 1 y 1,000,000,000, representando el área.
Salida
Una sola línea indicando la figura que se puede formar, si el área puede formar un cuadrado debes imprimir la
palabra “cuadrado” si el área puede formar un rectángulo, debes imprimir la palabra “rectangulo” y si el área
puede formar ambos debe imprimir la palabra “ambos” (note no hay acentos ni mayusculas), en caso de que no
se pueda formar un cuadrado o rectángulo escriba "ninguno" Ejemplos
Entrada Salida
9 cuadrado
6 rectangulo
36 ambos
Consideraciones
Tu programa se ejecutara con varios casos de prueba.
Tips
Área de un cuadrado = lado * lado
Área de un rectángulo= (base * altura )
¿Hasta que valor con respecto a “N” debo probar ?
Observa que solo debes probar desde 2 hasta raíz de "N", si un número es divisible entre 2 significa que
también es divisible entre N/2 por tanto si probamos con el numero 2, estamos al mismo tiempo probando
con el numero N/2.
Código: import java.util.*;
public class Figuras { public static void main(String[] args) { Scanner Yo=new Scanner(System.in);
System.out.println("Valor"); int n=Yo.nextInt(); System.out.println(ChecaQueEs(n));
} public static String ChecaQueEs(int n){ String Resultado="";
int c=0; int raiz=(int) Math.sqrt(n); for(int i=2;i<n;i++){
if(n%i==0){ c++; }
} if((raiz*raiz)==n && c>=2){ Resultado="Ambos";
} else if((raiz*raiz)!=n && c>=2){ Resultado="Rectangulo";
} else if((raiz*raiz)==n){ Resultado="Cuadrado";
} else{ Resultado="Ninguno"; }
return Resultado; } }
Pruebas de Escritorio:
Sumando
Problema Se tiene un matriz cuadrada de tamaño “n” y se requiere saber cuánto suma cada columna.
Entrada En el primer renglón un valor “n” indicando el tamaño de la matriz donde 1<=n<=1000 y en los siguientes
“n” renglones habrán “n” valores correspondientes los valores de cada renglón de la matriz donde 1<=V<=
1000.
Salida Un renglón con “n” cantidades, cada cantidad representa la sumatoria de cada columna de la matriz, el
primer valor corresponde a la columna 1, el segundo a la columna 2 ,... y el último valor corresponde a la
columna “n”.
Consideraciones Tu programa se evaluará con varios casos de prueba.
Ejemplos
Entrada Salida
Descripción
3 11 15 18 Case #1:
1 2 3
3 5 6
7 8 9
4 13 14 13 9 Case #2:
3 2 4 3
2 3 3 2
7 8 5 3
1 1 1 1
Código:
import java.util.*;
public class sumando{
public static void main(String[]args){
Scanner in=new Scanner(System.in);
int num=in.nextInt();
int numeros[][]= new int[num][num];
int suma[]=new int[num];
int sumafila[]=new int[num];
for(int i=0;i<num;i++){
for(int k=0;k<num;k++){
numeros[i][k]=in.nextInt();
} }
imprimir(numeros,num);
obsuma(numeros,num,suma,sumafila);
}
public static void imprimir(int [][] numeros,int n){
for(int i=0;i<n;i++){
for(int k=0;k<n;k++){
System.out.print("numeros["+i+"]["+k+"]=>"+numeros[i][k]+" ");
}
System.out.println(" ");
}
} public static void obsuma(int [][] numeros,int n,int [] suma,int []sumafila){
System.out.println("nnSuma de columnas:n");
for(int i=0;i<n;i++){
for(int k=0;k<n;k++){
suma[k]+=numeros[i][k];
} }
for(int j=0;j<n;j++){
System.out.println("Columna #"+(j+1)+" "+suma[j]+" "); }
System.out.println("nn");
System.out.println("Suma de filas:n");
for(int i=0;i<n;i++){
for(int k=0;k<n;k++){
sumafila[i]+=numeros[i][k];
} }
for(int l=0;l<n;l++){
System.out.println("Fila #"+(l+1)+" "+sumafila[l]+" ");
} } }
Frecuencias
Descripción Cierta escuela realiza cuestionarios para conocer al profesor favorito de los alumnos. Y lo realiza de la
siguiente manera; a cada profesor se le asigna un número posteriormente a cada alumno se le pregunta
cual es su profesor favorito, posteriormente, se calcula una tabla de frecuencia indicando en cada profesor
cual es la cantidad de alumnos que lo eligieron. Problema
Escribe un programa que ayude a la escuela a escribir la tabla de frecuencias.
Entrada En la primera línea el número “P” que indica la cantidad de pro fesores que tiene la escuela donde 1<=P <=
100 y el número “n” que indica la cantidad de alumnos en la escuela donde 1<=n<=1000. en la siguiente
línea habrán “n” números que representan el número de profesor favorito “F” de cada alumno donde 1<=F<=P.
Salida Deberá haber “P” cantidad de líneas y en cada una dos números separados por un guión, el primer número
será el número del profesor y el segundo número la cantidad de alumnos que lo eligieron. Consideraciones
Tu programa se evaluará con varios casos de prueba.
Ejemplos
Entrada Salida Descripción
4 10 1-4 Case #1:
1 1 2 1 1 2 3 2 3 4 2-3
3-2
4-1
4 8 1-3 Case #2:
1 2 4 1 2 4 1 2 2-3
3-0
4-2
Código:
import java.util.*;
public class frecuencias{
public static void main(String[]args){
Scanner datos=new Scanner(System.in);
int nprofs=datos.nextInt();//pide numero de profesores
int nprofsarray[]=new int[nprofs];//arreglo del numero de profesores
int nalumnos=datos.nextInt();//pide numero de alumnos
int votos[]=new int[nalumnos];//arreglo donde guarda los votos con longitud del numero
de alumnos
for(int contvotos=0;contvotos<nalumnos;contvotos++){
votos[contvotos]=datos.nextInt();
}
System.out.print("");
for (int a=0;a<nalumnos ;a++ ) {
nprofsarray[votos[a]-1]+=1;
}
for (int j=0;j<nprofs;j++) {
System.out.print("\nProfesor "+(j+1)+" => "+nprofsarray[j]);
}
}}
Pruebas de Escritoro:
Cuadrado
Descripción.
A continuación te mostramos un giro de 90 grados a la derecha de una matriz de 2 por 2 cuyos valores son:
Matriz original
1 2 3 4
Matriz Girada 90° a la derecha 3 1 4 2
Problema
Dada una matriz cuadrada de tamaño “n” , debes hacer que tu programa la gire 90 grados a la derecha.
Entrada
En la primera línea el valor “n” indicando el tamaño de la matriz donde 1<=n<=1000, en los siguientes “n”
renglones habrán “n” valores de la matriz separados por un espacio.
Salida
“n” renglones cada renglón con "n" valores mostrando la matriz girada 90 grados.
Consideraciones Tu programa se evaluará con varios casos de prueba
Ejemplo
Entrada Salida
Descripción
2 3 1 Case #1:
1 2 4 2
3 4
3 7 4 1 Case #2:
1 2 3 8 5 2
4 5 6 9 6 3
7 8 9
Código:
import java.util.*;
public class giro{
public static void main(String[] args) { Scanner datos=new Scanner(System.in); int numero=datos.nextInt();
int cuadro[][]=new int[numero][numero];
for(int di1=0;di1<numero;di1++){ for(int di2 =0;di2 <numero;di2 ++){
cuadro[di1][di2]=datos.nextInt(); }
} System.out.println("\nCuadro \n");
for(int di1=0;di1<numero;di1++){
for(int di2 =0;di2<numero;di2 ++){ System.out.print(cuadro[di1][di2]+" "); }System.out.println(" ");
} System.out.println("\n");
System.out.println("Giro de 90 \n"); int cont2=0;
for (int v=0;v<numero ;v++ ) { for(int di1=numero;di1>=0;di1--){
for(int h=0;h<numero;h++){ di1--; for(int di2=cont2;di2<=cont2;di2++){
System.out.print(cuadro[di1][di2]+" ");
} }
cont2++; }
System.out.println(" "); }
}
}
Pruebas de Escritorio:
Bardeando
Descripción Se tiene un conjunto de “n” trozos de malla ciclónica y un terreno de perímetro “P” el terreno es cuadrado.
Problema Debes escribir un programa que nos diga cuántos metros de malla ciclonica nos hace falta para poder
bardear el terreno.
Entrada En la primera línea dos números “P” y "n", donde "P" representa el perímetro del terreno con un rango de
valores de 1<=P <= 2,000,000,000 y “n” representa la cantidad de trozos de malla ciclónica que tenemos,
donde 1<=n<=100,000. En las siguientes “n” líneas es el tamaño de cada trozo de malla que tenemos. La
suma de todos los trozos siempre será menor a 2147483648. Salida
Un único valor entero indicando los metros de malla que nos hacen falta para bardear el terreno.
Ejemplos
Entrada Salida Descripción
100 3 45 Caso #1
25
20
10
100 2 0 Caso #2
1000
2000
21 1 1 Caso #3
20
Código:
import java.util.*;
public class bardeando{ public static void main(String []args){
Scanner leer=new Scanner(System.in); int P=leer.nextInt(); int m=leer.nextInt();
int x=0;
int [] trozos=new int[m]; for(int i=0;i<m;i++){ int n=leer.nextInt();
trozos[i]=n; }
for (int k=0;k<m;k++) { x=trozos[k]+x; }
int y=P-x; System.out.println("");
System.out.println(""); if (y<0) { System.out.println("0");
}else{ System.out.println(y);
} } }
Pruebas de Escritorio:
Matriz Cuadrada
Descripción Descripción Tenemos una matriz de “R” renglones por “C” columnas, donde
podemos enumerar las casillas de la siguiente manera, la casilla 1,1 (renglón 1,
columna 1), la casilla 1,2 (renglón 1, columna 2) y la casilla 1,3 (renglón 1,
columna 3 ) serían respectivamente las posiciones 1, 2 y 3 como se puede ver en
la figura, donde la casilla 1,1 es la esquina superior izquierda y la celda “R” x “C”
es la celda ubicada en la esquina inferior derecha. En esta cuadrícula, podemos hacer preguntas de la forma, ¿que número está en la casilla 1,2 ? y su
respuesta sería 2 otro ejemplo ¿qué número está en la celda 2,3? y su respuesta es 6.
Problema Escribe un programa que dada las dimensiones de la cuadrícula responda una cantidad “P” de preguntas.
Entrada En la primera línea dos valores indicando las dimensiones de la cuadrícula separados por un espacio „R‟
cantidad de renglones donde 1<=R<=10000 y “C” cantidad de columnas donde 1<=C<=10000, En la tercera
línea el número “P” cantidad de preguntas donde 1<=P<=10,000 y en las siguientes “P” líneas un par de
coordenadas de la forma r, c, representando las coordenadas de cada pregunta en donde “r” indica el
renglón 1<=r<=R y “c” la columna 1<=c<=C por cada pregunta. Salida
Por cada pregunta debe escribir en cada línea el número de casilla que le corresponde.
Ejemplos
Entrada Salida Descripción
3 3 1 5 9 Caso #1
3
1 1
2 2
3 3
3 1000 1001 Caso #2
2
2010
2 1
2 10
Código:
import java.util.*;
public class matriz{ public static void main(String[]args){
Scanner in=new Scanner(System.in); int fil=in.nextInt(); int colum=in.nextInt();
int num=in.nextInt(); int arreglox [][]=new int [num][num];
int res[]= new int[num]; for(int k=0;k<num;k++){ for(int i=0;i<2;i++){
arreglox[k][i]=in.nextInt(); }
} for (int z=0;z<num;z++){ res[z]=((arreglox[z][0]-1)*colum)+arreglox[z][1];
} for(int k=0;k<num;k++){
System.out.println(""+res[k]); } }
}
Pruebas de Escritorio:
Suma Triple
Descripción Se tiene la siguiente función f(n), formada por la suma de los tres números anteriores.
f(1)=1
f(2)=1
f(3)=2
f(4)=4
f(5)=7
f(6)=13
f(7)=24
f(8)=44
f(9)=81
Note que f(1) = 1 ya que no tiene números anteriores, f(2)=1 ya que es el único número anterior, f(3) tiene
solo 2 números anteriores y a partir de f(4) se da la suma de los tres números anteriores.
Problema Escribe un programa que dado el valor de “n” escriba la serie correspondiente.
Entrada Un solo renglón conteniendo el valor “n”donde 1<=n<=64.
Salida Una sola línea mostrando la serie desde el número menor hasta el mayor cada número debe estar
separado por un espacio.
Entrada Salida Descripción
4 1 1 2 4 Caso #1
6 1 1 2 4 7 13 Caso #2
9 1 1 2 4 7 13 24 44 81 Caso #3
Tips Un entero 32 bits es capaz de almacenar la f(n) para n=60
Código:
import java.util.*; public class Triple{ public static void main(String[] args) {
Scanner datos=new Scanner(System.in); int numero[]=new int[100]; int suma[]=new int[100];
numero[1]=1; int n=datos.nextInt();
System.out.print("\n"); for (int sumar=1;sumar<=n ;sumar++ ) { numero[sumar+3]=numero[sumar]+numero[sumar+1]+nume
ro[sumar+2]; System.out.print("["+sumar+"] "+numero[sumar+3]+" ");
} System.out.print("n"); }}
Pruebas de Escritorio:
Triángulo
Descripción Un triángulo es formado por 3 segmentos (con valor entero) de recta unidos por sus
extremos, sin embargo no todas las combinaciones de 3 segmentos pueden formar un
triángulo. Problema
Escriba un programa que dados 3 números que representan 3 segmentos de rectas, diga si
pueden formar un triángulo rectángulo. Entrada
En la primera línea 3 números “a”, “b” y “c” representando las longitudes de 3 segmentos de
recta en un rango de entre 1 y 32,000. Salida
Una sola línea en donde si es posible generar un triángulo rectángulo debes imprimir la
hipotenusa, el cateto mayor y el cateto menor y si no es posible formar un triángulo
rectángulo imprime la palabra “imposible”.
Consideraciones Tu programa se evaluará con varios casos de prueba, para cada caso de prueba (entrada)
Ejemplos
Entrada Salida Descripción
1 1 1 imposible Caso #1
3 4 5 5 4 3 Caso #2
Consideraciones Tu programa se ejecutara con varios casos de prueba.
Tips El teorema de Pitágoras la hipotenusa es igual a la raíz cuadrada de la suma de los
cuadrados de sus catetos. ¿Es necesario hacer el cálculo de la raíz cuadrada?
Código:
import java.util.*;
import java.io.*; import java.math.*;
public class Triangulo{ public static void main (String[]args){ Scanner datos=new Scanner(System.in);
int a=datos.nextInt(); int b=datos.nextInt();
int c=datos.nextInt(); int ab2=((int) Math.pow(a,2))+((int) Math.pow(b,2)); int c2=(int) Math.pow(c,2);
if (ab2==c2) { if (b>a) {
System.out.print("\nHip=> "+c+" CM=> "+b+" Cm=> "+a+"\n"); }
if (a>b) { System.out.print("\nHip=> "+c+" CM=> "+a+" Cm=>
"+b+"\n"); } }
else{ System.out.print("\nImposible");
} } }
Pruebas de Escritorio:
Romanos
Descripción
Escribe un programa que lea un entero entre 1 y 100 e imprima su equivalencia en números
romanos.
Entrada Una línea con el entero a convertir.
Salida la conversión a números romanos (en mayúsculas).
Ejemplos
Entrada Salida Descripción
48 Salida Las equivalencias de números arábigos a romanos son:
XLVIII
I 1
V 5
X 10
L 50
C 100
Entrada Salida Descripción
Salida
LXXXIX
Código:
import java.util.Scanner;
public class Romanos {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String Unidad[]={"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
String Decena[]={"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
String Centena[]={"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
System.out.println("Ingresa un numero");
int N = sc.nextInt();
int u=N%10;
int d=(N/10)%10;
int c=N/100;
if(N>=100){
System.out.println(Centena[c]+Decena[d]+Unidad[u]);
}else{
if(N>=10){
System.out.println(Decena[d]+Unidad[u]);
}else{
System.out.println(Unidad[N]);
}
}
}
}
Pruebas de Escritorio:
Tablero de Ajedrez
Descripción Dadas las coordenadas de una casilla en un tablero de ajedrez de 8x8, determinar el color de dicha
casilla.
Entrada Una línea con la letra y dígito separados por espacios correspondientes a la coordenada de la casilla.
Salida Imprime BLANCO, NEGRO según sea el caso.
Ejemplos
Entrada Salida Descripción
a 1 Salida
NEGRO
Entrada Salida Descripción
c 2
Salida
BLANCO
Código:
import java.util.*;
import java.io.*; public class ajedrez{ public static void main(String[] args){
Scanner datos=new Scanner(System.in); String tablero[][]=new String[1000][1000];
for (char filas=104;filas>=97 ;filas-=2 ) {
for (int cols=1;cols<=8 ;cols+=2 ) { tablero[filas][cols]="Negro ";
tablero[filas][cols+1]="Blanco "; } }
for (char filas=103;filas>=97 ;filas-=2 ) { for (int cols=1;cols<=8 ;cols+=2 ) {
tablero[filas][cols]="Blanco "; tablero[filas][cols+1]="Negro "; }
} System.out.print("\n");
for (char filas=104;filas>=97 ;filas-- ) { for (int cols=1;cols<=8 ;cols++ ) { System.out.print("["+filas+"]["+cols+"]
"+tablero[filas][cols]+" "); }
System.out.print("\n\n"); } System.out.print("\n");
char filas=datos.next().charAt(0); int cols = datos.nextInt();
System.out.print(tablero[filas][cols]); System.out.print("\n"); }
} Pruebas de Escritorio:
Intervalo
Descripción Escribe un programa que lea tres enteros a, b, c y determine si c se encuentra en el
intervalo [a,b], a la izquierda o a la derecha de dicho intervalo.
Entrada Una línea con los enteros a,b,c separados por un espacio
Salida Imprime INTERVALO, IZQUIERDA o DERECHA según sea el caso.
Ejemplos
Entrada Salida Descripción
3 10 6 Salida 6 se encuentra contenido en el intervalo desde 3 hasta 10
INTERVALO
Entrada Salida Descripción
4 20 30 Salida 30 está a la derecha del intervalo 4 a 20.
DERECHA
Entrada Salida Descripción
2 30 1 Salida 1 está a la izquierda del intervalo 2 a 30
IZQUIERDA
Entrada Salida Descripción
10 20 10 Salida
INTERVALO
Código:
import java.util.*;
public class intervalo{
public static void main(String[] args) {
Scanner datos=new Scanner(System.in);
int a=datos.nextInt();
int b=datos.nextInt();
int c=datos.nextInt();
System.out.print("\n");
if (c>=a && c<=b) {
System.out.print("INTERVALO");
}
if (c>b) {
System.out.print(c+" esta a la derecha del intervalo "+a+" a "+b);
}
if (c<a) {
System.out.print(c+" esta a la izquierda del intervalo "+a+" a
"+b);
}
}
}
Pruebas de Escritorio:
Sedes
Descripción Ahora que estás en la preselección de Veracruz, debes prepararte mucho para ser
seleccionado. Como parte de este proceso, se deben realizar algunos entrenamientos y de
preferencia en varias sedes del estado, por ejemplo Coatzacoalcos, Veracruz, Xalapa,
Tuxpan, etc. Puesto que a ti te gusta viajar mucho, quieres asistir a las dos sedes que
estén más lejos entre sí. Suponiendo que todas las sedes se encontraran en línea recta, una tras de otra, identifica,
cuál es la distancia más larga que deberías recorrer entre dos sedes.
Entrada En la primera línea el número n, que indica la cantidad de sedes para este año.
1<=n<=100000. En las siguientes n líneas un número indicando la distancia de esa sede
con respecto a tu ubicación actual entre 0<=d <=5000. Supón que tu ubicación actual es el
inicio de la línea recta, por lo que todas las distancias serán positivas. Siempre te
encuentras en el km 0, y en el ejemplo la primera sede está a 7 kilómetros de tu ubicación,
la segunda a 5, la tercera a 13, y la cuarta a 4 kilómetros de tu ubicac
Salida Un solo número con un salto de línea, indicando la distancia máxima que hay entre dos
sedes. Ejemplo
4 9 7
5
13
4
Código:
import java.util.*; public class sedes{ public static void main(String[] args) {
Scanner datos=new Scanner(System.in); int tiros=datos.nextInt();
int valor[]=new int[1000]; for(int pos=0;pos<tiros;pos++){//guarda los numeros valor[pos]=datos.nextInt();
} for(int pos1=0;pos1<tiros-1;pos1++) {
for(int pos2=0;pos2<tiros-1;pos2++) { if(valor[pos2]>valor[pos2+1]) { int aux=valor[pos2];
valor[pos2]=valor[pos2+1];
valor[pos2+1]=aux; }
} }
int pos=0; System.out.print("Orden: "); for(int pos1=0;pos1<tiros;pos1++) {
System.out.print(valor[pos1]+" "); }
int maxima=valor[(pos+tiros)-1]-valor[pos]; System.out.print("\nDistancia maxima: "+maxima); }}
Pruebas de Escritorio:
No-Fibonacci "Leonardo de Pisa o Leonardo Pisano o Leonardo Bigollo(c. 1175 - 1250), tambi llamado Fibonacci, fue un
matemático italiano,famoso por la invención de la sucesión de Fibonacci, surgida como consecuencia del
estudio del crecimiento de las poblaciones de conejos" Wikipedia La sucesión de Fibonacci es una serie de números enteros positivos de la cual sus primeros 2 números son
1 y 2, luego de eso, cada número es el resultado de sumar los dos anteriores de dicha serie de la siguiente
forma: 1, 2, 3, 5, 8, 13, 21, 34, 55... Nótese que 1+2=3, 2+3=5, 5+8=13, 13+21=34, 21+34=55 ... Ahora, podrías pensar que el problema será calcular la serie de fibonacci, sin embargo es exactamente lo
contrario. Problema Escribe un programa que imprima en pantalla todos los números enteros positivos estrictamente menores
que N que NO pertenezcan a la serie de Fibonacci. Entrada Tu programa deberá de leer del un solo número entero 2 ≤ N ≤ 30000 (30 mil)
Salida Tu programa deberá imprimir en pantalla todos los números enteros positivos menores que N que no formen
parte de la serie de Fibonacci, deberá imprimirlos en orden creciente, separados por espacios.
Ejemplo
Entrada Salida
9 4 6 7
Consideraciones 2 ≤ N ≤ 30000 (30 mil)
Código:
import java.util.*; public class fibonacci{ public static void main(String[] args) {
Scanner datos=new Scanner(System.in);
int num=datos.nextInt(); int fib[]=new int[10000000]; int todos[]=new int[10000000];
fib[1]=1; for (int pos=0;pos<num ;pos++ ) {
todos[pos+1]=todos[pos]+1; fib[pos+2]=fib[pos]+fib[pos+1]; }
for (int pos=0;pos<num ;pos++ ) { todos[fib[pos+1]]=0;
} for (int pos=1;pos<num ;pos++ ) { if (todos[pos]!=0) {
System.out.print(todos[pos]+" "); }
} } }
Pruebas de Escritorio: