CHECKIO_STAGE_01_INITIATION.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CHECKIO_STAGE_01_INITIATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 1: Multiply (Intro)\n",
    "def mult_two(a: int, b: int) -> int:\n",
    "    # your code here\n",
    "    return a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 2: You have a positive integer. Try to find out how many digits it has?\n",
    "#Analisis: \n",
    "\n",
    "def number_length(a: int) -> int:\n",
    "    # your code here:\n",
    "    cadena = str(a)\n",
    "    return len(cadena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 3:\n",
    "#https://py.checkio.org/en/mission/end-zeros/\n",
    "#Try to find out how many zeros a given number has at the end.\n",
    "#Alternativa dividiendo por 10 y agregar exp de n:\n",
    "\n",
    "def end_zeros(num: int) -> int:\n",
    "    # your code here\n",
    "    if num == 0:              #Parte del primer cero, si lo hay.\n",
    "        return 1              # si es asi, entrega 1.\n",
    "    elif num%10 == 0:         #Además, si es divisible por 10\n",
    "        n = 0                 #Parte con n=0.\n",
    "        while num%10**n == 0: #Exponencial de 10 ** n\n",
    "            n += 1            #Contador de n (si es divisible de 10, es 1)\n",
    "        return n-1            #No cache por que pero resulto...\n",
    "    else:\n",
    "        return 0              #Si el primero numero es distinto de cero es 0.\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 4:\n",
    "#You should return a given string in reverse order.\n",
    "#Ejemplo: backward_string('123456789') == '987654321'\n",
    "#Analisis: usar [::-1]\n",
    "\n",
    "def backward_string(val: str) -> str:\n",
    "    # your code here\n",
    "    lav = val[::-1]\n",
    "    return lav "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 5:\n",
    "#For the illustration we have a list [1, 2, 3, 4, 5] and we need to remove all elements that go before 3 - which is 1 and 2.\n",
    "#We have two edge cases here: (1) if a cutting element cannot be found, then the list shoudn't be changed. (2) if the list is empty, then it should remain empty.\n",
    "\n",
    "def remove_all_before(items: list, border: int) -> Iterable:\n",
    "\n",
    "    hay = items.count(border)          #cuenta cuantas veces aparece border\n",
    "    maximo = len(items)                #largo de la lista.   \n",
    "    \n",
    "    if hay == 0:                       #Si border no esta en la lista\n",
    "        return items                   #Devuelva la lista\n",
    "    \n",
    "    elif maximo == 0:                  #Si la lista tiene lingitud 0\n",
    "        return []                      #Devuelva []\n",
    "    \n",
    "    else:                              #En caso de que las alternativas anteriores no ocurran:\n",
    "        minimo = items.index(border)   #ubicacion del numero dado en la lista (si esto se codifica antes, arrojara error por que 2 no aparece en una de las listas).\n",
    "        return items[minimo:maximo]    #Devuelva la lista con los elementos menos los removidos.\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 6: Check if a given string has all symbols in upper case. If the string is empty or doesn't have any letter in it - function should return True.\n",
    "#Analisis:\n",
    "#mayusculas = len([c for c in texto if c.isupper()])\n",
    "#minusculas = len([c for c in texto if c.islower()])\n",
    "#numeros = len([c for c in texto if c.isdigit()])\n",
    "\n",
    "def is_all_upper(text: str) -> bool:\n",
    "    # your code here:\n",
    "    minusculas = len([c for c in text if c.islower()])   #Busca (cuenta) minusculas en el texto.    \n",
    "    if minusculas > 0:                                   #Si encuentra alguna minuscula retorna False\n",
    "        return False\n",
    "    else:                                                #Si no encuentra minusculas, retorna True\n",
    "        return True  \n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 7: In a given list the first element should become the last one. \n",
    "#An empty list or list with only one element should stay the same.\n",
    "#ANALISIS: Uso de array.\n",
    "\n",
    "from typing import Iterable\n",
    "def replace_first(items: list) -> Iterable:\n",
    "    # your code here:\n",
    "    try:\n",
    "        items.append(items[0])           #Agrega el primer item  al final de la lista.\n",
    "        del items[0]                     #Borra el primer item de la lista\n",
    "        return items    \n",
    "    except:\n",
    "        return items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 8: You have a number and you need to determine which digit in this number is the biggest.\n",
    "#ANALISIS: Separar el numero en sus caracteres para convertirlo en una lista y elegir el mayor.\n",
    "\n",
    "def max_digit(number: int) -> int:\n",
    "    # your code here:\n",
    "    number_text = str(number)\n",
    "    num_int = [int(i) for i in number_text]\n",
    "    return max(num_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 9: Split the string into pairs of two characters. If the string contains an odd number of characters, then the missing second character of the final pair should be replaced with an underscore ('_').\n",
    "#split_pairs('abcd') == ['ab', 'cd']\n",
    "#split_pairs('abc') == ['ab', 'c_']\n",
    "#Analisis: \n",
    "#Contar elementos de la lista\n",
    "#[y+2:] + e\n",
    "#si es impar => len()/2 =! 0 => e = + append _  [x for x in range(1,11) if x % 2 != 0]\n",
    "#else e = 0\n",
    "\n",
    "def split_pairs(a):\n",
    "    # your code here:\n",
    "    n = 2                                           #cantidad de caracteres por elemento de la lista\n",
    "    if len(a) % 2 == 1:                             #si len de a es impar:\n",
    "        cadena_impar = \"\".join([a, '_'])            #la cadena lleva '_'\n",
    "        w = [cadena_impar[i:i+n] for i in range(0, len(cadena_impar), n)]\n",
    "        return w\n",
    "    else:\n",
    "        w = [a[i:i+n] for i in range(0, len(a), n)]\n",
    "        return w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 10: You have a string that consist only of digits. You need to find how many zero digits (\"0\") are at the beginning of the given string.\n",
    "#https://py.checkio.org/en/mission/beginning-zeros/\n",
    "    \n",
    "def beginning_zeros(number: str) -> int:\n",
    "    # your code here\n",
    "    count = 0   \n",
    "    for n in number:            #hace recorrer n\n",
    "        if int(n) == 0:         #Si en un n detecta que el elmento es cero\n",
    "            count += 1          #Cuenta 1 mas\n",
    "        else:\n",
    "            return count        #retorna el contador\n",
    "    return count                #retorna el contador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 11: \n",
    "#You are given a string and two markers (the initial one and final). You have to find a substring enclosed between these two markers. But there are a few important conditions.\n",
    "#This is a simplified version of the Between Markers mission.\n",
    "#The initial and final markers are always different.\n",
    "#The initial and final markers are always 1 char size.\n",
    "#The initial and final markers always exist in a string and go one after another.\n",
    "#Input: Three arguments. All of them are strings. The second and third arguments are the initial and final markers.\n",
    "#Output: A string.\n",
    "#return text[text.index(begin)+1:text.index(end)]\n",
    "\n",
    "def between_markers(text: str, begin: str, end: str) -> str:\n",
    "    \"\"\"\n",
    "        returns substring between two given markers\n",
    "    \"\"\"\n",
    "    # your code here\n",
    "    a = text.find(begin)\n",
    "    b = text.find(end)\n",
    "    c = text[a+1:b]\n",
    "        \n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 12: For the input of your function, you will be given one sentence. You have to return a corrected version, that starts with a capital letter and ends with a period (dot).\n",
    "#Pay attention to the fact that not all of the fixes are necessary. If a sentence already ends with a period (dot), then adding another one will be a mistake.\n",
    "#Input: A string.\n",
    "#Output: A string.\n",
    "#return text[0].upper() + text[1:] + (\".\" if text[-1] != \".\" else \"\")\n",
    "\n",
    "def correct_sentence(text: str) -> str:\n",
    "    \"\"\"\n",
    "        returns a corrected sentence which starts with a capital letter\n",
    "        and ends with a dot.\n",
    "    \"\"\"\n",
    "    # your code here\n",
    "    # Buscar primer caracter y reemplazar por capital.\n",
    "    primer = text[0]\n",
    "    Upper = primer.capitalize()\n",
    "    text = text.replace(text[0], Upper, 1)\n",
    "    # Buscar ultimo caracter, si no tiene punto agregarlo.\n",
    "    ultima = text[-1]\n",
    "    Punto = '.'\n",
    "    if ultima != Punto:\n",
    "        #return print('agrega punto')\n",
    "        return text + Punto\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EJERCICIO 13: Check if the given number is even or not. Your function should return True if the number is even, and False if the number is odd.\n",
    "#https://py.checkio.org/en/mission/is-even/\n",
    "\n",
    "#return num & 1 == 0\n",
    "\n",
    "def is_even(num: int) -> bool:\n",
    "    # your code here\n",
    "    return False if num % 2 != 0 else True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fin de la etapa!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______________________________________________________"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}