Ejercicios de práctica.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importar bibliotecas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "from collections import defaultdict\n",
    "\n",
    "from datetime import datetime\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiplicar los elementos de una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mult(lista):\n",
    "    return reduce(lambda x,y: x*y,lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9216"
      ]
     },
     "execution_count": 367,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult([2,3,64,4,3,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=[3,[2,3,4],[5,6,7],[8,9,11]]\n",
    "def diagonalDifference(arr):\n",
    "    n=arr[0]\n",
    "    sup=[arr[1:][i][i] for i in range(n)]\n",
    "    sub=[arr[1:][i][n-1-i] for i in range(n)]\n",
    "    return abs(sum(sup)-sum(sub))\n",
    "\n",
    "diagonalDifference(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=[4,4,2,1,1]\n",
    "a=max(A)\n",
    "len([b for b in A if b==a])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.floor(3.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=[[1,1,1,0,0,0],[0,1,0,0,0,0],[1,1,1,0,0,0],[0,0,2,4,4,0],[0,0,0,2,0,0],[0,0,1,2,4,0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=len(A)\n",
    "lista=[]\n",
    "for i in range(1,n-1):\n",
    "    for j in range(1,n-1):\n",
    "        lista.append([A[i-1][j-1],A[i-1][j],A[i-1][j+1],A[i][j],A[i+1][j-1],A[i+1][j],A[i+1][j+1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aw(l,n):\n",
    "    for j in range(len(l)):\n",
    "        if l[j]==n:\n",
    "            return j\n",
    "\n",
    "def minimumBribes(q):\n",
    "    n=len(q)\n",
    "    N=[i for i in range(1,n+1)]\n",
    "    k=0\n",
    "    for i in range(n):\n",
    "        l=0\n",
    "        while aw(N,n-i)!=aw(q,n-i):\n",
    "            j=aw(N,n-i)\n",
    "            p=N[j-1]\n",
    "            N[j-1]=N[j]\n",
    "            N[j]=p\n",
    "            k=k+1\n",
    "            l=l+1\n",
    "        if l>=3:\n",
    "            return 'Pinshe madre'\n",
    "    return k,N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(3, [2, 1, 5, 3, 4]), 'Pinshe madre', 'Pinshe madre', 'Pinshe madre']\n"
     ]
    }
   ],
   "source": [
    "p=[2,1,5,3,4]\n",
    "q=[2,5,1,3,4]\n",
    "r=[5,1,2,3,7,8,6,4]\n",
    "s=[1,2,5,3,7,8,6,4]\n",
    "print(list(map(minimumBribes,[p,q,r,s])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ver si una cadena de caracteres está contenida en otra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [],
   "source": [
    "def twoStrings(s1, s2):\n",
    "    mensaje='NO'\n",
    "    if len(s1)>len(s2):\n",
    "        S=s2\n",
    "        T=s1\n",
    "    else:\n",
    "        S=s1\n",
    "        T=s2\n",
    "    for i in list(S):\n",
    "        if i in T:\n",
    "            mensaje='YES'\n",
    "            break\n",
    "    print(mensaje)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    }
   ],
   "source": [
    "twoStrings('holi','chale')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Media/Mediana/Moda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mmm(X):\n",
    "    n=len(X)\n",
    "    prom=round(sum(X)/n,1)  #promedio\n",
    "    med=sorted(X)           #mediana\n",
    "    if n%2==0:\n",
    "        mediana=(med[n//2]+med[n//2-1])/2\n",
    "    else:\n",
    "        mediana=med[(n-1)//2]\n",
    "    M=defaultdict(int)\n",
    "    for x in X:\n",
    "        M[x]+=1\n",
    "    maxnum=max(M.values())\n",
    "    moda=min([i for i in M.keys() if M[i]==maxnum])\n",
    "    print('{0:.1f}\\n{1:.1f}\\n{2}'.format(prom,mediana,moda))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.7\n",
      "4.0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "mmm([2,2,2,4,5,5,4,5,5,65,3,2,])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fibonacci (yield)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibo():\n",
    "    i=0\n",
    "    j=1\n",
    "    while True:\n",
    "        k=i+j\n",
    "        yield k\n",
    "        i=j\n",
    "        j=k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n"
     ]
    }
   ],
   "source": [
    "for i in fibo():\n",
    "    if i>100:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cuartiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mediana(L):\n",
    "    n=len(L)\n",
    "    L.sort()\n",
    "    if n%2==0:\n",
    "        return (L[n//2-1]+L[n//2])//2\n",
    "    else:\n",
    "        return L[n//2]\n",
    "    \n",
    "def quartiles(X):\n",
    "    X.sort()\n",
    "    n=len(X)\n",
    "    if n%2==0:\n",
    "        L=X[:n//2]\n",
    "        R=X[n//2:]\n",
    "    else:\n",
    "        L=X[:n//2]\n",
    "        R=X[n//2+1:]\n",
    "    print('{0}\\n{1}\\n{2}'.format(mediana(L),mediana(X),mediana(R)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "12\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "A='3 7 8 5 12 14 21 13 18'\n",
    "A=list(map(int,A.split()))\n",
    "\n",
    "quartiles(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cambio de base numérica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tablita(n):\n",
    "    ansho = len(\"{0:b}\".format(n))\n",
    "    for i in range(1,n+1):\n",
    "        print(\"{0:{ansho}d} {0:{ansho}o} {0:{ansho}X} {0:{ansho}b}\".format(i, ansho=ansho))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1      1      1      1\n",
      "     2      2      2     10\n",
      "     3      3      3     11\n",
      "     4      4      4    100\n",
      "     5      5      5    101\n",
      "     6      6      6    110\n",
      "     7      7      7    111\n",
      "     8     10      8   1000\n",
      "     9     11      9   1001\n",
      "    10     12      A   1010\n",
      "    11     13      B   1011\n",
      "    12     14      C   1100\n",
      "    13     15      D   1101\n",
      "    14     16      E   1110\n",
      "    15     17      F   1111\n",
      "    16     20     10  10000\n",
      "    17     21     11  10001\n",
      "    18     22     12  10010\n",
      "    19     23     13  10011\n",
      "    20     24     14  10100\n",
      "    21     25     15  10101\n",
      "    22     26     16  10110\n",
      "    23     27     17  10111\n",
      "    24     30     18  11000\n",
      "    25     31     19  11001\n",
      "    26     32     1A  11010\n",
      "    27     33     1B  11011\n",
      "    28     34     1C  11100\n",
      "    29     35     1D  11101\n",
      "    30     36     1E  11110\n",
      "    31     37     1F  11111\n",
      "    32     40     20 100000\n",
      "    33     41     21 100001\n",
      "    34     42     22 100010\n",
      "    35     43     23 100011\n",
      "    36     44     24 100100\n",
      "    37     45     25 100101\n",
      "    38     46     26 100110\n",
      "    39     47     27 100111\n",
      "    40     50     28 101000\n",
      "    41     51     29 101001\n",
      "    42     52     2A 101010\n",
      "    43     53     2B 101011\n",
      "    44     54     2C 101100\n",
      "    45     55     2D 101101\n",
      "    46     56     2E 101110\n",
      "    47     57     2F 101111\n",
      "    48     60     30 110000\n",
      "    49     61     31 110001\n",
      "    50     62     32 110010\n"
     ]
    }
   ],
   "source": [
    "tablita(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mosaico Rangoli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def alfabeto(m,n):\n",
    "    A=string.ascii_lowercase[:n]\n",
    "    j=A[m]\n",
    "    for i in A[m+1:n]:\n",
    "        j=i+'-'+j+'-'+i\n",
    "    return j\n",
    "\n",
    "def mos(n):\n",
    "    for i in range(2*n-1):\n",
    "        print('{:-^{holi}}'.format(\n",
    "            alfabeto(abs(n-1-i),n),holi=4*n-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------q--------------------------------\n",
      "------------------------------q-p-q------------------------------\n",
      "----------------------------q-p-o-p-q----------------------------\n",
      "--------------------------q-p-o-n-o-p-q--------------------------\n",
      "------------------------q-p-o-n-m-n-o-p-q------------------------\n",
      "----------------------q-p-o-n-m-l-m-n-o-p-q----------------------\n",
      "--------------------q-p-o-n-m-l-k-l-m-n-o-p-q--------------------\n",
      "------------------q-p-o-n-m-l-k-j-k-l-m-n-o-p-q------------------\n",
      "----------------q-p-o-n-m-l-k-j-i-j-k-l-m-n-o-p-q----------------\n",
      "--------------q-p-o-n-m-l-k-j-i-h-i-j-k-l-m-n-o-p-q--------------\n",
      "------------q-p-o-n-m-l-k-j-i-h-g-h-i-j-k-l-m-n-o-p-q------------\n",
      "----------q-p-o-n-m-l-k-j-i-h-g-f-g-h-i-j-k-l-m-n-o-p-q----------\n",
      "--------q-p-o-n-m-l-k-j-i-h-g-f-e-f-g-h-i-j-k-l-m-n-o-p-q--------\n",
      "------q-p-o-n-m-l-k-j-i-h-g-f-e-d-e-f-g-h-i-j-k-l-m-n-o-p-q------\n",
      "----q-p-o-n-m-l-k-j-i-h-g-f-e-d-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q----\n",
      "--q-p-o-n-m-l-k-j-i-h-g-f-e-d-c-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q--\n",
      "q-p-o-n-m-l-k-j-i-h-g-f-e-d-c-b-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q\n",
      "--q-p-o-n-m-l-k-j-i-h-g-f-e-d-c-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q--\n",
      "----q-p-o-n-m-l-k-j-i-h-g-f-e-d-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q----\n",
      "------q-p-o-n-m-l-k-j-i-h-g-f-e-d-e-f-g-h-i-j-k-l-m-n-o-p-q------\n",
      "--------q-p-o-n-m-l-k-j-i-h-g-f-e-f-g-h-i-j-k-l-m-n-o-p-q--------\n",
      "----------q-p-o-n-m-l-k-j-i-h-g-f-g-h-i-j-k-l-m-n-o-p-q----------\n",
      "------------q-p-o-n-m-l-k-j-i-h-g-h-i-j-k-l-m-n-o-p-q------------\n",
      "--------------q-p-o-n-m-l-k-j-i-h-i-j-k-l-m-n-o-p-q--------------\n",
      "----------------q-p-o-n-m-l-k-j-i-j-k-l-m-n-o-p-q----------------\n",
      "------------------q-p-o-n-m-l-k-j-k-l-m-n-o-p-q------------------\n",
      "--------------------q-p-o-n-m-l-k-l-m-n-o-p-q--------------------\n",
      "----------------------q-p-o-n-m-l-m-n-o-p-q----------------------\n",
      "------------------------q-p-o-n-m-n-o-p-q------------------------\n",
      "--------------------------q-p-o-n-o-p-q--------------------------\n",
      "----------------------------q-p-o-p-q----------------------------\n",
      "------------------------------q-p-q------------------------------\n",
      "--------------------------------q--------------------------------\n"
     ]
    }
   ],
   "source": [
    "mos(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Poner mayúsculas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [],
   "source": [
    "A='manuel mijail'\n",
    "def cap(palabras):\n",
    "    for p in palabras.split():\n",
    "        palabras = palabras.replace(p, p.capitalize())\n",
    "    print(palabras)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manuel Mijail\n"
     ]
    }
   ],
   "source": [
    "cap('manuel mijail')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Etiquetas temporales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio=pd.to_datetime('2013-01-01')\n",
    "fin=pd.to_datetime('2013-01-02')\n",
    "A=pd.date_range(start=inicio,end=fin,freq='H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interpolación / Extrapolación de funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "points = np.array([(1, 1), (2, 4), (3, 1), (9, 3)])\n",
    "\n",
    "x = points[:,0]\n",
    "y = points[:,1]\n",
    "\n",
    "z = np.polyfit(x, y, 3)\n",
    "f = np.poly1d(z)\n",
    "\n",
    "x_new = np.linspace(0, 10, 50)\n",
    "y_new = f(x_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=lambda x,y:x**2+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=np.ones([2,2])\n",
    "B=np.zeros([2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(A-B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1e-05)*10**5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}