Nombre:Alexandra Maguana
Ciclo:Sexto Sistemas
Tipos de
datos
El concepto de clase como tipo de datos compuesto
de campos, métodos y eventos es similar en Java y C#. (La herencia de clases se
describe independientemente en el tema titulado Herencia y
clases derivadas (C# y Java).) C# introduce el concepto de
estructura como tipo de datos compuesto asignado por pila que no admite la
herencia. En la mayoría de los otros aspectos, las estructuras son muy
similares a las clases. Las estructuras proporcionan una manera ligera de
agrupar campos y métodos relacionados para el uso en los bucles de pequeñas
dimensiones y otros escenarios donde el rendimiento es crucial.
C# permite crear un método de destructor al que se
llama antes de que se destruyan las instancias de una clase. En Java, se puede
utilizar un método finalize para contener código que limpia los recursos antes
de que se recolecten los elementos no utilizados del objeto. En C#, el que
realiza esta función es el destructor de clase. El destructor se parece a un
constructor sin los argumentos y con un carácter de tilde delante (~).
C# proporciona todos los tipos de datos que están
disponibles en Java y agrega compatibilidad para los números sin signo y un
nuevo tipo de punto flotante de 128 bits de alta precisión.
Para cada tipo de datos primitivo en Java, la
biblioteca de clases principal proporciona una clase contenedora, que lo
representa como un objeto de Java. Por ejemplo, la clase Int32
contiene el tipo de datos int y la clase Double
contiene el tipo de datos double.
Por otro lado, todos los tipos de datos primitivos
en C# son objetos en el espacio de nombres System.
Para cada tipo de datos, se proporciona un nombre corto o alias. Por ejemplo, int
es el nombre corto correspondiente a System.Int32 y double es la forma
abreviada de System.Double.
En la tabla siguiente se proporciona la lista de
tipos de datos de C# y sus alias. Como puede ver, los primeros ocho de estos
tipos corresponden a los tipos primitivos disponibles en Java. Sin embargo,
tenga en cuenta que el tipo boolean de Java se denomina bool en C#.
 |
||||
 |
||||
Dado que C# representa todos los tipos de datos
primitivos como objetos, es posible llamar a un método de objeto de un tipo de
datos primitivo. Por ejemplo:
C#
static void Main()
{
int i = 10;
object o = i;
System.Console.WriteLine(o.ToString());
}
Esto se logra con la ayuda de las conversiones
automáticas boxing y unboxing. Para obtener más información, vea Conversión
boxing y unboxing (Guía de programación de C#).
Java y C# proporcionan la capacidad para declarar
una variable cuyo valor se especifica en tiempo de compilación y no se puede
cambiar en tiempo de ejecución. Java utiliza el modificador de campo final para
declarar este tipo de variable, mientras que C# utiliza la palabra clave const.
Además de const, C# proporciona la palabra clave readonly
para declarar variables a las que se puede asignar un valor una vez en tiempo
de ejecución, ya sea en la instrucción de declaración o en otra parte del
constructor. Después de la inicialización, el valor de una variable readonly no
puede cambiar. Un escenario en el que las variables readonly son útiles es
cuando los módulos que se han compilado independientemente tienen que compartir
datos como un número de versión. Si el módulo A se actualiza y se vuelve a
compilar con un nuevo número de versión, el módulo B se puede inicializar con
ese nuevo valor constante sin tener que volver a compilarlo.
Las enumeraciones se utilizan para agrupar
constantes con nombres en forma similar a la forma en que se utilizan en C y
C++; no están disponibles en Java. En el ejemplo siguiente se define una enumeración
Color sencilla.
C#
public enum Color
{
Green, //defaults to 0
Orange, //defaults to 1
Red, //defaults to 2
Blue
//defaults to 3
}
También se pueden asignar valores integrales a las
enumeraciones, tal como se muestra en la siguiente declaración de enumeración:
C#
public enum Color2
{
Green = 10,
Orange = 20,
Red = 30,
Blue = 40
}
En el siguiente ejemplo de código se llama al
método GetNames
del tipo Enum
para mostrar las constantes disponibles para una enumeración. Luego, asigna un
valor a una enumeración y muestra el valor.
C#
class TestEnums
{
static void Main()
{
System.Console.WriteLine("Possible color choices: ");
//Enum.GetNames returns a
string array of named constants for the enum.
foreach(string s in
System.Enum.GetNames(typeof(Color)))
{
System.Console.WriteLine(s);
}
Color favorite =
Color.Blue;
System.Console.WriteLine("Favorite Color is {0}", favorite);
System.Console.WriteLine("Favorite Color value is {0}", (int)
favorite);
}
}
Possible color choices:
Green
Orange
Red
Blue
Favorite Color is Blue
Favorite Color value is 3
Los tipos de cadena en Java y C# denotan un
comportamiento similar con leves diferencias. Ambos tipos de cadena son
inmutables, lo que significa que los valores de las cadenas no se pueden cambiar
una vez que se han creado las cadenas. En ambos casos, los métodos que parecen
modificar el contenido real de una cadena crean en realidad una nueva cadena
que se devolverá como resultado, dejando la cadena original sin cambios. El
proceso de comparación de los valores de cadena es diferente en C# y Java. Para
comparar los valores de cadena en Java, los desarrolladores deben llamar al
método equals de un tipo string, mientras que el operador == compara los tipos
de referencia de forma predeterminada. En C#, los desarrolladores pueden
utilizar los operadores == o != para comparar directamente valores de cadena.
Aunque una cadena es un tipo de referencia en C#, los operadores == y !=
compararán, en forma predeterminada, los valores de las cadenas en lugar de las
referencias.
Como en Java, los desarrolladores de C# no deben
usar el tipo string para concatenar cadenas con el fin de evitar la sobrecarga
de crear nuevas clases de cadenas cada vez que se concatene la cadena. En su
lugar, los desarrolladores pueden utilizar la clase StringBuilder,
que es funcionalmente equivalente a la clase StringBuffer de Java.
C# proporciona la posibilidad de evitar el uso de
secuencias de escape como "\t" para la ficha o "\" para los
caracteres de barra diagonal inversa dentro de las constantes de cadena. Para
ello, simplemente declare la cadena textual mediante el símbolo @ para preceder
la asignación del valor de cadena. Los siguientes ejemplos muestran cómo
utilizar los caracteres de escape y cómo asignar literales de cadena:
C#
static void Main()
{
//Using escaped characters:
string path1 =
"\\\\FileShare\\Directory\\file.txt";
System.Console.WriteLine(path1);
//Using String Literals:
string path2 =
@"\\FileShare\Directory\file.txt";
System.Console.WriteLine(path2);
}
Java y C# siguen reglas similares para la
conversión automática y la conversión de tipos de datos.
Al igual que Java, C# admite conversiones de tipo
implícitas y explícitas. En el caso de conversiones de ampliación, las
conversiones son implícitas. Por ejemplo, la siguiente conversión de int a long
es implícita, como en Java:
C#
int int1 = 5;
long long1 = int1; //implicit
conversion
La siguiente es una lista de conversiones
implícitas entre los tipos de datos de .NET Framework:
 |
|
Puede convertir el tipo de expresiones que desee
convertir explícitamente usando la misma sintaxis que en Java:
C#
long long2 = 5483;
int int2 = (int)long2; //explicit
conversion
La tabla siguiente muestra las conversiones
explícitas.
C# admite dos tipos de variables:
- Tipos de valor
Estos son los tipos de datos
primitivos integrados, como char, int y float, así como también los tipos
definidos por el usuario declarados con la estructura.
- Tipos de referencia
Clases y otros tipos de datos
complejos que se construyen a partir de los tipos primitivos. Las variables de
estos tipos no contienen una instancia del tipo, sino sólo una referencia a una
instancia.
Si se crean dos variables del tipo de valor, i y j,
como se muestra a continuación, i y j son completamente independientes entre
sí:
C#
int i = 10;
int j = 20;
Si cambia el valor de una de estas variables, la
otra no se verá afectada de forma natural. Por ejemplo, si tiene una expresión
como la siguiente, aún no existe ninguna conexión entre las variables:
C#
int k = i;
Es decir, si cambia el valor de i, k permanecerá
con el valor que tenía i en el momento de la asignación.
C#
i = 30;
System.Console.WriteLine(i.ToString());
// 30
System.Console.WriteLine(k.ToString());
// 10
Sin embargo, los tipos de referencia actúan de
forma diferente
Tipos de Conversiones
Dado que a C# se le asignan tipos estáticos en
tiempo de compilación, después de declarar una variable, no se puede volver a
declarar ni tampoco utilizar para almacenar valores de otro tipo, a menos que
dicho tipo pueda convertirse en el tipo de la variable.
Sin embargo, en ocasiones puede que sea necesario
copiar un valor en un parámetro de método o variable de otro tipo. Por ejemplo,
puede que tenga una variable de tipo entero que deba pasar a un método cuyo
parámetro es de tipo double. O bien, puede que necesite asignar una variable de
clase a una variable de un tipo de interfaz. Estos tipos de operaciones se
denominan conversiones de tipos. En C#, puede realizar los siguientes tipos de
conversiones:
- Conversiones implícitas: no se requiere una sintaxis especial porque la conversión se realiza con seguridad de tipos y no se perderán datos. Entre los ejemplos se incluyen las conversiones de tipos enteros de menor a mayor y las conversiones de clases derivadas en clases base.
- Conversiones explícitas (conversiones de tipos): las conversiones explícitas requieren un operador de conversión. La conversión se requiere cuando es posible que se pierda información en el proceso o cuando esta puede no realizarse correctamente por otras razones. Entre los ejemplos habituales se incluye la conversión en un tipo con menor precisión o un intervalo menor, y la conversión de una instancia de clase base en una clase derivada.
- Conversiones definidas por el usuario: las conversiones definidas por el usuario se realizan a través de métodos especiales que puede definir para habilitar las conversiones explícitas e implícitas entre tipos personalizados que no tienen una relación de clase base-clase derivada. Para obtener más información.
- Conversiones con clases auxiliares: para realizar conversiones entre tipos no compatibles, como los enteros y los objetos System.DateTime, o bien cadenas hexadecimales y matrices de bytes, puede utilizar la clase System.BitConverter, la clase System.Convert y los métodos Parse de los tipos numéricos integrados, como Int32.Parse. Para obtener más información, vea Cómo: Convertir una matriz de bytes en un valor int (Guía de programación de C#), Cómo: Convertir una cadena en un número (Guía de programación de C#) y Cómo: Convertir cadenas hexadecimales en tipos numéricos (Guía de programación de C#).
En los tipos numéricos integrados, puede realizarse
una conversión implícita cuando el valor que se va a almacenar puede ajustarse
a la variable sin necesidad de truncamiento o redondeo. Por ejemplo, una
variable de tipo long
(entero de 8 bytes) puede almacenar cualquier valor que pueda almacenar a su
vez un elemento int
(4 bytes en un equipo de 32 bits). En el ejemplo siguiente, el compilador
convierte implícitamente el valor de la derecha en un tipo long antes de
asignarlo a bigNum.
En los tipos de referencia, siempre existe una
conversión implícita desde una clase a cualquiera de sus interfaces o clases
base directas o indirectas. No se requiere una sintaxis especial, ya que una
clase derivada siempre contiene todos los miembros de una clase base.
Derived d = new Derived();
Base b = d; // Always OK.
Sin embargo, si no se puede realizar una conversión
sin riesgo de perder información, el compilador requiere que se realice una
conversión explícita, denominada conversión de tipo. Una conversión de tipo es
una manera de informar al compilador de forma explícita de que pretende
realizar la conversión y que está al tanto de que puede producirse una pérdida
de datos. Para realizar una conversión de tipo, especifique entre paréntesis el
tipo al que se va a aplicar dicha conversión delante del valor o la variable
que se va a convertir. El programa siguiente convierte un tipo double
a un tipo int.
El programa no se compilará sin el operador de conversión de tipo.
En los tipos de referencia, se requiere una
conversión explícita si debe convertir de un tipo base a un tipo derivado:
Una operación de conversión entre tipos de
referencia no cambia el tipo en tiempo de ejecución del objeto subyacente; solo
cambia el tipo del valor que se utiliza como referencia para ese objeto.
En algunas conversiones de tipos de referencia, el
compilador no puede determinar si será válida una conversión de tipo. Es
posible que una operación de conversión de tipo que se compila correctamente
provoque un error en tiempo de ejecución. Como se muestra en el ejemplo
siguiente, una conversión de tipo que origine un error en tiempo de ejecución
hará que se produzca una excepción InvalidCastException.
C# proporciona los operadores is
y as,
que permiten comprobar la compatibilidad antes de realizar una conversión de
tipo.
Sintaxis del if
La estructura de control IF permite ejecutar una
porción de código sólo si la expresión entre paréntesis () es verdadera. Luego
se puede incluir la cláusula else para ejecutar código en caso de que
la expresión sea falsa.
Una instrucción if identifica que sentencia se tiene que ejecutar en función del
valor de una expresión Boolean. En
el ejemplo siguiente, la variable Booleanresult se establece en true y, a continuación, se comprueba en
la instrucción if. La salida es The condition is
true.
C#
bool condition = true;
if (condition)
{
Console.WriteLine("The variable is set to true.");
}
else
{
Console.WriteLine("The variable is set to false.");
}
Puede ejecutar los ejemplos
de este tema colocándolos en el método de Main de una aplicación de consola.
Una instrucción if en C#
puede tomar dos formas, como se muestra en el ejemplo siguiente.
C#
// if-else statement
if (condition)
{
then-statement;
}
else
{
else-statement;
}
// Next statement in the program.
// if statement without an else
if (condition)
{
then-statement;
}
// Next statement in the program.
En una instrucción if-else, si la condición se evalúa como true, se ejecuta la sentencia then-statement.
Si condition es false, else-statement ejecuta. Dado que la condición (condition) no puede ser simultáneamente
verdadera (true) y falsa (false), las sentencias then-statement y
else-statement de una instrucción if-else nunca pueden ejecutarse
simultáneamente. Después de then-statement o de las ejecuciones de else-statement, el control se transfiere a la instrucción siguiente después de
la instrucción de if.
En una instrucción de if que no incluya una instrucción de else, si condition es true, then-statement ejecuta. Si condition es false, el control se
transfiere a la instrucción siguiente después de la instrucción de if.
then-statement y else-statement pueden constar de una sola instrucción o varias instrucciones
que se agrega entre llaves ({}). Para una sola instrucción, las
llaves son opcionales pero recomendados.
La instrucción o
instrucciones en then-statement y else-statement puede ser de clase, incluso otra instrucción de if anidada dentro de la instrucción
original de if. En instrucciones anidadas de if, cada cláusula de else pertenece a if último que no tiene else correspondiente. En el ejemplo
siguiente, Result1 aparece
si m > 10 y n > 20 se evalúan como true. Si m > 10
es true pero n > 20 es
false, Result2 aparece.
C#
// Try with m = 12 and then with m = 8.
int m = 12;
int n = 18;
if (m > 10)
if (n > 20)
{
Console.WriteLine("Result1");
}
else
{
Console.WriteLine("Result2");
}
Si, en su lugar, se desea
que Result2 aparezca cuando
(m > 10) es false, puede
especificar que la asociación mediante las llaves para establecer el inicio y
el final de la instrucción anidada de if, como se muestra en el ejemplo siguiente.
C#
// Try with m = 12 and then with m = 8.
if (m > 10)
{
if (n > 20)
Console.WriteLine("Result1");
}
else
{
Console.WriteLine("Result2");
}
Result2 aparece si la condición (m > 10) evalúa en false.
En el ejemplo siguiente, se
escribe un carácter de teclado, y el programa utiliza una instrucción anidada
de if para determinar si
el carácter de entrada es un carácter alfabético. Si el carácter de entrada es
un carácter alfabético, programa comprueba si el carácter de entrada se escribe
en minúsculas o una mayúscula. Aparecerá un mensaje
para cada caso.
C#
Console.Write("Enter a character: ");
char c = (char)Console.Read();
if (Char.IsLetter(c))
{
if (Char.IsLower(c))
{
Console.WriteLine("The character is lowercase.");
}
else
{
Console.WriteLine("The character is uppercase.");
}
}
else
{
Console.WriteLine("The character isn't an alphabetic character.");
}
//Sample Output:
//Enter a character: 2
//The character isn't an alphabetic character.
//Enter a character: A
//The character is uppercase.
//Enter a character: h
//The character is lowercase.
También puede anidar una
instrucción de if dentro
de un bloque else, como el código parcial siguiente. Las instrucciones de if de los nidos de ejemplo desde dos
bloques otros y una continuación bloqueada. Los
comentarios especifican qué condiciones son true o false en cada bloque.
C#
// Change the values of these variables to test the results.
bool Condition1 = true;
bool Condition2 = true;
bool Condition3 = true;
bool Condition4 = true;
if (Condition1)
{
// Condition1 is true.
}
else if (Condition2)
{
// Condition1 is false and Condition2 is true.
}
else if (Condition3)
{
if (Condition4)
{
// Condition1 and Condition2 are false. Condition3 and Condition4 are true.
}
else
{
// Condition1, Condition2, and Condition4 are false. Condition3 is true.
}
}
else
{
// Condition1, Condition2, and Condition3 are false.
}
El ejemplo siguiente
determina si un carácter de entrada es una minúscula, una letra mayúscula, o un
número. Si las tres condiciones son false, el carácter no es un carácter alfanumérico.
El ejemplo muestra un mensaje para cada caso.
C#
Console.Write("Enter a character: ");
char ch = (char)Console.Read();
if (Char.IsUpper(ch))
{
Console.WriteLine("The character is an uppercase letter.");
}
else if (Char.IsLower(ch))
{
Console.WriteLine("The character is a lowercase letter.");
}
else if (Char.IsDigit(ch))
{
Console.WriteLine("The character is a number.");
}
else
{
Console.WriteLine("The character is not alphanumeric.");
}
//Sample Input and Output:
//Enter a character: E
//The character is an uppercase letter.
//Enter a character: e
//The character is a lowercase letter.
//Enter a character: 4
//The character is a number.
//Enter a character: =
//The character is not alphanumeric.
Igual que una instrucción del
bloque else o el bloque then puede ser cualquier instrucción válida, puede
utilizar cualquier expresión booleana válida para la condición. Puede usar
operadores lógicos como &&,
y,
||,
|y !
para crear condiciones compuestas. El código
siguiente muestra ejemplos.
C#
// NOT
bool result = true;
if (!result)
{
Console.WriteLine("The condition is true (result is false).");
}
else
{
Console.WriteLine("The condition is false (result is true).");
}
// Short-circuit AND
int m = 9;
int n = 7;
int p = 5;
if (m >= n && m >= p)
{
Console.WriteLine("Nothing is larger than m.");
}
// AND and NOT
if (m >= n && !(p > m))
{
Console.WriteLine("Nothing is larger than m.");
}
// Short-circuit OR
if (m > n || m > p)
{
Console.WriteLine("m isn't the smallest.");
}
// NOT and OR
m = 4;
if (!(m >= n || m >= p))
{
Console.WriteLine("Now m is the smallest.");
}
// Output:
// The condition is false (result is true).
// Nothing is larger than m.
// Nothing is larger than m.
// m isn't the smallest.
// Now m is the smallest.
Operadores
Lógicos
os operadores lógicos enteros permiten realizar
operaciones aritméticas booleanas sobre dos valores numéricos. A continuación
se explican algunos de ellos:
Operador AND
El operador AND se usa para calcular el valor AND
booleano de dos expresiones. Para este operador se usa el símbolo de unión
(&):
Nota: La sentencia será verdadera cuando
una o ambas variables proposicionales sean verdaderas.
Ejemplo: Lasiguiente instrucción
evalúa dos expresiones booleanas usando el &(And).
Booleana
= True & True;
bool
Var_boolean = (false & true);
Console.WriteLine(Var_boolean);
False
Operador OR
El operador OR se usa para calcular el valor booleano
OR de dos expresiones. Como operador OR se usa el carácter barra vertical (|):
Nota: Es una conectiva que puede definirse
como verdadera si al menos una expresión es verdadera.
Ejemplo: Lasiguiente instrucción evalúa
dos expresiones booleanas usando el | (OR).
Entero3
= False | True;
bool
Var_boolean = (false | true);
Console.WriteLine(Var_boolean);
True
Operador OR exclusivo
El operador OR exclusivo se usa para calcular el
valor booleano exclusivo OR de dos expresiones. Como operador OR exclusivo se
usa el signo de intercalación (^).
Nota: Es una conectiva que puede definirse
como falsas sólo cuando ambas variables proposicionales sean similares ya sean
falsas o verdaderas.
Ejemplo: el ejemplo siguiente evalúa dos
expresiones utilizando el OR exclusivo.
Var_boolean
= True ^ false;
bool
Var_boolean = (true ^ false);
Console.WriteLine(Var_boolean);
True
Operadores condicionales lógicos
El operador AND condicional:
Compara dos expresiones booleanas y da como
resultado de la operación True si ambos operandos devuelven True y
devuelve False si uno de los dos operandos devuelve False. Como operador AND
condicional se usan dos símbolos de unión (&&); una instrucción de
ejemplo para este operador sería la siguiente, donde el valor de var_boolean
es False porque uno de los dos operandos devuelve False.
Var_boolean
= (True ^ False) && (False & False);
Ejemplo:
bool Var_boolean = (true ^ false) &&
(false & false);
Console.WriteLine(Var_boolean);
False
El operador OR condicional:
Ddevuelve como resultado de la operación True si
uno de los dos operandos devuelve True y False si los dos operandos devuelven
False. Como operador OR condicional se usan dos barras verticales (||), el
siguiente es un ejemplo, donde el valor de var_boolean es True porque
uno de los dos operandos devuelve True.
Var_boolean = (4 < 2) || (3 > 1);
Ejemplo:
bool
Var_boolean = (4 < 2) || (3 > 1);
Console.WriteLine(Var_boolean);
True
Además existe otro operador condicional que
necesita tres operandos para reutilizar una operación lógica condicional. El
operador condicional (?) es la única expresión ternaria admitida por el
lenguaje C#.
Se debe escribir la expresión de entrada seguida
por un signo de interrogación. Si la expresión se evalúa como True tomara el
valor que aparece justo después, pero si se evalúa False tomara el valor que
esta a continuación de los dos puntos; por ejemplo:
Ejemplo: este ejemplo verifica si la
variable Mivalor es exactamente igual a 25 si es así la variable entero1
contendrá el valor de 3, de lo contrario contendrá el valor de 5.
Entero1 = (Mivalor == 25)? 3:5;
int Mivalor = 12;
int entero1;
entero1 = (Mivalor == 25) ? 3 : 5;
Console.WriteLine(entero1);
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CARATULA_3_NUMEROS
{
class Program
{
static void Main(string[] args)
{
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Nombres: ");
Console.WriteLine();
Console.WriteLine("CELIA ALEXANDRA");
Console.WriteLine();
Console.WriteLine("Apellidos: ");
Console.WriteLine();
Console.WriteLine("MAGUANA TOALONGO");
Console.WriteLine();
Console.WriteLine("Ciclo:");
Console.WriteLine();
Console.WriteLine("6TO SISTEMAS");
Console.WriteLine();
Console.WriteLine("Materia:");
Console.WriteLine();
Console.WriteLine("PROGRAMACION .NET");
Console.WriteLine();
Console.WriteLine("Profesor: ");
Console.WriteLine();
Console.WriteLine("ING. JUAN ESPINOZA");
Console.WriteLine();
int n1, n2, n3;
Console.Write("Ingrese valor de n1 : ");
n1 = Convert.ToInt16(Console.ReadLine());
Console.Write("Ingrese valor de n2 : ");
n2 = Convert.ToInt16(Console.ReadLine());
Console.Write("Ingrese valor de n3 : ");
n3 = Convert.ToInt16(Console.ReadLine());
if (n1 == n2 && n2 != n3)
{ Console.WriteLine("{0} y {1} son iguales ",n1,n2); }
else
{ if (n1 == n3 && n3 != n2)
{ Console.WriteLine("{0} y {1} son iguales ",n1,n3); }
else
{
if (n3 == n2 && n2 != n1)
{ Console.WriteLine("{0} y {1} son iguales ",n2,n3); }
}
}
if (n1 == n2 && n2 == n3)
{ Console.WriteLine("Son iguales aqui y en la conchinchina. "); }
else
{
if (n1 >= n2 && n1 >= n3)
{ Console.WriteLine("El mayor es {0} ", n1); }
else
{
if (n2 >= n1 && n2 >= n3)
{ Console.WriteLine("El mayor es {0} ", n2); }
else
{
if (n3 >= n2 && n3 >= n1)
{ Console.WriteLine("El mayor es {0} ", n3); }
else
{ }
}
}
if (n1 <= n2 && n1 <= n3)
{ Console.WriteLine("El menor es {0} ", n1); }
else
{
if (n2 <= n1 && n2 <= n3)
{ Console.WriteLine("El menor es {0} ", n2); }
else
{
if (n3 <= n2 && n3 <= n1)
{ Console.WriteLine("El menor es {0} ", n3); }
else
{ }
}
}
}
Console.ReadLine();
}
}
}
Caratula, el mayor de tres numeros y los repetidos.
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CARATULA_3_NUMEROS
{
class Program
{
static void Main(string[] args)
{
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Nombres: ");
Console.WriteLine();
Console.WriteLine("CELIA ALEXANDRA");
Console.WriteLine();
Console.WriteLine("Apellidos: ");
Console.WriteLine();
Console.WriteLine("MAGUANA TOALONGO");
Console.WriteLine();
Console.WriteLine("Ciclo:");
Console.WriteLine();
Console.WriteLine("6TO SISTEMAS");
Console.WriteLine();
Console.WriteLine("Materia:");
Console.WriteLine();
Console.WriteLine("PROGRAMACION .NET");
Console.WriteLine();
Console.WriteLine("Profesor: ");
Console.WriteLine();
Console.WriteLine("ING. JUAN ESPINOZA");
Console.WriteLine();
int n1, n2, n3;
Console.Write("Ingrese valor de n1 : ");
n1 = Convert.ToInt16(Console.ReadLine());
Console.Write("Ingrese valor de n2 : ");
n2 = Convert.ToInt16(Console.ReadLine());
Console.Write("Ingrese valor de n3 : ");
n3 = Convert.ToInt16(Console.ReadLine());
if (n1 == n2 && n2 != n3)
{ Console.WriteLine("{0} y {1} son iguales ",n1,n2); }
else
{ if (n1 == n3 && n3 != n2)
{ Console.WriteLine("{0} y {1} son iguales ",n1,n3); }
else
{
if (n3 == n2 && n2 != n1)
{ Console.WriteLine("{0} y {1} son iguales ",n2,n3); }
}
}
if (n1 == n2 && n2 == n3)
{ Console.WriteLine("Son iguales aqui y en la conchinchina. "); }
else
{
if (n1 >= n2 && n1 >= n3)
{ Console.WriteLine("El mayor es {0} ", n1); }
else
{
if (n2 >= n1 && n2 >= n3)
{ Console.WriteLine("El mayor es {0} ", n2); }
else
{
if (n3 >= n2 && n3 >= n1)
{ Console.WriteLine("El mayor es {0} ", n3); }
else
{ }
}
}
if (n1 <= n2 && n1 <= n3)
{ Console.WriteLine("El menor es {0} ", n1); }
else
{
if (n2 <= n1 && n2 <= n3)
{ Console.WriteLine("El menor es {0} ", n2); }
else
{
if (n3 <= n2 && n3 <= n1)
{ Console.WriteLine("El menor es {0} ", n3); }
else
{ }
}
}
}
Console.ReadLine();
}
}
}
BIBLIOGRAFIA
No hay comentarios:
Publicar un comentario