Assignments/PT-BR/Assignment_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Crie uma função chamada **\"quadrado\\_par\"** que receba como entrada um valor inteiro **N**, e retorne uma lista contendo, em ordem crescente, o quadrado de cada um dos valores pares, de 1 até N, incluindo N se for o caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Fazendo uso de um loop while e da função input, leia uma quantidade indefinida de **números inteiros** até que o número lido seja **-1**. Após esse processo, imprima duas listas na tela: A primeira contendo os elementos pares digitados, e a segunda contendo os elementos ímpares. Ambas devem estar em ordem crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) Crie uma função chamada **\"conta\\_par\"** que recebe uma lista de inteiros, conta a quantidade de elementos pares existentes, e retorna essa contagem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Crie uma função chamada **\"lista\\_ao\\_quadrado\"** que receba uma lista de inteiros e retorne outra lista cujos elementos são os quadrados dos elementos da primeira."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) Crie uma função chamada **\"decrescente\"** que receba duas listas de inteiros e retorne uma lista única, que contenha todos os elementos das demais em ordem decrescente, podendo incluir elementos repetidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Crie uma função chamada **\"adiciona\"** que receba uma lista **A**, e uma quantidade indeterminada de inteiros como entrada; Retorne uma nova lista contendo os elementos de **A** mais os inteiros passados como entrada, na ordem em que foram dados. Segue o exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = [10,20,30]\n",
    ">>>> adiciona(A, 4, 10, 50, 1)\n",
    "> [10, 20, 30, 4, 10, 50, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7) Crie uma função chamada **\"intercept\"** que receba duas listas de entrada e retorne uma outra lista com os valores que pertencem às duas listas simultaneamente (interseção) sem repetição de valores e em ordem crescente. Use a apenas a estrutura de listas e os comandos de loop e condicionais já vistos. Veja o exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = [-2, 0, 1, 2, 3]\n",
    ">>>> B = [-1, 2, 3, 6, 8]\n",
    ">>>> intercept(A,B)\n",
    "> [2, 3]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8) Crie uma função chamada **\"union\"** que receba duas listas de entrada e retorne uma outra lista com a união dos elementos das duas recebidas, sem repetição de elementos e em ordem crescente. Use apenas a estrutura de listas e os comandos de loop e condicionais já vistos. Veja exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = [-2, 0, 1, 2]\n",
    ">>>> B = [-1, 1, 2, 10]\n",
    ">>>> union(A,B)\n",
    "> [-2, ,-1, 0, 1, 2, 10]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9) Generalize a função **\"intercept\"** para que ela receba uma quantidade indefinida de listas e retorne a interceção de todas elas. Chame a nova função de **intercept2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio\n",
    "\n",
    "10) Iremos construir uma função chamada **\"matriz\"** que executa a operação de multiplicação de matrizes.\n",
    "    \n",
    "Seja a matriz:\n",
    "    \n",
    "$A_{m\\times n}=\n",
    "\\left[\\begin{matrix}\n",
    "a_{11}&a_{12}&...&a_{1n}\\\\\n",
    "a_{21}&a_{22}&...&a_{2n}\\\\\n",
    "\\vdots &\\vdots &&\\vdots\\\\\n",
    "a_{m1}&a_{m2}&...&a_{mn}\\\\\n",
    "\\end{matrix}\\right]$\n",
    "    \n",
    "No python, representaremos a matriz acima como uma lista de listas, onde cada lista interna representa uma linha da matriz original.\n",
    "\n",
    "$A = [[a_{11},a_{12},...,a_{1n}],[a_{21},a_{22},...,a_{2n}], . . . ,[a_{m1},a_{m2},...,a_{mn}]]$\n",
    "\n",
    "A sua função **\"matriz\"** dever receber duas matrizes $A$ e $B$ no formato especificado, e retornar $A\\times B$"
   ]
  },
  {
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}