Una cola es un tipo especial de lista abierta en la que sólo se pueden insertar nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el otro. Además, como sucede con las pilas, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.
Escriba un programa que imprima la siguiente figura de rombo. Puede utilizar instrucciones de salida que imprima un solo asterisco(*) o un solo espacio en blanco.
#include <iostream>
using namespace std;
int main (int argc, char *argv[]) {
double length ;
double width ;
double perimeter ;
double area;
cout<<"Type the width of the rectangle:";
cin>>width;
cout<<"Type the length of the rectangle:";
cin>>length;
perimeter =2*width+2*length;
area=width*length;
cout<<"the Area of the rectangle:"<<area<<endl;
cout<<"the Perimeter of the rectangle:"<<perimeter<<endl;
return 0;
}
#include<iostream>using namespace std; int main (int argc, char *argv[]) { double base; double altura; double perimetro; double area; cout<<"ingrese base del rectangulo:"; cin>>base; cout<<"ingrese altura del rectangulo:"; cin>>altura; perimetro=2*base+2*altura; area=base*altura; cout<<"el area del rectangulo es:"<<area<<endl; cout<<"el perimetro del rectangulo es:"<<perimetro<<endl; return 0; }
#include <iostream> using namespace std; int main (int argc, char *argv[]) {
char a='a';
int b=3;
float c=3.4f;
double d=4.78;
/*
->sin importar que valor tome b, a se convierte en un 97(entero) ya que
es la posición que ocupa el carácter 'a' en el código ASCII
->como b y a ahora son enteros nos dará como resultado de la operación
un entero
*/
cout<<a/b<<endl;
/*
->sin importar que valor tome b, a se convierte en un 97(entero) ya que
es la posición que ocupa el carácter 'a' en el código ASCII.
->como c es un float a(ahora entero) se convierte en float, por lo tanto
nos dara un resltado de tipo float
*/
cout<<a/c<<endl;
cout<<c/d<<endl;//c se convierte en un double
return 0; }
la salida de este programa es:3228.52940.711297
Se solicita realizar las siguientes operaciones con un Arreglo de 10 posiciones, para cada una de las operaciones programar un método que se llame de un menú principal.
package ejercicio1;
import java.util.Scanner;
public class Ejercicio1 {
private static Scanner ingreso = new Scanner(System.in);
public static int menu() {
int opcion = 0;
String menu = "\n\t MENÚ PRINCIPAL \n"
+ "\n1. Leer Elementos del arreglo."
+ "\n2. Ordenar de forma Ascendente."
+ "\n3. Imprimir arreglo."
+ "\n4. Generar Arreglo C (Suma de Arreglos A y B)"
+ "\n5. Impresion de Números Impares del Arreglo"
+ "\n6. Salir del programa.";
do {
System.out.print(menu);
System.out.print("\nIngrese una opcion: ");
opcion = ingreso.nextInt();
} while (opcion < 0 || opcion > 6);
return opcion;
}
private static void LeerArreglo(int[] arreglo) { // Opcion 1
for (int i = 0; i < 10; i++) {
System.out.print("Elemento[" + (i + 1) + "]= ");
arreglo[i] = ingreso.nextInt();
}
}
private static void ImprimirArreglo(int[] arreglo) { // Opcion 3
for (int i = 0; i < 10; i++) {
System.out.println("Elemento[" + (i + 1) + "]= " + arreglo[i]);
}
}
public static void OrdenamientoBurbuja(int[] arreglo) { // Opcion 2 - Ascendente
int aux;
for (int i = 0; i < arreglo.length - 1; i++) {
for (int j = 0; j < arreglo.length - i - 1; j++) {
if (arreglo[j + 1] < arreglo[j]) {
aux = arreglo[j + 1];
arreglo[j + 1] = arreglo[j];
arreglo[j] = aux;
}
}
}
}
public static void SumaDeArreglos() { // Opcion 4
int[] ArregloA = new int[10];
int[] ArregloB = new int[10];
int[] ArregloC = new int[10];
System.out.println("\nLectura de Elementos [ArregloA]: ...");
LeerArreglo(ArregloA);
System.out.println("\nLectura de Elementos [ArregloB]: ...");
LeerArreglo(ArregloB);
for (int i = 0; i < 10; i++) {
ArregloC[i] = ArregloA[i] + ArregloB[10 - i - 1];
}
System.out.println("\nImpresión [ArregloC]: ...");
ImprimirArreglo(ArregloC);
//Para el primer Caso : ArregloC[0]=ArregloA[0]+ArregloB[9];
//....................: ArregloC[1]=ArregloA[1]+ArregloB[8];
}
public static void NumerosImpares(int[] arreglo) { // Opcion 5
for (int i = 0; i < 10; i++) {
if (arreglo[i] % 2 == 1) {
System.out.println("Elemento[" + (i + 1) + "]= " + arreglo[i]);
}
}
}
public static void Return() {
System.out.print("Presione Enter para Regresar al MENU...");
new Scanner(System.in).nextLine();
}
public static void main(String[] args) {
int[] Arreglo = new int[10];
int opt;
do {
opt = menu();
switch (opt) {
case 1:
System.out.println("\nLectura de Elementos: ...");
LeerArreglo(Arreglo);
Return();
break;
case 2:
System.out.println("\nArreglo Ordenado - Imprima Arreglo ...");
OrdenamientoBurbuja(Arreglo);
Return();
break;
case 3:
System.out.println("\nImpresión del Arreglo: ...");
ImprimirArreglo(Arreglo);
Return();
break;
case 4:
System.out.print("\nSuma de Arreglos: ...");
SumaDeArreglos();
Return();
break;
case 5:
System.out.println("\nNúmeros Impares: ...");
NumerosImpares(Arreglo);
Return();
break;
case 6:
System.out.println("Ha cerrado el programa exitosamente . . .");
break;
default:
System.err.println("¡ Ha ingresado una opción inválida !");
}
} while (opt != 6);
}
}
Escribir un programa que permita visualizar el triángulo de Pascal:
elaborar un programa que determine cuántos números son de ARMSTRONG, desde un "n" hasta un "m". Un número es ARMSTRONG si la suma de los dígitos elevados a la cantidad de dígitos que lo componen es igual al número. Ejemplo
#include<iostream>
#include<cmath>//utilizar la funciion pow(base,exponente) using namespace std; int digitos(int x){
int cont=0;
while(x>0){
cont++;
x=x/10;
}
return cont;
} int sumaDigitosElevadosCantidadDigitos(int x){
int cd=digitos(x);//cantidad de digitos
int acum=0;//acumulador
while(x>0){
acum=acum+pow(x%10,cd);//el digito elevado al cubo
x=x/10;
}
return acum;
} void numerosARMSTRONG(int n,int m){
for(int i=n;i<=m;i++){
if(i==sumaDigitosElevadosCantidadDigitos(i))
cout<<i<<"\t";//mostrar los numeros ARMSTRONG }cout<<endl;//salto de linea} int main (int argc, char *argv[]) {
int n;
int m;
cin>>n;//ingresar valor n
cin>>m;//ingresar valor m
numerosARMSTRONG(n,m);
return 0; }
Escribe una función que dado un entero N,
Diseñar un algoritmo que al ingresar un número, devuelva una "cadena" que indique si el número es Smith o no.