bozza_esercizi_python_3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled3.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "2CPt7aiTYo2i",
        "colab_type": "code",
        "outputId": "fc5534e9-c222-4bad-f181-ec694b7ac80c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        }
      },
      "source": [
        "\n",
        "# Basic list exercises\n",
        "# Fill in the code for the functions below. main() is already set up\n",
        "# to call the functions with a few different inputs,\n",
        "# printing 'OK' when each function is correct.\n",
        "# The starter code for each function includes a 'return'\n",
        "# which is just a placeholder for your code.\n",
        "# It's ok if you do not complete all the functions, and there\n",
        "# are some additional functions to try in list2.py.\n",
        "\n",
        "# A. match_ends\n",
        "# Given a list of strings, return the count of the number of\n",
        "# strings where the string length is 2 or more and the first\n",
        "# and last chars of the string are the same.\n",
        "# Note: python does not have a ++ operator, but += works.\n",
        "# def match_ends(words):\n",
        "#   count = 0\n",
        "#   for s in words:\n",
        "#     if len(s) >= 2:\n",
        "#       if s[0] == s[-1]:  #s[0] == s[len(s)-1]\n",
        "#         count += 1\n",
        "#   return count\n",
        "def match_ends(words):\n",
        "  count = 0\n",
        "  for s in words:\n",
        "    if len(s) >= 2 and s[0] == s[-1]:  #s[0] == s[len(s)-1]\n",
        "        count += 1\n",
        "  return count\n",
        "\n",
        "\n",
        "# B. front_x\n",
        "# Given a list of strings, return a list with the strings\n",
        "# in sorted order, except group all the strings that begin with 'x' first.\n",
        "# e.g. ['mix', 'xyz', 'apple', 'xanadu', 'aardvark'] yields\n",
        "# ['xanadu', 'xyz', 'aardvark', 'apple', 'mix']\n",
        "# Hint: this can be done by making 2 lists and sorting each of them\n",
        "# before combining them.\n",
        "def front_x(words):\n",
        "  lista_x = []\n",
        "  lista = []\n",
        "  for s in words:\n",
        "    if s[0] == 'x':\n",
        "      lista_x.append(s)\n",
        "    else:\n",
        "      lista.append(s)\n",
        "\n",
        "  # lista = lista.sort()\n",
        "  # lista_x = lista_x.sort()\n",
        "  lista = sorted(lista)\n",
        "  lista_x = sorted(lista_x)\n",
        "\n",
        "  # lista_final = []\n",
        "  # for i in lista_x:\n",
        "  #   lista_final.append(i)\n",
        "  # for i in lista:\n",
        "  #   lista_final.append(i)\n",
        "  # return lista_final\n",
        "\n",
        "  # return lista_x + lista\n",
        "  \n",
        "  lista_x.extend(lista)\n",
        "  return lista_x\n",
        "\n",
        "# C. sort_last\n",
        "# Given a list of non-empty tuples, return a list sorted in increasing\n",
        "# order by the last element in each tuple.\n",
        "# e.g. [(1, 7), (1, 3), (3, 4, 5), (2, 2)] yields\n",
        "# [(2, 2), (1, 3), (3, 4, 5), (1, 7)]\n",
        "# Hint: use a custom key= function to extract the last element form each tuple.\n",
        "def sort_last(tuples):\n",
        "  # +++your code here+++\n",
        "  return\n",
        "\n",
        "\n",
        "# Simple provided test() function used in main() to print\n",
        "# what each function returns vs. what it's supposed to return.\n",
        "def test(got, expected):\n",
        "  if got == expected:\n",
        "    prefix = ' OK '\n",
        "  else:\n",
        "    prefix = '  X '\n",
        "  print('%s got: %s expected: %s' % (prefix, repr(got), repr(expected)))\n",
        "\n",
        "\n",
        "# Calls the above functions with interesting inputs.\n",
        "def main():\n",
        "  print ('match_ends')\n",
        "  test(match_ends(['aba', 'xyz', 'aa', 'x', 'bbb']), 3)\n",
        "  test(match_ends(['', 'x', 'xy', 'xyx', 'xx']), 2)\n",
        "  test(match_ends(['aaa', 'be', 'abc', 'hello']), 1)\n",
        "\n",
        "  print()\n",
        "  print ('front_x')\n",
        "  test(front_x(['bbb', 'ccc', 'axx', 'xzz', 'xaa']),\n",
        "       ['xaa', 'xzz', 'axx', 'bbb', 'ccc'])\n",
        "  test(front_x(['ccc', 'bbb', 'aaa', 'xcc', 'xaa']),\n",
        "       ['xaa', 'xcc', 'aaa', 'bbb', 'ccc'])\n",
        "  test(front_x(['mix', 'xyz', 'apple', 'xanadu', 'aardvark']),\n",
        "       ['xanadu', 'xyz', 'aardvark', 'apple', 'mix'])\n",
        "\n",
        "       \n",
        "  print()\n",
        "  print ('sort_last')\n",
        "  test(sort_last([(1, 3), (3, 2), (2, 1)]),\n",
        "       [(2, 1), (3, 2), (1, 3)])\n",
        "  test(sort_last([(2, 3), (1, 2), (3, 1)]),\n",
        "       [(3, 1), (1, 2), (2, 3)])\n",
        "  test(sort_last([(1, 7), (1, 3), (3, 4, 5), (2, 2)]),\n",
        "       [(2, 2), (1, 3), (3, 4, 5), (1, 7)])\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  main()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "match_ends\n",
            " OK  got: 3 expected: 3\n",
            " OK  got: 2 expected: 2\n",
            " OK  got: 1 expected: 1\n",
            "\n",
            "front_x\n",
            " OK  got: ['xaa', 'xzz', 'axx', 'bbb', 'ccc'] expected: ['xaa', 'xzz', 'axx', 'bbb', 'ccc']\n",
            " OK  got: ['xaa', 'xcc', 'aaa', 'bbb', 'ccc'] expected: ['xaa', 'xcc', 'aaa', 'bbb', 'ccc']\n",
            " OK  got: ['xanadu', 'xyz', 'aardvark', 'apple', 'mix'] expected: ['xanadu', 'xyz', 'aardvark', 'apple', 'mix']\n",
            "\n",
            "sort_last\n",
            "  X  got: None expected: [(2, 1), (3, 2), (1, 3)]\n",
            "  X  got: None expected: [(3, 1), (1, 2), (2, 3)]\n",
            "  X  got: None expected: [(2, 2), (1, 3), (3, 4, 5), (1, 7)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jRvXu0F_iKdf",
        "colab_type": "code",
        "outputId": "7ccc391d-d19d-4d62-eb65-bf02751d5b91",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 416
        }
      },
      "source": [
        "# Basic string exercises\n",
        "# Fill in the code for the functions below. main() is already set up\n",
        "# to call the functions with a few different inputs,\n",
        "# printing 'OK' when each function is correct.\n",
        "# The starter code for each function includes a 'return'\n",
        "# which is just a placeholder for your code.\n",
        "# It's ok if you do not complete all the functions, and there\n",
        "# are some additional functions to try in string2.py.\n",
        "\n",
        "\n",
        "# A. donuts\n",
        "# Given an int count of a number of donuts, return a string\n",
        "# of the form 'Number of donuts: <count>', where <count> is the number\n",
        "# passed in. However, if the count is 10 or more, then use the word 'many'\n",
        "# instead of the actual count.\n",
        "# So donuts(5) returns 'Number of donuts: 5'\n",
        "# and donuts(23) returns 'Number of donuts: many'\n",
        "def donuts(count):\n",
        "  pre_out = \"Number of donuts: \"\n",
        "\n",
        "  if count >= 10:\n",
        "    out = \"many\"\n",
        "  else:\n",
        "    out = str(count)\n",
        "\n",
        "  return pre_out + out\n",
        "\n",
        "\n",
        "# B. both_ends\n",
        "# Given a string s, return a string made of the first 2\n",
        "# and the last 2 chars of the original string,\n",
        "# so 'spring' yields 'spng'. However, if the string length\n",
        "# is less than 2, return instead the empty string.\n",
        "def both_ends(s):\n",
        "  new_s = \"\"\n",
        "\n",
        "  # if len(s) >= 2:\n",
        "  #   new_s += s[0]\n",
        "  #   new_s += s[1]\n",
        "  #   new_s += s[-2]\n",
        "  #   new_s += s[-1]\n",
        "\n",
        "  if len(s) >= 2:\n",
        "    new_s += s[0:2]\n",
        "    new_s += s[-2:] # s[-2:0]\n",
        "    \n",
        "  return new_s\n",
        "\n",
        "\n",
        "# C. fix_start\n",
        "# Given a string s, return a string\n",
        "# where all occurences of its first char have\n",
        "# been changed to '*', except do not change\n",
        "# the first char itself.\n",
        "# e.g. 'babble' yields 'ba**le'\n",
        "# Assume that the string is length 1 or more.\n",
        "# Hint: s.replace(stra, strb) returns a version of string s\n",
        "# where all instances of stra have been replaced by strb.\n",
        "def fix_start(s):\n",
        "  # new_s = s[0]\n",
        "  # s = s.replace(s[0], '*')\n",
        "  # new_s += s[1:]\n",
        "  # return new_s\n",
        "\n",
        "  return s[0] + s.replace(s[0], '*')[1:]\n",
        "\n",
        "\n",
        "# D. MixUp\n",
        "# Given strings a and b, return a single string with a and b separated\n",
        "# by a space '<a> <b>', except swap the first 2 chars of each string.\n",
        "# e.g.\n",
        "#   'mix', pod' -> 'pox mid'\n",
        "#   'dog', 'dinner' -> 'dig donner'\n",
        "# Assume a and b are length 2 or more.\n",
        "def mix_up(a, b):\n",
        "  # tmp = a[:2]\n",
        "  # tmp += b[3:]\n",
        "  \n",
        "  return b[:2]+a[2:] + ' ' + a[:2]+b[2:]\n",
        "\n",
        "\n",
        "# Provided simple test() function used in main() to print\n",
        "# what each function returns vs. what it's supposed to return.\n",
        "def test(got, expected):\n",
        "  if got == expected:\n",
        "    prefix = ' OK '\n",
        "  else:\n",
        "    prefix = '  X '\n",
        "  print ('%s got: %s expected: %s' % (prefix, repr(got), repr(expected)))\n",
        "\n",
        "\n",
        "# Provided main() calls the above functions with interesting inputs,\n",
        "# using test() to check if each result is correct or not.\n",
        "def main():\n",
        "  print ('donuts')\n",
        "  # Each line calls donuts, compares its result to the expected for that call.\n",
        "  test(donuts(4), 'Number of donuts: 4')\n",
        "  test(donuts(9), 'Number of donuts: 9')\n",
        "  test(donuts(10), 'Number of donuts: many')\n",
        "  test(donuts(99), 'Number of donuts: many')\n",
        "\n",
        "  print()\n",
        "  print ('both_ends')\n",
        "  test(both_ends('spring'), 'spng')\n",
        "  test(both_ends('Hello'), 'Helo')\n",
        "  test(both_ends('a'), '')\n",
        "  test(both_ends('xyz'), 'xyyz')\n",
        "\n",
        "  \n",
        "  print()\n",
        "  print ('fix_start')\n",
        "  test(fix_start('babble'), 'ba**le')\n",
        "  test(fix_start('aardvark'), 'a*rdv*rk')\n",
        "  test(fix_start('google'), 'goo*le')\n",
        "  test(fix_start('donut'), 'donut')\n",
        "\n",
        "  print()\n",
        "  print ('mix_up')\n",
        "  test(mix_up('mix', 'pod'), 'pox mid')\n",
        "  test(mix_up('dog', 'dinner'), 'dig donner')\n",
        "  test(mix_up('gnash', 'sport'), 'spash gnort')\n",
        "  test(mix_up('pezzy', 'firm'), 'fizzy perm')\n",
        "\n",
        "\n",
        "# Standard boilerplate to call the main() function.\n",
        "if __name__ == '__main__':\n",
        "  main()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "donuts\n",
            " OK  got: 'Number of donuts: 4' expected: 'Number of donuts: 4'\n",
            " OK  got: 'Number of donuts: 9' expected: 'Number of donuts: 9'\n",
            " OK  got: 'Number of donuts: many' expected: 'Number of donuts: many'\n",
            " OK  got: 'Number of donuts: many' expected: 'Number of donuts: many'\n",
            "\n",
            "both_ends\n",
            " OK  got: 'spng' expected: 'spng'\n",
            " OK  got: 'Helo' expected: 'Helo'\n",
            " OK  got: '' expected: ''\n",
            " OK  got: 'xyyz' expected: 'xyyz'\n",
            "\n",
            "fix_start\n",
            " OK  got: 'ba**le' expected: 'ba**le'\n",
            " OK  got: 'a*rdv*rk' expected: 'a*rdv*rk'\n",
            " OK  got: 'goo*le' expected: 'goo*le'\n",
            " OK  got: 'donut' expected: 'donut'\n",
            "\n",
            "mix_up\n",
            " OK  got: 'pox mid' expected: 'pox mid'\n",
            " OK  got: 'dig donner' expected: 'dig donner'\n",
            " OK  got: 'spash gnort' expected: 'spash gnort'\n",
            " OK  got: 'fizzy perm' expected: 'fizzy perm'\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-mjcu0EJfRxl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}