Está en la página 1de 52

INSTITUTO NACIONAL DE MXICO

INSTITUTO TECNOLGICO DE
VERACRUZ

ASIGNATURA:
LENGUAJES UNTOMATAS II

INTEGRANTES:

Gmez Gonzales Citlalli

Morales Hernndez Yazmin Yareli

Palomar Aguirre Jael

Solano Uscanga Maril

CARRERA:
Ing. Sistemas Computacionales.

PROYECTO:
Cdigo Intermedio

DOCENTE:

Martnez Moreno Martha

Veracruz, Ver.
2017.
INIDICE

NDICE 2
DECLARACIN 3
EJEMPLOS EN C# 3
EJEMPLOS EN ENSAMBLADO 4
EJEMPLOS EN JASSM 5
OPERADORES 6
EJEMPLOS EN C# 8
EJEMPLOS EN ENSAMBLADOR 13
EJEMPLOS EN JASSM 18
CICLOS O BUCLES 26
EJEMPLOS EN C# 27
EJEMPLOS EN ENSAMBLADOR 29
EJEMPLOS EN JASSM 32
ENTRADA Y SALIDA 33
EJEMPLOS EN C# 34
EJEMPLOS EN ENSAMBLADOR 37
EJEMPLOS EN JASSM 38
ESTRUCTURAS 40
EJEMPLOS EN C# 42
EJEMPLOS EN ENSAMBLADOR 47
EJEMPLOS EN JASSM 49
BIBIOGRAFA 52

2
DECLARACIN
En programacin, las lneas de cdigo de declaracin son aquellas en donde se escriben las
variables que se usarn y los tipos de datos de cada una.
Por ejemplo:
Int numero1, numero2;
Float numero3;
Esto declara dos variables que contendrn nmeros enteros y una tercera como flotante
.

Ejemplos en C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Suma {
class Program {
static void Main(string[] args) {
//Declaracion de Variables
int num1, num2, suma;

}
}

3
Ejemplos en Ensamblador
Instruccin ADD
Propsito: Adicin de los operandos.

Sintaxis:

ADD destino, fuente

Suma los dos operandos y guarda el resultado en el operando destino.

Debe haber correspondencia entre los tamaos de los registros, es decir:


no se puede sumar a un registro de 16, un registro de 8 y viceversa
ADD AX, BX; AX = 0A11, BX = 00A2

ADD AX,AB; AX = AB3

4
Ejemplos en Jassm
El siguiente cdigo es en Jassm, donde se mostrar cmo en la clase suma, resta,
multiplicacin y divisin se har la declaracin de las variables a utilizar:

.class public suma


.super java/lang/Object
.method public <init>()
aload_0
invokespecial java/lang/Object/<init>()
Return
.end method
.method public add
.limit stack 2
.limit locals 4
iload_1
iload_2
Iadd
istore_3
iload_3
Ireturn
.end method
.class public suma
.super java/lang/Object
.method public ()
aload_0
invokespecial java/lang/Object/()
Return
.end method

5
OPERADORES

En C#, un operador es un elemento de programa que se aplica a uno o varios operandos en


una expresin o instruccin. Los operadores que toman un operando, como el operador de
incremento (++) o new, se conocen como operadores unarios. Los operadores que toman
dos operandos, como los operadores aritmticos (+,-,*,/) se conocen como
operadores binarios. Un operador, el operador condicional (?:), toma tres operandos y es el
nico operador ternario de C#.
La instruccin de C# siguiente contiene un solo operador unario y un nico operando. El
operador de incremento, ++, modifica el valor del operando y.

Operadores unarios

Expresin Descripcin

+x Identidad

-x Negacin

!x Negacin lgica

~x Negacin bit a bit

++x Preincremento

--x Predecremento

6
(T)x Convertir x explcitamente en tipo T

Operadores multiplicativos

Expresin Descripcin

* Multiplicacin

/ Divisin

% Resto

Operadores de suma

Expresin Descripcin

x+y Suma, concatenacin de cadenas, combinacin de delegados

x-y Resta, eliminacin de delegados

7
Ejemplos en C#

SUMAS:
Ejercicio bsico de sumar dos nmeros en consola en C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Suma
{
class Program
{
static void Main(string[] args)
{
//Declaracion de Variables
int num1, num2, suma;

//Explicacion del Ejercicio


Console.Write("\n\tSuma de Dos Numeros");

//Ingresando el primer numero


Console.Write("\nIngrese un numero: ");
num1 = Int32.Parse(Console.ReadLine());

//Ingresando el primer numero


Console.Write("\nIngrese el numero 2: ");
num2 = Int32.Parse(Console.ReadLine());

//Realizando la Suma
suma = num1 + num2;

//Mostrando Resultado
Console.WriteLine("El Resultado es: " + suma);

//Detener pantalla
Console.WriteLine("\n\n\tPresione < ENTER > para salir . . .");
Console.ReadKey();

}
}
}

8
RESTAR:
Ejercicio bsico de Restar dos nmeros en consola en C#:
using System.Collections.Generic;

using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Resta
{
class Program
{
static void Main(string[] args)
{
//Declaracion de Variables
int num1, num2, resta;

//Explicacion del Ejercicio


Console.Write("\n\tResta de Dos Numeros");

//Ingresando el primer numero


Console.Write("\nIngrese un numero: ");
num1 = Int32.Parse(Console.ReadLine());

//Ingresando el primer numero


Console.Write("\nIngrese el numero 2: ");
num2 = Int32.Parse(Console.ReadLine());

//Realizando la Resta
resta = num1 - num2;

9
//Mostrando Resultado
Console.WriteLine("El Resultado es: " + resta);

//Detener pantalla
Console.WriteLine("\n\n\tPresione < ENTER > para salir . . .");
Console.ReadKey();

}
}
}

MULTIPLICACIN:
Ejercicio bsico de multiplicacion dos nmeros en consola en C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Multiplicacion
{
class Program
{
static void Main(string[] args)
{
//Declaracion de Variables
int num1, num2, multi;

10
//Explicacion del Ejercicio
Console.Write("\n\tMultiplicacion de Dos Numeros");

//Ingresando el primer numero


Console.Write("\nIngrese un numero: ");
num1 = Int32.Parse(Console.ReadLine());

//Ingresando el primer numero


Console.Write("\nIngrese el numero 2: ");
num2 = Int32.Parse(Console.ReadLine());

//Realizando la Multiplicacion
multi = num1 * num2;

//Mostrando Resultado
Console.WriteLine("El Resultado es: " + multi);

//Detener pantalla
Console.WriteLine("\n\n\tPresione < ENTER > para salir . . .");
Console.ReadKey();

}
}
}

11
DIVISIN:
Ejercicio bsico de division dos nmeros en consola en C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace division
{
class Program
{
static void Main(string[] args)
{
//Declaracion de Variables
int num1, num2, divi;

//Explicacion del Ejercicio


Console.Write("\n\tDivision de Dos Numeros");

//Ingresando el primer numero


Console.Write("\nIngrese un numero: ");
num1 = Int32.Parse(Console.ReadLine());

//Ingresando el primer numero


Console.Write("\nIngrese el numero 2: ");
num2 = Int32.Parse(Console.ReadLine());

//Realizando la Division
divi = num1 / num2;

//Mostrando Resultado
Console.WriteLine("El Resultado es: " + divi);

//Detener pantalla
Console.WriteLine("\n\n\tPresione < ENTER > para salir . . .");
Console.ReadKey();
}
}
}

12
Ensamblador

SUMA:
Ejercicio bsico de sumar dos nmeros en Turbo Debugger Assembler de intel

Instruccin ADD

Propsito: Adicin de los operandos.

Sintaxis:

ADD destino, fuente

Suma los dos operandos y guarda el resultado en el operando destino.

Debe haber correspondencia entre los tamaos de los registros, es decir:


no se puede sumar a un registro de 16, un registro de 8 y viceversa

ADD AX, BX; AX = 0A11, BX = 00A2

ADD AX,AB; AX = AB3

13
14
RESTA:

Instruccin SUB

Propsito: Substraccin

Sintaxis:

SUB destino, fuente

Resta el operando fuente del destino.

SUB AX, BX; AX = 0A11, BX = 00A2

SUB AX,AB; AX = 096F

15
MULTIPLICACIN:

Instruccin MUL

Propsito: Multiplicacin sin signo

Sintaxis:

MUL fuente

El ensamblador asume que el multiplicando ser del mismo tamao que el del
multiplicador, por lo tanto multiplica el valor almacenado en el registro que se le da como
operando por el que se encuentre contenido en AH si el multiplicador es de 8 bits o por AX
si el multiplicador es de 16 bits.

Cuando se realiza una multiplicacin con valores de 8 bits el resultado se almacena en el


registro AX y cuando la multiplicacin es con valores de 16 bits el resultado se almacena
en el registro par DX:AX.

MUL, dl AX: 0005 DX: 0010

AX: 0050

16
DIVISIN:
Ejercicio bsico de Divisin de dos nmeros en Turbo Debugger Assembler de intel

Instruccin DIV

Propsito: Divisin sin signo

Sintaxis:

DIV fuente

El divisor puede ser un byte o palabra y es el operando que se le da a la instruccin.

Si el divisor es de 8 bits se toma como dividendo el registro de 16 bits AX y si el divisor es


de 16 bits se tomara como dividendo el registro par DX:AX, tomando como palabra alta
DX y como baja AX.

Si el divisor fu un byte el cociente se almacena en el registro AL y el residuo en AH, si fu


una palabra el cociente se guarda en AX y el residuo en DX.

DIV dl AX: 0010 DX:000 AX:0103

17
Jassm

SUMA:
Ejercicio bsico de sumar dos nmeros en Jasmin Assembler

.class public suma


.super java/lang/Object
.method public <init>()
aload_0
invokespecial java/lang/Object/<init>()
Return
.end method
.method public add
.limit stack 2
.limit locals 4
iload_1
iload_2
Iadd
istore_3
iload_3
Ireturn
.end method
.class public suma

18
.super java/lang/Object
.method public ()
aload_0
invokespecial java/lang/Object/()
Return
.end method
.method public static main([Ljava/lang/String;)V
.limit stack 10
.limit locals 10
; get op
aload_0

iconst_0
Aaload
astore 1

; get a
aload_0
iconst_1
Aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_2
; get b
aload_0
iconst_2
Aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_3
; new Suma
new suma;
Dup
invokespecial Calculator/<init>()V
; branch if not add
aload_1
ldc "add"
invokevirtual java/lang/String.equals(Ljava/lang/Object;)Z
ifeq NOT_ADD
; add
iload_2
iload_3
invokevirtual Calculator/add

19
istore 4
; print result
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 4
invokevirtual java/io/PrintStream/println
return
NOT_ADD:
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "invalid arithmetic operator"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
Return .end method

RESTA:
Ejercicio bsico de restar dos nmeros en Jasmin Assembler

.class public Restar


.super java/lang/Object
.method public <init>()V
aload_0
invokespecial java/lang/Object/<init>()V
Return
.end method
.method public sub(II)I
.limit stack 2
.limit locals 4
iload_1
iload_2
isub
istore_3
iload_3
ireturn
.end method
.class public Resta
.super java/lang/Object
.method public ()V
aload_0
invokespecial java/lang/Object/()V
return
.end method
.method public static main([Ljava/lang/String;)V
.limit stack 10

20
.limit locals 10
; get op
aload_0
iconst_0
aaload
astore 1

; get a
aload_0
iconst_1
aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_2
; get b
aload_0
iconst_2
aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_3
; new resta
new resta
Dup
invokespecial Calculator/<init>()V
; branch if not sub
aload_1
ldc "sub"
invokevirtual java/lang/String.equals(Ljava/lang/Object;)Z
ifeq NOT_SUB
; sub
iload_2
iload_3
invokevirtual Calculator/sub(II)I
istore 4
; print result
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 4
invokevirtual java/io/PrintStream/println(I)V
return
NOT_SUB:
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "invalid arithmetic operator"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V

21
Return .end method
.

MULTIPLICACIN:
Ejercicio bsico de Multiplicar dos nmeros en Jasmin Assembler

.class public Multiplicacion


.super java/lang/Object
.method public <init>()V
aload_0
invokespecial java/lang/Object/<init>()V
Return
.method public mul(II)I
.limit stack 2
.limit locals 4
iload_1
iload_2
imul
istore_3
iload_3
ireturn
.end method
.class public multiplicacion
.super java/lang/Object
.method public ()V
aload_0
invokespecial java/lang/Object/()V
return
.end method

.method public static main([Ljava/lang/String;)V


.limit stack 10
.limit locals 10
; get op
aload_0
iconst_0
aaload
astore 1

22
; get a
aload_0
iconst_1
aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_2
; get b
aload_0
iconst_2
aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_3
; new multiplicacin
new multiplicacin
Dup
invokespecial Calculator/<init>()V
; branch if not mul
aload_1
ldc "mul"
invokevirtual java/lang/String.equals(Ljava/lang/Object;)Z
ifeq NOT_MUL
; mul
iload_2
iload_3
invokevirtual Calculator/mul(II)I
istore 4

; print result
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 4
invokevirtual java/io/PrintStream/println(I)V
return
NOT_MUL:
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "invalid arithmetic operator"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
return
.end method

23
DIVISIN:

Ejercicio bsico de Division dos nmeros en Jasm+in Assembler

.class public divisin


.super java/lang/Object
.method public <init>()V
aload_0
invokespecial java/lang/Object/<init>()V
Return
.method public div(II)I
.limit stack 2
.limit locals 4
iload_1
iload_2
Idiv
istore_3
iload_3
ireturn
.end method
.class public ExeCalculator
.super java/lang/Object

.method public ()V


aload_0
invokespecial java/lang/Object/()V
return
.end method

.method public static main([Ljava/lang/String;)V


.limit stack 10
.limit locals 10
; get op
aload_0
iconst_0
aaload
astore 1

24
; get a
aload_0
iconst_1
aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_2
; get b
aload_0
iconst_2
aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_3
; new divisin
new divisin
Dup
invokespecial Calculator/<init>()V
; branch if not div
aload_1
ldc "div"
invokevirtual java/lang/String.equals(Ljava/lang/Object;)Z
ifeq NOT_DIV
; div
iload_2
iload_3
invokevirtual Calculator/div(II)I
istore 4
; print result
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 4
invokevirtual java/io/PrintStream/println(I)V
Return
NOT_DIV:
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "invalid arithmetic operator"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
return
.end method

25
CICLOS O BUCLES

Un bucle es una instruccin o conjunto de instrucciones que se repite un nmero


especificado de veces o hasta que se cumpla alguna condicin. El tipo de bucle que deba
utilizar depender de la tarea de programacin y de sus preferencias a la hora de escribir
cdigo.

FOR
El bucle for o ciclo for es una estructura de control en programacin en la que se puede
indicar de antemano el nmero mnimo de iteraciones que la instruccin realizar.1 Est
disponible en casi todos los lenguajes de programacin imperativos.

While
El bucle while o bucle mientras es una estructura de la mayora de los lenguajes de
programacin estructurados cuyo propsito es repetir un bloque de cdigo mientras una
condicin se mantenga verdadera.

Do-While
El bucle do, bucle hacer, hacer-mientras o tambin llamado ciclo do-while, es
una estructura de control de la mayora de los lenguajes de
programacin estructurados cuyo propsito es ejecutar un bloque de cdigo y repetir la
ejecucin mientras se cumpla cierta condicin expresada en la clusula while. La diferencia
con el bucle while radica en que este evala la condicin al principio, y si esta no se
cumple, el cdigo que est encerrado dentro del cuerpo no se ejecuta. En cambio, el bucle
do-while evala la condicin para seguir ejecutndose luego de haber ejecutado el cdigo
dentro de su cuerpo; es decir, siempre se ejecuta por lo menos una vez el cdigo.

26
Ejemplos C#

FOR
Ms abajo se muestra cmo crear el mismo bucle utilizando la palabra clave for:
public class suma {
public static void main (String [] args) {
int LIMITE = 100 ;
int suma = 0 ;
for ( int cont = 1 ; (cont <LIMITE) ; cont ++) {
SUMA = (SUMA + cont) ;
}
System. cabo .println (( "\ nLa sumatoria de" Los Primeros
+ (+ LIMITE ( "nmeros es"
+ (SUMA + "\ n" ))))) ;
}
}

27
While
Las versiones del bucle while se muestran en los ejemplos siguientes:

Programa que imprime los nmeros pares entre el 1 y el 10(para hacerlo corto)

main(){

int i=1;

while(1!=10){

i++;

if(i%2==0){

printf(i);

DO-WHILE
Las versiones del bucle do-while se muestran en los ejemplos siguientes:
Lea 3 nmeros y mande a pantalla, cual nmero es el mayor as como el nmero menor, si
hay nmeros son iguales
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace tresnumeros
{
class Program
{
static void Main(string[] args)
{
int A, B, C, D, E;
string AUX;
Console.WriteLine("DAME EL PRIMER NUMERO");
AUX = Console.ReadLine();
A = int.Parse(AUX);
Console.WriteLine("DAME EL SEGUNDO NUMERO");
AUX = Console.ReadLine();
B = int.Parse(AUX);
Console.WriteLine("DAME EL TERCER NUMERO");
AUX = Console.ReadLine();
C = int.Parse(AUX);

28
Console.WriteLine("\n\n\n");
if (A == B && B == C)
{
Console.WriteLine("LOS NUMEROS SON IGUALES");
}
else
{
if (A > B && A> C )
{
if (B > C)
{

Console.WriteLine("EL NUMERO MAYOR ES " + A);


Console.WriteLine("EL NUMERO MENOR ES " + C);
D = A % 5;
E = C % 3;
}

Ensamblador

FOR
ORG 100 /El origen del programa es Hex 100

LDA ADS /Cargar primera direccin de operadores

STA PTR /Almacena en apuntador

LDA NBR /Cargar menos de 100

CLA /Borrar el acumulador /

LOP, ADD PTR I /Sumar un operador a AC

ISZ OTR /Incrementa Apuntador

29
ISZ CTR /Incrementar Contador

BUN LOP /Repetir Ciclo

STA SUM/ Almacenar Suma

HLT /Detener

ADS, HEX 100/Permitir direcciones de operadores

PTR, HEX 0/Esta posicin sta reservada para una posicin

NBR, DEC-100 /Constante para el contador inicializado

CTR, HEX0/Esta posicin sta reservada para un contador

SUM, HEX0/La suma esta almacenada aqu

ORG 100 /El origen de los operadores es HEX 100

DEC 75 /Primer operador

Dec 23 /Ultimo operador

END

While
Programa que imprime los nmeros pares entre el 1 y el 10(para hacerlo corto)

30
Do-While

.model small
.stack 64
.data
mayor1 Db 'Es mayor','$'
menor1 Db 'Es menor','$'
igual1 Db 'Son iguales','$'
.code
inicio:
mov ah,01
int 21h
mov bl,al
mov ah,01
int 21h
mov cl,al
cmp bl,cl
ja mayor
jb menor
je igual
mayor:
mov ax,@data

31
mov ds,ax
mov ah,09
mov dx,offset mayor1
int 21h
jmp salir
menor:
mov ax,@data
mov ds,ax
mov ah,09
mov dx,offset menor1
int 21h
jmp salir
igual:
mov ax,@data
mov ds,ax
mov ah,09
mov dx,offset igual1
int 21h
jmp salir
salir:
mov ah,4ch
int 21h
end inicio

Jasmine

Jasmin es un ensamblador para la Mquina Virtual Java, el cual toma como entrada un
fichero de texto con la descripcin de una clase Java, y produce como resultado el class de
esa clase

FOR
Method void main(java.lang.String[])

bipush 100
istore_1
iconst_0

32
istore_2
iconst_1
istore_3
goto 17
iload_2
iload_3
iadd
istore_2
iinc 3 1
iload_3
iload_1
if_icmplt 10
getstatic #13
new #6
dup
ldc #2
invokespecial #10
iload_1
invokevirtual #11
ldc #3
invokevirtual #12
iload_2
invokevirtual #11
ldc #1
invokevirtual #12
invokevirtual #15
invokevirtual #14
return

ENTRADA & SALIDA


En un programa, los datos de entrada son los que la computadora va a procesar. Los datos
de salida son datos derivados, es decir, obtenidos a partir de los datos de entrada. Por esta
razn, a los datos de salida se les considera ms significativos que a los datos de entrada.
Ambos tipos de datos son informacin (textos, imgenes, sonidos, vdeos,...) que maneja la
computadora. Sin embargo, en un sentido ms filosfico, a los datos de entrada se les
considera la materia prima de los datos de salida, considerados estos como la verdadera
informacin.

33
Ejemplos en C#

ENTRADA & SALIDA:


class Suma {
static void Main(string[] args) {
int A, B, C;
//Se crean variables de tipo entero que se llamarn A, B y C
string AUX;
Console.WriteLine("Introduce el primer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
A = int.Parse(AUX);
Console.WriteLine("Introduce el segundo nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
B = int.Parse(AUX);
Console.WriteLine("Introduce el tercer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
C = int.Parse(AUX);
Console.WriteLine("\n\n\n");
Console.WriteLine(Tus nmero a sumar son: A+B+C);
}
}

class Resta {
static void Main(string[] args) {
int A, B, C;

34
//Se crean variables de tipo entero que se llamarn A, B y C
string AUX;
Console.WriteLine("Introduce el primer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
A = int.Parse(AUX);
Console.WriteLine("Introduce el segundo nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
B = int.Parse(AUX);
Console.WriteLine("Introduce el tercer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
C = int.Parse(AUX);
Console.WriteLine("\n\n\n");
Console.WriteLine(Tus nmeros a restar son: A+B+C);
}
}

class Multiplicar {
static void Main(string[] args) {
int A, B, C;
//Se crean variables de tipo entero que se llamarn A, B y C
string AUX;
Console.WriteLine("Introduce el primer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado

35
A = int.Parse(AUX);
Console.WriteLine("Introduce el segundo nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
B = int.Parse(AUX);
Console.WriteLine("Introduce el tercer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
C = int.Parse(AUX);
Console.WriteLine("\n\n\n");
Console.WriteLine(Tus nmero a multiplicar son: A+B+C);
}
}
class Division {
static void Main(string[] args) {
int A, B, C;
//Se crean variables de tipo entero que se llamarn A, B y C
string AUX;
Console.WriteLine("Introduce el primer nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
A = int.Parse(AUX);
Console.WriteLine("Introduce el segundo nmero");
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
B = int.Parse(AUX);
Console.WriteLine("Introduce el tercer nmero");

36
//Pide que se introduzca un nmero como entrada
AUX = Console.ReadLine();
//Manda a pantalla lo que se puso entrecomillado
C = int.Parse(AUX);
Console.WriteLine("\n\n\n");
Console.WriteLine(Tus nmero a dividir son: A+B+C);
}
}

Ejemplos en Ensamblador

ENTRADA & SALIDA:


Al posicionarnos sobre la fila cs:0100>0363 estamos introduciendo las variables o datos
que queremos utilizar, en este caso add ax,bx y es all cuando el Turbo Assembler los lee y
les da salida mostrndolos en la pantalla.

A continuacin se hace lo mismo pero con la lectura y salida de las variables que
acompaan a la resta:

37
Ejemplos en Jassm

ENTRADA & SALIDA:


A continuacin, mediante el siguiente fragmento de programa de la clase Suma notaremos
los mtodos de entrada y salida de los datos a utilizar en Jassm:

.class public suma


.super java/lang/Object
.method public <init>()
aload_0
invokespecial java/lang/Object/<init>()
Return
.end method
.method public add
.limit stack 2
.limit locals 4
iload_1
iload_2
Iadd
istore_3
iload_3
Ireturn
.end method
.class public suma
.super java/lang/Object

38
.method public ()
aload_0
invokespecial java/lang/Object/()
Return
.end method
.method public static main([Ljava/lang/String;)V
.limit stack 10
.limit locals 10
; get op
aload_0

iconst_0
Aaload
astore 1

; get a
aload_0
iconst_1
Aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_2
; get b
aload_0
iconst_2
Aaload
invokestatic java/lang/Integer.parseInt(Ljava/lang/String;)I
istore_3
; new Suma
new suma;
Dup
invokespecial Calculator/<init>()V
; branch if not add
aload_1
ldc "add"
invokevirtual java/lang/String.equals(Ljava/lang/Object;)Z
ifeq NOT_ADD
; add
iload_2
iload_3
invokevirtual Calculator/add
istore 4

39
; print result
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 4
invokevirtual java/io/PrintStream/println
return
NOT_ADD:
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "invalid arithmetic operator"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
Return .end method

ESTRUCTURAS

PILAS
Puesto que la coleccin de lista estndar tiene un encabezamiento y un final, resulta fcil
crear una coleccin de lista derivada que imite el comportamiento de una pila en la que el
ltimo en entrar es el primero en salir. Una pila es como una pila de bandejas de una
cafetera. A medida que se agregan bandejas a la pila, se van colocando en la parte superior
de la pila. La ltima bandeja agregada es la primera en quitar. Las funciones miembro de
una coleccin de lista AddHead y RemoveHead se pueden utilizar para agregar y quitar
elementos especficamente del principio de la lista; por tanto, el ltimo elemento agregado
es el primero que se quita.

COLAS
Puesto que la coleccin de lista estndar tiene un encabezamiento y un final, resulta fcil
crear una coleccin de lista derivada que imite el comportamiento de una cola en la que el
primero en entrar es el primero en salir. Una cola es como una fila de gente en una
cafetera. La primera persona de la fila es la primera a quien se sirve. A medida que llega
ms gente, estas personas se sitan al final de la fila para esperar que les llegue su turno.
Las funciones miembro de una coleccin de lista AddTail y RemoveHead se pueden
utilizar para agregar y quitar elementos especficamente del encabezamiento o del final de
la lista; por tanto, el ltimo elemento agregado es siempre el ltimo que se quita.

40
LISTAS
Son una sucesin de cero o ms elementos. Esta es una definicin muy simple y que no
aclara demasiado en trminos informticos, as que profundizaremos un poco ms. Hay
varios tipos de listas, las hay enlazadas, no enlazadas, ordenadas y no ordenadas. Nosotros
vamos a estudiar las listas enlazadas, tanto ordenadas como no ordenadas. La diferencia
que existe entre las listas enlazadas y las no enlazadas es que las enlazadas utilizan
punteros, es decir, asignacin dinmica de memoria, lo que optimiza la gestin de la
misma. Una lista no enlazada es un simple array, y por lo tanto es un bloque contiguo de
memoria, mientras que una lista enlazada es un conjunto de nodos que no tienen porque

Ocupar posiciones contiguas de memoria. La diferencia entre listas ordenadas y no


ordenadas es obvia, las ordenadas mantienen cierto orden entre sus elementos. A partir de
ahora nos centraremos en las listas enlazadas no ordenadas. Una lista es una sucesin de
nodos en la que a partir de un nodo se puede acceder al que ocupa la siguiente posicin en
la lista. Esta caracterstica nos indica que el acceso a las listas es secuencial y no indexado,
por lo que para acceder al ltimo elemento de la lista hay que recorrer los n-1 elementos
previos (n es el tamao de la lista).

ARREGLOS

Es una coleccin de datos del mismo tipo. Sirve para manejar un nmero n de elementos
en comn, ya sea de tipos definidos por el Lenguaje,(int,float,String,etc) as como
aquellos definidos por el programador.
Un arreglo unidimensional es un tipo de datos estructurado que est formado de una
coleccin finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar
listas de elementos iguales. El tipo de acceso a los arreglos unidimensionales es el acceso
directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar
a elementos anteriores o posteriores, esto mediante el uso de un ndice para cada elemento
del arreglo que nos da su posicin relativa.

41
Ejemplos en C#

Pilas
Para crear una pila, emplearemos la clase Stack. Una pila nos permitir introducir un nuevo
elemento en la cima ("apilar", en ingls "push") y quitar el elemento que hay en la cima
("desapilar", en ingls "pop").

Este tipo de estructuras se suele denotar tambin usando las siglas "LIFO" (Last In First
Out: lo ltimo en entrar es lo primero en salir).

Para utilizar la clase "Stack" y la mayora de las que veremos en este tema, necesitamos
incluir en nuestro programa una referencia a "System.Collections".

As, un ejemplo bsico que creara una pila, introdujera tres palabras y luego las volviera a
mostrar sera:

using System;
using System.Collections;

public class Ejemplo_11_02a


{
public static void Main()
{
string palabra;

Stack miPila = new Stack();


miPila.Push("Hola,");
miPila.Push("soy");
miPila.Push("yo");

for (byte i=0; i<3; i++)


{

42
palabra = (string) miPila.Pop();
Console.WriteLine( palabra );
}
}
}

LISTAS:

Sea LISTA una lista enlazada, salvo que se indique lo contrario. Almacenaremos LISTA en
memoria de la forma siguiente. Como mnimo, LISTA estar compuesta por dos arrays
lineales, a los que llamaremos INFO y ENLACE, tales que INFO [K] y ENLACE [K]
contienen la parte de informacin y el campo de puntero de cada nodo de LISTA
respectivamente. Necesitamos tambin una variable especial llamada COMIENZO que
contiene la posicin ocupada por el primer elemento de la lista, y una marca especial
NULO que indica el final de la misma. Puesto que los ndices de los arrays INFO y
ENLACE sern habitualmente positivos, el valor NULO ser el -999, salvo que digamos lo
contrario.

El siguiente ejemplo muestra la representacin memoria de una lista enlazada en la que


cada nodo de la lista contiene un nico carcter. Podemos obtener la lista de caracteres o,
en otras palabras, la cadena de la forma siguiente:

COMIENZO = 9, luego INFO [9] = N primer carcter.

ENLACE [9] = 3, luego INFO [3] = 0 segundo carcter.

ENLACE [3] = 6, luego INFO [6] = (carcter blanco) tercer carcter.

ENLACE [6] = 11, luego INFO [11] = E cuarto carcter.

43
ENLACE [11] = 7, luego INFO [7] = X quinto carcter.

ENLACE [7] = 10, luego INFO [10] = I sexto carcter.

ENLACE [10] = 4, luego INFO [4] = T sptimo carcter.

ENLACE [4] = -999 valor nulo, luego termina la lista.

FORMA PRINCIPAL DE LA LISTA ENLAZADA

Cdigo:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

namespace WindowsApplication1

public partial class Listas : Form

public Listas()

InitializeComponent();

public static int[] enlace = new int[10] { 2, 3, 4, 0, -999, 6, 7, 8, 9, -999 };

44
public static string[] alumno = new string[10] { "Jose", "Ana", "Rosa", "Beto", "zeta",
"", "", "", "", "" };

public static int comienzo = 1;

public static int disponible = 5;

private void cmdInsercion_Click(object sender, EventArgs e)

Insercion ins = new Insercion();

ins.Show();

private void cmdRecorrido_Click(object sender, EventArgs e)

Recorrer rec = new Recorrer();

rec.Show();

private void cmdBusqueda_Click(object sender, EventArgs e)

Busqueda bus = new Busqueda();

bus.Show();

private void cmdEliminacion_Click(object sender, EventArgs e)

45
Eliminacion eli = new Eliminacion();

eli.Show();

ARREGLOS:
Matrices multidimensionales
Conceptualmente, una matriz multidimensional con dos dimensiones se asemeja a una
cuadrcula. Una matriz multidimensional con tres dimensiones se asemeja a un cubo.
C#
// declare multidimension array (two dimensions)
int[,] array2D = new int[2,3];

// declare and initialize multidimension array


int[,] array2D2 = { {1, 2, 3}, {4, 5, 6} };

// write elements in a multidimensional array


for (int i=0; i<2; i++)
{
for (int j=0; j<3; j++)
{
array2D[i,j] = (i + 1) * (j + 1);
}
}

// read elements in a multidimensional array


for (int i=0; i<2; i++)
{
for (int j=0; j<3; j++)
{
System.Console.Write(array2D[i,j]);
}
System.Console.WriteLine();

Ensamblador

PILAS:

46
.model small
.stack 64
.data
.code
mov ah 4h;
mov dx, Hola;
int 21
mov ah 3h;
mov dy soy;
int 20
mov ah,2h
mov db yo;
int 21h
push ax
loop meter
mov ah,4h
imprimir:
pop ax
mov ah,2h
mov dl,al
int 21h
loop imprimir
salir:
mov ah,3ch
int 21h
end

LISTAS
; Insercin de un elemento en una lista ordenada.

; La lista est almacenada a partir de la direccin definida por LISTOR y est

; constituida por elementos de 1 palabra de longitud expresados en binario puro.

; Estn ordenados de menor a mayor y estn almacenados en posiciones de memoria

; Consecutivas. El tamao de la lista est almacenado en la direccin

; LONLIS y el elemento a insertar est almacenado en la variable NUEVO.

; La lista no almacena elementos repetidos.

47
org 1000

LISTOR: data 1,3,7,45,56,67,101,200

org 2000

LONLIS: data 8

NUEVO: data 90

;Tras la ejecucion del programa los contenidos de memoria son:

; 992 01000000 03000000

; 1008 07000000 2D000000 38000000 43000000

; 1024 5A000000 65000000 C8000000 00000000

; 2000 09000000 5A000000

Jassm
LAS INSTRUCCIONES BIPUSH, SIPUSH Y IINC

Las instrucciones bipush y sipush toman un entero como un parmetro:

bipush <int>

sipush <int>

por ejemplo:

bipush 100; empujar 100 en la pila

La instruccin IINC toma dos parmetros enteros:

IINC <var-num> <cantidad>

por ejemplo:

IINC 3 -10; restar 10 de variable local 3

48
LA INSTRUCCIN NEWARRAY:
La instruccin newArray es seguido por el tipo de la matriz,

newArray <tipo array>

por ejemplo:

newArray int

newArray corta

flotador newArray

etctera

LA INSTRUCCIN MULTIANEWARRAY:

La instruccin multianewarray toma dos parmetros, el descriptor de tipo para la matriz y el


nmero de dimensiones para asignar:

multianewarray <array-descriptor> <num-dimensiones>

por ejemplo:

multianewarray [[[I 2

LA INSTRUCCIN LOOKUPSWITCH:
La instruccin lookupswitch tiene la sintaxis:

<Lookupswitch> :: =

lookupswitch
<INT1>: <label1>

<INT2>: <label2>

...

por defecto: <default-label>


Por ejemplo:

; Si el int en la pila es 3, saltar a Label1.

49
; Si es 5, saltar a Label2.

; De lo contrario saltar a DefaultLabel.

lookupswitch
3: Label1

5: Label2

por defecto: DefaultLabel

label1:

... Tiene 3

label2:
... Tiene 5

DefaultLabel:
... Tiene algo ms

LA INSTRUCCIN TABLESWITCH:

La instruccin tableswitch tiene la sintaxis:

<Tableswitch> :: =
tableswitch <bajos>

<Label1>

<Label2>

...
por defecto: <default-label>

Por ejemplo:

; Si el int en la pila es 0, saltar a Label1.

50
; Si es 1, saltar a Label2.

; De lo contrario saltar a DefaultLabel.

tableswitch 0

label1
label2

por defecto: DefaultLabel

label1:

... Conseguido 0

label2:

... Consigui 1

DefaultLabel:

51
BIBLIOGRAFIA

Anon, (2017). [online] Available at: https://msdn.microsoft.com/es-


es/library/cc451506(v=vs.71).aspx [Accessed 16 Mar. 2017].

Anon, (2017). [online] Available at: https://msdn.microsoft.com/es-


es/library/9ct4ey7x(v=vs.90).aspx [Accessed 16 Mar. 2017].

Anon, (2017). [online] Available at: https://msdn.microsoft.com/es-


es/library/6sh2ey19(v=vs.110).aspx [Accessed 16 Mar. 2017].

Carlosnuel.com. (2017). Tutorial de lenguaje ensamblador. [online] Available at:


http://www.carlosnuel.com/tutorial-de-lenguaje-ensamblador-en-espanol-con-
ejemplos.html [Accessed 16 Mar. 2017].

Hernndez, L., Hernndez, L. and perfil, V. (2017). Codigo Fuente Hola Mundo. [online]
Asembler-uaeh-esh.blogspot.mx. Available at: http://asembler-uaeh-
esh.blogspot.mx/2009/10/hola-mi-queridos-alumnos.html [Accessed 16 Mar. 2017].

52