update

.devcontainer/Dockerfile

@@ -0,0 +1,22 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.145.1/containers/python-3/.devcontainer/base.Dockerfile
+
+# [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
+ARG VARIANT="3"
+FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
+
+# [Option] Install Node.js
+ARG INSTALL_NODE="true"
+ARG NODE_VERSION="lts/*"
+RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
+
+# [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
+# COPY requirements.txt /tmp/pip-tmp/
+# RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
+#    && rm -rf /tmp/pip-tmp
+
+# [Optional] Uncomment this section to install additional OS packages.
+# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+#     && apt-get -y install --no-install-recommends <your-package-list-here>
+
+# [Optional] Uncomment this line to install global node packages.
+# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1

.devcontainer/devcontainer.json

@@ -0,0 +1,45 @@
+{
+	"name": "Python 3",
+	"build": {
+		"dockerfile": "Dockerfile",
+		"context": "..",
+		"args": { 
+			// Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8, 3.9
+			"VARIANT": "3.8",
+			// Options
+			"INSTALL_NODE": "true",
+			"NODE_VERSION": "lts/*"
+		}
+	},
+
+	// Set *default* container specific settings.json values on container create.
+	"settings": { 
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"python.pythonPath": "/usr/local/bin/python",
+		"python.linting.enabled": true,
+		"python.linting.pylintEnabled": true,
+		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+		"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+		"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+		"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+		"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+		"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+		"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
+	},
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-python.python"
+	]
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "pip3 install --user -r requirements.txt",
+
+	// Uncomment to connect as a non-root user. See https://aka.ms/vscode-remote/containers/non-root.
+	// "remoteUser": "vscode"
+}

algoritmos.md

@@ -0,0 +1,100 @@
+# Estructuras de datos
+Las estructuras de datos son una forma eficiente de almacenar y organizar la información de nuestro programa. Existen diferentes estructuras que vamos a estudiar durante el curso, es muy importante trabajar con una buena estructura que nos ayude a resolver nuestros problemas de la mejor manera posible.
+
+Podemos clasificar las estructuras en dos grandes grupos:
+
+## Lineales: 
+La información se guarda de forma secuencial y podemos personalizar el orden en que se guardan. Por ejemplo, de acuerdo a las fecha, relevancia de la información, entre otras.
+
+## No lineales: (Arboles y grafos)
+No toda la información está al mismo nivel o almacenada con un orden especifico. Por ejemplo, en la estructura de árbol tenemos un tronco principal con diferentes ramificaciones que surgen a partir de este o, también, la estructura de grafos donde tenemos puntos de información dispersos pero interconectados entre sí.
+
+# Que es un Algoritmo 
+* Una serie de instrucciones o reglas establecidas que, por medio de una sucesión de pasos, permiten arribar a un resultado o solución.
+* En programación, un algoritmo establece, de manera genérica e informal, la secuencia de pasos o acciones que resuelve un determinado problema y, para representarlo, se utiliza, fundamentalmente, dos tipos de notación: pseudocódigo y diagramas de flujo.
+
+## Metodologia para la contruccion de un algoritmo
+Los pasos recomendados para desarrollar un algoritmo son los siguientes:
+
+* Definición del problema
+* Análisis del problema
+* Diseño del algoritmo
+* Verificación o pruebas
+
+Para la definición del problema debemos obtener los siguientes elementos:
+
+* **Entradas:** ¿Qué se necesita para realizar los pasos?
+* **Salidas:** ¿Qué se obtiene al final del algoritmo?
+* **Tipos de datos involucrados:** Textos, números, listas, etc.
+
+## User defined data types
+Los User Defined DataTypes son tipos de datos creados por los desarrolladores de software para realizar múltiples acciones.
+
+Estos datos pueden estar compuestos por otro tipo de datos previamente definidos pero, por defecto, no son parte del sistema. Además, dependiendo del lenguaje de programación que manejes, deberás tener claro (o no) el consumo de memoria.
+
+Por ejemplo, las aplicación de cobranzas necesitan un tipo de dato personalizado para las personas con deudas.
+
+**Tipo de dat abstracto**
+Repesenta un set particular de comportamientos. 
+    * Podemos definir con precision lo que hara un ADT
+      * Un Stack es una lista que implementa una politica "LIFO" en elementos agregados o eliminados"
+    * Una estructura de datos es mas correcta. Tipicamente es una tecnica o estrategia para implementar un ADT. 
+      * Por ejemplo podemos utilizar una Linked List o en un Array(estructura de datos) para implementar un Stack(ADT)
+    * Algunos de los ADT mas comunes que debes conocer como programador preparado son: 
+      * Stack(pila), Queue(cola), PriorityQueue(Cola de prioridades), Diccionarios, Trees(arboles), Graphs(grafos).
+    * Algunas de las estructuras de datos usadas para implementar esos ADTs son:
+      * Array, linked list, hash tables.
+      * Trees
+
+**List ADT**
+Una lista es un tipo de datos abstracto utilizado para representar un número contable de valores ordenados. El mismo valor puede existir más de una vez, esta es la implementación computacional del concepto matemático de secuencia finita, la lista.
+
+A continuación te comparto las operaciones disponibles en este ADT:
+
+get() – Retorna un elemento de la lista en cualquier posición especificada.
+insert() – Inserta un elemento en cualquier posición de la lista.
+remove() – Remueve la primera aparición de cualquier elemento en una lista no-vacía.
+removeAt() – Remueve el elemento que se encuentre en la posición especificada en una lista que no esté vacía.
+replace() – Reemplaza un elemento en cualquier posición por otro elemento.
+size() – Retorna el número de elementos contenidos en la lista.
+isEmpty() – Retorna true si la lista está vacía, si no, regresa false.
+isFull() – Retorna true si la lista está llena, si no, regresa false.
+
+**Stack ADT**
+Un Stack es un tipo de datos abstracto que sirve como una colección de elementos con dos operaciones principales:
+Push: agrega un elemento a la colección
+Pop remueve el elemento que se añadió más recientemente y que no ha sido removido, el orden en el que esto funciona como hemos visto en clases sigue la lógica LIFO (last in, first out) que en español sería “último o más reciente en entrar, primero en salir”
+
+A continuación te comparto las operaciones disponibles en este ADT:
+
+push() – Inserta un elemento en un extremo de la pila denominado “cima”.
+pop() – Remueve y retorna el elemento en la cima de la pila, si el stack no está vació.
+peek() – Retorna el elemento en la cima del stack sin removerlo, si el stack no está vacío.
+size() – Retorna el número de elementos en el stack.
+isEmpty() – Retorna true si el stack está vacío, si no, retorna false.
+isFull() – Retorna true si la lista está llena, si no, regresa false.
+
+**Queue ADT**
+Una cola es un ADT que sirve para almacenar datos en el orden en el que los datos van llegando, sigue una lógica del tipo FIFO o “primero en llegar, primero en salir” como es en la mayoría de supermercados.
+
+A continuación te comparto las operaciones disponibles en este ADT:
+
+enqueue() – Inserta un nuevo elemento al final de la cola.
+dequeue() – Remueve y retorna el primer elemento de la cola si la cola no está vacía.
+peek() – Retorna el primer elemento de la cola sin removerlo.
+size() – Retorna el número de elementos almacenados en la cola.
+isEmpty() – Retorna true si la cola está vacía, si no, retorna false.
+isFull() – Retorna true si la cola está vacía, si no, retorna false.
+
+## TRABAJAREMOS CON QUEUE:
+### PASOS:
+
+Crear un pointer para saber que hay en el front y rear
+Colocar estos valores en -1 al inicializar
+Incrementar en 1 el valor de rear cuando agreguemos algún elemento
+Retornar el valor de front al quitar algún elemento, y incrementar en 1 el valor de front al usar dequeue
+Ante de agregar algún elemento revisar si hay espacio (ISEMPTY()) importante, ya que si no revisamos se puede estar perdiendo información importante.
+Antes de remover algún elemento revisamos que existan elementos (ISEMPTY()) se debe revisar, ya que al no haber elementos nos dirá que removió algún elemento cuando realmente no ha hecho nada
+Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1. Importantísimo, ya que si no reseteamos cuando retomemos algún valor nos puede dar 5, el cual no existe, ya que tenemos solo 5 posiciones iniciando en cero (0,1,2,3,4).
+Este queue lo vamos a realizar con un Array, ya que sabemos el numero de elementos que se van a guardar en el Array.
+Lo mejor es inicializar en -1, ya que siempre en programación se utiliza la posición 0 (cero).

aproximacion.py

@@ -0,0 +1,12 @@
+objetivo = int(input('Escoge un numero: '))
+epsilon = 0.01 
+paso = epsilon**2
+respuesta = 0.0 
+
+while abs (respuesta**2 - objetivo) >=epsilon and respuesta <=objetivo:
+    respuesta += paso 
+
+if abs(respuesta**2-objetivo)>=epsilon: 
+    print (f'No se encontro la raiz cuadrada de {objetivo}')
+else:
+    print (f'la raiz cuadrada de {objetivo} es {respuesta}')

break_continue.py

@@ -0,0 +1,15 @@
+def run():
+
+    # for contador in range(1000):
+    #     if contador % 2 != 0:
+    #         continue
+    #     print (contador)
+    for i in range(10000):
+        print (i)
+        if i == 5678:
+            break
+
+
+
+if __name__ == "__main__":
+    run()

bucles.py

@@ -0,0 +1,14 @@
+def run():
+    LIMITE = 2000 
+
+    contador = 0
+    potencia_2 = 2**contador
+
+    while potencia_2 < LIMITE:
+        print('2 elevado a ' + str(contador)+ ' es igual a: ' + str(potencia_2))
+        contador= contador+1
+        potencia_2 = 2**contador
+
+
+if __name__ == '__main__':
+    run()

busqueda_binaria.py

@@ -0,0 +1,23 @@
+# Busqueda Binaria 
+# La busqueda binaria solo sirvve cuando nuestro conjunto de 
+# datos tienen un orden. 
+
+# def run():
+objetivo = int(input("Escoge un numero: "))
+epsilon = 0.01 
+bajo = 0.0 
+alto = max(1.0 , objetivo)
+respuesta = (alto+bajo) / 2
+
+while abs(respuesta**2-objetivo) >= epsilon:
+    if respuesta**2 < objetivo:
+        bajo = respuesta
+    else:
+        alto = respuesta
+
+    respuesta = (alto + bajo) / 2
+
+print(f'La raiz cuadrada de objetivo es {objetivo} es {respuesta}')
+
+# if __name__ == "__main__":
+#     run()

condicionales.py

@@ -0,0 +1,16 @@
+# Uso de condicionales 
+
+# edad = int(input("Escribe tu edad: "))
+# if edad>17:
+#    print("Eres mayor de edad") 
+# else: 
+#    print("Eres menor de edad")
+
+numero = int(input("Ingrese un numero: "))
+if numero>5:
+    print("Es mayot a 5")
+elif numero==5:
+    print("Es igual a 5")
+else:
+    print("Es menor a 5")
+

conversor.py

@@ -0,0 +1,34 @@
+
+def conversor(tipo_pesos,valor_dolar):
+    pesos = input("Ingrese la cantidad de pesos "+ tipo_pesos + "tienes:")
+    pesos = float(pesos)
+    dolares = pesos / valor_dolar
+    dolares = round(dolares,2)
+    dolares = str(dolares)
+    print("Tienes $" + dolares + " dolares")
+
+menu = """"
+Bienvenido al conversor de monedas $$
+1 - Pesos colombianos 
+2 - Pesos argentinos 
+3 - Pesos Colombianos 
+
+Elige una opcion:
+"""
+
+opcion=int(input(menu))
+
+if opcion ==1:
+    conversor("Colombianos ",3875)
+elif opcion ==2:
+    conversor("Argentinos ",65)
+elif opcion ==3:
+    conversor("Mexicanos ",24)
+else:
+    print("Ingrese una optcion correcta")
+
+
+
+
+
+

desafio.py

@@ -0,0 +1,22 @@
+# desafio.py
+import random
+
+
+def run():
+    contador=0
+    nombre=input('Ingresa tu nombre: ')
+    numero_aleatorio=random.randint(1,100)
+    numero_elegido=int(input('Elige un numero de 1 a 100: '))
+    while numero_elegido != numero_aleatorio:
+        if numero_elegido<numero_aleatorio:
+            print('Busca un numero mas grande')
+            contador = contador+1
+        else:
+            print('Busca un numero mas pequeño')
+            contador = contador+1
+        numero_elegido=int(input('Elige otro numero: '))
+    print(nombre+' ¡Ganaste con '+ str(contador) +' intentos!')
+
+
+if __name__ == "__main__":
+    run()    

enumeracion.py

@@ -0,0 +1,11 @@
+objetivo = int(input('Éscoge un numero entero: '))
+respuesta = 0 
+
+while respuesta**2 < objetivo:
+    print(respuesta)
+    respuesta += 1
+
+if respuesta**2 == objetivo:
+    print(f'La raiz cuadrada de {objetivo} es {respuesta}')
+else: 
+    print(f'{objetivo} no tiene raiz cuadrada exacta')

factiriales.py

@@ -0,0 +1,15 @@
+def factorial(n):
+
+#    Calcula el factorial de n. 
+#    n int > 0 
+#    return n!
+
+    print (n)   
+    if n == 1: 
+        return 1 
+    return n * factorial(n-1)
+
+n=int(input("Escribe un entero: ")) 
+
+print(factorial(n))
+

flotantes.py

@@ -0,0 +1,9 @@
+x =0.0
+for i in range (10):
+    x += 0.1
+
+if x== 1.0:
+    print(f'x={x}')
+else:
+    print(f'x!={x}')
+

for.py

@@ -0,0 +1,8 @@
+# contador =1
+# print(contador)
+# while contador < 1000: 
+#     contador +=1
+#     print(contador)
+
+for contador in range (1000):
+    print(contador)

funciones.py

@@ -0,0 +1,31 @@
+# def imprimir_mensaje():
+#     print("Mensaje Especial")
+#     print("Estoy aprendiendo a usar funciones")
+
+# imprimir_mensaje()
+# imprimir_mensaje()
+# imprimir_mensaje()
+
+# def conversacion(mensaje):
+#     print ('Hola')
+#     print ('Elegiste la opcion 1')
+#     print('mensaje')
+#     print ('adios')
+
+# opcion = int(input("Elige una opcion (1,2,3): "))
+# if opcion==1:
+#     conversacion('Elegiste la opcion 1')
+# elif opcion==2:
+#     conversacion('Elegiste la opcion 2')
+# elif opcion==3:
+#     conversacion('Elegiste la opcion 3')
+# else: 
+#     print ('elige la opcion correcta')
+
+def suma(a,b):
+    print('Se suman dos numero')
+    resultado = a+b
+    return resultado
+
+sumatoria = suma (1,4)
+print(sumatoria)