# Made by : Dharok
# Programa para calcular el area de un triangulo conociendo solo sus vertices, se utiliza la formula de Herón
# Ingresa los puntos del plano cartesiano

from math import *
x1 = int(input("Ingrese X1: "))
y1 = int(input("Ingrese Y1: "))
x2 = int(input("Ingrese X2: "))
y2 = int(input("Ingrese Y2: "))
x3 = int(input("Ingrese X3: "))
y3 = int(input("Ingrese Y3: "))

#Calcula e imprime las longitudes de los lados utilizando la formula de distancia entre 2 puntos
print "Los puntos son:(",x1,",",y1,")(",x2,",",y2,")(",x3,",",y3,")"
a1 = (y2-y1)**2 + (x2-x1)**2
a = sqrt(a1)
b1 = (y3-y2)**2 + (x3-x2)**2
b = sqrt(b1)
c1 = (y3-y1)**2 + (x3-x1)**2
c = sqrt(c1)


print "La longitud del lado a es:",a
print "La longitud del lado b es:",b
print "La longitud del lado c es:",c

#Segun la formula de Herón para hallar el area de un triangulo conociendo solo sus lados es necesario el semiperimetro"

p = (a+b+c)/2.0

print "El semiperimetro es:",p

#Calculando el area

A1 = p*(p-a)*(p-b)*(p-c)
A = sqrt(A1)

print "El Area del tringulo es:",A

#Fin

virtual void draw(); 

virtual float earningsO const = 0; 

#include <iostream.h>
#include <math.h>
#include <conio.h>

// clase Shape

class Shape {
      public:
         virtual double area() const { return 0.0; }
         virtual double volume() const { return 0.0; }

         // funcion virtual pura sobrepuesta en las clases derivadas
         virtual void print() const=0;
};

////////////////////////////////
// clase TwoDimensionalShape ///
////////////////////////////////

class TwoDimensionalShape : public Shape {
      public:
         virtual void print () const=0;
};

// clase triangulo
class triangulo : public TwoDimensionalShape {
      double lado1, lado2, lado3;
      public:
         triangulo (double=0.0, double=0.0, double=0.0);
         void fijar_triangulo(double, double, double);
         virtual double area() const;
         virtual void print() const;
};

triangulo :: triangulo (double l1, double l2, double l3){
      fijar_triangulo(l1,l2,l3);
}

void triangulo :: fijar_triangulo  (double l1, double l2, double l3){
      lado1= l1 > 0 ? l1 : 0;
      lado2= l2 > 0 ? l2 : 0;
      lado3= l3 > 0 ? l3 : 0;
}

double triangulo :: area () const {
      double s;
      s=(lado1+lado2+lado3)/2;

      return sqrt(s*(s-lado1)*(s-lado2)*(s-lado3));
}

void triangulo :: print () const {
      cout << endl << "Triangulo" << endl
      << "Lado 1= " << lado1 << endl
      << "Lado 2= " << lado2 << endl
      << "Lado 3= " << lado3;
}

// clase cuadrado
class cuadrado : public TwoDimensionalShape {
      double lado;
      public:
         cuadrado (double=0.0);
         void fijar_cuadrado(double);
         virtual double area() const;
         virtual void print() const;
};

cuadrado :: cuadrado (double l) {
      fijar_cuadrado(l);
}

void cuadrado :: fijar_cuadrado (double l){
      lado= l>0 ? l : 0;
}

double cuadrado :: area () const {
      return lado*lado;
}

void cuadrado :: print() const {
      cout << endl << "Cuadrado" << endl
            <<"Lado= " << lado;
}

////////////////////////////////
// clase ThreeDimensionalShape /
////////////////////////////////

class ThreeDimensionalShape : public Shape {
      public:
         virtual void print () const=0;
};

// clase cubo
class cubo : public ThreeDimensionalShape {
      double lado;
      public:
         cubo(double=0.0);
         void fijar_cubo(double);
         virtual double area() const;
         virtual double volume() const;
         virtual void print() const;
};

cubo :: cubo (double l){
      fijar_cubo(l);
}

void cubo :: fijar_cubo (double l){
      lado= l>0 ? l : 0;
}

double cubo :: area () const {
      return 6*lado*lado;
}

double cubo :: volume () const {
      return lado*lado*lado;
}

void cubo :: print() const{
      cout << endl << "Cubo" << endl
            <<"Lado= " << lado;
};

// clase paralelepipedo
class paralelepipedo : public ThreeDimensionalShape {
      double largo, ancho, altura;
      public:
         paralelepipedo(double=0.0, double=0.0, double=0.0);
         void fijar_paralelepipedo(double, double, double);
         virtual double area() const;
         virtual double volume() const;
         virtual void print() const;
};

paralelepipedo :: paralelepipedo (double l, double a, double h){
      fijar_paralelepipedo(l,a,h);
}

void paralelepipedo :: fijar_paralelepipedo (double l, double a, double h){
      largo= l>0 ? l : 0;
      ancho= a>0 ? a : 0;
      altura= h>0 ? h : 0;
}

double paralelepipedo :: area () const {
      return 2*largo*ancho + 4*ancho*altura;
}

double paralelepipedo :: volume () const {
      return largo*ancho*altura;
}

void paralelepipedo :: print() const{
      cout << endl <<"Paralelep¡pedo" << endl
            <<"Largo= " << largo << endl 
            <<"Ancho= " << ancho << endl
           <<"Altura= " << altura;
}

// llama a funcion virtual a partir del apuntador de clase base
// utilizando enlace dinamico
void virtualViaPointer (const Shape* baseClassPtr){
      baseClassPtr->print();
      cout << endl <<"Area= " << baseClassPtr->area() << endl
            <<"Volumen= " << baseClassPtr->volume() << endl;
}

// llama a funcion virtual a partir de referencia a clase base
// utilizando enlace dinamico
void virtualViaReference (const Shape& baseClassRef){
      baseClassRef.print();
      cout << endl <<"Area= " << baseClassRef.area() << endl
            <<"Volumen= " << baseClassRef.volume() << endl;
}

// funcion principal
void main(){
      clrscr();
      triangulo t(5.2,6.5,7.1);
      virtualViaPointer (& t);
      virtualViaReference (t);

      cuadrado c(8.7);
      virtualViaPointer (&c);
      virtualViaReference (c);

      getch();
      clrscr();

      cubo cub(8.3);
      virtualViaPointer (&cub);
      virtualViaReference (cub);

      paralelepipedo p(4.5,6.7,9.2);
      virtualViaPointer (&p);
      virtualViaReference (p);

      getch();
} 

template <class T>
template <class Element Type>
template <class BorderType, class FillType> 

template <class T>
class Nombre { . . .uso del parámetro T en funciones o datos miembro.. } 

#include <iostream.h> 
#include <conio.h>

template <class T>
T minimo (T * Array, int num_elemen) 
{ 
   T min= Array [0] ;

   for (int i=1; i< num_elemen; i++)
        if( Array[ i ] < min) 
            min = Array [ i ];

   return min; 
} ;

template <class T>
T maximo (T * Array, int num_elemen) 
{
   T max= Array [0];

   for (int i=1; i< num_elemen; i++)
        if( Array[ i ] > max) 
            max = Array [ i ];

   return max; 
};

void main(void)
{ 
   int ArrayInt [3] = { 2, 8, 6}; 
   float ArrayFloat [3] = { 12.1, 8.7, 5.6 }; 
   int i;
   
   cout<<"Arreglo de enteros: ";
   for (i=0; i<3; i++) 
         cout << ArrayInt[ i ] << " "; 

   cout << endl << "Numero minimo: " << minimo (ArrayInt, 3) << endl
         <<"Numero maximo: " << maximo (ArrayInt, 3) << endl << endl;

   cout << "Arreglo de flotantes: ";
   for (i=0; i<3; i++) 
        cout << ArrayFloat[ i ] << " "; 
        cout << endl <<"Numero minimo: " << minimo (ArrayFloat, 3) << endl
               <<"Numero maximo: " << maximo (ArrayFloat, 3);

   getch(); 
} 

#include <iostream.h>
#include <conio.h>

template <class T>
void Ordenar ( T * a, int st, int fn) 
{
   int i, j , k;
   T item_a_ordenar;

   k = 1 ;

   do 
   {
       k= 3 * k + 1; 
    } while (k < fn - st + 1) ;

   do 
   {
       k /= 3 ;

       for (i= st+k; i<=fn; i++) 
       { 
             item_a_ordenar = a [ i ] ; 
             j = i ;

            while (item_a_ordenar < a [ j-k]) 
            { 
               a [ j] =a [ j-k] ; 
               j -=k;

               if(j < st+k) 
                 break; 
            }

            a [j]=item_a_ordenar; 
        } 
   } while(k > 1); 
}

void main(void)
{ 
    int Arraylnt[3] = { 2, 3, 1 } ;
    float ArrayFloat[3] = {25.0, 3.0, 45.2 } ;
    int i ;

    cout << "Enteros: " << endl
          << "Arreglo original: ";

    for (i=0; i<3; i++) 
          cout << Arraylnt[ i ] << " ";

    Ordenar(Arraylnt, 0, 2); 
    cout << endl << "Luego de ordenar: ";

    for (i=0; i<3; i++) 
          cout << Arraylnt[ i ] << " ";


    cout << endl << endl 
          << "Flotantes: " << endl 
          << "Arreglo original: "; 

    for (i=0; i<3; i++) 
          cout << ArrayFloat[ i ] << " ";

    Ordenar(ArrayFloat, 0, 2); 
    cout << endl << "Luego de ordenar: ";

    for (i=0; i<3; i++) 
          cout << ArrayFloat[ i ] << " ";


    getch() ; 
} 

#include <iostream.h>
#include <conio.h>

enum estado_pila { OK, LLENA, VACIA };

template <class T> 
class NuevaPila 
{ 
   int tamanyo; 
   T *tabla; 
   int cima;
   estado_pila estado; 

   public:
             NuevaPila(int =10);
             ~NuevaPila() { delete [] tabla; }
             void meter (T);
             T sacar ();
             void visualizar ();
             int num_elementos ();
             int leer_tamanyo () { return tamanyo; }
}

template <class T>
NuevaPila <T> :: NuevaPila (int tam) 
{
   tamanyo=tam;
   tabla= new T [tamanyo] ;
   cima=0;
   estado=VACIA;
}
 
template <class T>
void NuevaPila <T> :: meter (T elemento) 
{ 
   if( estado!=LLENA) 
       tabla [cima++]=elemento;
    else cout << "*** Pila llena ***";

    if(cima>=tamanyo) 
       estado=LLENA; 
    else 
       estado=OK; 
}

template <class T>
T NuevaPila <T> :: sacar () 
{
   T elemento=0;

   if(estado!=VACIA) 
      elemento=tabla[--cima];
   else cout<<"*** Pila vac¡a ***";

   if(cima<=0)
      estado=VACIA; 
   else 
      estado=OK; 

   return elemento; 
}

template <class T>
void NuevaPila <T> :: visualizar () 
{ 
   for (int i=cima-1; i >=0; i--) 
        cout << tabla[ i ] <<" "; 
}

template <class T> 
int NuevaPila <T> :: num_elementos () 
{
   return cima; 
}

void main() 
{
   cout << "Probando pila de enteros";

   NuevaPila <int> s1 (5);
   s1.meter(5);
   s1.meter(10);
   s1.meter(15);

   cout << endl << "Numero de elementos: " << s1.num_elementos() << endl <<"Pila: ";  
   s1.visualizar(); 

   cout << endl << "Sacando elementos : " 
          << s1.sacar() <<" " << s1.sacar() << " " << s1.sacar() << endl; 
   s1.sacar();

   cout << endl << endl << "Probando pila de flotantes";
   NuevaPila <float> s2 (5);
   s2.meter(7.5);
   s2.meter(10.2);
   s2.meter(15.3);

   cout << endl << "Numero de elementos: " << s2.num_elementos() << endl
         <<"Pila: "; 
   s2.visualizar(); 
   cout << endl << "Sacando elementos : " 
           << s2.sacar() << " " << s2.sacar() << " " << s2.sacar() << endl; 
   s2.sacar ();

   cout << endl << endl << "Probando pila de caracteres";
   NuevaPila <char> s3 (5);
   s3.meter('m');
   s3.meter('p');
   s3.meter('s');

   cout << endl << "Numero de elementos: " << s3.num_elementos() << endl <<"Pila: "; 
    s3.visualizar(); 
    cout << endl << "Sacando elementos : " 
          << s3.sacar () << " " << s3.sacar() << " " << s3.sacar() << endl; 
   s3.sacar();


   getch();
} 

#include <iostream.h>
#include <conio.h>
#include <assert.h>

template <class TIPONODO>
class Cola;

///////////////////////////////////
// definicion clase NodoCola /////
//////////////////////////////////

template <class TIPONODO>
class NodoCola {
      TIPONODO dato;                         // dato
      NodoCola <TIPONODO> * sig;             // puntero siguiente nodo
      public:
         NodoCola (const TIPONODO &);    // constructor
         TIPONODO getDato() const;       // devuelve dato del nodo

      friend class Cola <TIPONODO>;          // hace que Cola sea friend
};

// constructor
template <class TIPONODO>
NodoCola <TIPONODO> :: NodoCola (const TIPONODO & info)
     : dato(info), sig (0) { }

// devuelve una copia del dato que esta en el nodo
template <class TIPONODO>
TIPONODO NodoCola <TIPONODO> :: getDato() const {
     return dato;
}

// definicion enumeracion //
enum bool { false, true };

//////////////////////////////////
// definicion clase Cola /////////
//////////////////////////////////

template <class TIPONODO>
class Cola {
      NodoCola <TIPONODO> * primero;          // puntero al primer nodo
      NodoCola <TIPONODO> * ultimo;           // puntero al ultimo nodo
      public:
         Cola ();                         // constructor
         ~Cola();                         // destructor
         void encolar (const TIPONODO &); // permite insertar nodo
         bool decolar (TIPONODO &);       // permite eliminar nodo
         bool estaVacia() const;          // verifica si la cola esta vacia
         void imprimir() const;              // imprime datos de la cola

      // funci¢n de utileria para asignar un nuevo nodo
      NodoCola <TIPONODO> * getNuevoNodo (const TIPONODO &);
};

// constructor predeterminado
template <class TIPONODO>
Cola <TIPONODO> :: Cola (): primero(0), ultimo(0) { }

// destructor
template <class TIPONODO>
Cola <TIPONODO> :: ~Cola () {
     if( !estaVacia() ) {         // ingresa si la cola no esta vacia
    cout<<"Eliminando nodos ..." << endl;

    NodoCola <TIPONODO> * actual = primero, *temporal;

    while (actual != 0) {     // borra los nodos restantes
           temporal = actual;
           cout<< temporal->dato << endl;
           actual = actual->sig;
           delete temporal;
    }
     }
     cout << "Todos los nodos han sido eliminados" << endl << endl;
}

// inserta un nodo
template <class TIPONODO>
void Cola <TIPONODO> :: encolar (const TIPONODO & valor) {
     NodoCola <TIPONODO> * nuevo = getNuevoNodo (valor);

     if ( estaVacia() )                // si la cola esta vacia
    primero=ultimo=nuevo;

     else {                           // si la cola no esta vacia
       ultimo->sig=nuevo;
       ultimo=nuevo;
     }
}

// elimina un nodo
template <class TIPONODO>
bool Cola <TIPONODO> :: decolar (TIPONODO & valor) {
     if( estaVacia() )                // la cola esta vacia
     return false;                // eliminacion no satisfactoria

     NodoCola <TIPONODO> *temporal = primero;

     if(primero==ultimo)
    primero=ultimo=0;

     else
      primero=temporal->sig;

     valor=temporal->dato;            // dato que se esta eliminando
     delete temporal;
     return true;                     // eliminacion satisfactoria
}

// verifica si la cola esta vacia
template <class TIPONODO>
bool Cola <TIPONODO> :: estaVacia () const {
     if (primero==0) return true;
     return false;
}

// imprime el contenido de la cola
template <class TIPONODO>
void Cola <TIPONODO> :: imprimir() const {
     if ( estaVacia() ) {
     cout<<"La lista esta vacia" << endl << endl;
     return;
     }

     NodoCola <TIPONODO> *actual = primero;

     cout<<"La cola es: ";

     while (actual!=0) {
        cout<< actual->dato <<" ";
        actual=actual->sig;
     }

     cout << endl << endl;
}

// funcion de utileria: devuelve un apuntador a un nodo recientemente asignado
template <class TIPONODO>
NodoCola <TIPONODO> * Cola <TIPONODO> :: getNuevoNodo (const TIPONODO & valor) {
     NodoCola <TIPONODO> * nuevo = new NodoCola <TIPONODO> (valor);
     assert(nuevo!=0);
     return nuevo;
}

/////////////////////////////////////////////////////////////////////////////

// funcion que prueba una cola
template <class T>
void probarCola ( Cola <T> & ObjetoCola) {

     T valor;
     int opcion;

     for (;;){
           cout<<endl<<"(1) Insertar, (2) Eliminar, (3) Imprimir, (4) Salir"<<endl;
           cout<<"Seleccion: ";
           cin>>opcion;

           switch( opcion ){
              case 1:
                 cout<<"Ingrese dato: ";
                 cin>> valor;
                 ObjetoCola.encolar(valor);
                 break;

              case 2:
                 if(ObjetoCola.decolar(valor))
                cout<<"Dato " << valor <<" eliminado" << endl << endl;

                 else cout<<"No puede eliminar : la cola esta vacia" << endl << endl;

                 break;

              case 3:
                 ObjetoCola.imprimir();
                 break;
           }
           if(opcion==4) break;
     }
}

// funcion principal
void main(){
     clrscr();
     Cola <int> ColaEnteros;
     probarCola (ColaEnteros);

} 

obj eto2=obj eto2+obj eto1; 

obj eto2 +=obj eto1; 

#include<iostream.h>
#include<string.h>
#include<stdlib.h>
#include<conio.h>
#include<assert.h>

enum bool { false, true };

class string {
      int size;
      char *ptr;
      public:
         string (char []="");    //constructor predeterminado
         string (string &);     //constructor por copia
         ~string();             //destructor
         string & operator= (string &);   //asignaci¢n
         bool operator== (string &);      //prueba si s1=s2
         bool operator!= (string &);      //prueba si s1!=s2
         bool operator! ();               //prueba si string esta vacia
         bool operator< (string &);       //prueba si s1<s2
         bool operator> (string &);       //prueba si s1>s2
         bool operator<= (string &);      //prueba si s1<=s2
         bool operator>= (string &);      //prueba si s1>=s2
         string & operator+= (string &);  //concatenaci¢n
         char operator[] (int);           //operador de sub¡ndice
         string operator() (int, int);    //devuelve una subcadena
         int longitud (void);             //devuelve longitud de la cadena

         friend ostream & operator<< (ostream &, string &);
         friend istream & operator>> (istream &, string &);

};

string :: string (char * cadena){
      size=strlen(cadena);
      ptr=new char[size+1];
      if(ptr==NULL){ cout<<"No hay memoria"; exit(0); }
      strcpy(ptr, cadena);
}

string :: string (string & copia){
      size=strlen(copia.ptr);
      ptr=new char[size+1];
      if(ptr==NULL){ cout<<"No hay memoria"; exit(0); }
      strcpy(ptr, copia.ptr);
}

string :: ~string(){
      delete [] ptr;
}

string & string :: operator= (string & s){
      if(&s != this){          //evita la autoasignaci¢n
     delete [] ptr;        //evita fugas de memoria
     size=s.size;
     ptr=new char[size+1];
     strcpy(ptr, s.ptr);
      }
      else cout<<"Intento de asignar un objeto a si mismo";

      return (*this);          //habilita asignaciones en cascada
}

bool string :: operator== (string & s){
      if(!strcmp(ptr, s.ptr)) return (true);
      return (false);
}

bool string :: operator!= (string & s){
      if(!(*this==s)) return(true);    //usa sobrecarga de ==
      return(false);
}

bool string :: operator! (){
      if (size==0) return true;
      return false;
}

bool string :: operator< (string & s){
      if (strcmp(ptr, s.ptr)< 0) return true;
      return false;
}

bool string ::  operator> (string & s){
      if (s < *this) return true;
      return false;
}

bool string :: operator<= (string & s){
      if( !( s < *this) ) return true;
      return false;
}

bool string :: operator>= (string & s){
      if( !(s > *this) ) return true;
      return false;
}

string & string :: operator+= (string & s){
      char *temps=ptr;
      size+=s.size;
      ptr=new char[size+1];
      if(ptr==NULL){ cout<<"No hay memoria"; exit(0); }
      strcpy(ptr, temps);
      strcat(ptr, s.ptr);
      delete [] temps;
      return (*this);           //habilita llamadas en cascada
}

char string :: operator[] (int num){
      assert(num>=0 && num<size);   //prueba si num est  en el rango
      return (ptr[num]);
}

//Devuelve subcadena que comienza en: inicio y de longitud: subsize
string string :: operator() (int inicio, int subsize){
   //asegura que inicio este en el rango y que subsize sea >=0
      assert(inicio>=0 && inicio<size && subsize >=0);

      string *subptr= new string;      //string vac¡a
      if(subptr==0){ cout<<"No hay memoria"; exit(0); }

      //determina la longitud de la subcadena
      if((subsize==0) || (inicio+ subsize> size))
      subptr->size= size- inicio+ 1;
      else
      subptr->size= subsize+1;

      //asigna memoria para la subcadena
      delete subptr->ptr;        //borra el arreglo de caract,res
      subptr->ptr= new char[subsize];
      if(subptr->ptr==NULL){ cout<<"No hay memoria"; exit(0); }

      //copia la subcadena a la nueva string
      strncpy(subptr->ptr, & ptr[inicio], subptr->size);
      subptr->ptr[subptr->size]='\0';    //termina string

      return (*subptr);   //devuelve la nueva string
}

int string :: longitud (void){
      return (size);
}

ostream & operator<< (ostream & salida, string & s){
      salida<< s.ptr;
      return (salida);    //habilita el proceso en cascada
}

istream & operator>> (istream & entrada, string & s){
      entrada>> s.ptr;
      return (entrada);   //habilita proceso en cascada
}

void main(void){
     textcolor(BLACK);
     textbackground(WHITE);
     clrscr();
     string s1("hola"), s2(" amigos"), s3;


     //probando operadores de igualdad y relacionales
     cout<<"s1: " <<s1 <<" , s2: " <<s2  <<" , s3: " <<s3;

     cout<<endl<<endl<<"Resultados al comparar s1 y s2: "
     <<endl<<"Resultado de s1==s2: " << (s1==s2 ? "verdadero" : "falso")
     <<endl<<"Resultado de s1!=s2: " << (s1!=s2 ? "verdadero" : "falso")
     <<endl<<"Resultado de s1> s2: " << (s1> s2 ? "verdadero" : "falso")
     <<endl<<"Resultado de s1< s2: " << (s1< s2 ? "verdadero" : "falso")
     <<endl<<"Resultado de s1>=s2: " << (s1>=s2 ? "verdadero" : "falso")
     <<endl<<"Resultado de s1<=s2: " << (s1<=s2 ? "verdadero" : "falso");

     //prueba operador sobrecargado (!)
     cout<<endl<<endl<<"Probando !s3: ";
     if(!s3){
          cout<<"s3 esta  vacio, asignando s1 a s3";
          s3=s1;
          cout<<"ns3: " << s3;
        }

     //probando operador sobrecargado de concatenacion
     cout<<endl<<endl<<"Resultado de s1+=s2: "<<endl;
     s1+=s2;
     cout<<"s1: " <<s1;
     //probando operador sobrecargado []
     cout<<", s1[8]= " <<s1[8];

     //prueba del operador sobrecargado ()
     cout<<endl<<endl<<"Cadena resultante de s1(5,6): " <<s1(5,6) ;

     //prueba el constructor de copiado
     string *s4= new string(s1);
     cout<<endl<<endl<<"Constructor copia para *s4: " <<*s4;

     //prueba del operador de asignacion =
     cout<<endl<<endl<<"Asignando s3 a *s4, *s4: ";
      *s4=s3;
     cout<< *s4
     <<endl<<"Longitud de *s4: " <<s4->longitud();

     getch();
} 

#include <stdio.h>
main()
{
    int a, b, c = 1;
    printf("Introduzca el limite menor:");
    scanf("%d", &a);
    printf("Introduzca el limite mayor:"); 
    scanf("%d", &b);

    if(a < b)
       while(a < b-1)
       {
               a++;
               printf("%d", a);
       }

    else
    {
         a = c;
         b = a;
         c = b;

         while(a < b)
         {
              a++;
              printf("%d", a);
         }
    }
} 

#include <iostream>
using namespace std;
main()
{    
    int a, b, c = 1;
    cout << "Introduzca el limite menor:";
    cin >> a;
    cout << "Introduzca el limite mayor:";
    cin >> b;

    if (a < b)
        while(a < b -1)
        {
            a++;
            cout << a << "";
        }

    else
    {
        a = c;
        b = a;
        c = b;

        while(a < b)
        {
            a++;
            cout << a << "";
        }
    }
} 

#include <iostream>
int main()
    { 
      std::cout << "Mi primer programa" << std::endl;
      return 0;
     }

#include <iostream>
using namespace std;
int main()
{
	cout << "Escribe el signo o letra:" << endl;
	char variable;
	cin  >> variable;
	cout << "La letra escrita fue:\t"<< variable;
	cout << endl;
	return 0;
}

#include <iostream>
using namespace std;
int main()
{
	cout << "Buenos dias! mi nombre es Dharok, cual es el tullo?" << endl;
	char nombre[25];
	cin  >> nombre;
	cout << "Buenos dias "<< nombre <<"!";
	cout << endl;
	return 0;
}

@echo off
@title Maze Madness
@mode con cols=22 lines=20
::Batch Game Maze Madness
::by Splendit
::Based On SmartGenius Batch Game Logics

setlocal enabledelayedexpansion
If Not Exist Keyboard.exe (Call :Keyboard)

:Vars
Set LimX=16
Set LimY=16
Set IniX=0
Set IniY=0
Set MovX=0
Set MovY=0
Set "Bound=Û"
Set "Space= "
Set "Player=O"
Set "Limit=°"
Set "Exit=X"

:Init
For /l %%a in (%IniX%,1,%LimX%) do (
For /l %%b in (%IniY%,1,%LimY%) do (
Set X%%aY%%b=%Limit%))
Call :Nivel_1
Set "X4Y6=%Player%"
Set Curpos=X4Y6
Goto :Graphic

:Graphic
Call :Clear
For /l %%d in (%IniX%,1,%LimY%) do (
For /l %%e in (%IniX%,1,%LimX%) do (
Set Lin_%%d=!Lin_%%d!!X%%eY%%d!))
Echo.
Echo.
For /l %%f in (0,1,%LimY%) do (echo.  !Lin_%%f!)
Echo.
If Defined MovL (
Ping -n 1 localhost >nul
Call :%MovL% "%CurPos%"
Goto :Graphic
) else (
Keyboard
)
If "%errorlevel%"=="77" (call :MovX "+" "%CurPos%")
If "%errorlevel%"=="75" (call :MovX "-" "%CurPos%")
If "%errorlevel%"=="80" (call :MovY "+" "%CurPos%")
If "%errorlevel%"=="72" (call :MovY "-" "%CurPos%")
If "%errorlevel%"=="88" (pause&exit)
If "%errorlevel%"=="120" (pause&exit)
Goto :Graphic

:MovY
For /f "tokens=1,2 delims=X,Y" %%p in ("%~2") do (
if "%%q"=="%LimY%" Goto :Eof
Set /a MovY=%%q%~11
Call Set NMovY=%%X%%pY!MovY!%%
If "!NMovY!"=="%Bound%" (Set "MovL="&Goto :Eof)
If "!NMovY!"=="%Exit%" (Goto :Win)
If "!NMovY!"=="%Limit%" (Goto :Lose)
Set X%%pY!MovY!=%Player%
Set CurPos=X%%pY!MovY!
Set MovL=MovY "%~1"
Set "%~2=%Space%")
Goto :Eof

:MovX
For /f "tokens=1,2 delims=X,Y" %%p in ("%~2") do (
If "%%p"=="%LimX%" Goto :Eof
Set /a MovX=%%p%~11
Call Set NMovX=%%X!MovX!Y%%q%%
If "!NMovX!"=="%Bound%" (Set "MovL="&Goto :Eof)
If "!NMovX!"=="%Exit%" (Goto :Win)
If "!NMovX!"=="%Limit%" (Goto :Lose)
Set "X!MovX!Y%%q=%Player%"
Set "CurPos=X!MovX!Y%%q"
Set MovL=MovX "%~1"
Set "%~2=%Space%")
Goto :Eof

:Clear
for /l %%m in (0,1,%LimY%) do (set Lin_%%m=)
Goto :Eof

:Win
Cls
Echo.
Echo.   Felicitaciones
Echo.
Echo.    Completaste
Echo.     El Nivel
Echo.
Echo.
Pause >nul
Exit

:Lose
Cls
Echo.
Echo.    Has Perdido
Echo.
Echo.  Intenta de Nuevo
Echo.
Echo.
Set "MovL="
Pause >nul
Goto :Vars

:Nivel_1
For %%a in (X1Y1,X1Y2,X1Y4,X1Y7,X1Y8,X1Y11,X2Y1,X2Y14,X2Y15,X3Y1,X3Y3,X3Y5,X3Y10,X3Y12,X4Y1,X4Y7,X5Y9,X5Y10,X5Y11,X6Y5,X6Y9,X6Y11,X6Y15,X7Y1,X7Y5,X7Y11,X7Y15,X8Y3,X8Y11,X8Y15,X9Y3,X9Y7,X9Y11,X9Y15,X10Y11,X10Y15,X11Y5,X11Y10,X11Y11,X11Y15,X12Y1,X12Y2,X12Y8,X12Y13,X13Y3,X13Y6,X13Y7,X13Y8,X13Y9,X13Y13,X14Y1,X14Y15,X15Y3,X15Y4,X15Y7,X15Y11,X15Y12,X15Y14,X15Y15) do (Set %%a=%Bound%)
For %%a in (X1Y3,X1Y5,X1Y6,X1Y9,X1Y10,X1Y12,X1Y13,X1Y14,X1Y15,X2Y2,X2Y3,X2Y4,X2Y5,X2Y6,X2Y7,X2Y8,X2Y9,X2Y10,X2Y11,X2Y12,X2Y13,X3Y2,X3Y4,X3Y6,X3Y7,X3Y8,X3Y9,X3Y11,X3Y13,X3Y14,X3Y15,X4Y2,X4Y3,X4Y4,X4Y5,X4Y8,X4Y9,X4Y10,X4Y11,X4Y12,X4Y13,X4Y14,X4Y15,X5Y1,X5Y2,X5Y3,X5Y4,X5Y5,X5Y6,X5Y7,X5Y8,X5Y12,X5Y13,X5Y14,X5Y15,X6Y1,X6Y2,X6Y3,X6Y4,X6Y6,X6Y7,X6Y8,X6Y10,X6Y12,X6Y13,X6Y14,X7Y2,X7Y3,X7Y4,X7Y6,X7Y8,X7Y9,X7Y10,X7Y12,X7Y13,X7Y14,X8Y1,X8Y2,X8Y4,X8Y5,X8Y6,X8Y7,X8Y8,X8Y9,X8Y10,X8Y12,X8Y13,X8Y14,X9Y1,X9Y2,X9Y4,X9Y5,X9Y6,X9Y8,X9Y9,X9Y10,X9Y12,X9Y13,X9Y14,X10Y1,X10Y2,X10Y3,X10Y4,X10Y5,X10Y6,X10Y7,X10Y8,X10Y9,X10Y10,X10Y12,X10Y13,X10Y14,X11Y1,X11Y2,X11Y3,X11Y4,X11Y6,X11Y7,X11Y8,X11Y9,X11Y12,X11Y13,X11Y14,X12Y3,X12Y4,X12Y5,X12Y6,X12Y7,X12Y9,X12Y10,X12Y11,X12Y12,X12Y14,X12Y15,X13Y1,X13Y2,X13Y4,X13Y5,X13Y10,X13Y11,X13Y12,X13Y14,X13Y15,X14Y2,X14Y3,X14Y4,X14Y5,X14Y6,X14Y7,X14Y8,X14Y9,X14Y10,X14Y11,X14Y12,X14Y13,X14Y14,X15Y1,X15Y2,X15Y5,X15Y6,X15Y8,X15Y9,X15Y10,X15Y13) do (Set %%a=%Space%)
Set "X7Y7=%Exit%"
Goto :Eof

:Keyboard
Echo. Cargando...
(
echo n keyboard.dat
echo e 0000 4D 5A 2E 00 01 00 00 00 02 00 00 10 FF FF F0 FF
echo e 0010 FE FF 00 00 00 01 F0 FF 1C 00 00 00 00 00 00 00
echo e 0020 B4 08 CD 21 3C 00 75 02 CD 21 B4 4C CD 21
echo rcx
echo 002E
echo w0
echo q
echo.
)>keyboard.dat
type keyboard.dat|debug>NUL 2>&1
del /f/q/a "keyboard.exe">NUL 2>&1
ren keyboard.dat "keyboard.exe"
Goto :Eof