├── .gitignore ├── 30DaysOfPython └── README.md ├── README.md ├── Roadmap ├── 1-bases.md ├── 10-ml-ds.md ├── 11-otros.md ├── 2-cmd-git.md ├── 3-avanzado.md ├── 4-libs.md ├── 5-computer-science.md ├── 6-web-scrap.md ├── 7-web-dev.md ├── 8-scripting.md ├── 9-ethical-hack.md └── README.md ├── apuntes ├── Python para todos.pdf ├── README.md └── apunte PYTHON.pdf ├── docs └── pull_request_template.md ├── ejercicios ├── CodeWars │ ├── AmitSna │ │ ├── README.md │ │ ├── are_arrow_functions_odd.AmitSna.py │ │ ├── array_diff.AmitSna.py │ │ ├── basic_function_fixer.AmitSna.py │ │ ├── cascading_subsets.AmitSna.py │ │ ├── circles_in_polygons.AmitSna.py │ │ ├── convert_to_binary.AmitSna.py │ │ ├── do_you_speak_english.AmitSna.py │ │ ├── does_my_number_look_big_in_this.AmitSna.py │ │ ├── ensure_question.AmitSna.py │ │ ├── first_non_repeating_character.AmitSna.py │ │ ├── floating_point_comparison.AmitSna.py │ │ ├── generate_range_of_integers.AmitSna.py │ │ ├── give_me_a_diamond.AmitSna.py │ │ ├── math_operations.AmitSna.py │ │ ├── opposite_number.AmitSna.py │ │ ├── persistent_bugger.AmitSna.py │ │ ├── pick_first_elements.AmitSna.py │ │ ├── regex_pincode.AmitSna.py │ │ ├── reversed_strings.AmitSna.py │ │ ├── smallest_integer.AmitSna.py │ │ ├── string_repeat.AmitSna.py │ │ ├── take_a_ten_minute_walk.AmitSna.py │ │ ├── template_strings.AmitSna.py │ │ ├── uefa_euro_2016.AmitSna.py │ │ └── youre_a_square.AmitSna.py │ ├── Gabriel-Fierro │ │ ├── README.md │ │ ├── break_camelCase.py │ │ ├── credit_card_mask.py │ │ ├── mumbling.py │ │ ├── row_weights.py │ │ ├── string_repeat.py │ │ ├── two_sum.py │ │ ├── unique_in_order.py │ │ └── vowel_count.py │ ├── Gabriella-Martinez │ │ ├── README.md │ │ ├── counting_duplicates.py │ │ ├── is_narcissistic_number.py │ │ ├── powers_of_two.py │ │ ├── rectangles_in_a_grid.py │ │ ├── reversed_strings.py │ │ └── will_you_make_it.py │ ├── Javier-Rodriguez │ │ ├── README.md │ │ ├── array_diff.py │ │ ├── diamond.py │ │ ├── ensure_question.py │ │ ├── odd_arrow_functions.py │ │ ├── opposite_number.py │ │ ├── persistent_bugger.py │ │ ├── regex_pincode.py │ │ ├── smallest_integer.py │ │ ├── string_repeat.py │ │ ├── to_binary.py │ │ └── youre_square.py │ ├── Pedro-Bonafé │ │ ├── MeGusta.py │ │ ├── README.md │ │ ├── find_parity_outlier.py │ │ ├── ordenador_palabras.py │ │ └── suma_numeros_int.py │ └── README.md ├── Django │ └── introPython │ │ ├── README.md │ │ ├── ej1.py │ │ ├── ej2.py │ │ ├── ej3.py │ │ ├── ej4.py │ │ ├── modules │ │ ├── __init__.py │ │ └── calculadora.py │ │ └── the-zen-of-python.txt ├── Flask │ └── README.md ├── README.md └── ejerciciosGeneral │ ├── README.md │ ├── ej1-pruebas │ ├── amitsna.py │ ├── gabrielfierro.py │ ├── jmceche.py │ ├── joeosg.py │ ├── manuel96meg.py │ └── valen.py │ ├── ej1_palindromo.py │ ├── ej2_secuencia_gen.py │ ├── ej3-pruebas │ ├── ej3-fruno.py │ ├── ej3-p1.py │ ├── ej3-p2.py │ └── ej3-p3.py │ ├── ej3_justificador.py │ ├── ej6-pruebas │ ├── amit.py │ ├── grabriel.py │ └── keto.py │ ├── ej7-pruebas │ ├── amit.py │ └── keto.py │ └── extras │ └── palindromoPyConAr.py ├── imgs ├── channel-discord.jpg ├── codigo-genetico.jpg └── icons │ ├── github.svg │ └── linkedin.svg └── proyectos ├── README.md └── Technical_Challenge.pdf /.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__ -------------------------------------------------------------------------------- /30DaysOfPython/README.md: -------------------------------------------------------------------------------- 1 | # 📆 30 Days of Python 2 | 3 | Cada día tomaremos un nuevo reto para aprender más sobre Python. Tomaremos este [repositorio de Asabeneh](https://github.com/Asabeneh/30-Days-Of-Python) para realizar los desafíos diarios. 4 | 5 | Iremos subiendo soluciones de los desafíos en la tabla de abajo. Si hay varias versiones de un mismo problema, lo subimos también! 6 | 7 | ## ¿Cómo participo? 🤔 8 | 9 | - Simplemente, tenés que hacer los desafíos diarios. 10 | - Los tenés que subir a un repositorio nuevo (o a un fork del repositorio de Asabeneh). 11 | - Tenés que pasarnos tus soluciones al canal del grupo de estudio para darte un review! (si es necesario) 12 | 13 | ## Días 📆 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 31 | 32 | 33 | 34 | 35 | 42 | 43 | 44 | 45 | 46 | 49 | 50 | 51 | 52 | 53 | 56 | 57 | 58 | 59 | 60 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 |
DayTemaSolución
1Introduction 25 | - JaviCeRodriguez
26 | - DamianPalavecino
27 | - JorgeR3nteria
28 | - anhg02
29 | - pachecurita
30 |
2Variables, Built-in Functions 36 | - JaviCeRodriguez
37 | - DamianPalavecino
38 | - JorgeR3nteria
39 | - anhg02
40 | - pachecurita
41 |
3Operators 47 | - JaviCeRodriguez 48 |
4Strings 54 | - JaviCeRodriguez
55 |
5Lists 61 | - JaviCeRodriguez
62 |
6Tuples
7Sets
8Dictionaries
9Conditionals
10Loops
11Functions
12Modules
13List Comprehension
14Higher Order Functions
15Python Type Errors
16Python Date time
17Exception Handling
18Regular Expressions
19File Handling
20Python Package Manager
21Classes and Objects
22Web Scraping
23Virtual Environment
24Statistics
25Pandas
26Python web
27Python with MongoDB
28API
29Building API
30Conclusions
190 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Grupo de estudio con Python 🐍 2 | 3 | *Update README: 21/08/21* 4 | 5 | En este grupo de estudio con Python, vamos a realizar ejercicios de lo que sea: algoritmos, estructuras de datos, desarrollo web, apps de escritorio y mucho más. Desde lo más simple hasta lo más complejo. 6 | 7 | ## 1) ¿Qué estamos haciendo ahora en el grupo? 🤔 8 | Vamos a estar haciendo 2 actividades en paralelo: 9 | 10 | ### 1.1) #30DaysOfPython 📆 11 | Queremos progresar como desarrolladores Python, por lo que hay practicar con teoría y retos! En la carpeta [30DaysOfPython](./30DaysOfPython) vamos a colocar todos los ejercicios que vayamos a realizar junto con su contenido teórico necesario para lograr resolverlos. 12 | 13 | ### 1.2) Roadmap de Python 🚴‍♂️ 14 | Este es un proyecto colaborativo en cual todos pueden participar. Vamos a crear una Roadmap de Python para que todos puedan seguir el camino del ecosistema de Python. 15 | 16 | ### 1.3) ✨ Proyectos! ✨ 17 | Queremos poner en práctica todo lo que fuimos aprendiendo, seguir aprendiendo y/o prepararnos para entrevistas técnicas. Esto significa una sola cosa: PROYECTOS!. Vamos a estar realizando proyectos con los miembros del grupo de estudio, aplicando un stack tecnológico y mostrarlo junto a nuestro portfolio 😃. Más info, en [este enlace](./proyectos). 18 | 19 | 20 | ## 2) ¿Cómo nos organizamos? 👍 21 | La idea principal es que podamos aprender entre todos este lindo lenguaje! 22 | 23 | La **metodología** que usamos es la siguiente: 24 | - 📢 Estaremos utilizando como medio de comunicación el canal del grupo de estudio en FrontendCafé (clic a la imagen!): 25 | 26 | 27 | 28 | - 📢 De ser necesario, organizaremos una reunión en el canal de voz del grupo para poder comunicarnos, poder compartir ideas y resolver dudas. 29 | 30 | - 📢 Para colaborar, esta [publicación de la Wiki](https://github.com/frontendcafe/py-study-group/wiki/Colaborar)! 31 | 32 | 33 | 🐍 Si te gustó esto y no estás en el servidor de Discord de **FrontendCafé**, no esperemes más y [haz clic aquí](https://discord.gg/frontendcafe) para empezar a participar! 34 | 35 | 36 | ## 3) Contenido 📚 37 | - **Proyectos**: Proyectos de los integrantes del grupo de estudio. 38 | - **30DaysOfPython**: Carpeta que contendrá todos los README del con la teoría y ejercicios a realizar 39 | - **Roadmap**: Proyecto colaborativo para armar guías esenciales para aprender Python 40 | - **apuntes**: Apuntes teóricos y personales para compartir con la comunidad 41 | - **ejercicios**: Ejercicios realizados anteriormente en la comunidad 42 | 43 | --- 44 | ## Colaboradores en la organización del grupo ✒️ 45 | 46 | 47 | 48 | 51 | 54 | 57 | 60 | 61 | 62 | 65 | 68 | 71 | 74 | 75 | 76 | 84 | 87 | 92 | 97 | 98 |
49 | Javier Rodriguez 50 | 52 | Jorge Marrero 53 | 55 | Marco Richetta 56 | 58 | Gabriel La Torre 59 |
63 | 64 | 66 | 67 | 69 | 70 | 72 | 73 |
77 | 78 | 79 |   80 | 81 | 82 | 83 | 85 | 86 | 88 | 89 | 90 | 91 | 93 | 94 | 95 | 96 |
99 | -------------------------------------------------------------------------------- /Roadmap/1-bases.md: -------------------------------------------------------------------------------- 1 | << [Inicio](./README.md) / [Terminal/Command Prompt + Git/GitHub 💻](./2-cmd-git.md) >> 2 | 3 | # Bases 🐍 4 | 5 | - Python 3 vs Python 2 6 | 7 | - [Python 2 vs Python 3: What's the Difference Between Python 2.x and Python 3.x?](https://www.guru99.com/python-2-vs-python-3.html) 8 | 9 | - Editores de código 10 | - Vim 11 | - VSCode 12 | - Sublime Text 13 | - PyCharm 14 | - Atom 15 | - Juypter Notebook 16 | - Google Colab 17 | - ¿Cómo funciona Python? 18 | - Intérprete de Python 19 | - Ejecutando código Python 20 | - Tipos de datos y sus operaciones y uso 21 | - Números, Operadores, Prioridad del operador 22 | - Variables 23 | - Conversión de tipo 24 | - Indentación 25 | - Operadores Lógicos 26 | - Condicionales: If, Else, Else if, Truthy, Falsey 27 | - Loops: for, while, loop control statements (break, continue, etc) 28 | - Funciones: scope, parámetros, argumentos, return 29 | - Built-in Functions 30 | - Comentarios: single-line, multi-line, docstrings 31 | -------------------------------------------------------------------------------- /Roadmap/10-ml-ds.md: -------------------------------------------------------------------------------- 1 | << [Ethical Hacking 🤐](./9-ethical-hack.md) / [Inicio](./README.md) / [Otros recursos](./11-otros.md) >> 2 | 3 | # Machine Learning/Data Science 🤖 4 | 5 | - Tensorflow 6 | - PyTorch 7 | - Keras 8 | - Scikit-learn 9 | - Numpy 10 | - Pandas 11 | - SciPy 12 | - Matplotlib 13 | - Seaborn 14 | - Neural Networks 15 | - Machine Learning Algorithms 16 | - Data 17 | -------------------------------------------------------------------------------- /Roadmap/11-otros.md: -------------------------------------------------------------------------------- 1 | << [Machine Learning/Data Science 🤖](./10-ml-ds.md) / [Inicio](./README.md) >> 2 | 3 | # Otros recursos! 4 | -------------------------------------------------------------------------------- /Roadmap/2-cmd-git.md: -------------------------------------------------------------------------------- 1 | << [Bases 🐍](./1-bases.md) / [Inicio](./README.md) / [Python Avanzado 🐍](./3-avanzado.md) >> 2 | 3 | # Terminal/Command Prompt + Git/GitHub 💻 4 | 5 | - Basic Bash Commands 6 | - Git Basics 7 | - GitHub Basics 8 | - Source Control 9 | -------------------------------------------------------------------------------- /Roadmap/3-avanzado.md: -------------------------------------------------------------------------------- 1 | << [Terminal/Command Prompt + Git/GitHub 💻](./2-cmd-git.md) / [Inicio](./README.md) / [Librerías Populares 📙](./4-libs.md) >> 2 | 3 | # Python Avanzado 🐍 4 | 5 | - OOP 6 | - Clases 7 | - Dunder 8 | - Métodos 9 | - Herencia 10 | - Decoradores 11 | - Programación Funcional 12 | - Funciones Lambda 13 | - Map, filter, zip, reduce 14 | - Errores 15 | - Error Handling: try, except 16 | - Archivos I/O 17 | - Regex 18 | - Testing, unittest 19 | - Import 20 | - Modules 21 | - Packages 22 | - Pip 23 | - Virtual Environments 24 | - Debugging 25 | -------------------------------------------------------------------------------- /Roadmap/4-libs.md: -------------------------------------------------------------------------------- 1 | << [Python Avanzado 🐍](./3-avanzado.md) / [Inicio](./README.md) / [Computer Science 🤓](./5-computer-science.md) >> 2 | 3 | # Librerías Populares 📙 4 | 5 | - Tkinter 6 | - Requests 7 | - Pillow 8 | - PyQT 9 | - Pygame 10 | -------------------------------------------------------------------------------- /Roadmap/5-computer-science.md: -------------------------------------------------------------------------------- 1 | << [Librerías Populares 📙](./4-libs.md) / [Inicio](./README.md) / [Web Scrapping 🗄️](./6-web-scrap.md) >> 2 | 3 | # Computer Science 🤓 4 | 5 | - Time Complexity 6 | - Space Complexity 7 | - Big O Notation 8 | - Data Structures 9 | - Algorithms 10 | -------------------------------------------------------------------------------- /Roadmap/6-web-scrap.md: -------------------------------------------------------------------------------- 1 | << [Computer Science 🤓](./5-computer-science.md) / [Inicio](./README.md) / [Desarrollo Web 🌐](./7-web-dev.md) >> 2 | 3 | # Web Scrapping 🗄️ 4 | 5 | - Beautiful soup 6 | - Selenium 7 | - Scrapy 8 | 9 | ## Ideas de proyecto 🔥: 10 | 11 | - Hacker News Scraper 12 | - Dev.to Scrapper 13 | - Amazon Price Tracker 14 | - Jobs Portal Scraper 15 | - COVID-19 Web Scraper 16 | -------------------------------------------------------------------------------- /Roadmap/7-web-dev.md: -------------------------------------------------------------------------------- 1 | << [Web Scrapping 🗄️](./6-web-scrap.md) / [Inicio](./README.md) / [Scripting 📜](./8-scripting.md) >> 2 | 3 | # Desarrollo Web 🌐 4 | 5 | - Django 6 | - Flask 7 | - Zappa 8 | - Dash 9 | - FastAPI 10 | 11 | ## Ideas de proyecto 🔥 12 | 13 | - Login System 14 | - Portfolio 15 | - Blog Site 16 | - Todo App 17 | - Ecommerce website 18 | -------------------------------------------------------------------------------- /Roadmap/8-scripting.md: -------------------------------------------------------------------------------- 1 | << [Desarrollo Web 🌐](./7-web-dev.md) / [Inicio](./README.md) / [Ethical Hacking 🤐](./9-ethical-hack.md) >> 2 | 3 | # Scripting 📜 4 | 5 | - DevOps: Docker, Kubernetes, Gradle, etc 6 | - System Admin 7 | 8 | ## Project Ideas 🔥: 9 | 10 | - Automate the Boring Stuff 11 | - Create a Calculator 12 | - Contact Book 13 | - Directory Tree Generator 14 | - Expense Tracker 15 | -------------------------------------------------------------------------------- /Roadmap/9-ethical-hack.md: -------------------------------------------------------------------------------- 1 | << [Scripting 📜](./8-scripting.md) / [Inicio](./README.md) / [Machine Learning/Data Science 🤖](./10-ml-ds.md) >> 2 | 3 | # Ethical Hacking 🤐 4 | 5 | - SQL injection 6 | - Session hijacking 7 | - Man in the Middle 8 | - Networking 9 | - IP Adress 10 | - Exploitation 11 | - Social Engineering 12 | - Pen Testing 13 | - Footprinting 14 | - Firewall 15 | 16 | ## Project Ideas 🔥: 17 | 18 | - Hacking wireless networks 19 | - Create a vulnerable site and hack it 20 | - Password cracker 21 | - Web Application Pen Testing 22 | - Break A Caesar Cipher 23 | -------------------------------------------------------------------------------- /Roadmap/README.md: -------------------------------------------------------------------------------- 1 | # 🚴‍♂️ Roadmap de Python 🐍 2 | 3 | En este README dejaremos todos los recursos que veamos que pueda servir y aportar al conocimiento. La idea principal es que entre toda la comunidad podamos conseguir toda la información necesaria par aspirar a cualquier área con Python. 4 | 5 | Para colaborar, lee la [Wiki](https://github.com/frontendcafe/py-study-group/wiki/Colaborar)! 6 | 7 | Se pueden agregar aportes de dos formas: 8 | 9 | - Si son publicaciones externas al grupo, agregar un enlace ( `[Enlace](https://www.example.com/`) ). 10 | - Si son apuntes en formato Markdown, podés agregar archivos MD en esta carpeta (preferiblemente, que sea en `Roadmap/recursos/TEMA`). 11 | 12 | # Tabla de Contenidos 13 | 14 | Los siguientes temas están basados en el [artículo en DEV.to de Henry Boisdequin](https://dev.to/hb/python-developer-roadmap-in-2021-2bmo). 15 | 16 | 1. [Bases 🐍](./1-bases.md) 17 | 2. [Terminal/Command Prompt + Git/GitHub 💻](./2-cmd-git.md) 18 | 3. [Python Avanzado 🐍](./3-avanzado.md) 19 | 4. [Librerías Populares 📙](./4-libs.md) 20 | 5. [Computer Science 🤓](./5-computer-science.md) 21 | 6. [Web Scrapping 🗄️](./6-web-scrap.md) 22 | 7. [Desarrollo Web 🌐](./7-web-dev.md) 23 | 8. [Scripting 📜](./8-scripting.md) 24 | 9. [Ethical Hacking 🤐](./9-ethical-hack.md) 25 | 10. [Machine Learning/Data Science 🤖](./10-ml-ds.md) 26 | 11. [Otros recursos](./11-otros.md) 27 | -------------------------------------------------------------------------------- /apuntes/Python para todos.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/frontendcafe/py-study-group/5c863f47f703a5d120b1824e75ca5dc93b5b7418/apuntes/Python para todos.pdf -------------------------------------------------------------------------------- /apuntes/README.md: -------------------------------------------------------------------------------- 1 | # Resumen 📝 2 | Acá podrás encontrar material de estudio de todos los temas que te interesen. En la lista de abajo, veras el título del archivo (Markdown, PDF, Word) con una breve descripción de los temas abarcados. En el caso de ser un enlace, solo aparecerá en el listado. 3 | 4 | 📌 Si deseas agregar contenido, realizá un pull request y luego uno de los colaboradores podrá revisarlo y aceptarlo. 5 | 6 | ## Fuentes recomendadas para empezar de 0 🐍 7 | Para este grupo de estudio, usaremos como referencia las siguientes fuentes: 8 | - [Programación en Python - UNSAM 2° Cuatrimestre 2020](https://github.com/python-unsam/UNSAM_2020c2_Python/tree/master/Notas) 9 | - [Algoritmos y Programación I. Aprendiendo a programar usando Python como herramienta](https://github.com/JaviCeRodriguez/py-study-group/blob/main/apuntes/apunte%20PYTHON.pdf) ([O desde el enlace original](http://materias.fi.uba.ar/7501/apunte%20PYTHON.pdf)) 10 | 11 | En ambos pueden utilizar el buscador para encontrar temas específicos o pueden utilizar otras fuentes. Los que están en el listado son los recomendados, pero no obligatorios. 12 | 13 | 14 | ## Material recomendado 📚 15 | - [Curso gratuito de Flask - Código Facilito](https://codigofacilito.com/cursos/flask): Curso introductorio de Flask. Fácil de entender, con videos cortos pero muy bien explicado cada tema. Es perfecto para las personas que estén iniciándose en Python y desarrollo web. 16 | - ... -------------------------------------------------------------------------------- /apuntes/apunte PYTHON.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/frontendcafe/py-study-group/5c863f47f703a5d120b1824e75ca5dc93b5b7418/apuntes/apunte PYTHON.pdf -------------------------------------------------------------------------------- /docs/pull_request_template.md: -------------------------------------------------------------------------------- 1 | # Título 2 | Un título corto y descriptivo. 3 | 4 | 5 | ## Descripción 6 | Una descripción en donde podés explayarte en detalle todo lo que quieras. 7 | 8 | 9 | ## Comentarios 10 | Algún comentario que necesites realizarnos para tener en cuenta. -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/README.md: -------------------------------------------------------------------------------- 1 | # CodeWars Katas - AmitSna 2 | 3 | ## Done 4 | - [persistent_bugger.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/persistent_bugger.AmitSna.py) / [Persistent Bugger.](https://www.codewars.com/kata/55bf01e5a717a0d57e0000ec) 5 | - [smallest_integer.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/smallest_integer.AmitSna.py) / [Find the smallest integer in the array](https://www.codewars.com/kata/55a2d7ebe362935a210000b2) 6 | - [string_repeat.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/string_repeat.AmitSna.py) / [String repeat](https://www.codewars.com/kata/57a0e5c372292dd76d000d7e) 7 | - [array_diff.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/array_diff.AmitSna.py) / [Array.diff](https://www.codewars.com/kata/523f5d21c841566fde000009) 8 | - [opposite_number.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/opposite_number.AmitSna.py) / [Opposite number](https://www.codewars.com/kata/56dec885c54a926dcd001095) 9 | - [regex_pincode.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/regex_pincode.AmitSna.py) / [Regex validate PIN code](https://www.codewars.com/kata/55f8a9c06c018a0d6e000132) 10 | - [youre_a_square.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/youre_a_square.AmitSna.py) / [You're a square!](https://www.codewars.com/kata/54c27a33fb7da0db0100040e) 11 | - [are_arrow_functions_odd.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/are_arrow_functions_odd.AmitSna.py) / [Are arrow functions odd?](https://www.codewars.com/kata/559f80b87fa8512e3e0000f5) 12 | - [ensure_question.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/ensure_question.AmitSna.py) / [Ensure question](https://www.codewars.com/kata/5866fc43395d9138a7000006) 13 | - [basic_function_fixer.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/basic_function_fixer.AmitSna.py) / [Grasshopper - Basic Function Fixer](https://www.codewars.com/kata/56200d610758762fb0000002) 14 | - [math_operations.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/math_operations.AmitSna.py) / [For Twins: 2. Math operations](https://www.codewars.com/kata/59c287b16bddd291c700009a) 15 | - [convert_to_binary.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/convert_to_binary.AmitSna.py) / [Convert to Binary](https://www.codewars.com/kata/59fca81a5712f9fa4700159a) 16 | - [floating_point_comparison.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/floating_point_comparison.AmitSna.py) / [Floating point comparison](https://www.codewars.com/kata/5f9f43328a6bff002fa29eb8) 17 | - [uefa_euro_2016.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/uefa_euro_2016.AmitSna.py) / [UEFA EURO 2016](https://www.codewars.com/kata/57613fb1033d766171000d60) 18 | - [take_a_ten_minute_walk.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/take_a_ten_minute_walk.AmitSna.py) / [Take a Ten Minute Walk](https://www.codewars.com/kata/54da539698b8a2ad76000228) 19 | - [first_non_repeating_character.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/first_non_repeating_character.AmitSna.py) / [First non-repeating character](https://www.codewars.com/kata/52bc74d4ac05d0945d00054e) 20 | - [generate_range_of_integers.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/generate_range_of_integers.AmitSna.py) / [Generate range of integers](https://www.codewars.com/kata/55eca815d0d20962e1000106) 21 | - [template_strings.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/template_strings.AmitSna.py) / [Template Strings](https://www.codewars.com/kata/55a14f75ceda999ced000048) 22 | - [reversed_strings.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/reversed_strings.AmitSna.py) / [Reversed Strings](https://www.codewars.com/kata/5168bb5dfe9a00b126000018) 23 | - [give_me_a_diamond.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/give_me_a_diamond.AmitSna.py) / [Give me a Diamond](https://www.codewars.com/kata/5503013e34137eeeaa001648) 24 | - [cascading_subsets.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/cascading_subsets.AmitSna.py) / [Enumerable Magic #20 - Cascading Subsets](https://www.codewars.com/kata/545af3d185166a3dec001190) 25 | - [does_my_number_look_big_in_this.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/does_my_number_look_big_in_this.AmitSna.py) / [Does my number look big in this?](https://www.codewars.com/kata/5287e858c6b5a9678200083c) 26 | - [do_you_speak_english.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/do_you_speak_english.AmitSna.py) / [Do you speak "English"?](https://www.codewars.com/kata/58dbdccee5ee8fa2f9000058) 27 | - [pick_first_elements.AmitSna.py](https://github.com/JaviCeRodriguez/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/pick_first_elements.AmitSna.py) / [pick a set of first elements](https://www.codewars.com/kata/572b77262bedd351e9000076) 28 | - [circles_in_polygons.AmitSna.py](https://github.com/hifrontendcafe/py-study-group/blob/main/ejercicios/CodeWars/AmitSna/circles_in_polygons.AmitSna.py) / [Circles in Polygons](https://www.codewars.com/kata/5a026a9cffe75fbace00007f) 29 | 30 | ## WIP 31 | - / [Pole Vault Starting Marks](https://www.codewars.com/kata/5786f8404c4709148f0006bf) 32 | - / [Simple Encryption #1 - Alternating Split](https://www.codewars.com/kata/57814d79a56c88e3e0000786) 33 | - / [Number of trailing zeros of N!](https://www.codewars.com/kata/52f787eb172a8b4ae1000a34) 34 | - / [FizzBuzz Backwards](https://www.codewars.com/kata/59ad13d5589d2a1d84000020) 35 | - / [Tic-Tac-Toe Checker](https://www.codewars.com/kata/525caa5c1bf619d28c000335) 36 | - / [String incrementer](https://www.codewars.com/kata/54a91a4883a7de5d7800009c) 37 | - / [Snail](https://www.codewars.com/kata/521c2db8ddc89b9b7a0000c1) 38 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/are_arrow_functions_odd.AmitSna.py: -------------------------------------------------------------------------------- 1 | odds = lambda nums: [num for num in nums if num%2==1] 2 | 3 | def odds(nums): 4 | return [num for num in nums if num%2==1] 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/array_diff.AmitSna.py: -------------------------------------------------------------------------------- 1 | array_diff = lambda a, b: [num for num in a if num not in set(b)] 2 | 3 | def array_diff(a, b): 4 | return [num for num in a if num not in set(b)] 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/basic_function_fixer.AmitSna.py: -------------------------------------------------------------------------------- 1 | add_five = lambda num: num + 5 2 | 3 | def add_five(num): 4 | return num + 5 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/cascading_subsets.AmitSna.py: -------------------------------------------------------------------------------- 1 | each_cons = lambda lst, n: [lst[section: section + n] for section in range(0, len(lst) - n + 1)] 2 | 3 | def each_cons(lst, n): 4 | cascaded = [] 5 | for section in range(0, len(lst) - n + 1): 6 | cascaded.append(lst[section:section + n]) 7 | return cascaded 8 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/circles_in_polygons.AmitSna.py: -------------------------------------------------------------------------------- 1 | from math import tan, pi 2 | circle_diameter = lambda sides, side_length: side_length / tan(pi / sides) 3 | 4 | from math import tan, pi 5 | def circle_diameter(sides, side_length): 6 | return side_length / tan(pi / sides) 7 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/convert_to_binary.AmitSna.py: -------------------------------------------------------------------------------- 1 | to_binary = lambda n: int(bin(n)[2:]) 2 | 3 | def to_binary(n): 4 | return int(bin(n)[2:]) 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/do_you_speak_english.AmitSna.py: -------------------------------------------------------------------------------- 1 | sp_eng = lambda sentence: "english" in sentence.lower() 2 | 3 | def sp_eng(sentence): 4 | return "english" in sentence.lower() 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/does_my_number_look_big_in_this.AmitSna.py: -------------------------------------------------------------------------------- 1 | narcissistic = lambda value: sum([num**len(str(value)) for num in [int(digit) for digit in str(value)]]) == value 2 | 3 | def narcissistic(value): 4 | return sum([num**len(str(value)) for num in [int(digit) for digit in str(value)]]) == value 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/ensure_question.AmitSna.py: -------------------------------------------------------------------------------- 1 | ensure_question = lambda word: [f"{word}?", word][len(word) >= 1 and word[-1] == "?"] 2 | 3 | def ensure_question(word): 4 | if len(word) >= 1 and word[-1] == "?": 5 | return word 6 | else: 7 | return f"{word}?" 8 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/first_non_repeating_character.AmitSna.py: -------------------------------------------------------------------------------- 1 | def first_non_repeating_letter(string): 2 | for char in string: 3 | if string.lower().count(char.lower()) == 1: 4 | return char 5 | return "" 6 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/floating_point_comparison.AmitSna.py: -------------------------------------------------------------------------------- 1 | approx_equals = lambda a, b: abs(a - b) <= 0.001 2 | 3 | def approx_equals(a, b): 4 | return abs(a - b) <= 0.001 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/generate_range_of_integers.AmitSna.py: -------------------------------------------------------------------------------- 1 | generate_range = lambda min, max, step: [num for num in range(min, max, step)] 2 | 3 | generate_range = lambda min, max, step: list(range(min, max, step)) 4 | 5 | def generate_range(min, max, step): 6 | result_list = [] 7 | while min < max: 8 | result_list.append(min) 9 | min += step 10 | return result_list 11 | 12 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/give_me_a_diamond.AmitSna.py: -------------------------------------------------------------------------------- 1 | def diamond(n): 2 | if n < 1 or n%2==0: 3 | return None 4 | diamond = "" 5 | for amount in range(1, n + 1, 2): 6 | diamond += " " * ((n - amount) // 2) + "*" * amount + "\n" 7 | for amount in range(n - 2, 0, -2): 8 | diamond += " " * ((n - amount) // 2) + "*" * amount + "\n" 9 | return diamond 10 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/math_operations.AmitSna.py: -------------------------------------------------------------------------------- 1 | ice_brick_volume = lambda radius, bottle_length, rim_length: ((radius * 2) ** 2 / 2) * (bottle_length - rim_length) 2 | 3 | def ice_brick_volume(radius, bottle_length, rim_length): 4 | return ((radius * 2) ** 2 / 2) * (bottle_length - rim_length) 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/opposite_number.AmitSna.py: -------------------------------------------------------------------------------- 1 | opposite = lambda number: -number 2 | 3 | def opposite(number): 4 | return -number 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/persistent_bugger.AmitSna.py: -------------------------------------------------------------------------------- 1 | def persistence(n): 2 | counter = 0 3 | while n > 9: 4 | accumulator = 1 5 | for digit in [int(digit) for digit in str(n)]: 6 | accumulator *= digit 7 | counter += 1 8 | n = accumulator 9 | return counter 10 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/pick_first_elements.AmitSna.py: -------------------------------------------------------------------------------- 1 | first = lambda seq n=1: seq[0:n] 2 | 3 | def first(seq, n=1): 4 | return seq[0:n] 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/regex_pincode.AmitSna.py: -------------------------------------------------------------------------------- 1 | validate_pin = lambda pin: pin.isnumeric() and len(pin) in (4, 6) 2 | 3 | def validate_pin(pin): 4 | return pin.isnumeric() and len(pin) in (4, 6) 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/reversed_strings.AmitSna.py: -------------------------------------------------------------------------------- 1 | solution = lambda str: str[::-1] 2 | 3 | def solution(str): 4 | return str[::-1] 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/smallest_integer.AmitSna.py: -------------------------------------------------------------------------------- 1 | find_smallest_int = lambda arr: min(arr) 2 | 3 | def find_smallest_int(arr): 4 | return min(arr) 5 | 6 | def find_smallest_int(arr): 7 | min = arr[0] 8 | for num in arr: 9 | if num < min: 10 | min = num 11 | return min 12 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/string_repeat.AmitSna.py: -------------------------------------------------------------------------------- 1 | repeat_str = lambda repeat, string: repeat * string 2 | 3 | def repeat_str(repeat, string): 4 | return repeat * string 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/take_a_ten_minute_walk.AmitSna.py: -------------------------------------------------------------------------------- 1 | is_valid_walk = lambda walk: len(walk) == 10 and walk.count("n") == walk.count("s") and walk.count("e") == walk.count("w") 2 | 3 | def is_valid_walk(walk): 4 | return len(walk) == 10 and walk.count("n") == walk.count("s") and walk.count("e") == walk.count("w") 5 | 6 | def is_valid_walk(walk): 7 | if len(walk) != 10: 8 | return false 9 | coordinates = [0, 0] 10 | for step in walk: 11 | if step == "n": 12 | coordinates[1] += 1 13 | elif step == "s": 14 | coordinates[1] -= 1 15 | elif step == "e": 16 | coordinates[0] += 1 17 | elif step == "w": 18 | coordinates[0] -= 1 19 | return coordinates[0] == coordinates[1] 20 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/template_strings.AmitSna.py: -------------------------------------------------------------------------------- 1 | temple_strings = lambda obj, feature: " are ".join([obj, feature]) 2 | 3 | def temple_strings(obj, feature): 4 | return f"{obj} are {feature}" 5 | 6 | def temple_strings(obj, feature): 7 | return obj + " are " + feature 8 | 9 | def temple_strings(obj, feature): 10 | return "{0} are {1}".format(obj, feature) 11 | 12 | def temple_strings(obj, feature): 13 | return " are ".join([obj, feature]) 14 | 15 | def temple_strings(obj, feature): 16 | return "%s are %s" % (obj, feature) 17 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/uefa_euro_2016.AmitSna.py: -------------------------------------------------------------------------------- 1 | uefa_euro_2016 = lambda teams, scores: f"At match {teams[0]} - {teams[1]}, {'teams played draw.' if scores[0] == scores[1] else teams[scores.index(max(scores))] + ' won!'}" 2 | 3 | def uefa_euro_2016(teams, scores): 4 | if scores[0] == scores[1]: 5 | return f"At match {teams[0]} - {teams[1]}, teams played draw." 6 | else: 7 | highest_score = max(scores) 8 | winner_index = scores.index(highest_score) 9 | winner_team = teams[winner_index] 10 | return f"At match {teams[0]} - {teams[1]}, {winner_team} won!" 11 | 12 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/AmitSna/youre_a_square.AmitSna.py: -------------------------------------------------------------------------------- 1 | is_square = lambda n: n >= 0 and int(n**0.5)**2 == n 2 | 3 | def is_square(n): 4 | return n >= 0 and int(n**0.5)**2 == n 5 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/README.md: -------------------------------------------------------------------------------- 1 | # Katas de CodeWars - Gabriel Fierro 2 | 3 | Éstas son las katas que resolví y que voy a ir resolviendo desde la página de CodeWars. 4 | 5 | ## Ejercicios finalizados 6 | 7 | - string_repeat.py / [String Repeat](https://www.codewars.com/kata/57a0e5c372292dd76d000d7e) 8 | - vowel_count.py / [Vowel Count](https://www.codewars.com/kata/54ff3102c1bad923760001f3/) 9 | - mumbling.py / [Mumbling](https://www.codewars.com/kata/5667e8f4e3f572a8f2000039) 10 | - row_weights.py / [Row Weights](https://www.codewars.com/kata/5abd66a5ccfd1130b30000a9) 11 | - break_camelCase.py / [Break CamelCase](https://www.codewars.com/kata/5208f99aee097e6552000148) 12 | - unique_in_order.py / [Unique In Order](https://www.codewars.com/kata/54e6533c92449cc251001667) 13 | - take_sum.py / [Take sum](https://www.codewars.com/kata/52c31f8e6605bcc646000082) 14 | - credit_card_mask.py / [Credit card mask](https://www.codewars.com/kata/5412509bd436bd33920011bc) 15 | 16 | ## Ejercicios en desarrollo 17 | 18 | - [Take a ten minute walk](https://www.codewars.com/kata/54da539698b8a2ad76000228) 19 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/break_camelCase.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Complete the solution so that the function will break up camel casing, using a space between words. 3 | 4 | Example: solution("camelCasing") ==> "camel Casing" 5 | 6 | https://www.codewars.com/kata/5208f99aee097e6552000148/train/python 7 | ''' 8 | 9 | 10 | def solution(s): 11 | string = "" 12 | 13 | for x in s: 14 | if x == x.upper(): 15 | string = string + " " 16 | string = string + x 17 | 18 | return string 19 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/credit_card_mask.py: -------------------------------------------------------------------------------- 1 | # return masked string 2 | def maskify(cc): 3 | cadena = list(cc) 4 | longitud = len(cc)-4 5 | 6 | for x in range(0, longitud): 7 | cadena[x] = "#" 8 | cadena = ''.join(cadena) 9 | return cadena -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/mumbling.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Mumbling 3 | 4 | Examples: 5 | 6 | accum("abcd") -> "A-Bb-Ccc-Dddd" 7 | accum("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy" 8 | accum("cwAt") -> "C-Ww-Aaa-Tttt" 9 | 10 | https://www.codewars.com/kata/5667e8f4e3f572a8f2000039 11 | ''' 12 | 13 | def accum(s): 14 | # Defino variables con valores iniciales 15 | position = 0 16 | longitud = 0 17 | longitud = len(s) 18 | i = 0 19 | string = "" 20 | 21 | while(i < longitud): 22 | # El primer character está capitalizado 23 | if(i == 0): 24 | string = string + s[i] + "-" 25 | else: 26 | string += s[i].capitalize() + (s[i] * position).lower() + "-" 27 | i += 1 28 | position += 1 29 | 30 | return string[:-1] 31 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/row_weights.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Task: Given an array of positive integers (the weights of the people), return a new array/tuple 3 | of two integers, where the first one is the total weight of team 1, and the second one is the 4 | total weight of team 2. 5 | 6 | https://www.codewars.com/kata/5abd66a5ccfd1130b30000a9 7 | ''' 8 | 9 | def row_weights(array): 10 | i = 0 11 | longitud = 0 12 | longitud = len(array) 13 | even = 0 14 | odd = 0 15 | 16 | while(i < longitud): 17 | if(i % 2 == 0): 18 | even += array[i] 19 | else: 20 | odd += array[i] 21 | i += 1 22 | 23 | return (even, odd) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/string_repeat.py: -------------------------------------------------------------------------------- 1 | ''' 2 | String repeat 3 | https://www.codewars.com/kata/57a0e5c372292dd76d000d7e/train/python 4 | ''' 5 | def repeat_str(repeat, string): 6 | str = "" 7 | for x in range(0, repeat): 8 | str = str + string 9 | 10 | return str -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/two_sum.py: -------------------------------------------------------------------------------- 1 | def two_sum(numbers, target): 2 | # start coding! 3 | encontrado = False 4 | i = 0 5 | j = 1 6 | longitud = len(numbers) 7 | tuple = [-1, -1] 8 | 9 | while(not encontrado and i < longitud): 10 | while(not encontrado and j < longitud): 11 | acum = numbers[i] + numbers[j] 12 | if(acum == target): 13 | encontrado = True 14 | tuple = [i, j] 15 | j = j + 1 16 | i = i + 1 17 | j = 0 18 | return tuple 19 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/unique_in_order.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Implement the function unique_in_order which takes as argument a sequence and returns a list of items without any elements with the same value next to each other and preserving the original order of elements. 3 | 4 | Examples: 5 | 6 | unique_in_order('AAAABBBCCDAABBB') ==> ['A', 'B', 'C', 'D', 'A', 'B'] 7 | unique_in_order('ABBCcAD') ==> ['A', 'B', 'C', 'c', 'A', 'D'] 8 | unique_in_order([1,2,2,3,3]) ==> [1,2,3] 9 | 10 | https://www.codewars.com/kata/54e6533c92449cc251001667/train/python 11 | ''' 12 | 13 | 14 | def unique_in_order(iterable): 15 | list = [] 16 | acum = "" 17 | for x in iterable: 18 | if(x != acum): 19 | acum = x 20 | list.append(acum) 21 | 22 | return list 23 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriel-Fierro/vowel_count.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Vowel count 3 | Return the number (count) of vowels in the given string. 4 | 5 | We will consider a, e, i, o, u as vowels for this Kata (but not y). 6 | 7 | The input string will only consist of lower case letters and/or spaces. 8 | 9 | https://www.codewars.com/kata/54ff3102c1bad923760001f3 10 | ''' 11 | def get_count(input_str): 12 | num_vowels = 0 13 | # your code here 14 | for x in input_str: 15 | result = isAVowel(x) 16 | if(result): 17 | num_vowels += 1 18 | return num_vowels 19 | 20 | def isAVowel(character): 21 | 22 | if character == 'a': 23 | return True 24 | if character == 'e': 25 | return True 26 | if character == 'i': 27 | return True 28 | if character == 'o': 29 | return True 30 | if character == 'u': 31 | return True -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/README.md: -------------------------------------------------------------------------------- 1 | # ¡¡¡Katas de codewars!!! 🐱‍👤 2 | 3 | ## *--- 🏹 Llegó la hora de resolver Katas! ---* 4 | 5 | Me uno a esta iniciativa que surje del grupo de estudio de Python de la comunidad [FrontendCafé](https://twitter.com/frontendcafe). 6 | 7 | Pero ya va, ¿Qué es un Kata? Es un ejercicio dirigido a que los programadores desarrollen sus habilidades a base de práctica y repetición (cual ninja) con diferentes niveles de dificultad compartidos por la web [codewars](https://www.codewars.com/). 8 | 9 | ![Codewarrior Profile Badge](https://www.codewars.com/users/martinezga/badges/small) 10 | 11 | A continuación comparto los scripts de los que he resuelto, los que estoy resolviendo y los que pienso pueden refactorizarse. 12 | 13 | ## 🏆 Resueltos 14 | 15 | - [Count the number of Duplicates](https://www.codewars.com/kata/54bf1c2cd5b56cc47f0007a1) ---> counting_duplicates.py 16 | 17 | - [Will you make it?](https://www.codewars.com/kata/5861d28f124b35723e00005e) ---> will_you_make_it.py 18 | 19 | - [Does my number look big in this?](https://www.codewars.com/kata/5287e858c6b5a9678200083c) ---> is_narcissistic_number.py 20 | 21 | - [Powers of 2](https://www.codewars.com/kata/57a083a57cb1f31db7000028) ---> powers_of_two.py 22 | 23 | - [Reversed Strings](https://www.codewars.com/kata/5168bb5dfe9a00b126000018) ---> reversed_strings.py 24 | 25 | - [Number of Rectangles in a Grid](https://www.codewars.com/kata/556cebcf7c58da564a000045) ---> rectangles_in_a_grid.py 26 | 27 | ## ⏳ En progreso 28 | 29 | - [FizzBuzz Backwards](https://www.codewars.com/kata/59ad13d5589d2a1d84000020) ---> fizzBuzz_backwards.py 30 | 31 | - [Simple Encryption #1 - Alternating Split](https://www.codewars.com/kata/57814d79a56c88e3e0000786) ---> simple_encryption_1.py 32 | 33 | ## 🔎 Resueltos para refactorizar 34 | 35 | - 36 | 37 | Si quieres pertenecer a este grupo de estudio únete al canal de [Discord](https://discord.gg/frontendcafe) y si quieres ver el repositorio completo del grupo visita este [enlace](https://github.com/JaviCeRodriguez/py-study-group). 38 | 39 | --- 40 | 41 | ⌨️ con ❤️ por [Gabriella Martínez](https://github.com/martinezga) 😊 -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/counting_duplicates.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Count the number of Duplicates 3 | https://www.codewars.com/kata/54bf1c2cd5b56cc47f0007a1 4 | ''' 5 | 6 | 7 | def duplicate_count(text): 8 | ''' 9 | input: text (required) - Alphabetic characters and numeric digits 10 | output: char_duplicate_num - Number of times a digit occurs more than once 11 | ''' 12 | letters_count = {} 13 | char_duplicate_num = 0 14 | text = text.lower() 15 | 16 | for letter in text: 17 | letters_count.setdefault(letter, text.count(letter)) 18 | for value in letters_count.values(): 19 | if value >= 2: 20 | char_duplicate_num += 1 21 | 22 | return char_duplicate_num 23 | 24 | 25 | # Solved by Gabriella Martínez. https://github.com/martinezga -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/is_narcissistic_number.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Does my number look big in this? 3 | https://www.codewars.com/kata/5287e858c6b5a9678200083c 4 | 5 | A Narcissistic Number is a positive number which is the sum of its own digits, 6 | each raised to the power of the number of digits in a given base. In this Kata, 7 | we will restrict ourselves to decimal (base 10). 8 | 9 | For example, take 153 (3 digits), which is narcisstic: 10 | 11 | 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153 12 | 13 | Your code must return true or false depending upon whether the given number is a 14 | Narcissistic number in base 10. 15 | ''' 16 | 17 | 18 | def narcissistic( value ): 19 | ''' 20 | input: value (required) - Positive number 21 | output: True - If the given number is a Narcissistic number 22 | False - If the given number is NOT a Narcissistic number 23 | ''' 24 | sum_of_digits = 0 25 | value_list = list(str(value)) 26 | number_of_digits = len(value_list) 27 | 28 | for i in range(number_of_digits): 29 | number_str = value_list[i] 30 | sum_of_digits += int(number_str) ** number_of_digits 31 | 32 | return True if value == sum_of_digits else False 33 | 34 | 35 | # Solved by Gabriella Martínez. https://github.com/martinezga 36 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/powers_of_two.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Powers of 2 3 | https://www.codewars.com/kata/57a083a57cb1f31db7000028 4 | 5 | Complete the function that takes a non-negative integer n as input, and 6 | returns a list of all the powers of 2 with the exponent ranging from 0 to n (inclusive). 7 | ''' 8 | 9 | 10 | def powers_of_two(n): 11 | ''' 12 | input: n (required) - Non-negative integer 13 | output: powers_of_two - List of all the powers of 2 with the exponent ranging from 0 to n (inclusive) 14 | ''' 15 | powers_of_two = [] 16 | 17 | if n < 0: 18 | return 'Error. "n" must be a positive number' 19 | else: 20 | for i in range(int(n) + 1): 21 | powers_of_two.append(2 ** i) 22 | return powers_of_two 23 | 24 | 25 | # Solved by Gabriella Martínez. https://github.com/martinezga 26 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/rectangles_in_a_grid.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Number of Rectangles in a Grid 3 | https://www.codewars.com/kata/556cebcf7c58da564a000045 4 | 5 | Given a grid of size m x n, calculate the total number of rectangles 6 | contained in this rectangle. All integer sizes and positions are counted. 7 | ''' 8 | 9 | def number_of_rectangles(m, n): 10 | amount = m * n * (m + 1) * (n + 1) // 4 11 | 12 | return amount 13 | 14 | 15 | # Clue to solve it: it is a mathematical formula 16 | # Solved by Gabriella Martínez. https://github.com/martinezga 17 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/reversed_strings.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Reversed Strings 3 | https://www.codewars.com/kata/5168bb5dfe9a00b126000018 4 | 5 | Complete the solution so that it reverses the string passed into it 6 | ''' 7 | 8 | def solution(string): 9 | reversed_string = '' 10 | 11 | for i in range(len(string) - 1, -1, -1): 12 | reversed_string += string[i] 13 | 14 | return reversed_string 15 | 16 | # Other solution: 17 | # def solution(string): 18 | # reversed_string = '' 19 | # reversed_iterator = reversed(string) 20 | 21 | # for letter in reversed_iterator: 22 | # reversed_string += letter 23 | 24 | # return reversed_string 25 | 26 | 27 | # Solved by Gabriella Martínez. https://github.com/martinezga 28 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Gabriella-Martinez/will_you_make_it.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Will you make it? 3 | https://www.codewars.com/kata/5861d28f124b35723e00005e 4 | ''' 5 | 6 | 7 | def zero_fuel(distance_to_pump, mpg, fuel_left): 8 | ''' 9 | input: distance_to_pump (required) - Nearest distance to pump in miles 10 | mpg (required) - Miles per gallon 11 | fuel_left (required) - Gallons left 12 | output: True - It is possible to get to the pump 13 | False - It is NOT possible to get to the pump 14 | ''' 15 | gallons_needed = distance_to_pump / mpg 16 | return True if gallons_needed <= fuel_left else False 17 | 18 | 19 | # Solved by Gabriella Martínez. https://github.com/martinezga -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/README.md: -------------------------------------------------------------------------------- 1 | # Katas de CodeWars - Javier Rodriguez 2 | A continuación, dejo mis scripts Python de las katas finalizadas, que debo refactorizar y aun está en desarrollo. 3 | 4 | ## Finalizados 5 | - persistent_bugger.py / [Persistent Bugger](https://www.codewars.com/kata/55bf01e5a717a0d57e0000ec) 6 | - smallest_integer.py / [Find the smallest integer in the array](https://www.codewars.com/kata/55a2d7ebe362935a210000b2) 7 | - string_repeat.py / [String Repeat](https://www.codewars.com/kata/57a0e5c372292dd76d000d7e) 8 | - array_diff.py / [Array.diff](https://www.codewars.com/kata/523f5d21c841566fde000009) 9 | - opposite_number.py / [Opposite number](https://www.codewars.com/kata/56dec885c54a926dcd001095) 10 | - regex_pincode.py / [Regex validate PIN code](https://www.codewars.com/kata/55f8a9c06c018a0d6e000132) 11 | - youre_square.py / [You're a square!](https://www.codewars.com/kata/54c27a33fb7da0db0100040e) 12 | - diamond.py / [Give me a Diamond!](https://www.codewars.com/kata/5503013e34137eeeaa001648/train/python) 13 | - odd_arrow_functions.py / [Are arrow functions odd?](https://www.codewars.com/kata/559f80b87fa8512e3e0000f5) 14 | - ensure_question.py / [Ensure question](https://www.codewars.com/kata/5866fc43395d9138a7000006) 15 | - to_binary.py / [Convert to Binary](https://www.codewars.com/kata/59fca81a5712f9fa4700159a) 16 | 17 | ## En desarrollo 18 | - [Grasshopper - Basic Function Fixer](https://www.codewars.com/kata/56200d610758762fb0000002) 19 | - [For Twins: 2. Math operations](https://www.codewars.com/kata/59c287b16bddd291c700009a) 20 | - [Floating point comparison](https://www.codewars.com/kata/5f9f43328a6bff002fa29eb8) 21 | - [Pole Vault Starting Marks](https://www.codewars.com/kata/5786f8404c4709148f0006bf) 22 | - [UEFA EURO 2016](https://www.codewars.com/kata/57613fb1033d766171000d60) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/array_diff.py: -------------------------------------------------------------------------------- 1 | # Array.diff 2 | # https://www.codewars.com/kata/523f5d21c841566fde000009 3 | # Javier Rodriguez 4 | 5 | # Version 1 6 | def array_diff(a, b): 7 | diff = [] 8 | if (len(a) == 0): 9 | return diff 10 | if (len(b) == 0): 11 | return a 12 | for e in a: 13 | if not (e in b): 14 | diff.append(e) 15 | return diff -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/diamond.py: -------------------------------------------------------------------------------- 1 | def diamond(n): 2 | if (n % 2 == 0 or n < 1): 3 | return None 4 | 5 | if (n == 1): 6 | return "*\n" 7 | 8 | dArr = [' ' * ((n - i) // 2) + ('*' * i) + '\n' for i in range(n+1) if (i % 2 != 0)] 9 | salida = '' 10 | 11 | for d in (dArr + dArr[-2::-1]): 12 | salida += d 13 | 14 | return salida 15 | 16 | print (diamond(5)) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/ensure_question.py: -------------------------------------------------------------------------------- 1 | def ensure_question(s): 2 | if s == '' or s[-1] is not '?': 3 | return s + '?' 4 | else: 5 | return s 6 | 7 | print(ensure_question('')) 8 | print(ensure_question('asd')) 9 | print(ensure_question('dsa?')) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/odd_arrow_functions.py: -------------------------------------------------------------------------------- 1 | # Version 2 2 | odds = lambda lista : [n for n in lista if n % 2 != 0] 3 | 4 | # Version 1 5 | # def odds(lista:list): 6 | # return [n for n in lista if n % 2 != 0] 7 | 8 | print(odds([56, 74, 32, 83, 22, 70, 54, 99, 43, 56, 56, 8, 77, 12, 79, 14, 96, 48, 36, 58, 74, 85, 82, 34, 54, 69, 93, 57, 75, 89, 43, 1, 57, 99, 75, 35, 22, 67, 23, 95, 95, 60, 35, 88, 29, 35, 16, 29, 100, 73, 19, 14, 89, 14, 73, 68, 4, 33, 9, 21, 66, 2, 74, 81, 99, 56, 26, 36])) 9 | print(odds([61, 67, 79])) 10 | print(odds([27, 24, 61, 63, 12, 78])) 11 | print(odds([28, 69, 69, 55, 4, 3, 64, 53])) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/opposite_number.py: -------------------------------------------------------------------------------- 1 | # Opposite number 2 | # https://www.codewars.com/kata/56dec885c54a926dcd001095 3 | # Javier Rodriguez 4 | 5 | # Version 1 6 | def opposite(number): 7 | return (-number) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/persistent_bugger.py: -------------------------------------------------------------------------------- 1 | # Persistent Bugger 2 | # https://www.codewars.com/kata/55bf01e5a717a0d57e0000ec 3 | # Javier Rodriguez 4 | 5 | # Version 2 6 | def persistence(n): 7 | resu = 0 8 | if n < 10: 9 | return 0 10 | else: 11 | while n >= 10: 12 | aux = 1 13 | for d in str(n): 14 | aux *= int(d) 15 | n = aux 16 | resu += 1 17 | return resu 18 | 19 | # Version 1 20 | def persistence(n): 21 | per = 0 22 | val = str(n) 23 | while len(val) > 1: 24 | k = 1 25 | for num in val: 26 | k *= int(num) 27 | val = str(k) 28 | per += 1 29 | return per -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/regex_pincode.py: -------------------------------------------------------------------------------- 1 | # Opposite number 2 | # https://www.codewars.com/kata/55f8a9c06c018a0d6e000132 3 | # Javier Rodriguez 4 | 5 | # Version 1 6 | def validate_pin(pin): 7 | if (pin.isnumeric()): 8 | if ((len(pin) == 4) or (len(pin) == 6)): 9 | return True 10 | return False -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/smallest_integer.py: -------------------------------------------------------------------------------- 1 | # Find the smallest integer in the array 2 | # https://www.codewars.com/kata/55a2d7ebe362935a210000b2 3 | # Javier Rodriguez 4 | 5 | # Version 1 6 | def find_smallest_int(arr): 7 | resu = arr[0] 8 | for i in arr: 9 | if i < resu: 10 | resu = i 11 | return resu -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/string_repeat.py: -------------------------------------------------------------------------------- 1 | # String repeat 2 | # https://www.codewars.com/kata/57a0e5c372292dd76d000d7e 3 | # Javier Rodriguez 4 | 5 | def repeat_str(repeat, string): 6 | return string * repeat -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/to_binary.py: -------------------------------------------------------------------------------- 1 | def to_binary(n): 2 | resu = '' 3 | while n >= 1: 4 | resu = str(n % 2) + resu 5 | n //= 2 6 | return int(resu) 7 | 8 | to_binary(10) -------------------------------------------------------------------------------- /ejercicios/CodeWars/Javier-Rodriguez/youre_square.py: -------------------------------------------------------------------------------- 1 | # You're a square! 2 | # https://www.codewars.com/kata/54c27a33fb7da0db0100040e 3 | # Javier Rodriguez 4 | 5 | # Version 1 6 | def is_square(n): 7 | res = 0 # Sumatoria 8 | k = 1 # Referencia inicial de sumatoria 9 | 10 | if (n < 0): # En el caso de que sea negativo 11 | return False 12 | 13 | while (res < n): # Sumatoria 14 | res += 2*k - 1 15 | k += 1 16 | 17 | if n == res: # Si resultado de sumatoria es igual al valor de entrada... 18 | return True 19 | return False -------------------------------------------------------------------------------- /ejercicios/CodeWars/Pedro-Bonafé/MeGusta.py: -------------------------------------------------------------------------------- 1 | #El programa debe ser una funcion que una función como :: [String] -> String, 2 | #que debe incluir una matriz de entrada, que contiene los nombres de las personas a las que les gusta un elemento. 3 | #Debe devolver el texto de la pantalla como se muestra en los ejemplos: 4 | # likes([]) # must be "no one likes this" 5 | #likes(["Peter"]) # must be "Peter likes this" 6 | #likes(["Jacob", "Alex"]) # must be "Jacob and Alex like this" 7 | #likes(["Max", "John", "Mark"]) # must be "Max, John and Mark like this" 8 | #likes(["Alex", "Jacob", "Mark", "Max"]) # must be "Alex, Jacob and 2 others like this" 9 | 10 | #Nota para 4 o mas nombres debe decir los primeros dos nombres 'and 2 others like this' 11 | 12 | 13 | def likes(names): 14 | if names == []: 15 | return 'no one likes this' 16 | elif len(names) == 1: 17 | return f'{names[0]} likes this' 18 | elif len(names)==2: 19 | return f'{names[0]} and {names[1]} like this' 20 | elif len(names) == 3: 21 | return f'{names[0]}, {names[1]} and {names[2]} like this' 22 | if len(names)>= 4: 23 | a = len(names) - 2 24 | return f'{names[0]}, {names[1]} and {a} others like this' 25 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Pedro-Bonafé/README.md: -------------------------------------------------------------------------------- 1 | # Katas de CodeWars - Pedro Bonafé 2 | A continuación, dejo mis scripts Python de las katas finalizadas, aun no tengo katas en desarrollo sin finalizar pero cuando así sea las agregaré en un apartado bajo las ya finalizadas. 3 | 4 | 5 | ## Finalizados 6 | - find_parity_outlier.py / [Find The Parity Outlier](https://www.codewars.com/kata/5526fc09a1bbd946250002dc) 7 | - ordenador_palabras.py / [Your order, please](https://www.codewars.com/kata/55c45be3b2079eccff00010f) 8 | - suma_numeros_int.py/ [Beginner Series #3 Sum of Numbers](https://www.codewars.com/kata/55f2b110f61eb01779000053) 9 | - MeGusta.py / [Who likes it?](https://www.codewars.com/kata/5266876b8f4bf2da9b000362) 10 | 11 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Pedro-Bonafé/find_parity_outlier.py: -------------------------------------------------------------------------------- 1 | #El ejercicio pedía definir una funcion que tomara un array de enteros con una característica peculiar, poseía todos los valores pares excepto uno impar, o viceverza 2 | #la funcion debía tomar dicho array y devolver el elemento "distinto" (en el caso del array con mayoría pares devolver el unico elemento impar y viceverza) 3 | 4 | def find_outlier(integers): 5 | pares = [] 6 | impares = [] 7 | for i in integers: 8 | if i % 2 == 0: 9 | pares.append(i) 10 | 11 | else: 12 | impares.append(i) 13 | 14 | if len(pares) == 1: 15 | return pares[0] 16 | else: 17 | return impares[0] 18 | 19 | 20 | return 21 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Pedro-Bonafé/ordenador_palabras.py: -------------------------------------------------------------------------------- 1 | #La tarea es ordenar una cadena determinada. 2 | #Cada palabra de la cadena contendrá un solo número. 3 | #Este número es la posición que debería tener la palabra en el resultado. 4 | 5 | #Nota: Los números pueden ser del 1 al 9. Por lo tanto, 1 será la primera palabra (no 0). 6 | 7 | #Si la cadena de entrada está vacía, devuelve una cadena vacía. Las palabras en la cadena de entrada solo contendrán números consecutivos válidos. 8 | 9 | 10 | def order(sentence): 11 | lista = sentence.split() 12 | lista2 = [] 13 | for palabra in lista: 14 | for letra in palabra: 15 | if letra == '1': 16 | lista2.append(palabra) 17 | for palabra in lista: 18 | for letra in palabra: 19 | if letra == '2': 20 | lista2.append(palabra) 21 | for palabra in lista: 22 | for letra in palabra: 23 | if letra == '3': 24 | lista2.append(palabra) 25 | for palabra in lista: 26 | for letra in palabra: 27 | if letra == '4': 28 | lista2.append(palabra) 29 | for palabra in lista: 30 | for letra in palabra: 31 | if letra == '5': 32 | lista2.append(palabra) 33 | for palabra in lista: 34 | for letra in palabra: 35 | if letra == '6': 36 | lista2.append(palabra) 37 | for palabra in lista: 38 | for letra in palabra: 39 | if letra == '7': 40 | lista2.append(palabra) 41 | for palabra in lista: 42 | for letra in palabra: 43 | if letra == '8': 44 | lista2.append(palabra) 45 | for palabra in lista: 46 | for letra in palabra: 47 | if letra == '9': 48 | lista2.append(palabra) 49 | nuevo = ' '.join(lista2) 50 | return nuevo 51 | -------------------------------------------------------------------------------- /ejercicios/CodeWars/Pedro-Bonafé/suma_numeros_int.py: -------------------------------------------------------------------------------- 1 | #Dados dos enteros ayb, que pueden ser positivos o negativos, 2 | #el ejercicio pide encontrar la suma de todos los enteros entre ellos, a y b inclusive, y devolverla 3 | #Si los dos números son iguales, devuelver a o b. 4 | 5 | #Nota: ¡ayb no están ordenados! 6 | 7 | 8 | def get_sum(a,b): 9 | if a==b: 10 | return a 11 | if a Javier-R 18 | |-> multiply.py 19 | |-> multiples.py 20 | |-> youre_square.py 21 | |-> README.md 22 | |-> Gabriel-K 23 | |-> order_list.py 24 | |-> calculator.py 25 | |-> README.md 26 | ``` 27 | Pedimos que el nombre de la carpeta tenga al menos su primer nombre y siglas del apellido. Si la combinación se repite, agregar sigla de segundo nombre o apellido. 28 | 29 | **2.** El contenido de dicho `README.md` sería así: 30 | ```md 31 | # Katas de CodeWars - Javier Rodriguez 32 | A continuación, dejo mis scripts de Python de los Katas finalizadas, los que debo refactorizar y los que aún están en desarrollo. 33 | 34 | - multiply.py / [Multiply](https://www.codewars.com/kata/50654ddff44f800200000004/train/python) / Finalizado 35 | - multiples.py / [Multiples of 3 o 5](https://www.codewars.com/kata/514b92a657cdc65150000006/train/python) / Refactorizar 36 | - youre_square.py / [You're a square!](https://www.codewars.com/kata/54c27a33fb7da0db0100040e/train/python) / En desarrollo 37 | ``` 38 | **3.** Una vez hecho un ejercicio (en cualquiera de los tres estados), realizar un Pull Request y asignar a alguno de los colaboradores a que revisen el PR. 39 | 40 | **4.** Divertirse y aprender. Eso es lo más importante! Cualquier consulta la pueden realizar en el canal de discord. 41 | -------------------------------------------------------------------------------- /ejercicios/Django/introPython/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a Python 🐍 2 | 3 | Link original: [Django / Introducción a Python](https://www.notion.so/javonotion/Introducci-n-a-Python-6bc469a4d92241929606ee82264d4235) 4 | 5 | ## Ejercicios 🏃‍♀️ 6 | **1)** Vamos a crear una calculadora. Para eso vamos a tener que definir funciones que resuelvan las operaciones básicas (suma, resta, multiplicación y división). Hacelo todo en un mismo archivo! 7 | 8 | Ejemplo de uso: 9 | 10 | ```py 11 | a = 20 12 | b = 0 13 | 14 | print(suma(a, b)) 15 | print(resta(a, b)) 16 | print(multiplicacion(a, b)) 17 | print(division(a, b)) # Ojo acá! 18 | ``` 19 | 20 | --- 21 | 22 | **2)** Queremos mejorar el ejercicio anterior. Creá una clase `Calculadora` y meté adentro las funciones creadas para que se conviertan en métodos. Hacelo todo en un mismo archivo! 23 | 24 | Ejemplo de uso: 25 | 26 | ```py 27 | a = 20 28 | b = 0 29 | 30 | calc = Calculadora() 31 | 32 | print(calc.suma(a, b)) 33 | print(calc.resta(a, b)) 34 | print(calc.multiplicacion(a, b)) 35 | print(calc.division(a, b)) # Ojo acá! 36 | ``` 37 | 38 | --- 39 | 40 | **3)** Queremos mejorar aún más el ejercicio anterior. Vamos a modularizar la clase `Calculadora` y vamos a importarla (esto requiere que crees un nuevo archivo .py con la clase dentro). Te debería quedar algo así el ejercicio 41 | 42 | ```md 43 | ./main.py 44 | ./modules/calculadora.py 45 | ``` 46 | 47 | Comprobá que funcione igual que en el ejercicio anterior. 48 | 49 | Te animás a crear otra clase, llamada `CalculadoraPro`? Debe heredar los métodos de `Calculadora` y debería tener más funciones matemáticas (logaritmos, porcentaje, raíz, potencia, etc). La cantidad de funciones a implementar la dejamos a libre albedrío. 50 | 51 | --- 52 | 53 | **4)** Dejando en paz a la calculadora, vamos a manipular datos. Tenemos la siguiente función que va a leer un archivo de texto (está en esta carpeta, llamado `the-zen-of-python.txt`) 54 | 55 | ```py 56 | def read_text(path): 57 | lines = [] 58 | with open(path) as f: 59 | lines = f.readlines() 60 | return lines 61 | 62 | file_dir = 'the-zen-of-python.txt' 63 | lineas = read_text(file_dir) 64 | ``` 65 | 66 | Necesitamos leer lo que procesa esa función. Utilizá un ciclo for para poder leer la lista lineas e imprimirla por pantalla. Debería ser algo así como resultado: 67 | 68 | ![Resultado 1](https://s3.us-west-2.amazonaws.com/secure.notion-static.com/ef73be2b-ded9-49b3-953e-44ccb4b6bf9d/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAT73L2G45O3KS52Y5%2F20210527%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20210527T131754Z&X-Amz-Expires=86400&X-Amz-Signature=77862ffdf3b67e62fa9aea0ef34fd52308ed20939de7c0de85f14269fcd6aa6a&X-Amz-SignedHeaders=host&response-content-disposition=filename%20%3D%22Untitled.png%22) 69 | 70 | **Plus**: Te animás a laburar un poco más? Fijate que si lees la lista tal cual como la recibís de la función `read_text`, vas a ver algo así: 71 | 72 | ![Resultado 2](https://s3.us-west-2.amazonaws.com/secure.notion-static.com/a01bb546-7fa2-4e83-8980-deae0eddc4fe/Untitled.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAT73L2G45O3KS52Y5%2F20210527%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20210527T131809Z&X-Amz-Expires=86400&X-Amz-Signature=fb0aa85c139b55de40ea7fa5f4ef18c5c67ee9258b7b7b4683504ab50c58712e&X-Amz-SignedHeaders=host&response-content-disposition=filename%20%3D%22Untitled.png%22) 73 | 74 | Los `\n` que se ven ahí crean un salto de línea innecesario (es el espacio que hay entre líneas del resultado anterior). Buscá un método para poder eliminar esos `\n`. 75 | Ojo con el último elemento de la lista! -------------------------------------------------------------------------------- /ejercicios/Django/introPython/ej1.py: -------------------------------------------------------------------------------- 1 | def suma(x, y): 2 | ''' 3 | Realiza la suma de dos números 4 | ''' 5 | return x + y 6 | 7 | def resta(x, y): 8 | ''' 9 | Realiza la resta de dos números 10 | ''' 11 | return x - y 12 | 13 | def producto(x, y): 14 | ''' 15 | Realiza el producto de dos números 16 | ''' 17 | return x * y 18 | 19 | def division(x, y): 20 | ''' 21 | Realiza la divisón de dos números\n 22 | Devuelve "Inf" si "y" es 0 23 | ''' 24 | if y == 0: 25 | return 'Inf' 26 | else: 27 | return x / y 28 | 29 | 30 | a = 20 31 | b = 0 32 | 33 | print(suma(a, b)) 34 | print(resta(a, b)) 35 | print(producto(a, b)) 36 | print(division(a, b)) # Ojo acá! -------------------------------------------------------------------------------- /ejercicios/Django/introPython/ej2.py: -------------------------------------------------------------------------------- 1 | class Calculadora: 2 | def __init__(self, x, y): 3 | self.x = x 4 | self.y = y 5 | 6 | def suma(self): 7 | ''' 8 | Realiza la suma de dos números 9 | ''' 10 | return self.x + self.y 11 | 12 | def resta(self): 13 | ''' 14 | Realiza la resta de dos números 15 | ''' 16 | return self.x - self.y 17 | 18 | def producto(self): 19 | ''' 20 | Realiza el producto de dos números 21 | ''' 22 | return self.x * self.y 23 | 24 | def division(self): 25 | ''' 26 | Realiza la divisón de dos números\n 27 | Devuelve "Inf" si "y" es 0 28 | ''' 29 | if self.y == 0: 30 | return 'Inf' 31 | else: 32 | return self.x / self.y 33 | 34 | 35 | a = 20 36 | b = 0 37 | calc = Calculadora(a, b) 38 | 39 | print(calc.suma()) 40 | print(calc.resta()) 41 | print(calc.producto()) 42 | print(calc.division()) # Ojo acá! -------------------------------------------------------------------------------- /ejercicios/Django/introPython/ej3.py: -------------------------------------------------------------------------------- 1 | import modules 2 | 3 | if __name__ == "__main__": # No es necesaria esta linea, en este caso 4 | a = 20 5 | b = 0 6 | calc = modules.Calculadora(a, b) 7 | 8 | print(calc.suma()) 9 | print(calc.resta()) 10 | print(calc.producto()) 11 | print(calc.division()) # Ojo acá! -------------------------------------------------------------------------------- /ejercicios/Django/introPython/ej4.py: -------------------------------------------------------------------------------- 1 | import tkinter as tk 2 | from tkinter import filedialog 3 | 4 | def file_read() -> str: 5 | ''' 6 | Abro el explorador para buscar un archivo y obtener su ruta 7 | ''' 8 | file_path = filedialog.askopenfilename() 9 | return file_path 10 | 11 | def read_text(path: str) -> list: 12 | # ''' 13 | # Leo un archivo de texto (*.txt) y devuelvo un lista con las lineas 14 | # ''' 15 | lines = [] 16 | with open(path) as f: 17 | lines = f.readlines() 18 | return lines 19 | 20 | 21 | root = tk.Tk() 22 | root.withdraw() 23 | 24 | file_dir = file_read() 25 | lineas = read_text(file_dir) 26 | 27 | for line in lineas: 28 | print(line.strip('\n')) 29 | 30 | 31 | 32 | # Easter egg: comentá todo lo anterior y descomentá la siguiente línea: 33 | # import this 34 | 35 | # + info: https://www.python.org/dev/peps/pep-0020/ -------------------------------------------------------------------------------- /ejercicios/Django/introPython/modules/__init__.py: -------------------------------------------------------------------------------- 1 | from .calculadora import Calculadora -------------------------------------------------------------------------------- /ejercicios/Django/introPython/modules/calculadora.py: -------------------------------------------------------------------------------- 1 | class Calculadora: 2 | def __init__(self, x, y): 3 | self.x = x 4 | self.y = y 5 | 6 | def suma(self): 7 | ''' 8 | Realiza la suma de dos números 9 | ''' 10 | return self.x + self.y 11 | 12 | def resta(self): 13 | ''' 14 | Realiza la resta de dos números 15 | ''' 16 | return self.x - self.y 17 | 18 | def producto(self): 19 | ''' 20 | Realiza el producto de dos números 21 | ''' 22 | return self.x * self.y 23 | 24 | def division(self): 25 | ''' 26 | Realiza la divisón de dos números\n 27 | Devuelve "Inf" si "y" es 0 28 | ''' 29 | if self.y == 0: 30 | return 'Inf' 31 | else: 32 | return self.x / self.y -------------------------------------------------------------------------------- /ejercicios/Django/introPython/the-zen-of-python.txt: -------------------------------------------------------------------------------- 1 | Beautiful is better than ugly. 2 | Explicit is better than implicit. 3 | Simple is better than complex. 4 | Complex is better than complicated. 5 | Flat is better than nested. 6 | Sparse is better than dense. 7 | Readability counts. 8 | Special cases aren't special enough to break the rules. 9 | Although practicality beats purity. 10 | Errors should never pass silently. 11 | Unless explicitly silenced. 12 | In the face of ambiguity, refuse the temptation to guess. 13 | There should be one-- and preferably only one --obvious way to do it. 14 | Although that way may not be obvious at first unless you're Dutch. 15 | Now is better than never. 16 | Although never is often better than *right* now. 17 | If the implementation is hard to explain, it's a bad idea. 18 | If the implementation is easy to explain, it may be a good idea. 19 | Namespaces are one honking great idea -- let's do more of those! -------------------------------------------------------------------------------- /ejercicios/Flask/README.md: -------------------------------------------------------------------------------- 1 | # Contenido 2 | Mostraremos las consignas para cada semana en este README. Cualquier consulta, haganla en el canal del grupo en [FrontendCafé](https://discord.gg/frontendcafe). 3 | 4 | ## ./semana4 5 | Ultimo ejercicio de Flask! Vamos a hacer la conexión a una base de datos :D 6 | 7 | Ejercicio: Crear una base de datos en Firebase, FaunaDB o MongoDB (opuede ser cualquier otro) y crear un sistema de comentarios. Por facilidad, se recomienda primero realizar este sistema de comentarios en una página, mostrando los comentarios de otras personas. 8 | Siguiendo con el ejemplo del ejercicio anterior, la estructura de las páginas sería: 9 | 10 | ``` 11 | Portfolio: `/` 12 | |--> About: /about (opcional) 13 | |--> Projects: /projects (opcional) 14 | |--> Skills: /skills (opcional) 15 | |--> My Profile Github: /github 16 | |--> Comments: /comments 17 | ``` 18 | Pueden aumentar la complejidad si quieren! También lo puede implementar de otra forma. 19 | Para esto, se suele utilizar un `.env` en la raiz del proyecto y se coloca las claves de seguridad de la DB o la url de conexión. Para las primeras pruebas pueden hacerlo sin un `.env`. 20 | 21 | **Material**: 22 | Estos cuatro enlaces son videos de YT en donde explican como realizar un CRUD con alguna de las DB mencionadas. 23 | - (*) [Python Firebase|✅| realtime DATABASE tutorial en ESPAÑOL! | 2020🤯](https://www.youtube.com/watch?v=f64e18ohYlY) 24 | - (*) [Python-Firebase Real Time Database | CRUD Tutorial](https://www.youtube.com/watch?v=Lphl9yQsw2A) 25 | - [Fauna DB and Python connection.](https://www.youtube.com/watch?v=mKPBJsoxOpU) 26 | - [Working with mongoDB Atlas using Python](https://www.youtube.com/watch?v=VQnmcBnguPY) 27 | 28 | (*) Edit de Javo: Al parecer, no estaría funcionando el método que usan en los videos de Firebase (tal vez me equivoco y funciona). Dejo una guía alternativa usando otra librería para Firebase: [How to Get Started with Firebase Using Python - freeCodeCamp](https://www.freecodecamp.org/news/how-to-get-started-with-firebase-using-python/) 29 | 30 | ## ./semana3 31 | En la tercera semana vamos a seguir trabajando con Flask y hacer el Deploy. 32 | 33 | Ejercicio: Crear un portfolio personal (puede ser un CV, una galeria, lo que sea), utilizando lo aprendido hasta ahora. 34 | Agregar rutas para poder mostrar información sobre el usuario propio de GitHub (/GitHub), siendo el portfolio como página principal (/). 35 | Opcionalmente, crear otras rutas para agregar distintas secciones. 36 | 37 | Ejemplo de app: 38 | 39 | ```cmd 40 | Portfolio: / 41 | |--> About: /about (opcional) 42 | |--> Projects: /projects (opcional) 43 | |--> Skills: /skills (opcional) 44 | |--> My Profile Github: /github 45 | ``` 46 | 47 | Para realizar deploy de la app, pueden usar esta [guía para hacerlo en Heroku](https://stackabuse.com/deploying-a-flask-application-to-heroku/). Cualquier duda sobre deploy, no duden en consultar en el canal. No es sencillo, pero tampoco imposible :smile:. 48 | 49 | 50 | ## ./semana2 51 | En la segunda semana, ya sabiendo una base de HTML y CSS, ya podemos arrancar con la parte divertida (*wiii*). Lo dividimos en 2 partes: 52 | 53 | 1) **API GitHub** 54 | Debemos realizar peticiones a la API de GitHub y obtener información de usuarios de la plataforma. Este ejercicio pide: 55 | - Realizar una petición a la API, sabiendo el usuario de GitHub. Por ejemplo: `https://api.github.com/users/JaviCeRodriguez`. 56 | - Obtener los datos de interés como el nombre, usuario, ubicación, biografía, cantidad de repositorios, usuario de twitter, etc. 57 | - Imprimir estos datos de interés en consola con el siguiente formato: 58 | ```cmd 59 | Usuario: JaviCeRodriguez 60 | Nombre: Javier Rodriguez 61 | Ubicación: San Fernando, Buenos Aires, Argentina 62 | Biografía: Hago Testing Manual, Desarrollo Frontend y buenos mates. 63 | Twitter: javicerodriguez 64 | . 65 | . 66 | . 67 | ``` 68 | Probar con varios usuarios existentes y con un par que no existan, para ver que datos recibimos. 69 | Este ejercicio guardalo, lo vamos a usar en Flask. 70 | 71 | 2) **Primera app en Flask** 72 | Siguiendo el material de estudio recomendado, ya pueden realizar una app en Flask. En este segundo ejercicio se piede: 73 | - Desarrollar en un script `main.py` las funciones necesarias para poder visualizar el contenido buscado, colocando dos posibles rutas: 74 | - `/` será la página principal, con solo el buscador, título, header y footer. 75 | - `/error` solo si recibimos un 404. Acá pueden mostrar el cuadro de búsqueda o un botón para volver atrás. 76 | - `/user/JaviCeRodriguez` si obtenemos datos de la API 77 | - Usar un lenguaje de plantillas para reutilizar el código HTML. 78 | 79 | El ejercicio de la semana pasada lo vamos a usar acá para aplicar un poco de diseño a la app. Si no pudieron terminarlo, avisen por el canal del servidor! 80 | 81 | **Material** 82 | - [Curso Flask de Código Facilito (hasta el video 13)](https://codigofacilito.com/cursos/flask) 83 | - [Template Designer Documentation - Jinja](https://jinja.palletsprojects.com/en/2.10.x/templates/) 84 | - [Python requests](https://realpython.com/python-requests/) 85 | - [Enlace de ejemplo de API de GitHub: https://api.github.com/users/JaviCeRodriguez](https://api.github.com/users/JaviCeRodriguez) (solo deberían cambiar el usuario 'JaviCeRodriguez') 86 | - [Extensión de Google Chrome para parsear los JSON de las API: JSON Formatter](https://chrome.google.com/webstore/detail/json-formatter/bcjindcccaagfpapjjmafapmmgkkhgoa) 87 | 88 | 89 | ## ./semana1 90 | Para esta primer semana, haremos un repaso de lo que es **HTML y CSS**. Si queremos ver Flask, debemos tener un mínimo de conocimiento de HTML y saber usar CSS para poder llamar la atención que nuestros proyectos sean más lindos. 91 | 92 | El ejercicio es simple, estará orientado a lo que realizaremos en la segunda semana. Básciamente haremos peticiones a la API de GitHub para poder obtener información, pero necesitaremos un entorno agradable para verlo... y acá es donde entra HTML y CSS :D 93 | 94 | **Ejercicio**: Crear una página con HTML y CSS, imitando la estética de GitHub para mostrar perfil de usuario (foto, datos, repos, etc). Pueden usar los colores del modo dark o los clásicos. 95 | 96 | **Material**: 97 | - https://dev.to/javicerodriguez/ciendiasconcourseit-dia-1-100-890 98 | - https://www.w3schools.com/ 99 | - https://www.youtube.com/watch?v=D-h8L5hgW-w 100 | - Cualquier otro video de YT o artículo 101 | 102 | > Hice un [video](https://www.youtube.com/watch?v=r6QmrHsW5X0) haciendo un diseño en *Figma* y hecho con HTML y CSS, tal vez les pueda servir o no (*pongan el video en x2 jaj*) 103 | 104 | Pueden tomar como ejemplo la [siguiente página](https://javier-rodriguez.vercel.app/proyectos/GitHubAPI/index.html) para que vean como podría ser un posible diseño. Pueden copiarla o hacer otro, usar Tailwind, Bootstrap, lo que les sea más cómodo! Pero si o si, tenemos que tener una estructura y un estilo. 105 | -------------------------------------------------------------------------------- /ejercicios/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios! 2 | En este README, tendrás una vista previa de que podés encontrar en cada carpeta, su contenido y etcéteras. 3 | 4 | ## ejercicios 5 | 6 | ## Flask -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios Generales 2 | Acá podran ver los ejercicios que fuimos dando en el año 2020. Por ahora lo dejaremos por acá! 3 | Vamos a ir acomodando el repositorio a medida de que avancemos. 4 | 5 | ## Ejercicios 6 | En el siguiente listado, se agregaran ejercicios en orden cronológico: 7 | 8 | ### Ejercicio 9: Datos y gatitos 9 | Utilizando clases y el módulo `datetime`, crear un diccionario que obtenga datos de salida de gatos de una casa de adopción con el siguiente formato: 10 | ```cmd 11 | Gatos: 3 12 | Nombres: Juan, Carlos, Sanchez 13 | Fecha de salida: 28/10/2020 14 | ``` 15 | 16 | Para este ejercicio, se pide: 17 | - Crear un diccionario que obtenga los valores de las claves `Gatos` (int), `Nombres` (list) y `Fecha` (datetime). El largo de la lista Nombres debe ser igual al de Gatos. 18 | - Se debe crear un `plot de barras` (o pueden elegir otro a gusto) para ver la cantidad de gatos que tuvieron adopción en un **día**, en un **mes** y en un **año**. Día, mes y año se especifican en consola. 19 | - Se sugiere crear un archivo `csv` en donde se van a almacenar estos datos y así poder volver a *consultar* los mismo datos utilizados. 20 | - Crear una función `menu` para poder mostrar por consola si se quiere: 21 | 1) Insertar datos nuevos 22 | 2) Consultar datos 23 | 3) Eliminar datos 24 | 4) Crear plot con datos del diccionario (solo si el diccionario no está vacío). 25 | 26 | Pueden encarar este ejercicio como les sea más cómodo o como les salga primero! Hay muchas formas de encarar este ejercicio. 27 | 28 | > **Sugerencia**: 29 | 30 | Para que el código no sea tan largo (y fácil de perderse), pueden armar códigos Python por separado y luego importarlos en uno principal. Un ejemplo puede ser: `csvData.py` (para guardar, eliminar y consultar datos de un archivo csv), `plotData.py` (para generar plot) y `gatitos.py` (como código principal). 31 | Luego deberían importar así: 32 | ```py 33 | #gatitos.py 34 | 35 | import csvData 36 | import plotData 37 | 38 | o 39 | 40 | from csvData import nombreClaseCSV 41 | from plotData import plotearClaseGatos 42 | ``` 43 | Es mejor utilizar la segunda opción, porque solo utilizarían las clases y no todo el código que posiblemente no nos sirva. 44 | 45 | --- 46 | 47 | ### Ejercicio 8: Módulos de tiempo (Opcional para practicar) 48 | Utilizando los módulos `datetime` y `time`, se pide: 49 | - Calcular la edad actual de una persona según su fecha de nacimiento (en `dd/MM/yyyy`). 50 | - Crear cuenta regresiva (para fines prácticos, conviene usar tiempos cortos). 51 | 52 | Pueden realizar este ejercicio o saltearlo, es solo para familiarizarse con estos módulos antes de empezar el **Ejercicio 9**. El formato de salida en consola se deja a libre albedrío. 53 | 54 | --- 55 | 56 | ### Ejercicio 7: Funciones Matemáticas 57 | > Enunciado 58 | 59 | Realizar las funciones correspondientes con clases como lo planteado en el ejercicio anterior, para realizar las siguientes operaciones sobre listas de elementos: 60 | 61 | - Calcular el promedio. 62 | - Hallar el valor máximo. 63 | - Hallar el valor mínimo. 64 | - Buscar valores repetidos y mostrarlos por consola. 65 | - Dado un número se debe calcular la sucesión de Fibonacci. En este caso, dicho número representa la cantidad de dígitos que se tienen en cuenta. 66 | 67 | > Observaciones 68 | 69 | - En caso de que la lista no posea elementos, se debe mostrar una lista vacía. 70 | - Para el caso en que la lista tenga 1 solo elemento, ese elemento se considera el promedio, el valor máximo y el valor mínimo. 71 | - Además si la lista no posee valores repetidos, se debe mostrar un cartel indicando que dicha lista no posee elementos repetidos. 72 | - En caso de que se deba dividir por 0, se debe mostrar la palabra por consola "Error". 73 | 74 | > Ejemplos 75 | ```cmd 76 | >>> a = [2, 5, 27, 13, -7, 1, 1] 77 | >>> b = [-1, 1] 78 | >>> c = [] 79 | >>> d = [10] 80 | 81 | Funcion promedio: 82 | 83 | >>> operacion = FuncionMatematica() 84 | >>> operacion.promedio(a) 85 | 6 86 | 87 | >>> operacion.promedio(b) 88 | "Error" 89 | 90 | >>> operacion.promedio(c) 91 | [] 92 | 93 | >>> operacion.promedio(d) 94 | 10 95 | 96 | Funcion mínimo: 97 | 98 | >>> operacion.minimo(a) 99 | -7 100 | 101 | >>> operacion.minimo(b) 102 | -1 103 | 104 | >>> operacion.minimo(c) 105 | [] 106 | 107 | >>> operacion.minimo(d) 108 | 10 109 | 110 | Funcion máximo: 111 | 112 | >>> operacion.maximo(a) 113 | 27 114 | 115 | >>> operacion.maximo(b) 116 | 1 117 | 118 | >>> operacion.maximo(c) 119 | [] 120 | 121 | >>> operacion.maximo(d) 122 | 10 123 | 124 | Funcion repetido: 125 | 126 | >>> operacion.repetido(a) 127 | 1 128 | 129 | >>> operacion.repetido(b) 130 | No posee elementos repetidos 131 | 132 | >>> operacion.repetido(c) 133 | No posee elementos repetidos 134 | 135 | >>> operacion.repetido(d) 136 | No posee elementos repetidos 137 | 138 | Funcion Fibonacci: 139 | 140 | >>> num = 8 141 | >>> operacion.fibonacci(num) 142 | 13 143 | Esto se debe a que cuenta: 144 | 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 145 | ``` 146 | 147 | Para conocer sobre Fibonacci pueden seguir el siguiente link a [Wikipedia - Sucesión de Fibonacci](https://es.wikipedia.org/wiki/Sucesi%C3%B3n_de_Fibonacci). 148 | 149 | --- 150 | 151 | ### Ejercicio 6: Operaciones Matemáticas 152 | > Enunciado 153 | 154 | Desarrollar una clase llamada "OperacionMatematica" que contenga una función, por cada una de las operaciones matemáticas habituales descriptas a continuación: 155 | - Suma. 156 | - Resta. 157 | - Multiplicación. 158 | - División. 159 | - Potenciación. 160 | - Radicación. 161 | 162 | > Ejemplos 163 | ```cmd 164 | >>> operacion = OperacionMatematica() 165 | >>> operacion.suma(2,3) 166 | 5 167 | >>> operacion.resta(5,12) 168 | -7 169 | >>> operacion.multiplicacion(-3,-6) 170 | 18 171 | >>> operacion.division(1,2) 172 | 0.5 173 | >>> operacion.potenciacion(2,8) 174 | 256 175 | >>> operacion.radicacion(36) 176 | 6 177 | ``` 178 | > Observación: En los ejemplos de arriba, se ha creado un objeto de tipo Operaciones_matematicas, para luego operar con las funciones (o métodos llámense) de nuestra clase, las cuales muestran por consola el resultado, es decir, hacen un "print(resultado)". Pueden hacerlo de ésta forma, o retornar el valor. 179 | 180 | 181 | > Requerimientos 182 | 183 | - Para los ejercicios se deben utilizar clases y, como buena práctica de programación se deben modularizar los problemas. Es decir, tendrán una clase llamada "OperacionMatematica" (es importante que comience en mayúscula el nombre de la clase), y dentro de la misma tendrán una función por cada operación matemática. De esa forma se dividen los problemas en partes pequeñas de código. 184 | 185 | - Se debe utilizar documentación (docstrings) tanto para la clase como para cada función. 186 | 187 | Para conocer sobre las clases en Python pueden seguir el siguiente link a [W3Schools](https://www.w3schools.com/python/python_classes.asp). 188 | 189 | --- 190 | 191 | ### Ejercicio 5: Intersección de Conjuntos (PyWombat) 192 | > Enunciado 193 | 194 | Desarrollar una función que recibe dos listas a y b que contienen números enteros, 195 | 196 | la lista a cuenta con una cantidad de elementos menor que b (a < b), 197 | 198 | luego las compara entre sí y retorna una única lista con todos los números enteros presentes en ambas listas. 199 | 200 | Los elementos de la lista retornada deben estar ordenados de menor a mayor y sólo deben estar listados una única vez. 201 | 202 | En caso de no tener elementos en común ambas listas, debe retornar una lista vacía. 203 | 204 | > Ejemplos 205 | ```cmd 206 | >>> interseccion([1, 2, 3, 4, 5, 6, 7, 8], [10, 25, 52, 80, 1, 46, 6, 33, 14, 27, 19]) 207 | [1, 6] 208 | >>> interseccion([1, 1, 1], [2, 2, 2]) 209 | [] 210 | >>> interseccion([3, 2, 1], [4, 3, 2, 1]) 211 | [1, 2, 3] 212 | >>> interseccion([1, 2, 3, 4, 5], [0, 2, 4, 6, 8, 10]) 213 | [2, 4] 214 | >>> interseccion([6, 7, 1, 2, 1, 3, 4, 5], [7, 8, 1, 3, 2, 1, 7, 3, 7, 10]) 215 | [1, 2, 3, 7] 216 | ``` 217 | 218 | 219 | ### Ejercicio 4: Imprimir Números (PyWombat) 220 | > Enunciado 221 | 222 | Desarrollar una función que reciba por input una lista de números enteros separados por coma, 223 | 224 | y retorne cada uno de los números impresos en saltos de líneas separados. 225 | 226 | > Ejemplos 227 | ```cmd 228 | >>> print_numeros([1, 2, 3, 4, 5]) 229 | 1 230 | 2 231 | 3 232 | 4 233 | 5 234 | >>> print_numeros([1, 1, 1]) 235 | 1 236 | 1 237 | 1 238 | >>> print_numeros([3, 2, 1]) 239 | 3 240 | 2 241 | 1 242 | >>> print_numeros([10, 20, 30, 14, 14, 16, 20]) 243 | 10 244 | 20 245 | 30 246 | 14 247 | 14 248 | 16 249 | 20 250 | ``` 251 | 252 | 253 | ### Ejercicio 3: Justificador de Líneas (propuesto AmitSna) 254 | > Enunciado 255 | 256 | Desarrollar una función que, al recibir una cadena de texto la formatea para que siempre contenga un máximo de 30 caracteres y la finaliza con un salto de línea. 257 | 258 | En caso de tener menos de 30 caracteres, le completa con espacios en blanco por la derecha hasta completar los 30 y luego la finaliza con salto de línea. 259 | 260 | En caso de tener 30 caracteres exactos, le añade un salto de línea. 261 | 262 | En caso de tener más de 30 caracteres, la fracciona en distintas cadenas de máximo 30 y les realiza mismas operatorias. 263 | 264 | El retorno debe ser una cadena de texto justificada según la consigna. 265 | 266 | > Ejemplos 267 | ```cmd 268 | >>> justificador("Esta es una cadena de texto de ejemplo de unos 60 caracteres") 269 | "Esta es una cadena de texto de\n ejemplo de unos 60 caracteres\n" 270 | >>> justificador("Cadenita de tan sólo 32 símbolos") 271 | "Cadenita de tan sólo 32 símbol\nos \n" 272 | >>> justificador("hola") 273 | "hola \n" 274 | >>> justificador("¡stringsstringsstringsstrings!") 275 | "¡stringsstringsstringsstrings!\n" 276 | ``` 277 | 278 | ### Ejercicio 2: Secuencia Genética (Inventado) 279 | > Nota aclaratoria 280 | 281 | Este ejercicio es uno de tantos que vamos a meter para tocar varias áreas en donde se utiliza Python. Acá lo vamos a encarar para que puedan hacerlo desde cero, pero sepan que existen librerías (por ejemplo: [Biopython](https://biopython.org/)) que hacen esto y mucho más de manera más sencilla. 282 | 283 | > Mini teoría 284 | 285 | Para no meternos en tanta teoría, lo resumo así (para el interesado, googleenlo): Todos los "seres vivos" contienen material genético en el cual nos identifica como tal: Humanos, Monos, Pythons (*ba dum tss*), etc. Este material genético tiene al conocido **ADN** (Ácido desoxirribunicléico) con sus respectivos nucleótidos, que son la **Adenina, Citosina, Guanina y Timina** (simplificados en A, C, G y T, respectivamente). Estos mismos, ayudan al organismo en la producción de biomoléculas a partir de grupos de **codones** (grupos de 3 nucleótidos). 286 | 287 | Una *secuencia* de ejemplo sería: 288 | **AUG** CCA GAC AAC **UAA** 289 | 290 | *Observación*: hay una U, que corresponde al **Uracilo** y aparece en el **ARN** (Ácido ribunucléico). Este nucleótido reemplaza a la Timina (para más detalles, le preguntan a Javo). 291 | 292 | Hay una tabla para poder identificar cada codón: 293 |

294 | 295 | FrontendCafe 296 | 297 |

298 | 299 | Una cosa para destacar es que **las secuencias de ARN empiezan con el codón AUG, y terminan con el codón UAA, UAG o UGA**. No importa que tan largo sea, es una de las condiciones de las secuencias para producir "algo" en el organismo. 300 | 301 | > Enunciado 302 | 303 | Una vez entendida la teoría (si no, consulten), vamos a desarrollar un detector de secuencias de ARN que contiene una cadena de varios A, U, C, G, sin importar el largo que tenga. Si existe una secuencia, debe avisar por consola e indicar cuantas. De lo contrario, avisar que no hay secuencia. 304 | 305 | > Requerimientos 306 | 307 | - Simplemente, detectar la secuencia como indica el enunciado. Deben asegurarse de poder detectar primero un codón AUG y (si o sí) un codón UAA, UAG o UGA al final. 308 | - Para que sea secuencia genética, debe al menos existir 1 codón, junto con el AUG al inicio y el UAA, UAG o UGA al final. 309 | - Opcional 1: Mostrar por consola las secuencias detectadas 310 | - Opcional 2: Indicar cuantos codones contiene cada secuencia 311 | - Opcional 3: Emplear un diccionario para guardar todas las secuencias 312 | - Opcional 4: Guardar las secuencias en un documento de texto, excel o como prefieran. 313 | 314 | Los opcionales están para que veamos que saben y como lo encaran. Estaría bueno que hagan todos o algunos opcionales para que aprendan otras cositas de Python, a parte de la lógica. 315 | 316 | > Ejemplos 317 | ```cmd 318 | Inserte secuencia: AUGGGGUACUACUAUAGGUAG 319 | Secuencias detectadas: 1 320 | 321 | Inserte secuencia: AUGGGGUaUxAXUA-AGGUaG 322 | Secuencias detectadas: 0 323 | 324 | Inserte secuencia: AUGGGGUAUUAUUAUAGGUAGAUGGGGUAUUAUUAUAGGUAGAUGGGGUAUUAUUAUAGGUAG 325 | Secuencias detectadas: 3 326 | ``` 327 | *NOTA*: No es obligatorio ingresar las secuencias, pueden generarlas de forma automática con random! (aunque las posibilidades de obtener una secuencia son bajas dependiendo del largo de la cadena). 328 | 329 | --- 330 | ### Ejercicio 1: Palíndromo ([PyWombat](https://pywombat.com/)): 331 | > Enunciado 332 | 333 | Definir una función la cual permita conocer si un string es un *palíndromo* o no. 334 | 335 | Un palíndromo es una palabra, o frase, que se lee igual de izquierda a derecha que de derecha a izquierda 336 | > Requerimientos 337 | 338 | - La función debe tener por nombre palíndromo. 339 | - La función debe poseer como parámetro la variable sentencia. 340 | - La función debe retornar verdadero(True) si el parámetro es una palíndromo, en caso contrario retornará falso(False). 341 | > Ejemplos 342 | 343 | ```cmd 344 | >>> palindromo('Anita lava la tina') 345 | True 346 | >>> palindromo('Sometamos o matemos') 347 | True 348 | >>> palindromo('Super palindromo') 349 | False 350 | ``` 351 | -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1-pruebas/amitsna.py: -------------------------------------------------------------------------------- 1 | """ 2 | #Versión Función: 3 | 4 | def palindromo(sentencia): 5 | print(sentencia.lower().replace(" ", "") == sentencia.lower().replace(" ", "")[::-1]) 6 | 7 | sentencia = input("Ingrese la frase a validar: ") 8 | 9 | palindromo(sentencia) 10 | """ 11 | 12 | palindromo = lambda sentencia: print(sentencia.lower().replace(" ", "") == sentencia.lower().replace(" ", "")[::-1]) 13 | 14 | sentencia = input("Ingrese la frase a validar: ") 15 | 16 | palindromo(sentencia) 17 | -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1-pruebas/gabrielfierro.py: -------------------------------------------------------------------------------- 1 | import unidecode 2 | 3 | def palindromo(sentencia, inicio, longitud): 4 | # Función que recibe como argumento 3 valores, el primero es una cadena de caracteres la cual la función verifica si es palíndromo retornando un valor booleano. 5 | # Los valores inicio y longitud son de tipo entero, para comparar las posiciones iniciales con las finales. 6 | 7 | # Zona de inicialización de variable 8 | exito = False 9 | 10 | if inicio == longitud or inicio < longitud: 11 | if sentencia[inicio] == sentencia[longitud]: 12 | exito = True 13 | else: 14 | exito = palindromo(sentencia, inicio+1, longitud-1) 15 | if sentencia[inicio] == sentencia[longitud]: 16 | exito = True 17 | else: 18 | exito = False 19 | 20 | return exito 21 | 22 | def verificar_condicion(condicion): 23 | # Función que dada una cadena de caracteres recibida como argumento, verifica que sea SI sin importar las ocurrencias, retornando un valor booleano. 24 | 25 | # Zona de inicialización de variables 26 | i = 0 27 | familia = ["SI","Si","si","sI","SÍ","Sí","sí","sÍ"] 28 | encontrado = False # Busca la ocurrencia de SI dentro de la lista familia 29 | continuar = True # Valor a retornar 30 | longitud_familia = len(familia)-1 31 | 32 | while encontrado == False and i <= longitud_familia: 33 | if familia[i] == condicion: 34 | encontrado = True # Encontró la palabra que buscaba 35 | else: 36 | i = i + 1 # Si no encontró la palabra, sigo buscando 37 | 38 | if not encontrado: 39 | continuar = False # Si no encontro la palabra SI en la lista, retorna False 40 | 41 | return continuar 42 | 43 | # Zona de inicialización de variable 44 | cont = True 45 | 46 | while(cont): 47 | 48 | # Zona de inicialización de variables dentro del bucle 49 | encontrado = False 50 | inicio = 0 51 | print("Ingrese la palabra que desea verificar si es palíndromo o no") 52 | palabra_original = input() 53 | 54 | palabra = (palabra_original.replace(" ","")).lower() #Le quito los espacios y transformo los caracteres a minúsculos 55 | 56 | resultado = unidecode.unidecode(palabra) # Utilizo la librería unidecode para sacar los acentos de las vocales 57 | 58 | longitud = len(resultado)-1 59 | 60 | print("palabra_original:", palabra_original) 61 | print("palabra:", palabra) 62 | print("resultado:", resultado) 63 | # Invocación de la función palindromo que verifica si la palabra ingresada es o no palindromo 64 | exito = palindromo(resultado, inicio, longitud) 65 | 66 | if exito: 67 | print("La palabra",palabra_original,"es palíndromo") 68 | else: 69 | print("La palabra",palabra_original,"no es palíndromo") 70 | 71 | print("¿Desea continuar?. Ingrese SI, en caso contrario ingrese cualquier letra.") 72 | condicion = input() 73 | 74 | cont = verificar_condicion(condicion) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1-pruebas/jmceche.py: -------------------------------------------------------------------------------- 1 | def palindromo(str): 2 | new_str = "".join(str.split(" ")).lower() 3 | if new_str == new_str[::-1]: # cadena[inicio:fin:paso] 4 | return True 5 | return False 6 | 7 | print(palindromo('Anita lava la tina')) 8 | print(palindromo('Sometamos o matemos')) 9 | print(palindromo('Super palindromo')) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1-pruebas/joeosg.py: -------------------------------------------------------------------------------- 1 | palabra = 'Anitalavalatina' 2 | espalindromo = 1 3 | contador = 1 4 | for letra in palabra: 5 | if letra.lower() != palabra[contador*-1].lower(): 6 | espalindromo = 0 7 | contador+=1 8 | 9 | if espalindromo == 0: 10 | print ("no es") 11 | else: 12 | print ("si es") 13 | -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1-pruebas/manuel96meg.py: -------------------------------------------------------------------------------- 1 | def palindromo(word): 2 | word = word.lower() 3 | 4 | wordPalin = word 5 | wordPalin = list(wordPalin) 6 | wordPalin.reverse() 7 | while wordPalin.__contains__(' '): # variable in cadena 8 | wordPalin.remove(' ') 9 | 10 | word = list(word) 11 | while word.__contains__(' '): 12 | word.remove(' ') 13 | return word == wordPalin 14 | 15 | word = str(input('ingresar palabra: ')) 16 | print(palindromo(word)) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1-pruebas/valen.py: -------------------------------------------------------------------------------- 1 | # función que permite conocer si un string es un palíndromo o no 2 | def palindromo(sentencia): 3 | try: 4 | joined_string = sentencia.replace(" ", "") 5 | lower_case_string = joined_string.lower() 6 | reverse_string = lower_case_string[::-1] 7 | if lower_case_string == reverse_string: 8 | return True 9 | else: 10 | return False 11 | except AttributeError: 12 | print("Ingrese una palabra u oracion") 13 | 14 | print(palindromo('Neuquen')) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej1_palindromo.py: -------------------------------------------------------------------------------- 1 | # Autor: Javier Rodriguez (Javo.py) | GitHub: JaviCeRodriguez 2 | # Para FrontendCafé 3 | 4 | #///---- Función palindromo ----/// 5 | def palindromo(sentencia): 6 | ''' #docstring 7 | Descripcion: Obtengo una cadena 'sentencia' y verifico si es palindromo. 8 | Precondicion: Dar como argumento una cadena con al menos 1 elemento. 9 | Poscondicion: Devuelve True si es palindromo. De lo contrario, False. 10 | ''' 11 | cadenaPrincipal = sentencia.replace(' ', '').lower() # Elimino espacio con replace y 12 | # pongo todo en minusculas con lower 13 | cadenaReversa = ''.join(reversed(cadenaPrincipal)) # Invierto cadena con reversed y 14 | # lo convierto en cadena con join (Ustedes: "what?") 15 | print(cadenaPrincipal) 16 | print(reversed(cadenaPrincipal)) # Ver texto comentado abajo si descomentan este print 17 | print(cadenaReversa) 18 | if (cadenaPrincipal == cadenaReversa): # Si son iguales, es palindromo (True) 19 | return True 20 | return False 21 | 22 | print('Ingrese frase para palindromear: ', end='') # Pido que escriba una frase 23 | frase = input() # Obtengo la frase y la guardo 24 | print(palindromo(frase)) # Voy a la función 25 | 26 | 27 | # Seguramente vas a ver algo raro cuando ejecutes la linea 15. Esto se debe a que estamos en 28 | # presencia de un iterador, que contiene nuestra frase invertida! 29 | 30 | # Iteradores: Los iteradores son objetos que utilizan el protocolo iterador. Esto significa que 31 | # podemos utilizar la función 'next()' para obtener la siguiente letra de la secuencia. Aplicamos 32 | # la función 'next()' hasta que Python nos lanza un error 'StopIteration', indicando que llegamos al 33 | # final de la secuencia del objeto. 34 | 35 | # secuencias = [dic1, dic2, dic3] 36 | # dic = {'nombre': 'Javier'} -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej2_secuencia_gen.py: -------------------------------------------------------------------------------- 1 | # Autor: Javier Rodriguez (Javo.py) | GitHub: JaviCeRodriguez 2 | # Para FrontendCafé 3 | 4 | #! Formato de diccionario 5 | #! {'SecuenciaN': 'secuencia', 'Num secuencias': 'cantidad', 'Num codones': 'cantidad'} 6 | 7 | from pprint import pprint 8 | 9 | #///---- Función deteccion ----/// 10 | def deteccion(secuencias): 11 | listSecuencias = [] # Guardo diccionarios de secuencias 12 | auxSecuencia = '' 13 | listCantCodones = [] 14 | cantCodones = 0 15 | 16 | for nucleotido in secuencias: 17 | if (nucleotido.islower()) or (not nucleotido.isalpha()): 18 | return [], [] 19 | 20 | while len(secuencias) >= 3: 21 | if secuencias[0:3] == 'AUG': 22 | auxSecuencia = secuencias[0:3] 23 | cantCodones = 1 24 | 25 | elif secuencias[0:3] in ['UAA', 'UAG', 'UGA']: 26 | if len(auxSecuencia) <= 3: 27 | auxSecuencia == '' 28 | cantCodones = 0 29 | 30 | else: 31 | auxSecuencia += secuencias[0:3] 32 | listSecuencias.append(auxSecuencia) 33 | auxSecuencia = '' 34 | cantCodones += 1 35 | listCantCodones.append(cantCodones) 36 | 37 | elif auxSecuencia[0:3].islower(): 38 | cantCodones = 0 39 | auxSecuencia = '' 40 | 41 | elif auxSecuencia[0:3] == 'AUG': 42 | auxSecuencia += secuencias[0:3] 43 | cantCodones += 1 44 | 45 | secuencias = secuencias[3:] 46 | 47 | return listSecuencias, listCantCodones 48 | 49 | #///---- Función dictSave ----/// 50 | def dictSave(listSec): 51 | dictsSec = [] 52 | 53 | for n, _ in enumerate(listSec): 54 | numSecuencia = 'Secuencia ' + str(n+1) 55 | dictsSec.append({numSecuencia: listSec[n], 'Codones': len(listSec[n])//3}) 56 | 57 | pprint(dictsSec, width=1) 58 | 59 | #///---- Main ----/// 60 | validSecuencias = [] 61 | secuencias = ['AUGGGGUaUxAXUA-AGGUaG', 62 | 'UAGAUGGAAUUUAUGGAAUUUUAAUAGAUGGAAUUUUAA', 63 | 'AAAUUUUUUUUU', 64 | 'UAGAUGGAAUUUGAAUUUGAAUUUGAAUUUGAAUUUGAAUUUUAAUAGAUGGAAUUUUAA', 65 | 'AUGGGGUACUACUAUAGGUAG', 66 | 'UAGAUGGAAUUUUAA', 67 | 'UAGAUGGAAUUUUAA'] 68 | 69 | for i, data in enumerate(secuencias): 70 | tupleData = deteccion(data) 71 | if (not tupleData[0]) and (not tupleData[1]): 72 | print(f'No hay gen en secuencia {i+1}') 73 | else: 74 | print(f'Hay {tupleData[1][0]} codones en secuencia {i+1}') 75 | validSecuencias.append(tupleData[0][0]) 76 | 77 | print('\n\n') 78 | dictSave(validSecuencias) 79 | # print(validSecuencias) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej3-pruebas/ej3-fruno.py: -------------------------------------------------------------------------------- 1 | 2 | def justificador(txt,width): 3 | # Dividir la cadena en una lista de longitud width. 4 | split = ["{}\n".format(txt[i:i+width].ljust(width,"-")) for i in range(0,len(txt),width)] 5 | 6 | # Unir la lista usando \n como union 7 | print(repr("".join(split))) 8 | 9 | 10 | 11 | texto = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. In venenatis malesuada elit," 12 | texto2 = "Lorem ipsum dolor sit" 13 | 14 | #justificador(texto,30) 15 | justificador(texto,30) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej3-pruebas/ej3-p1.py: -------------------------------------------------------------------------------- 1 | def justifica(trabajo): 2 | if len(trabajo) < 29: 3 | contador = len(trabajo) 4 | 5 | while contador < 30: 6 | trabajo = trabajo + ' ' 7 | contador+=1 8 | 9 | trabajo = trabajo + '\n' 10 | 11 | print(trabajo[0:30]) 12 | 13 | 14 | justifica('Hola5678911234567892123456789314Hola5678911234567892123456789314Hola5678911234567892123456789314') 15 | justifica('Hola') -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej3-pruebas/ej3-p2.py: -------------------------------------------------------------------------------- 1 | def justficador (linea): 2 | if len(linea) > 30: 3 | while len(linea) > 30: 4 | linea += ' ' 5 | linea += '\n' 6 | elif len(line) == 30: 7 | linea += '\n' 8 | else: 9 | linea[30] += '\n' 10 | justificador(linea) 11 | print(linea) 12 | 13 | justficador("Esta es una cadena de texto de ejemplo de unos 60 caracteres") 14 | 15 | # justficador("Cadenita de tan sólo 32 símbolos") 16 | # justficador('hola') 17 | #justficador('Cadena de tan sólo 30 símbolos') -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej3-pruebas/ej3-p3.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def justify(text, max_width=30): 4 | sliced = [] 5 | 6 | for letter in text: 7 | sliced.append(letter) 8 | 9 | for index, item in enumerate(sliced): 10 | if index % (max_width+1) == 0: 11 | sliced.insert(index, '\n') 12 | 13 | if sliced[index+1] == ' ': 14 | sliced[index+1] = '' 15 | 16 | for item in sliced: 17 | sys.stdout.write(item) 18 | sys.stdout.write('\n') 19 | 20 | def main(): 21 | just = input('Ingresá un texto: ') 22 | justify(just) 23 | 24 | main() -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej3_justificador.py: -------------------------------------------------------------------------------- 1 | # Autor: Javier Rodriguez (Javo.py) | GitHub: JaviCeRodriguez 2 | # Para FrontendCafé 3 | 4 | #! Desarrollar una función que, al recibir una cadena de text la formatea para que siempre contenga un máximo de 30 5 | #! caracteres y la finaliza con un salto de línea. 6 | 7 | #! En caso de tener menos de 30 caracteres, le completa con espacios en blanco por la derecha hasta completar los 30 8 | #! y luego la finaliza con salto de línea. 9 | 10 | #! En caso de tener 30 caracteres exactos, le añade un salto de línea. 11 | #! En caso de tener más de 30 caracteres, la fracciona en distintas cadenas de máximo 30 y les realiza mismas operatorias. 12 | 13 | def justifica(text): 14 | ''' 15 | Description: Justifica texto a 30 caracteres por linea 16 | Pre: Recibe texto 17 | Pos: Devuelve texto justificado 18 | ''' 19 | newText = '' 20 | while len(text) >= 30: 21 | newText += texto[0:30] + '\n' 22 | text = text[30:] 23 | newText += texto[0:] + '\n' 24 | 25 | return newText 26 | 27 | print('Escribite algo: ', end='') 28 | texto = input() 29 | print(justifica(texto)) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej6-pruebas/amit.py: -------------------------------------------------------------------------------- 1 | class OperacionMatematica: 2 | """Basic Math Operations Class""" 3 | 4 | def add(self, a, b): 5 | """Adds two numbers""" 6 | return a + b 7 | 8 | def substract(self, a, b): 9 | """Substracts two numbers""" 10 | return a - b 11 | 12 | def multiply(self, a, b): 13 | """Multiplies two numbers""" 14 | return a * b 15 | 16 | def divide(self, a, b=1): 17 | """Divides two numbers""" 18 | return a / b 19 | 20 | def int_divide(self, a, b=1): 21 | """Divides two numbers by integer part""" 22 | return a // b 23 | 24 | def modulo(self, a, b): 25 | """Modulo of two numbers""" 26 | return a % b 27 | 28 | def power(self, a, b): 29 | """Power of a number""" 30 | return a ** b 31 | 32 | def root(self, a, b): 33 | """Root of a number""" 34 | return a ** (1 / b) 35 | 36 | 37 | #Tests 38 | operator = OperacionMatematica() 39 | 40 | print(operator.add(1, 1)) #2 41 | print(operator.substract(2, 1)) #1 42 | print(operator.multiply(2, 1)) #2 43 | print(operator.divide(2, 2)) #1.0 44 | print(operator.int_divide(4, 2)) #2 45 | print(operator.modulo(3, 2)) #1 46 | print(operator.power(2, 1)) #2 47 | print(operator.root(144, 2)) #12.0 -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej6-pruebas/grabriel.py: -------------------------------------------------------------------------------- 1 | # Importar librería math 2 | import math 3 | 4 | 5 | class OperacionMatematica(): 6 | # Clase que se compone de funciones que resuelven operaciones matemáticas 7 | 8 | def suma(self, a, b): 9 | # Función que recibe dos números por parámetro y retorna el resultado de sumarlos 10 | return a+b 11 | 12 | def resta(self, a, b): 13 | # Función que recibe dos números por parámetro y retorna el resultado de restarlos 14 | return a-b 15 | 16 | def multiplicacion(self, a, b): 17 | # Función que recibe dos números por parámetro y retorna el resultado de multiplicarlos 18 | return a*b 19 | 20 | def division(self, a, b): 21 | # Función que recibe dos números por parámetro y retorna el resultado de dividirlos 22 | return a/b 23 | 24 | def potenciacion(self, a, b): 25 | # Función que recibe dos números por parámetro y retorna el resultado de elevar un número sobre otro 26 | return int(math.pow(a, b)) 27 | 28 | def radicacion(self, a): 29 | # Función que recibe un número por parámetro y calcula su raíz 30 | return math.sqrt(a) 31 | 32 | 33 | # Creación de un objeto de tipo OperacionMatematica 34 | operacion = OperacionMatematica() 35 | 36 | print("Suma 2+3 =", operacion.suma(2, 3)) 37 | 38 | print("Resta 5-12 =", operacion.resta(5, 12)) 39 | 40 | print("Multiplica -3*(-6) =", operacion.multiplicacion(-3, -6)) 41 | 42 | print("Divide 1/2 =", operacion.division(1, 2)) 43 | 44 | print("Potenciacion 2^8 =", operacion.potenciacion(2, 8)) 45 | 46 | print("Radicacion de 36 =", operacion.radicacion(36)) -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej6-pruebas/keto.py: -------------------------------------------------------------------------------- 1 | class OperacionMatematica: 2 | 3 | def suma(self, num1, num2): 4 | return num1 + num2 5 | 6 | def resta(self, num1, num2): 7 | return num1 - num2 8 | 9 | def multiplicacion(self, num1, num2): 10 | return num1 * num2 11 | 12 | def division(self, num1, num2): 13 | return num1 / num2 14 | 15 | def potenciacion(self, num1, num2): 16 | return num1 ** num2 17 | 18 | def radicacion(self, num1, num2): 19 | return num1 ** (1/num2) 20 | 21 | def main(): 22 | operacion = OperacionMatematica() 23 | 24 | print(operacion.suma(1, 2)) 25 | # 3 26 | print(operacion.resta(10, 8)) 27 | # 2 28 | print(operacion.multiplicacion(3, 5)) 29 | # 15 30 | print(operacion.division(20, 4)) 31 | # 5 32 | print(operacion.potenciacion(2, 4)) 33 | # 16 34 | print(operacion.radicacion(9, 2)) 35 | # 3 36 | 37 | main() -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej7-pruebas/amit.py: -------------------------------------------------------------------------------- 1 | class FuncionesMatematicas: 2 | """Math Functions Class""" 3 | 4 | def average(self, a): 5 | """Average from list""" 6 | 7 | if a: 8 | sum = 0 9 | for num in a: 10 | sum += num 11 | return 0 if sum == 0 else sum / len(a) 12 | else: 13 | return a 14 | 15 | def maximum(self, a): 16 | """Max value from list""" 17 | #return max(a) 18 | 19 | if a: 20 | max = a[0] 21 | for num in a: 22 | if num > max: 23 | max = num 24 | return max 25 | else: 26 | return a 27 | 28 | def minimum(self, a): 29 | """Min value from list""" 30 | #return min(a) 31 | 32 | if a: 33 | min = a[0] 34 | for num in a: 35 | if num < min: 36 | min = num 37 | return min 38 | else: 39 | return a 40 | 41 | def summation(self, a): 42 | """Return sum from nums in list""" 43 | #sum(a) 44 | 45 | sum = 0 46 | for num in a: 47 | sum += num 48 | return sum 49 | 50 | def repeated(self, a): 51 | """Show repeated values in list""" 52 | 53 | return sorted(set([num for num in a if a.count(num) > 1])) 54 | 55 | def unique(self, a): 56 | """Show unique values in list""" 57 | 58 | return sorted(set([num for num in a if a.count(num) == 1])) 59 | 60 | def fibo(self, a): 61 | """Calculate Fibonacci Sucession from a given quantity of digits""" 62 | #return [int((((1 + (5 ** 0.5)) / 2) ** (a - 1) / (5 ** 0.5)) + 0.5), a][a < 2] 63 | 64 | if a < 2: 65 | return a 66 | return self.fibo(a - 1) + self.fibo(a - 2) 67 | 68 | #Tests 69 | 70 | function = FuncionesMatematicas() 71 | 72 | print(function.average([3, 2, 1])) #2.0 73 | print(function.maximum([1, 2, 3])) #3 74 | print(function.minimum([3, 1, 2])) #1 75 | print(function.summation([1, 2, -1])) #2 76 | print(function.repeated([1, 1, 1])) #[1] 77 | print(function.unique([1, 1, 1])) #[] 78 | print(function.fibo(7)) #13 79 | -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/ej7-pruebas/keto.py: -------------------------------------------------------------------------------- 1 | class OperacionMatematica: 2 | 3 | def promedio(self, lista): 4 | if len(lista) > 0: 5 | return sum(lista) / len(lista) 6 | else: 7 | return lista 8 | 9 | def minimo(self, lista): 10 | if len(lista) > 0: 11 | min = lista[0] 12 | 13 | for num in lista[1:]: 14 | if num < min: 15 | min = num 16 | 17 | return min 18 | else: 19 | return lista 20 | 21 | def maximo(self, lista): 22 | if len(lista) > 0: 23 | max = lista[0] 24 | 25 | for num in lista[1:]: 26 | if num > max: 27 | max = num 28 | 29 | return max 30 | else: 31 | return lista 32 | 33 | def repetido(self, lista): 34 | dups = set([x for x in lista if lista.count(x) > 1]) 35 | 36 | if len(dups) > 0: 37 | return dups 38 | else: 39 | return 'No hay elementos duplicados' 40 | 41 | def fibonacci(self, nums): 42 | a_1 = 0 43 | a_2 = 1 44 | fibo = a_1 + a_2 45 | 46 | for i in range(nums-2): 47 | fibo = a_1 + a_2 48 | a_1 = a_2 49 | a_2 = fibo 50 | 51 | return fibo 52 | 53 | def main(): 54 | operacion = OperacionMatematica() 55 | 56 | a = [2, 5, 27, 13, -7, 1, 1] 57 | b = [-1, 1] 58 | c = [] 59 | d = [10] 60 | 61 | print('PROMEDIOS') 62 | print('a:', operacion.promedio(a)) 63 | # 6 64 | print('b:', operacion.promedio(b)) 65 | # 0 66 | print('c:', operacion.promedio(c)) 67 | # [] 68 | print('d:', operacion.promedio(d)) 69 | # 10 70 | 71 | print() 72 | 73 | print('MÍNIMOS') 74 | print('a:', operacion.minimo(a)) 75 | # -7 76 | print('b:', operacion.minimo(b)) 77 | # -1 78 | print('c:', operacion.minimo(c)) 79 | # [] 80 | print('d:', operacion.minimo(d)) 81 | # 10 82 | 83 | print() 84 | 85 | print('MÁXIMOS') 86 | print('a:', operacion.maximo(a)) 87 | # 27 88 | print('b:', operacion.maximo(b)) 89 | # 1 90 | print('c:', operacion.maximo(c)) 91 | # [] 92 | print('d:', operacion.maximo(d)) 93 | # 10 94 | 95 | print() 96 | 97 | print('REPETIDOS') 98 | print('a:', operacion.repetido(a)) 99 | # 1 100 | print('b:', operacion.repetido(b)) 101 | # No posee elementos duplicados 102 | print('c:', operacion.repetido(c)) 103 | # No posee elementos duplicados 104 | print('d:', operacion.repetido(d)) 105 | # No posee elementos duplicados 106 | 107 | print() 108 | 109 | print('FIBONACCI') 110 | print(operacion.fibonacci(8)) 111 | # 13 112 | 113 | main() -------------------------------------------------------------------------------- /ejercicios/ejerciciosGeneral/extras/palindromoPyConAr.py: -------------------------------------------------------------------------------- 1 | def isPalindrome (word): 2 | return True if(word == word[::-1]) else False 3 | 4 | 5 | def backCounting(word): 6 | if(isPalindrome(word)): 7 | return 0 8 | word = word[:-2] 9 | return 1 + backCounting(word) 10 | 11 | def frontCounting(word): 12 | if(isPalindrome(word)): 13 | return 0 14 | word = word[1:] 15 | return 1 + frontCounting(word) 16 | 17 | 18 | def comparations(word): 19 | return min(backCounting(word), frontCounting(word)) 20 | 21 | 22 | def main(): 23 | word = input("Write:\n") 24 | # word = [c for c in input_word] 25 | print(comparations(word)) 26 | 27 | 28 | if __name__ == "__main__": 29 | main() -------------------------------------------------------------------------------- /imgs/channel-discord.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/frontendcafe/py-study-group/5c863f47f703a5d120b1824e75ca5dc93b5b7418/imgs/channel-discord.jpg -------------------------------------------------------------------------------- /imgs/codigo-genetico.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/frontendcafe/py-study-group/5c863f47f703a5d120b1824e75ca5dc93b5b7418/imgs/codigo-genetico.jpg -------------------------------------------------------------------------------- /imgs/icons/github.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /imgs/icons/linkedin.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /proyectos/README.md: -------------------------------------------------------------------------------- 1 | # ✨ Proyectos ✨ 2 | 3 | Todos en algún momento necesitamos practicar y obtener experiencia en proyectos para sumar a nuestro curriculum. Pero, a veces no sabemos que hacer, no? 4 | Entonces, la propuesto del grupo de estudio es realizar proyectos (individuales o grupales) para volcar todo lo que aprendimos o queremos aprender. 5 | 6 | ## 👀 Modalidad 7 | 8 | Estaremos realizando las actividades de la siguiente manera: 9 | 10 | ✅ Elegir un proyecto 11 | 12 | ✅ Definir el stack tecnológico a utilizar 13 | 14 | ✅ Si no se sabe algo, se recomienda aprender con algún ejemplo antes de tirarse a la pileta 15 | 16 | ✅ Crear un repositorio con su tablero (Projects) para mostrar el grado de avance 17 | 18 | ✅ Si se trabaja en grupo, lo ideal sería que realicen reuniones semanales o quincenales para afinar detalles del proyecto y agregar nuevas features 19 | 20 | ✅ Dar un reporte semanal del avance en el grupo, en que se trabaron, dudas, etc. Entre todos aprendemos 🙂 21 | 22 | 23 | ## 🚀 Lista de Proyectos 24 | 25 | - **ABM de Usuarios** (Python, FastAPI, Flask, Django) 26 | - **API de Libros** (same arriba) 27 | - **Generador de informes en formato PDF** (Numpy, Matplotlib, Pandas, PDFKit, Sphinx) 28 | - **Blog** (Django: Django Girls) 29 | - **Scrapping** (Beautiful Soup, Selenium, Splinter, Helium) 30 | - **Testing** (Unittest, Pytest) 31 | - **Portfolio** (Django, DRF, FastAPI, Flask, Blask) 32 | - **Integración Continua** (AVANZADO, se puede integrar en los demás proyectos) 33 | - **Desafíos de MeLi**: Microservicio con Flask y Desafío Teórico (*Adjunto: [Technical_Challenge.pdf](./Technical_Challenge.pdf)*) -------------------------------------------------------------------------------- /proyectos/Technical_Challenge.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/frontendcafe/py-study-group/5c863f47f703a5d120b1824e75ca5dc93b5b7418/proyectos/Technical_Challenge.pdf --------------------------------------------------------------------------------