Sezzle_Codility_Prep.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNTV3RCaBTP8QD9WiOM10bj",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/facundomarino1/CS50/blob/main/Sezzle_Codility_Prep.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Codility: DEMO TEST\n"
      ],
      "metadata": {
        "id": "-zTtTK9PXmeB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X5BYxVtp-u33",
        "outputId": "2ba16513-2b8c-4674-bbd2-55a60c9b2e32"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a list of integers separated by spaces: 341 12354 45 45 235 35 2 512\n",
            "1\n"
          ]
        }
      ],
      "source": [
        "# prompt: Write a function:\n",
        "# def solution(A)\n",
        "# that, given an array A of N integers, returns the smallest positive integer (greater than 0) that does not occur in A.\n",
        "# For example, given A = [1, 3, 6, 4, 1, 2], the function should return 5.\n",
        "# Given A = [1, 2, 3], the function should return 4.\n",
        "# Given A = [−1, −3], the function should return 1.\n",
        "# Write an efficient algorithm for the following assumptions:\n",
        "# N is an integer within the range [1..100,000];\n",
        "# each element of array A is an integer within the range [−1,000,000..1,000,000].\n",
        "# Make sure to add in the begginingg something to ask the user to input a number, so we can run the code many times and test with different inputs if the code doesn't fail. Make it that it only asks for input once.\n",
        "\n",
        "def solution(A):\n",
        "    seen = set()\n",
        "    for x in A:\n",
        "        if x > 0:\n",
        "            seen.add(x)\n",
        "    i = 1\n",
        "    while i in seen:\n",
        "        i += 1\n",
        "    return i\n",
        "\n",
        "# Get input from the user only once\n",
        "input_str = input(\"Enter a list of integers separated by spaces: \")\n",
        "try:\n",
        "    A = [int(x) for x in input_str.split()]\n",
        "    result = solution(A)\n",
        "    print(result)\n",
        "except ValueError:\n",
        "    print(\"Invalid input. Please enter a list of integers separated by spaces.\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def solution(A):\n",
        "    seen = set()\n",
        "    for x in A:\n",
        "        if x > 0:\n",
        "            seen.add(x)\n",
        "    i = 1\n",
        "    while i in seen:\n",
        "        i += 1\n",
        "    return i\n",
        "\n",
        "input_str = input(\"Enter a list of integers separated by spaces: \")\n",
        "try:\n",
        "    A = [int(x) for x in input_str.split()]\n",
        "    result = solution(A)\n",
        "    print(result)\n",
        "except ValueError:\n",
        "    print(\"Invalid input. Please enter a list of integers separated by spaces.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AOXzg6OIAO1A",
        "outputId": "0858116c-0d61-427e-ba59-eb760dcd35e6"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a list of integers separated by spaces: -1 0  -4\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Codility 1: Iteration\n",
        "## Binary gap"
      ],
      "metadata": {
        "id": "LCcSkQ1IXyn5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# prompt: A binary gap within a positive integer N is any maximal sequence of consecutive zeros that is surrounded by ones at both ends in the binary representation of N.\n",
        "# For example, number 9 has binary representation 1001 and contains a binary gap of length 2. The number 529 has binary representation 1000010001 and contains two binary gaps: one of length 4 and one of length 3. The number 20 has binary representation 10100 and contains one binary gap of length 1. The number 15 has binary representation 1111 and has no binary gaps. The number 32 has binary representation 100000 and has no binary gaps.\n",
        "# Write a function:\n",
        "# def solution(N)\n",
        "# that, given a positive integer N, returns the length of its longest binary gap. The function should return 0 if N doesn't contain a binary gap.\n",
        "# For example, given N = 1041 the function should return 5, because N has binary representation 10000010001 and so its longest binary gap is of length 5. Given N = 32 the function should return 0, because N has binary representation '100000' and thus no binary gaps.\n",
        "# Write an efficient algorithm for the following assumptions:\n",
        "# N is an integer within the range [1..2,147,483,647].\n",
        "# Make it so that you first ask me for an input, and then you show me the binary translation of the input and the final result. Also take into account edge cases.\n",
        "\n",
        "def solution(N):\n",
        "    binary_representation = bin(N)[2:]  # Convert to binary and remove \"0b\" prefix\n",
        "    print(f\"Binary representation of {N}: {binary_representation}\")\n",
        "\n",
        "    max_gap = 0\n",
        "    current_gap = 0\n",
        "    in_gap = False\n",
        "\n",
        "    for digit in binary_representation:\n",
        "        if digit == '1':\n",
        "            if in_gap:\n",
        "                max_gap = max(max_gap, current_gap)\n",
        "                current_gap = 0\n",
        "            in_gap = True\n",
        "        elif digit == '0' and in_gap:\n",
        "            current_gap += 1\n",
        "\n",
        "    return max_gap\n",
        "\n",
        "# Get input from the user\n",
        "try:\n",
        "    N = int(input(\"Enter a positive integer: \"))\n",
        "    if N <= 0:\n",
        "        print(\"Input must be a positive integer.\")\n",
        "    else:\n",
        "        result = solution(N)\n",
        "        print(f\"Length of the longest binary gap: {result}\")\n",
        "except ValueError:\n",
        "    print(\"Invalid input. Please enter a positive integer.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hE-BaTrXWN4y",
        "outputId": "eda3176d-4f27-430c-dc10-181f6aaf8984"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a positive integer: 123456789\n",
            "Binary representation of 123456789: 111010110111100110100010101\n",
            "Length of the longest binary gap: 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# acá va la respuesta que me dió chatgpt:\n",
        "\n",
        "def solution(N):\n",
        "    # Input validation: Ensure N is a positive integer\n",
        "    if not isinstance(N, int) or N <= 0:\n",
        "        return \"Invalid input: N must be a positive integer.\"\n",
        "\n",
        "    binary = bin(N)[2:]  # Convert to binary and strip '0b'\n",
        "    max_gap = 0          # Track the length of the longest binary gap\n",
        "    current_gap = 0      # Track the current binary gap\n",
        "    counting = False     # Flag to determine when to count gaps\n",
        "\n",
        "    # Traverse through each bit in the binary representation\n",
        "    for bit in binary:\n",
        "        if bit == '1':  # When we encounter a '1'\n",
        "            if counting:  # If we were in a gap, finalize the current gap\n",
        "                max_gap = max(max_gap, current_gap)\n",
        "            counting = True  # Start counting after the first '1'\n",
        "            current_gap = 0  # Reset the current gap\n",
        "        elif counting:  # Count '0's only after encountering the first '1'\n",
        "            current_gap += 1\n",
        "\n",
        "    return max_gap\n",
        "\n",
        "# Wrapper function for safer input handling\n",
        "def safe_solution(input_value):\n",
        "    try:\n",
        "        # Convert input to an integer\n",
        "        N = int(input_value)\n",
        "        return solution(N)\n",
        "    except (ValueError, TypeError):  # Catch invalid conversions\n",
        "        return \"Invalid input: Input must be a positive integer.\"\n",
        "\n",
        "# Test Cases for Validation\n",
        "print(safe_solution(1041))       # Valid input: 5\n",
        "print(safe_solution(32))         # Valid input: 0\n",
        "print(safe_solution(\"a\"))        # Invalid input\n",
        "print(safe_solution(\"-\"))        # Invalid input\n",
        "print(safe_solution(2.4))        # Invalid input\n",
        "print(safe_solution(\"2,4\"))      # Invalid input\n",
        "print(safe_solution(-5))         # Invalid input\n",
        "print(safe_solution(1))          # Edge case: 0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mfWHE2sXYLBt",
        "outputId": "463cd90e-e270-4e5b-fee7-1e0d02972fba"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "0\n",
            "Invalid input: Input must be a positive integer.\n",
            "Invalid input: Input must be a positive integer.\n",
            "0\n",
            "Invalid input: Input must be a positive integer.\n",
            "Invalid input: N must be a positive integer.\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Codility 2: Arrays\n",
        "## BinaryGap"
      ],
      "metadata": {
        "id": "lzJI4yDIZzDK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# prompt: An array A consisting of N integers is given. Rotation of the array means that each element is shifted right by one index, and the last element of the array is moved to the first place. For example, the rotation of array A = [3, 8, 9, 7, 6] is [6, 3, 8, 9, 7] (elements are shifted right by one index and 6 is moved to the first place).\n",
        "# The goal is to rotate array A K times; that is, each element of A will be shifted to the right K times.\n",
        "# Write a function:\n",
        "# def solution(A, K)\n",
        "# that, given an array A consisting of N integers and an integer K, returns the array A rotated K times.\n",
        "# For example, given\n",
        "#     A = [3, 8, 9, 7, 6]\n",
        "#     K = 3\n",
        "# the function should return [9, 7, 6, 3, 8]. Three rotations were made:\n",
        "#     [3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7]\n",
        "#     [6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9]\n",
        "#     [7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]\n",
        "# For another example, given\n",
        "#     A = [0, 0, 0]\n",
        "#     K = 1\n",
        "# the function should return [0, 0, 0]\n",
        "# Given\n",
        "#     A = [1, 2, 3, 4]\n",
        "#     K = 4\n",
        "# the function should return [1, 2, 3, 4]\n",
        "# Assume that:\n",
        "# N and K are integers within the range [0..100];\n",
        "# each element of array A is an integer within the range [−1,000..1,000].\n",
        "# In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.\n",
        "\n",
        "def solution(A, K):\n",
        "    n = len(A)\n",
        "    if n == 0:\n",
        "        return A\n",
        "\n",
        "    k = K % n  # Handle cases where K is larger than the array length\n",
        "\n",
        "    return A[-k:] + A[:-k]"
      ],
      "metadata": {
        "id": "ggfd_KrtZ4er"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Codility 2: Arrays\n",
        "## Odd Ocurrences in Array"
      ],
      "metadata": {
        "id": "Y34VcfRhefhn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# prompt: A non-empty array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired.\n",
        "# For example, in array A such that:\n",
        "#   A[0] = 9  A[1] = 3  A[2] = 9\n",
        "#   A[3] = 3  A[4] = 9  A[5] = 7\n",
        "#   A[6] = 9\n",
        "# the elements at indexes 0 and 2 have value 9,\n",
        "# the elements at indexes 1 and 3 have value 3,\n",
        "# the elements at indexes 4 and 6 have value 9,\n",
        "# the element at index 5 has value 7 and is unpaired.\n",
        "# Write a function:\n",
        "# def solution(A)\n",
        "# that, given an array A consisting of N integers fulfilling the above conditions, returns the value of the unpaired element.\n",
        "# For example, given array A such that:\n",
        "#   A[0] = 9  A[1] = 3  A[2] = 9\n",
        "#   A[3] = 3  A[4] = 9  A[5] = 7\n",
        "#   A[6] = 9\n",
        "# the function should return 7, as explained in the example above.\n",
        "# Write an efficient algorithm for the following assumptions:\n",
        "# N is an odd integer within the range [1..1,000,000];\n",
        "# each element of array A is an integer within the range [1..1,000,000,000];\n",
        "# all but one of the values in A occur an even number of times.\n",
        "\n",
        "def solution(A):\n",
        "    result = 0\n",
        "    for number in A:\n",
        "        result ^= number\n",
        "    return result"
      ],
      "metadata": {
        "id": "LEeNNsmQepJK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ChatGPT Tests"
      ],
      "metadata": {
        "id": "4YiUY2pWJpdV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem 1: Data Cleaning and Missing Values\n",
        "\n",
        "### Problem Statement\n",
        "\n",
        "You are analyzing a transaction dataset provided as a list of dictionaries. Some transactions are incomplete or have invalid entries (negative amounts or missing customer_id or transaction_id).\n",
        "\n",
        "Write a Python function that:\n",
        "\t1.\tFilters out transactions with invalid or missing data.\n",
        "\t2.\tReturns a list of valid transactions.\n",
        "\n",
        "Requirements\n",
        "\t•\tA transaction is valid if:\n",
        "\t•\ttransaction_id exists (not None).\n",
        "\t•\tcustomer_id exists (not None).\n",
        "\t•\tamount is positive (> 0)."
      ],
      "metadata": {
        "id": "op53J6uSJwEG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def filter_valid_transactions(transactions):\n",
        "  # initialize a list to store valid transactions\n",
        "    valid_transactions = []\n",
        "\n",
        "  # itererate through transactions\n",
        "    for transaction in transactions:\n",
        "        # check for missing data on each transaction\n",
        "        if transaction['transaction_id'] is not None and transaction['customer_id'] is not None and transaction['amount'] > 0:\n",
        "            valid_transactions.append(transaction)\n",
        "    return valid_transactions\n",
        "\n",
        "def get_transactions_from_user():\n",
        "  transactions = []\n",
        "  while True:\n",
        "    transaction_id = input(\"Enter transaction ID (or 'q' to quit): \")\n",
        "    if transaction_id.lower() == 'q':\n",
        "      break\n",
        "    try:\n",
        "      transaction_id = int(transaction_id)\n",
        "      customer_id = int(input(\"Enter customer ID: \"))\n",
        "      amount = float(input(\"Enter amount: \"))\n",
        "      transactions.append({'transaction_id': transaction_id, 'customer_id': customer_id, 'amount': amount})\n",
        "    except ValueError:\n",
        "      print(\"Invalid input. Please enter valid numbers or 'q' to quit.\")\n",
        "  return transactions\n",
        "\n",
        "  transactions = get_transactions_from_user()\n",
        "  valid_transactions = filter_valid_transactions(transactions)\n",
        "  print(\"Valid Transactions:\")\n",
        "  for transaction in valid_transactions:\n",
        "    print(transaction)\n",
        "\n",
        "    # example input\n",
        "    #transactions = [\n",
        "        #{'transaction_id': 1, 'customer_id': 101, 'amount': 50},\n",
        "        #{'transaction_id': 2, 'customer_id': 102, 'amount': -10},\n",
        "        #{'transaction_id': 2, 'customer_id': 102, 'amount': -10},\n",
        "        #{'transaction_id': 2, 'customer_id': 102, 'amount': -10},\n",
        "        #{'transaction_id': 3, 'customer_id': 103, 'amount': 100},\n",
        "        #{'transaction_id': 4, 'customer_id': None, 'amount': 0},\n",
        "        #]\n",
        "\n",
        "    #test the function\n",
        "    #valid_transactions = filter_valid_transactions(transactions)\n",
        "    #print(valid_transactions)\n"
      ],
      "metadata": {
        "id": "dCVS3VFIJ5Tc"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def filter_valid_transactions(transactions):\n",
        "    valid_transactions = []\n",
        "    for transaction in transactions:\n",
        "        if transaction['transaction_id'] is not None and transaction['customer_id'] is not None and transaction['amount'] > 0:\n",
        "            valid_transactions.append(transaction)\n",
        "    return valid_transactions\n",
        "\n",
        "def get_transactions_from_user():\n",
        "    transactions = []\n",
        "    while True:\n",
        "        transaction_id = input(\"Enter transaction ID (or 'done' to finish): \")\n",
        "        if transaction_id.lower() == 'done':\n",
        "            break\n",
        "        try:\n",
        "            transaction_id = int(transaction_id)\n",
        "            customer_id = int(input(\"Enter customer ID: \"))\n",
        "            amount = float(input(\"Enter amount: \"))\n",
        "            transactions.append({'transaction_id': transaction_id, 'customer_id': customer_id, 'amount': amount})\n",
        "        except ValueError:\n",
        "            print(\"Invalid input. Please enter numbers for transaction ID, customer ID, and amount.\")\n",
        "    return transactions\n",
        "\n",
        "transactions = get_transactions_from_user()\n",
        "valid_transactions = filter_valid_transactions(transactions)\n",
        "print(\"Valid transactions:\")\n",
        "print(valid_transactions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EuMlDj-NOhEm",
        "outputId": "e036a650-558e-4906-9da3-5b675b3ab019"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter transaction ID (or 'done' to finish): 1\n",
            "Enter customer ID: 2313\n",
            "Enter amount: 3213\n",
            "Enter transaction ID (or 'done' to finish): 2\n",
            "Enter customer ID: \n",
            "Invalid input. Please enter numbers for transaction ID, customer ID, and amount.\n",
            "Enter transaction ID (or 'done' to finish): 3\n",
            "Enter customer ID: 3\n",
            "Enter amount: -1\n",
            "Enter transaction ID (or 'done' to finish): 1\n",
            "Enter customer ID: 21\n",
            "Enter amount: -90\n",
            "Enter transaction ID (or 'done' to finish): 7\n",
            "Enter customer ID: \n",
            "Invalid input. Please enter numbers for transaction ID, customer ID, and amount.\n",
            "Enter transaction ID (or 'done' to finish): 6\n",
            "Enter customer ID: 6547\n",
            "Enter amount: 457\n",
            "Enter transaction ID (or 'done' to finish): 6\n",
            "Enter customer ID: 4657\n",
            "Enter amount: 0\n",
            "Enter transaction ID (or 'done' to finish): 579\n",
            "Enter customer ID: \n",
            "Invalid input. Please enter numbers for transaction ID, customer ID, and amount.\n",
            "Enter transaction ID (or 'done' to finish): 5678\n",
            "Enter customer ID: 5678\n",
            "Enter amount: 578\n",
            "Enter transaction ID (or 'done' to finish): done\n",
            "Valid transactions:\n",
            "[{'transaction_id': 1, 'customer_id': 2313, 'amount': 3213.0}, {'transaction_id': 6, 'customer_id': 6547, 'amount': 457.0}, {'transaction_id': 5678, 'customer_id': 5678, 'amount': 578.0}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bueno mi conclusión: no estoy completamente contento/satisfecho. No funciona como quiero ni hace lo que quiero pero la verdad es que si hace lo que se necesita y fin. Si fuera por mí hubiera hecho el programa más amigable al estilo de pedirle al user que inputee cuantas va a querer, que las suba de tal manera, y que después de procesar y filtrarlas todas le devuelva diciendo acá están las filtradas y acá están las que no. Todo más amigable. Pero la verdad que ahora es un programa que filtra, almacena y fin, no le pidas nada de usabilidad o no. Pero la verdad es que los tests de Codility son así, no te piden que armes el input del usuario o la printeada o nada, sólo que el programa filtre o analice X y fin. Y esto lo hace. La cagada es que yo no puedo testearlo acá cómodamente nomás jajaj pero bue. Pierdo más tiempo armando interfaz que el programa ajjajj."
      ],
      "metadata": {
        "id": "O8y3PSZrO7Gp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem 3: Identify Duplicate Transactions\n",
        "\n",
        "###Problem Statement\n",
        "\n",
        "You are given a list of transactions represented as tuples:\n",
        "(transaction_id, amount, date)\n",
        "Write a Python function to identify and return a list of duplicate transactions that have the same amount and date."
      ],
      "metadata": {
        "id": "r5J9lZYWQa0j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def find_duplicates(transactions):\n",
        "  transaction_map = {}\n",
        "\n",
        "  for transaction_id, amount, date in transactions:\n",
        "    key = (float(amount), date)\n",
        "    if key not in transaction_map:\n",
        "      transaction_map[key] = []\n",
        "    transaction_map[key].append(transaction_id)\n",
        "\n",
        "  print(\"duplicate transaction: \", duplicates)\n",
        "\n",
        "  duplicates = []\n",
        "  for key, transaction_ids in transaction_map.items():\n",
        "    if len(transaction_ids) > 1:\n",
        "      for tid in transaction_ids:\n",
        "        duplicates.append((tid, key[0], key[1]))\n",
        "\n",
        "  return duplicates\n",
        "\n",
        "  transactions = [\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "  ]\n",
        "\n",
        "  print(\"hello\")\n",
        "  duplicates = find_duplicates(transactions)\n",
        "  print(\"duplicate transaction: \", duplicates)"
      ],
      "metadata": {
        "id": "W0yC-sUfO80T"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def find_duplicates(transactions):\n",
        "  transaction_map = {}\n",
        "\n",
        "  for transaction_id, amount, date in transactions:\n",
        "    key = (float(amount), date)\n",
        "    if key not in transaction_map:\n",
        "      transaction_map[key] = []\n",
        "    transaction_map[key].append(transaction_id)\n",
        "\n",
        "  print(\"duplicate transaction: \", duplicates)\n",
        "\n",
        "  duplicates = []\n",
        "  for key, transaction_ids in transaction_map.items():\n",
        "    if len(transaction_ids) > 1:\n",
        "      for tid in transaction_ids:\n",
        "        duplicates.append((tid, key[0], key[1]))\n",
        "\n",
        "  return duplicates\n",
        "\n",
        "transactions = [\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "      (106, 150.0,'2024-06-11'),\n",
        "  ]\n",
        "\n",
        "\n",
        "duplicates = find_duplicates(transactions)\n",
        "print(\"duplicate transaction: \", duplicates)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "6jLbZScAqqpK",
        "outputId": "e2223b90-5278-4722-ef39-aecba744d803"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "error",
          "ename": "UnboundLocalError",
          "evalue": "local variable 'duplicates' referenced before assignment",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-45-e2b3a2345881>\u001b[0m in \u001b[0;36m<cell line: 30>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0mduplicates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfind_duplicates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtransactions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     31\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"duplicate transaction: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mduplicates\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-45-e2b3a2345881>\u001b[0m in \u001b[0;36mfind_duplicates\u001b[0;34m(transactions)\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mtransaction_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtransaction_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"duplicate transaction: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mduplicates\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m   \u001b[0mduplicates\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'duplicates' referenced before assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Genuinamente me rindo, no logré entender."
      ],
      "metadata": {
        "id": "DphkB7AwrMfv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem 4: Missing Payments in a Sequential List\n",
        "\n",
        "### Problem Statement\n",
        "You have two lists:\n",
        "\t1.\texpected_ids: A list of sequential transaction IDs (e.g., [1, 2, 3, ..., N]), representing all expected transaction IDs.\n",
        "\t2.\tcompleted_ids: A list of transaction IDs that have been completed.\n",
        "\n",
        "Write a Python function to identify the missing transaction IDs."
      ],
      "metadata": {
        "id": "oa5UlEgOrPyA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def find_missing_transactions(expected_ids, completed_ids):\n",
        "    # Convert completed_ids to a set for fast lookups\n",
        "    completed_set = set(completed_ids)\n",
        "\n",
        "    # Find missing transaction IDs\n",
        "    missing_ids = [tid for tid in expected_ids if tid not in completed_set]\n",
        "\n",
        "    return missing_ids\n",
        "\n",
        "# Example Input\n",
        "expected_ids = [1, 2, 3, 4, 5, 6, 7]\n",
        "completed_ids = [1, 3, 4, 6, 7]\n",
        "\n",
        "# Test the function\n",
        "missing_transactions = find_missing_transactions(expected_ids, completed_ids)\n",
        "print(\"Missing Transaction IDs:\", missing_transactions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1xcNeDlCrMVu",
        "outputId": "73bac94d-ac6d-4a32-bdb9-f22e14d850d0"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Missing Transaction IDs: [2, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "expected_ids = [1, 2, 3, 4, 5, 6, 7]\n",
        "completed_ids = [1, 3, 4, 6, 7]"
      ],
      "metadata": {
        "id": "AkC7SwE3rvQP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "completed_set = {1, 3, 4, 6, 7}"
      ],
      "metadata": {
        "id": "4NTqTSfJrzDS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Missing Transaction IDs: [2, 5]"
      ],
      "metadata": {
        "id": "2GbtrvVfr123"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# All Transactions Completed\n",
        "print(find_missing_transactions([1, 2, 3], [1, 2, 3]))  # Output: []\n",
        "\n",
        "# All Transactions Missing\n",
        "print(find_missing_transactions([1, 2, 3], []))  # Output: [1, 2, 3]\n",
        "\n",
        "# Empty Expected List\n",
        "print(find_missing_transactions([], [1, 2, 3]))  # Output: []\n",
        "\n",
        "# Non-Sequential Input\n",
        "print(find_missing_transactions([1, 2, 4, 5], [1, 4]))  # Output: [2, 5]"
      ],
      "metadata": {
        "id": "lnd0dl63r3XI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem 5: Fraud Detection for Repeated Customers\n",
        "\n",
        "### Problem Statement\n",
        "\n",
        "You are given a list of transactions represented as (customer_id, transaction_time) tuples. A transaction is suspicious if a customer makes multiple transactions within a 1-minute window.\n",
        "\n",
        "Write a Python function to identify customers who made multiple transactions within a 1-minute window."
      ],
      "metadata": {
        "id": "6vwII0aornFl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime\n",
        "\n",
        "def detect_fraudulent_customers(transactions):\n",
        "    # Step 1: Group transactions by customer_id\n",
        "    customer_transactions = {}\n",
        "    for customer_id, transaction_time in transactions:\n",
        "        if customer_id not in customer_transactions:\n",
        "            customer_transactions[customer_id] = []\n",
        "        customer_transactions[customer_id].append(transaction_time)\n",
        "\n",
        "    # Step 2: Identify customers with transactions within 1 minute\n",
        "    suspicious_customers = set()\n",
        "\n",
        "    for customer_id, times in customer_transactions.items():\n",
        "        # Convert string times to datetime and sort\n",
        "        times = sorted([datetime.strptime(t, \"%Y-%m-%d %H:%M:%S\") for t in times])\n",
        "\n",
        "        # Check for consecutive transactions within 1 minute\n",
        "        for i in range(1, len(times)):\n",
        "            if (times[i] - times[i - 1]).total_seconds() <= 60:\n",
        "                suspicious_customers.add(customer_id)\n",
        "                break  # No need to check further for this customer\n",
        "\n",
        "    return list(suspicious_customers)\n",
        "\n",
        "# Example Input\n",
        "transactions = [\n",
        "    (101, \"2024-06-10 10:00:00\"),\n",
        "    (101, \"2024-06-10 10:00:30\"),\n",
        "    (102, \"2024-06-10 10:01:00\"),\n",
        "    (101, \"2024-06-10 10:05:00\"),\n",
        "    (103, \"2024-06-10 10:10:00\"),\n",
        "    (103, \"2024-06-10 10:11:30\")\n",
        "]\n",
        "\n",
        "# Test the function\n",
        "suspicious = detect_fraudulent_customers(transactions)\n",
        "print(\"Suspicious Customers:\", suspicious)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EFgZ4J3drML2",
        "outputId": "b3be0550-45bc-4d05-a14c-6a0f287581bf"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Suspicious Customers: [101]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# No Suspicious Transactions\n",
        "print(detect_fraudulent_customers([\n",
        "    (101, \"2024-06-10 10:00:00\"),\n",
        "    (101, \"2024-06-10 10:02:00\"),\n",
        "    (102, \"2024-06-10 10:05:00\")\n",
        "]))  # Output: []\n",
        "\n",
        "# Multiple Suspicious Customers\n",
        "print(detect_fraudulent_customers([\n",
        "    (101, \"2024-06-10 10:00:00\"),\n",
        "    (101, \"2024-06-10 10:00:30\"),\n",
        "    (102, \"2024-06-10 11:00:00\"),\n",
        "    (102, \"2024-06-10 11:00:50\")\n",
        "]))  # Output: [101, 102]\n",
        "\n",
        "# Single Transaction per Customer\n",
        "print(detect_fraudulent_customers([\n",
        "    (101, \"2024-06-10 10:00:00\"),\n",
        "    (102, \"2024-06-10 10:01:00\")\n",
        "]))  # Output: []\n",
        "\n",
        "# Empty Input\n",
        "print(detect_fraudulent_customers([]))  # Output: []"
      ],
      "metadata": {
        "id": "BDW5VjTIsLNq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem 7: Weekly Average Revenue\n",
        "\n",
        "### Problem Statement\n",
        "\n",
        "You are provided with a list of daily revenues for a merchant, represented as a list of dictionaries with the following format:\n",
        "\n",
        "[\n",
        "    {\"date\": \"YYYY-MM-DD\", \"revenue\": amount},\n",
        "    ...\n",
        "]\n",
        "\n",
        "Write a Python function that calculates the rolling 7-day average revenue for each day, starting from the 7th day. For dates where there are fewer than 7 days of data, no rolling average is calculated."
      ],
      "metadata": {
        "id": "tPHA9N35sQPt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime, timedelta\n",
        "\n",
        "def calculate_rolling_7day_average(daily_revenues):\n",
        "    # Step 1: Sort the data by date\n",
        "    daily_revenues.sort(key=lambda x: datetime.strptime(x[\"date\"], \"%Y-%m-%d\"))\n",
        "\n",
        "    # Step 2: Initialize variables\n",
        "    rolling_average = []\n",
        "    window = []  # Sliding window to hold revenues of the last 7 days\n",
        "\n",
        "    # Step 3: Calculate rolling average\n",
        "    for i, record in enumerate(daily_revenues):\n",
        "        window.append(record[\"revenue\"])\n",
        "\n",
        "        # Ensure the window size is at most 7\n",
        "        if len(window) > 7:\n",
        "            window.pop(0)\n",
        "\n",
        "        # Calculate average only when we have 7 days of data\n",
        "        if len(window) == 7:\n",
        "            avg = sum(window) / 7\n",
        "            rolling_average.append({\"date\": record[\"date\"], \"7_day_avg\": round(avg, 2)})\n",
        "\n",
        "    return rolling_average\n",
        "\n",
        "# Example Input\n",
        "daily_revenues = [\n",
        "    {\"date\": \"2024-06-01\", \"revenue\": 100},\n",
        "    {\"date\": \"2024-06-02\", \"revenue\": 200},\n",
        "    {\"date\": \"2024-06-03\", \"revenue\": 300},\n",
        "    {\"date\": \"2024-06-04\", \"revenue\": 400},\n",
        "    {\"date\": \"2024-06-05\", \"revenue\": 500},\n",
        "    {\"date\": \"2024-06-06\", \"revenue\": 600},\n",
        "    {\"date\": \"2024-06-07\", \"revenue\": 700},\n",
        "    {\"date\": \"2024-06-08\", \"revenue\": 800},\n",
        "    {\"date\": \"2024-06-09\", \"revenue\": 900}\n",
        "]\n",
        "\n",
        "# Test the function\n",
        "rolling_avg = calculate_rolling_7day_average(daily_revenues)\n",
        "print(\"Rolling 7-Day Average Revenue:\")\n",
        "for entry in rolling_avg:\n",
        "    print(entry)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dvYC9KaKsdEs",
        "outputId": "6ab232a7-e6a7-4058-fc8f-0f81e576c010"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rolling 7-Day Average Revenue:\n",
            "{'date': '2024-06-07', '7_day_avg': 400.0}\n",
            "{'date': '2024-06-08', '7_day_avg': 500.0}\n",
            "{'date': '2024-06-09', '7_day_avg': 600.0}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fewer than 7 Days\n",
        "print(calculate_rolling_7day_average([\n",
        "    {\"date\": \"2024-06-01\", \"revenue\": 100},\n",
        "    {\"date\": \"2024-06-02\", \"revenue\": 200}\n",
        "]))  # Output: []\n",
        "\n",
        "# Exact 7 Days\n",
        "print(calculate_rolling_7day_average([\n",
        "    {\"date\": \"2024-06-01\", \"revenue\": 100},\n",
        "    {\"date\": \"2024-06-02\", \"revenue\": 200},\n",
        "    {\"date\": \"2024-06-03\", \"revenue\": 300},\n",
        "    {\"date\": \"2024-06-04\", \"revenue\": 400},\n",
        "    {\"date\": \"2024-06-05\", \"revenue\": 500},\n",
        "    {\"date\": \"2024-06-06\", \"revenue\": 600},\n",
        "    {\"date\": \"2024-06-07\", \"revenue\": 700}\n",
        "]))  # Output: [{'date': '2024-06-07', '7_day_avg': 400.0}]"
      ],
      "metadata": {
        "id": "jK4HiAyrspO9"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}