Lab0.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Lab0.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tudorcebere/tmp_LFA/blob/master/Lab0.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PzLMBT2eMlQm",
        "colab_type": "text"
      },
      "source": [
        "#Laborator 0: Introducere in Jupyter Notebook si Python\n",
        "\n",
        "##Curs: Limbaje formale si automate\n",
        "\n",
        "##Autor: Cebere Tudor"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LUZLTRvne4Zs",
        "colab_type": "text"
      },
      "source": [
        "#Partea 0: Jupyter Notebook\n",
        "\n",
        "Jupyter Notebook este un tool open source pentru crearea si distribuirea documentelor care contin cod si sectiuni de text. Text-ul si portiunile de cod sunt puse in celule diferite, fiecare modificare dintr-o celula devenind vizibila interpretarilor ulterioare prin rulare. Fiecare celula isi retine ultima stare cu care a fost rulata, inclusiv valoarea la care au fost evaluate variabilele. O parte din lucrurile utile in Jupyter Notebooks sunt:\n",
        "\n",
        "\n",
        "*   ! - rularea unei comenzi intr-un CLI in working path-ul curent. eg: !ls\n",
        "*   %% HTML - randeaza HTML intr-un cell de notebook.\n",
        "*   %matplotlib inline - randeaza o imagine server side si returneaza plotting-ul.\n",
        "*   Latex rendering: $P(A \\mid B) = \\frac{P(B \\mid A)P(A)}{P(B)}$\n",
        "*   Autocomplete cu Ctrl+Space in linia curenta\n",
        "*   Explicarea parametrilor la autocomplete cu Ctrl+Shift+Space\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PJhW73l4fkwT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!echo \"Ain't this cool?\" > jupyter_tricks.txt\n",
        "!ls\n",
        "!cat jupyter_tricks.txt\n",
        "!rm jupyter_tricks.txt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZehYA4pxjdN_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%%HTML \n",
        "<img src=\"https://i.pinimg.com/originals/37/f8/ed/37f8ed7686f5342ed76ef3df09e602d9.png\" style=\"height:300px\">"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nVuOwacipN23",
        "colab_type": "text"
      },
      "source": [
        "#Partea 1: Introducere in limbajul Python\n",
        "\n",
        "Python este un limbaj interpretat, high-level, tipat slab. Tipurile variabilelor sunt deduse\n",
        "la runtime, oferind un nivel mare de libertate, dar si de greseli. In sectiunea de Bonus prezentam cum putem de hint-uri interpretorului despre tipul anumitor variabile pentru a face codul mai lizibil si a mai reduce din bug-urile produse de lipsa tiparii.\n",
        "\n",
        "Mai jos vom prezenta un set minimal de functionalitati din Python pentru a va acomoda cu limbajul.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5KDfimo9hrE",
        "colab_type": "text"
      },
      "source": [
        "### Partea 1.1: Scoping\n",
        "Scoping-ul in Python este determinat de identare, nu de acolade ca in C/Java.\n",
        "\n",
        "**Identarea trebuie facuta consecvent, cu tab-uri/spatii**, amestecarea lor va crea\n",
        "eroare la runtime. (cred ca aici suna mai bine sa zicem analiza lexicala/parsing desi nu stiu cum sa le formulam sa sune bine - runtime inseamna ca programul \"ruleaza\" insa indentarea e data inainte de rulare)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ClInHy1sUL5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 9\n",
        "\n",
        "# in Python, pentru a defini un scope, in loc de acolade folosim tab-uri/spatii.\n",
        "\n",
        "if a == 10:\n",
        "  #acesta este scope-ul cazului True din if.\n",
        "  print(\"a is indeed \", 10)\n",
        "else:\n",
        "  #acesta este scope-ul cazului False din if\n",
        "  print(\"Nope, a este \", a)\n",
        "  #pentru a trece la un nivel de imbricare inferior, folosim un tab in minus\n",
        "\n",
        "#in momentul in care am scazult nivelul imbricarii, am incheiat un scope\n",
        "print(\"Scope-ul cazurilor din if s-a terminat\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Rg5evXWuShF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "5640bda1-e432-4b7d-c6ca-fa521918d3d4"
      },
      "source": [
        "# scoping in if blocks\n",
        "a = 1\n",
        "if True:\n",
        "  a = 2\n",
        "  print (a)\n",
        "print (a)\n",
        "\n",
        "\n",
        "if True:\n",
        "  b = 3\n",
        "  print(b)\n",
        "print(b)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "2\n",
            "3\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1cM0_W2L9jaf",
        "colab_type": "text"
      },
      "source": [
        "## Partea 1.2: Functii\n",
        "Functiile in python sunt definite prin keyword-ul `def` urmat de numele functiei si parametri.\n",
        "\n",
        "In python o functie poate intoarce unul sau mai multi parametri, interpretorul impachetand variabilele returnate intr-un tuplu.\n",
        "\n",
        "\n",
        "Python are suport si pentru functii lambda, fiind utile cand scriem functii de dimensiuni mici si locale unei alte functii (nu se polueaza nici namespace-ul programului) - trebuie sa scriem criterii de sortare\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Abafj0AuNcsh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#demonstram scoping-ul cu ajutorul functiilor\n",
        "global_variable = 10\n",
        "\n",
        "def first_func():\n",
        "  print(\"First_func can see the global_variable:\", global_variable)\n",
        "\n",
        "def second_func():\n",
        "  local_variable = 5\n",
        "  print(\"Second_func can see the the global_variable\", global_variable)\n",
        "  print(\"Second can see the local_variable\", local_variable)\n",
        "\n",
        "def third_func():\n",
        "  global_variable = 6\n",
        "  print(\"Third_func changed (or not?) the global variable\", global_variable)\n",
        "\n",
        "first_func()\n",
        "second_func()\n",
        "third_func()\n",
        "first_func()\n",
        "forth_func()\n",
        "first_func()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3BTkNuT79PSd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#urmatorul comportament apare cand incercam sa accesam o variabila care nu este\n",
        "#este vibizila in scop-ul curent.https://github.com/tudorcebere/tmp_LFA/blob/master/Lab0.ipynb\n",
        "print(local_variable)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SWUZx0EC9VG-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#exemplu de functie care returneaza mai multe valori\n",
        "def multiple_returns_function():\n",
        "  return \"first_return_val\", \"second_return_val\", \"third_return_val\"\n",
        "\n",
        "#putem desfasura in forma initiala\n",
        "first, second, third = multiple_returns_function()\n",
        "print(first)\n",
        "print(second)\n",
        "print(third)\n",
        "\n",
        "#sau putem pastra forma de tuplu, util cand nu stim numarul\n",
        "#de parametri returnati de catre o functie\n",
        "tuple_of_return_values = multiple_returns_function()\n",
        "print(tuple_of_return_values)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "503m9ie_9a_4",
        "colab_type": "text"
      },
      "source": [
        "##Partea 1.3: Liste\n",
        "Python-ul nu foloseste notiunea de vector ca C/Java, preferand in loc o lista, iar elementele se pot accesa utilizand indecsi.\n",
        "\n",
        "Metode des folosite:\n",
        "\n",
        "* append\n",
        "* insert\n",
        "* remove\n",
        "* pop\n",
        "* reverse\n",
        "\n",
        "Un alt tip de date comun in Python sunt tuplurile, care sunt multimi de cate N elemente imutabile in memorie.\n",
        "\n",
        "Un exemplu imediat ar fi echivalentul lui std::pair din C++.\n",
        "\n",
        "\n",
        "Documentatia completa din standardul de Python cu privire la structurile de date disponibile este [aici](https://docs.python.org/3/tutorial/datastructures.html), iar pentru complexitati [aici](https://wiki.python.org/moin/TimeComplexity)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oLhSu1ant0jC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#exemplu de lista in python\n",
        "x = [1, 2, 3, 4]\n",
        "\n",
        "print(\"Lista de intregi:\", x)\n",
        "\n",
        "#fata de Haskell, Python-ul accepta orice elemente intr-o lista, fiind tipat slab.\n",
        "#(listele sunt structuri de date eterogene)\n",
        "y = [\"Lista\", \"simpla\", 5]\n",
        "print(\"Lista cu elemente de diferite tipuri:\", y)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kz1djUaLxc66",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dummy_list = [\"LFA\", 10, \"PP\", 30]\n",
        "#Parcurgerea unei liste pe baza iteratorilor\n",
        "print(\"Parcurgere lista cu iterator\")\n",
        "for token in dummy_list:\n",
        "    print(token)\n",
        "\n",
        "print(\"Parcurgere lista cu indecsi\")\n",
        "#Parcurgerea unei liste pe baza indexului\n",
        "for i in range(0, len(dummy_list)):\n",
        "    print(dummy_list[i])\n",
        "\n",
        "print(\"Parcurgere lista cu enumerate\")\n",
        "#Parcurgere avand si index si element\n",
        "for i, token in enumerate(dummy_list):\n",
        "    print(i, token)\n",
        "\n",
        "#explicatie:\n",
        "#i - indexul curent\n",
        "#len(y) - lungimea listei\n",
        "#range(0, len(y)) - genereaza pe rand elemente din lista [0 .. len(y) -1]\n",
        "# ia cate un element din lista in ordine si il foloseste ca index"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ASgZOOhnxsG6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#exemplu de definire a unui tuplu\n",
        "ex_tuple = (\"This\", \"is\", \"immutable\")\n",
        "ex_list = [\"This\", \"is\", \"not\"]\n",
        "#Listele sunt mutabile in memorie, tuplurile nu."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LxynKx1h_te8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ex_tuple[0] = \"Won't work\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XzlFs6on_tvQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ex_list[1] = \"Works\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pN-6JOHi1--X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#exemple de utilizare a metodelor asociate structurilor\n",
        "dummy_list = [3, 6, 9]\n",
        "\n",
        "#adaugam la sfarsitul listei numarul 10\n",
        "dummy_list.append(10)\n",
        "print(dummy_list)\n",
        "\n",
        "#adaugam la sfarsitul listei numarul 20\n",
        "dummy_list.append(20)\n",
        "print(dummy_list)\n",
        "\n",
        "#stergem aparitia numarului 10\n",
        "dummy_list.remove(10)\n",
        "print(dummy_list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EHD3w8_H1_MI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#listele in python suporta indexare negativa, care presupune indexarea de la\n",
        "#sfarsit spre inceput, list[-1] va returna ultimul element dintr-o lista\n",
        "ref = [1, 2, 3, 4, 5, 6]\n",
        "print(\"Ultimul element din lista:\", ref[-1])\n",
        "\n",
        "#in Python putem crea subliste (sintaxa asemanatoare cu cea din Matlab), prin\n",
        "#care putem preciza intre ce indecsi dorim o sublista\n",
        "little_slice = ref[1:3]\n",
        "print(\"Slice folosind [1:3]:\", little_slice)\n",
        "\n",
        "#dorim sublista facuta de toate elementele dintre al 2-lea element inclusiv si\n",
        "#al 3-lea element de la sfarsit exclusiv\n",
        "negative_slice = ref[2:-3]\n",
        "print(\"Slice folosind [2:-3]:\", negative_slice)\n",
        "\n",
        "#al 3-lea parametru il putem folosi pentru a decide cum iteram prin lista.\n",
        "normal_list = ref[::1]\n",
        "print(\"Lista folosind pas de 1:\", normal_list)\n",
        "\n",
        "reversed_string = ref[::-1]\n",
        "print(\"Lista inversata: \", reversed_string)\n",
        "\n",
        "normal2_list = ref[::2]\n",
        "print(\"Lista folosind pas de 2:\", normal2_list)\n",
        "\n",
        "#un mecanism simplu si intuitiv de creat liste\n",
        "#list comprehension (Remember from Haskell?)\n",
        "# ** ridica un numar la o putere\n",
        "l = [x ** 2 for x in range(10)]\n",
        "print(\"List comprehension, primele 10 numere naturale la patrat:\", l)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcIMNFC91Cl-",
        "colab_type": "code",
        "outputId": "57ecabb3-f1c0-4568-9799-29a0de6b86a6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 607
        }
      },
      "source": [
        "single_quote_string = 'this is a single quote string'\n",
        "print(\"String cu apostrof:\", single_quote_string)\n",
        "\n",
        "double_quote_string = \"this a double quote string\"\n",
        "print(\"String cu ghilimele:\", double_quote_string)\n",
        "\n",
        "\n",
        "#definirea unui string in Python pe mai multe linii\n",
        "pokemon_intro = (\"I wanna be the very best \\n \"\n",
        "                 \"Like no one ever was \\n \"\n",
        "                 \"To catch them is my real test \\n \"\n",
        "                 \"To train them is my cause\")\n",
        "print(\"\\nString pe mai multe randuri\")\n",
        "print(pokemon_intro)\n",
        "\n",
        "#putem sparge un string in substring-uri cu ajutorul metodei split, cu care\n",
        "#putem sparge un string dupa un anumit caracter\n",
        "lyrics = pokemon_intro.split(\"\\n\")\n",
        "print(\"\\nVersuri\")\n",
        "print(lyrics)\n",
        "\n",
        "print(\"\\nLista de cuvinte\")\n",
        "words = pokemon_intro.split(\" \")\n",
        "print(words)\n",
        "\n",
        "#observam ca avem string-ul \"\\n\" in lista de cuvinte, dorim sa\n",
        "#scapam de acest comportament\n",
        "\n",
        "print(\"\\nSolutia 1\")\n",
        "#iteram prin rezultat si nu adaugam la lista newline-urile\n",
        "words_clean1 = []\n",
        "for word in words:\n",
        "  if word != \"\\n\":\n",
        "    words_clean1.append(word)\n",
        "\n",
        "print(words_clean1)\n",
        "\n",
        "print(\"\\nSolutia 2\")\n",
        "#folosim metoda replace pe string-ul original\n",
        "#metoda intoarce noul string, fara a modifica string-ul original\n",
        "#se inlocuieste \"\\n\" cu nimic \"\"\n",
        "words_clean2 = pokemon_intro.replace(\"\\n\", \"\")\n",
        "print(words_clean2.split())\n",
        "\n",
        "#cautam aparitia unui string intr-un alt string\n",
        "print(\"\\n'Pikachu' in intro:\", \"Pikachu\" in pokemon_intro)\n",
        "print(\"\\n'train' in intro:\", \"train\" in pokemon_intro)\n",
        "\n",
        "#concatenarea a mai multor stringuri\n",
        "concat = \"This\" + \" \" + \"is\" + \" \" + \"concatenation\"\n",
        "print(\"\\nConcatenare string-uri:\", concat)\n",
        "\n",
        "#concatenarea functioneaza la fel si pentru liste\n",
        "concat_on_lists = [1, 2] + [3, 4] + [5, 6]\n",
        "print(\"\\nConcatenare liste:\", concat_on_lists)\n",
        "\n",
        "#join va concatena toate string-urile dintr-o lista folosind ca string intermediar\n",
        "#string-ul pe care facem join.\n",
        "different_format = \"_\".join(words)\n",
        "print(\"\\nJoin\")\n",
        "print(different_format)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String cu apostrof: this is a single quote string\n",
            "String cu ghilimele: this a double quote string\n",
            "\n",
            "String pe mai multe randuri\n",
            "I wanna be the very best \n",
            " Like no one ever was \n",
            " To catch them is my real test \n",
            " To train them is my cause\n",
            "\n",
            "Versuri\n",
            "['I wanna be the very best ', ' Like no one ever was ', ' To catch them is my real test ', ' To train them is my cause']\n",
            "\n",
            "Lista de cuvinte\n",
            "['I', 'wanna', 'be', 'the', 'very', 'best', '\\n', 'Like', 'no', 'one', 'ever', 'was', '\\n', 'To', 'catch', 'them', 'is', 'my', 'real', 'test', '\\n', 'To', 'train', 'them', 'is', 'my', 'cause']\n",
            "\n",
            "Solutia 1\n",
            "['I', 'wanna', 'be', 'the', 'very', 'best', 'Like', 'no', 'one', 'ever', 'was', 'To', 'catch', 'them', 'is', 'my', 'real', 'test', 'To', 'train', 'them', 'is', 'my', 'cause']\n",
            "\n",
            "Solutia 2\n",
            "['I', 'wanna', 'be', 'the', 'very', 'best', 'Like', 'no', 'one', 'ever', 'was', 'To', 'catch', 'them', 'is', 'my', 'real', 'test', 'To', 'train', 'them', 'is', 'my', 'cause']\n",
            "\n",
            "'Pikachu' in intro: False\n",
            "\n",
            "'train' in intro: True\n",
            "\n",
            "Concatenare string-uri: This is concatenation\n",
            "\n",
            "Concatenare liste: [1, 2, 3, 4, 5, 6]\n",
            "\n",
            "Join\n",
            "I_wanna_be_the_very_best_\n",
            "_Like_no_one_ever_was_\n",
            "_To_catch_them_is_my_real_test_\n",
            "_To_train_them_is_my_cause\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yIkLCxcl-Hfe",
        "colab_type": "text"
      },
      "source": [
        "#Partea 1.5: Dictionare"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vgxrFPv21TjD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#dictionarele sunt alta structura de date comuna in Python\n",
        "#dictionarele default sunt neordonate, echivalente cu std::unordered_map din C++\n",
        "\n",
        "string_valued_dict_1 = {0 : \"cool\", 1 : \"opensource\", 2 : \"data\"}\n",
        "print(string_valued_dict_1[0])\n",
        "print(string_valued_dict_1[1])\n",
        "print(string_valued_dict_1[2])\n",
        "print() # se poate folosi doar print pentru inserare newline\n",
        "\n",
        "string_valued_dict_2 = {\"index_1\" : \"cool\", \"index_2\" : \"opensource\", \"index_3\" : \"data\"}\n",
        "print(string_valued_dict_2[\"index_1\"])\n",
        "print(string_valued_dict_2[\"index_2\"])\n",
        "print(string_valued_dict_2[\"index_3\"])\n",
        "print()\n",
        "\n",
        "cool_guys_and_where_to_find_them = {\"Turing\" : \"Alan\",\n",
        "                                    \"Church\" : \"Alonzo\", \n",
        "                                    \"materii\": [\"PP\", \"AA\", \"LFA\"]}\n",
        "\n",
        "for k,v in cool_guys_and_where_to_find_them.items():\n",
        "  print(k + \": \" + str(v))\n",
        "print()\n",
        "\n",
        "dict_tuples = dict([(\"A\", \"a\"), (\"B\", \"b\"), (\"C\", \"c\")])\n",
        "print(dict_tuples)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-uAXN6Wo-OyX",
        "colab_type": "text"
      },
      "source": [
        "# Partea 1.6: Seturi"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I5Di0jYX397i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "outputId": "402fa12a-9bfa-41ea-e317-6c19216cebac"
      },
      "source": [
        "#seturile sunt o structura cu care putem valida rapid apartanenta unui element la o multime\n",
        "\n",
        "#crearea unui set\n",
        "set_example = {\"apple\", \"banana\", \"cherry\"}\n",
        "\n",
        "#exemplu echivalent\n",
        "another_set_example = set([\"apple\", \"banana\", \"cherry\"])\n",
        "\n",
        "\n",
        "print(\"Set_example:\", set_example)\n",
        "print(\"Another_set_example:\", another_set_example)\n",
        "\n",
        "#iterarea printr-un set\n",
        "for x in set_example:\n",
        "  print(x)\n",
        "\n",
        "#adaugam un element in set\n",
        "set_example.add(\"watermelon\")\n",
        "print(len(set_example))\n",
        "\n",
        "#scoatem un element din set\n",
        "set_example.remove(\"banana\")\n",
        "print(set_example)\n",
        "\n",
        "#verificam apartenenta intr-un set\n",
        "print(\"apple\" in set_example)\n",
        "\n",
        "#observam ca daca adaugam un element care deja este in set, nu va fi duplicat\n",
        "set_example.add(\"banana\")\n",
        "print(set_example)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Set_example: {'cherry', 'banana', 'apple'}\n",
            "Another_set_example: {'cherry', 'banana', 'apple'}\n",
            "cherry\n",
            "banana\n",
            "apple\n",
            "4\n",
            "{'cherry', 'apple', 'watermelon'}\n",
            "True\n",
            "{'cherry', 'banana', 'apple', 'watermelon'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9mMehXweHmHy",
        "colab_type": "text"
      },
      "source": [
        "#Partea a II-a: Exercitii\n",
        "\n",
        "## Exercitiul 1:\n",
        "\n",
        "Scrieti o functie care sa inverseze o lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w8K21CSGzBH1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5V6igdnhzRYe",
        "colab_type": "text"
      },
      "source": [
        "## Exercitiul 2:\n",
        "\n",
        "Scrieti o functie care sa creeze un set dintr-o lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-lPwvoqNzdFH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QNxhYx9Rzfbx",
        "colab_type": "text"
      },
      "source": [
        "## Exercitiul 3:\n",
        "Scrieti o functie care returneaza reuniunea a doua seturi."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MPKeiMCYzo06",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l8cKiVcbzyUm",
        "colab_type": "text"
      },
      "source": [
        "## Exercitiul 4:\n",
        "Scrieti o functie care returneaza intersectia a doua seturi."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rflx_3jJz-_Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zg-K_yhI0CgR",
        "colab_type": "text"
      },
      "source": [
        "## Exercitiul 5:\n",
        "Scrieti o functie care primeste un set si un subset si care sa returneze complementul subsetului fata de setul dat."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z4zKp1xx0n1Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_aWhlBG0oS0",
        "colab_type": "text"
      },
      "source": [
        "## Exercitiul 6:\n",
        "Scrieti o functie care primeste doua string-uri A si B si returneaza indexul primei aparitii a stringului A in B.\n",
        "\n",
        "Exemplu:\n",
        "\n",
        "A = \"CGC\"\n",
        "\n",
        "B = \"CGCTCCCGCAATCGCTATGT\"\n",
        "\n",
        "Raspuns: 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gnqth56i3TB2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2CHs6QC3TbE",
        "colab_type": "text"
      },
      "source": [
        "## Exercitiul 7:\n",
        "Scrieti o functie care primeste string-urile str1 si str2 si un text format din cuvinte separate prin spatiu, algoritmul trebuie sa returneze toate aparitiile lui str3 din pattern-urile de forma str1 str2 str3 din text, unde str3 este urmatorul cuvant dupa aparitia cuvintelor str1 si str2.\n",
        "\n",
        "Exemplu:\n",
        "\n",
        "text = \"we will we will rock you\"\n",
        "\n",
        "str1 = \"we\"\n",
        "\n",
        "str2 = \"will\"\n",
        "\n",
        "Output: [\"we\", \"rock\"]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MfAn4bW8853a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ia0YqLLN_8Hz",
        "colab_type": "text"
      },
      "source": [
        "#Exercitiul 8:\n",
        "Scrieti o functie care primeste o lista de tipuri de paranteze si un string compus din aceste tipuri de paranteze. Functie trebuie sa intoarca daca string-ul este parantezat corect.\n",
        "\n",
        "Exemplu:\n",
        "\n",
        "paranteze = \"(){}\"\n",
        "\n",
        "string = \"({})(())\"\n",
        "\n",
        "Raspuns: True\n",
        "\n",
        "paranteze = \"()\"\n",
        "\n",
        "string = \")(\"\n",
        "\n",
        "Raspuns: Fals\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hMug2sY3A-CV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qsDs3a4XBlBK",
        "colab_type": "text"
      },
      "source": [
        "#Exercitiul 9:\n",
        "\n",
        "Implementati o funcctie care face DFS/BFS intr-un graf reprezentat printr-o matrice de adiacenta pornind dintr-un nod dat."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FM-O5hecBxoU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}