RingStackPupLinkedListDemo.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOFVu6hDQGkxhsjk0qrgVGp",
      "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/walkerjian/dev/blob/main/RingStackPupLinkedListDemo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Implementing push and pop as functions that do not use side effect"
      ],
      "metadata": {
        "id": "OAcDYqJlEe3l"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Certainly! When you want to implement `Push` and `Pop` as functions without side effects in Pascal, it means these functions will return a new modified stack instead of changing the original stack in place. This approach leans towards functional programming, where data is immutable and functions return new versions of data instead of modifying them in place.\n",
        "\n",
        "Here's how you can implement `Push` and `Pop` as functions that avoid side effects:\n",
        "\n",
        "```pascal\n",
        "function Push(s: TStack; c: Char): TStack;\n",
        "begin\n",
        "    if s.top < MaxSize then\n",
        "    begin\n",
        "        Inc(s.top);\n",
        "        s.arr[s.top] := c;\n",
        "    end;\n",
        "    Result := s;\n",
        "end;\n",
        "\n",
        "function Pop(s: TStack; var poppedChar: Char): TStack;\n",
        "begin\n",
        "    if not IsEmpty(s) then\n",
        "    begin\n",
        "        poppedChar := s.arr[s.top];\n",
        "        Dec(s.top);\n",
        "    end\n",
        "    else\n",
        "        poppedChar := #0;  // Null character\n",
        "    Result := s;\n",
        "end;\n",
        "```\n",
        "\n",
        "Usage:\n",
        "\n",
        "```pascal\n",
        "var\n",
        "    s: TStack;\n",
        "    c: Char;\n",
        "begin\n",
        "    s := Push(s, 'A');\n",
        "    s := Pop(s, c);\n",
        "    WriteLn(c);  // Outputs: A\n",
        "end.\n",
        "```\n",
        "\n",
        "Changes made:\n",
        "\n",
        "1. **Push**: The `Push` function now takes a stack and a character, and it returns a new modified stack. This means you'd use the result of the `Push` function to continue your operations.\n",
        "2. **Pop**: The `Pop` function now also returns a modified stack. However, since we also need to know which character was popped, an additional `poppedChar` variable (passed by reference) is used to store the popped character.\n",
        "\n",
        "This approach ensures that the original stack is not modified inside the functions, adhering to the idea of avoiding side effects."
      ],
      "metadata": {
        "id": "pVvRkuCDCvVK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### When using var you are really just using a pointer as a reference, hence call by reference. Is there a way you could explicitly use pointers to do the same, and not have the overhead of immutable objects"
      ],
      "metadata": {
        "id": "MRsAnSScEy4T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Yes, in Pascal, you can use pointers explicitly to achieve call-by-reference behavior without the overhead of creating new objects. Using pointers allows us to directly manipulate the data in memory, leading to efficient operations without the need for copying or creating new data structures.\n",
        "\n",
        "Here's how you can implement `Push` and `Pop` using pointers:\n",
        "\n",
        "1. **Data Structure**:\n",
        "   \n",
        "   - Define a pointer to the `TStack` type.\n",
        "\n",
        "```pascal\n",
        "type\n",
        "    PStack = ^TStack;\n",
        "```\n",
        "\n",
        "2. **Push and Pop Functions**:\n",
        "\n",
        "```pascal\n",
        "procedure Push(s: PStack; c: Char);\n",
        "begin\n",
        "    if s^.top < MaxSize then\n",
        "    begin\n",
        "        Inc(s^.top);\n",
        "        s^.arr[s^.top] := c;\n",
        "    end;\n",
        "end;\n",
        "\n",
        "function Pop(s: PStack): Char;\n",
        "begin\n",
        "    if not IsEmpty(s^) then\n",
        "    begin\n",
        "        Result := s^.arr[s^.top];\n",
        "        Dec(s^.top);\n",
        "    end\n",
        "    else\n",
        "        Result := #0;  // Null character\n",
        "end;\n",
        "```\n",
        "\n",
        "3. **Usage**:\n",
        "\n",
        "```pascal\n",
        "var\n",
        "    s: TStack;\n",
        "    sp: PStack;\n",
        "    c: Char;\n",
        "begin\n",
        "    sp := @s;  // get the address of s\n",
        "    Push(sp, 'A');\n",
        "    c := Pop(sp);\n",
        "    WriteLn(c);  // Outputs: A\n",
        "end.\n",
        "```\n",
        "\n",
        "With this approach:\n",
        "\n",
        "- The `Push` procedure and the `Pop` function directly operate on the memory address of the stack.\n",
        "- The `sp` variable is a pointer to a `TStack`, so when you pass it to the functions, you're passing the memory address of the original stack `s`.\n",
        "- The `^` operator is used to dereference the pointer and access the actual `TStack` record.\n",
        "  \n",
        "This allows us to work directly with the memory of the original stack without creating new copies, achieving efficiency and adhering to the idea of call-by-reference using explicit pointers."
      ],
      "metadata": {
        "id": "o0Xj-X41C9mK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Can you think of an idiom to use push as a function too"
      ],
      "metadata": {
        "id": "ofJedq2cE7Oq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Certainly! If we want to maintain the function format for `Push` and still avoid the overhead of copying, we can use a combination of pointers and functions. The idea is to return a pointer to the modified stack, which allows us to achieve both the functional idiom and efficiency.\n",
        "\n",
        "Here's how you can implement this:\n",
        "\n",
        "1. **Data Structure**:\n",
        "   \n",
        "   - As before, define a pointer to the `TStack` type.\n",
        "\n",
        "```pascal\n",
        "type\n",
        "    PStack = ^TStack;\n",
        "```\n",
        "\n",
        "2. **Push Function**:\n",
        "\n",
        "```pascal\n",
        "function Push(s: PStack; c: Char): PStack;\n",
        "begin\n",
        "    if s^.top < MaxSize then\n",
        "    begin\n",
        "        Inc(s^.top);\n",
        "        s^.arr[s^.top] := c;\n",
        "    end;\n",
        "    Result := s;  // Return the pointer to the modified stack\n",
        "end;\n",
        "```\n",
        "\n",
        "3. **Usage**:\n",
        "\n",
        "```pascal\n",
        "var\n",
        "    s: TStack;\n",
        "    sp, newSp: PStack;\n",
        "    c: Char;\n",
        "begin\n",
        "    sp := @s;  // get the address of s\n",
        "    newSp := Push(sp, 'A');\n",
        "    c := Pop(newSp);\n",
        "    WriteLn(c);  // Outputs: A\n",
        "end.\n",
        "```\n",
        "\n",
        "In this approach:\n",
        "\n",
        "- The `Push` function takes a pointer to a stack and a character. After modifying the stack, it returns the pointer to the modified stack. This allows us to chain operations if desired.\n",
        "- The `Pop` function remains unchanged, directly operating on the memory address of the stack.\n",
        "  \n",
        "This idiom allows us to achieve a functional style with `Push` while still avoiding the overhead of copying data structures, thanks to the use of pointers."
      ],
      "metadata": {
        "id": "Fyt1Ko0sDOqV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pup\n",
        "so now it is possible to create a function that does both push and pop - call it pup please"
      ],
      "metadata": {
        "id": "L1zk5fymDVVb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Certainly! The function `Pup` can take a pointer to a stack, a character to push, and then pop a character from the updated stack, effectively combining the operations of `Push` and `Pop`.\n",
        "\n",
        "Here's how you can implement the `Pup` function:\n",
        "\n",
        "```pascal\n",
        "function Pup(s: PStack; c: Char): Char;\n",
        "begin\n",
        "    s := Push(s, c);  // Push the character onto the stack\n",
        "    Result := Pop(s);  // Pop a character from the updated stack\n",
        "end;\n",
        "```\n",
        "\n",
        "**Usage**:\n",
        "\n",
        "```pascal\n",
        "var\n",
        "    s: TStack;\n",
        "    sp: PStack;\n",
        "    poppedChar: Char;\n",
        "begin\n",
        "    sp := @s;  // get the address of s\n",
        "    poppedChar := Pup(sp, 'A');\n",
        "    WriteLn(poppedChar);  // Outputs: A\n",
        "end.\n",
        "```\n",
        "\n",
        "In this approach:\n",
        "\n",
        "- The `Pup` function pushes the provided character onto the stack and then immediately pops a character from the stack, returning the popped character.\n",
        "  \n",
        "The `Pup` function provides a concise way to combine the `Push` and `Pop` operations into a single action."
      ],
      "metadata": {
        "id": "zDuzU6kqDa4n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ring-based Stack with `Pup` using Doubly-Linked List"
      ],
      "metadata": {
        "id": "V5yACf7bFT5z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Got it. Let's implement a ring-based stack using a doubly-linked list and only the `Pup` function. The doubly-linked list will allow for efficient wrap-around behavior.\n",
        "\n",
        "\n",
        "\n",
        "```pascal\n",
        "program RingStackPupLinkedListDemo;\n",
        "\n",
        "type\n",
        "    PNode = ^TNode;\n",
        "    TNode = record\n",
        "        data: Char;\n",
        "        prev, next: PNode;\n",
        "    end;\n",
        "\n",
        "    PRingStack = ^TRingStack;\n",
        "    TRingStack = record\n",
        "        head, tail: PNode;\n",
        "        size, capacity: Integer;\n",
        "    end;\n",
        "\n",
        "procedure InitializeStack(var s: PRingStack; cap: Integer);\n",
        "begin\n",
        "    New(s);\n",
        "    s^.head := nil;\n",
        "    s^.tail := nil;\n",
        "    s^.size := 0;\n",
        "    s^.capacity := cap;\n",
        "end;\n",
        "\n",
        "function Pup(s: PRingStack; c: Char): Char;\n",
        "var\n",
        "    newNode, temp: PNode;\n",
        "begin\n",
        "    // Create new node\n",
        "    New(newNode);\n",
        "    newNode^.data := c;\n",
        "    newNode^.prev := nil;\n",
        "    newNode^.next := nil;\n",
        "\n",
        "    // If stack is full, pop the tail (last node)\n",
        "    if s^.size = s^.capacity then\n",
        "    begin\n",
        "        Result := s^.tail^.data;  // Return the data of the node to be removed\n",
        "        temp := s^.tail;\n",
        "        s^.tail := s^.tail^.prev;\n",
        "        if s^.tail <> nil then\n",
        "            s^.tail^.next := nil;\n",
        "        Dispose(temp);\n",
        "        Dec(s^.size);\n",
        "    end\n",
        "    else\n",
        "        Result := #0;  // No character is removed\n",
        "\n",
        "    // Push new node to the head of the list\n",
        "    newNode^.next := s^.head;\n",
        "    if s^.head <> nil then\n",
        "        s^.head^.prev := newNode;\n",
        "    s^.head := newNode;\n",
        "    if s^.tail = nil then\n",
        "        s^.tail := newNode;\n",
        "    Inc(s^.size);\n",
        "end;\n",
        "\n",
        "var\n",
        "    stack: PRingStack;\n",
        "    i: Integer;\n",
        "    poppedChar, c: Char;\n",
        "begin\n",
        "    InitializeStack(stack, 10);  // Capacity set to 10\n",
        "\n",
        "    WriteLn('Demonstrating Pup function with a ring-based stack using linked list:');\n",
        "    WriteLn('--------------------------------------------------------------------');\n",
        "\n",
        "    // Use Pup function\n",
        "    for i := 1 to 12 do  // More than capacity to demonstrate wrapping\n",
        "    begin\n",
        "        c := Chr(64 + i);  // Convert numbers to uppercase letters: A, B, C, ...\n",
        "        poppedChar := Pup(stack, c);\n",
        "        WriteLn('Pushed: ', c, ', Popped: ', poppedChar);\n",
        "    end;\n",
        "end.\n",
        "```\n",
        "\n",
        "**Documentation**:\n",
        "\n",
        "- The program demonstrates a ring-based stack using a doubly-linked list and only the `Pup` function.\n",
        "- Each node in the linked list has data, a previous pointer, and a next pointer.\n",
        "- The `Pup` function:\n",
        "  - If the stack is full, pops the tail node.\n",
        "  - Pushes a new node to the head of the list.\n",
        "- The main program demonstrates the `Pup` function's behavior with a stack that wraps around when reaching its capacity."
      ],
      "metadata": {
        "id": "SgcQ2-m2Dibc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Implementing a Ring-based Stack with `Pup` using Doubly-Linked List:"
      ],
      "metadata": {
        "id": "J6AB2mu4FdCs"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3cwPG88b7jsE",
        "outputId": "1fe83bfb-68cf-4d3e-aed4-9c81804a74f8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting RingStackPupLinkedListDemo.pas\n"
          ]
        }
      ],
      "source": [
        "%%writefile RingStackPupLinkedListDemo.pas\n",
        "program RingStackPupLinkedListDemo;\n",
        "\n",
        "type\n",
        "    PNode = ^TNode;\n",
        "    TNode = record\n",
        "        data: Char;\n",
        "        prev, next: PNode;\n",
        "    end;\n",
        "\n",
        "    PRingStack = ^TRingStack;\n",
        "    TRingStack = record\n",
        "        head, tail: PNode;\n",
        "        size, capacity: Integer;\n",
        "    end;\n",
        "\n",
        "procedure InitializeStack(var s: PRingStack; cap: Integer);\n",
        "begin\n",
        "    New(s);\n",
        "    s^.head := nil;\n",
        "    s^.tail := nil;\n",
        "    s^.size := 0;\n",
        "    s^.capacity := cap;\n",
        "end;\n",
        "\n",
        "function Pup(s: PRingStack; c: Char): Char;\n",
        "var\n",
        "    newNode, temp: PNode;\n",
        "begin\n",
        "    if c = #0 then\n",
        "    begin\n",
        "        if s^.size > 0 then\n",
        "        begin\n",
        "            Pup := s^.head^.data;\n",
        "            temp := s^.head;\n",
        "            s^.head := s^.head^.next;\n",
        "            if s^.head <> nil then\n",
        "                s^.head^.prev := nil;\n",
        "            Dispose(temp);\n",
        "            Dec(s^.size);\n",
        "            if s^.size = 0 then\n",
        "                s^.tail := nil;\n",
        "            Exit;\n",
        "        end\n",
        "        else\n",
        "        begin\n",
        "            Exit(#0);  // Return null if stack is empty\n",
        "        end;\n",
        "    end;\n",
        "\n",
        "    New(newNode);\n",
        "    newNode^.data := c;\n",
        "    newNode^.prev := nil;\n",
        "    newNode^.next := nil;\n",
        "    newNode^.next := s^.head;\n",
        "    if s^.head <> nil then\n",
        "        s^.head^.prev := newNode;\n",
        "    s^.head := newNode;\n",
        "    if s^.tail = nil then\n",
        "        s^.tail := newNode;\n",
        "    Inc(s^.size);\n",
        "    if s^.size > s^.capacity then\n",
        "    begin\n",
        "        temp := s^.tail;\n",
        "        s^.tail := s^.tail^.prev;\n",
        "        if s^.tail <> nil then\n",
        "            s^.tail^.next := nil;\n",
        "        Dispose(temp);\n",
        "        Dec(s^.size);\n",
        "    end;\n",
        "    Pup := #0;  // Default return when pushing\n",
        "end;\n",
        "\n",
        "\n",
        "procedure TestSuite;\n",
        "var\n",
        "    stack: PRingStack;\n",
        "    i: Integer;\n",
        "    poppedChar, c: Char;\n",
        "begin\n",
        "    InitializeStack(stack, 10);\n",
        "\n",
        "    WriteLn('Basic Pup Operations:');\n",
        "    WriteLn('--------------------');\n",
        "    for i := 1 to 12 do\n",
        "    begin\n",
        "        c := Chr(64 + i);\n",
        "        poppedChar := Pup(stack, c);\n",
        "        WriteLn('Pushed: ', c, ', Popped: ', poppedChar);\n",
        "    end;\n",
        "    WriteLn;\n",
        "\n",
        "    WriteLn('Overflow Test:');\n",
        "    WriteLn('--------------');\n",
        "    for i := 1 to stack^.capacity + 5 do\n",
        "    begin\n",
        "        c := Chr(74 + i);\n",
        "        poppedChar := Pup(stack, c);\n",
        "        WriteLn('Pushed: ', c, ', Popped: ', poppedChar);\n",
        "    end;\n",
        "    WriteLn;\n",
        "\n",
        "    WriteLn('Underflow Test:');\n",
        "    WriteLn('---------------');\n",
        "    while stack^.size > 0 do\n",
        "    begin\n",
        "        poppedChar := Pup(stack, #0);\n",
        "    end;\n",
        "    poppedChar := Pup(stack, 'Z');\n",
        "    WriteLn('Pushed: Z, Popped: ', poppedChar);\n",
        "    WriteLn;\n",
        "\n",
        "    WriteLn('Mixed Operations Test:');\n",
        "    WriteLn('----------------------');\n",
        "    for i := 1 to 5 do\n",
        "    begin\n",
        "        c := Chr(84 + i);\n",
        "        poppedChar := Pup(stack, c);\n",
        "        WriteLn('Pushed: ', c, ', Popped: ', poppedChar);\n",
        "    end;\n",
        "    poppedChar := Pup(stack, 'Y');\n",
        "    WriteLn('Pushed: Y, Popped: ', poppedChar);\n",
        "    poppedChar := Pup(stack, 'Z');\n",
        "    WriteLn('Pushed: Z, Popped: ', poppedChar);\n",
        "    poppedChar := Pup(stack, 'A');\n",
        "    WriteLn('Pushed: A, Popped: ', poppedChar);\n",
        "    WriteLn;\n",
        "end;\n",
        "procedure RecognizableTest;\n",
        "var\n",
        "    stack: PRingStack;\n",
        "    sentence: string;\n",
        "    i: Integer;\n",
        "    poppedChar: Char;\n",
        "begin\n",
        "    WriteLn('Recognizable Test:');\n",
        "    WriteLn('------------------');\n",
        "    sentence := 'The quick brown fox jumped over the lazy dog';\n",
        "\n",
        "    InitializeStack(stack, 100);\n",
        "\n",
        "    for i := 1 to Length(sentence) do\n",
        "    begin\n",
        "        poppedChar := Pup(stack, sentence[i]);\n",
        "        WriteLn('Pushed: ', sentence[i], ', Popped: ', poppedChar);\n",
        "    end;\n",
        "    WriteLn;\n",
        "\n",
        "    for i := 1 to Length(sentence) do\n",
        "    begin\n",
        "        poppedChar := Pup(stack, #0);\n",
        "        WriteLn('Pushed: ', #0, ', Popped: ', poppedChar);\n",
        "    end;\n",
        "    WriteLn;\n",
        "end;\n",
        "\n",
        "begin\n",
        "    TestSuite;\n",
        "    RecognizableTest;\n",
        "end."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!fpc RingStackPupLinkedListDemo.pas"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vx0cwfGU8NBI",
        "outputId": "307615d9-353c-49e4-ebf7-4bad7806b380"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Free Pascal Compiler version 3.2.2+dfsg-9ubuntu1 [2022/04/11] for x86_64\n",
            "Copyright (c) 1993-2021 by Florian Klaempfl and others\n",
            "Target OS: Linux for x86-64\n",
            "Compiling RingStackPupLinkedListDemo.pas\n",
            "Linking RingStackPupLinkedListDemo\n",
            "159 lines compiled, 0.1 sec\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!./RingStackPupLinkedListDemo"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gof21viT8hwS",
        "outputId": "73b0f22a-f444-41e3-bef2-490172af5f04"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Basic Pup Operations:\n",
            "--------------------\n",
            "Pushed: A, Popped: \u0000\n",
            "Pushed: B, Popped: \u0000\n",
            "Pushed: C, Popped: \u0000\n",
            "Pushed: D, Popped: \u0000\n",
            "Pushed: E, Popped: \u0000\n",
            "Pushed: F, Popped: \u0000\n",
            "Pushed: G, Popped: \u0000\n",
            "Pushed: H, Popped: \u0000\n",
            "Pushed: I, Popped: \u0000\n",
            "Pushed: J, Popped: \u0000\n",
            "Pushed: K, Popped: \u0000\n",
            "Pushed: L, Popped: \u0000\n",
            "\n",
            "Overflow Test:\n",
            "--------------\n",
            "Pushed: K, Popped: \u0000\n",
            "Pushed: L, Popped: \u0000\n",
            "Pushed: M, Popped: \u0000\n",
            "Pushed: N, Popped: \u0000\n",
            "Pushed: O, Popped: \u0000\n",
            "Pushed: P, Popped: \u0000\n",
            "Pushed: Q, Popped: \u0000\n",
            "Pushed: R, Popped: \u0000\n",
            "Pushed: S, Popped: \u0000\n",
            "Pushed: T, Popped: \u0000\n",
            "Pushed: U, Popped: \u0000\n",
            "Pushed: V, Popped: \u0000\n",
            "Pushed: W, Popped: \u0000\n",
            "Pushed: X, Popped: \u0000\n",
            "Pushed: Y, Popped: \u0000\n",
            "\n",
            "Underflow Test:\n",
            "---------------\n",
            "Pushed: Z, Popped: \u0000\n",
            "\n",
            "Mixed Operations Test:\n",
            "----------------------\n",
            "Pushed: U, Popped: \u0000\n",
            "Pushed: V, Popped: \u0000\n",
            "Pushed: W, Popped: \u0000\n",
            "Pushed: X, Popped: \u0000\n",
            "Pushed: Y, Popped: \u0000\n",
            "Pushed: Y, Popped: \u0000\n",
            "Pushed: Z, Popped: \u0000\n",
            "Pushed: A, Popped: \u0000\n",
            "\n",
            "Recognizable Test:\n",
            "------------------\n",
            "Pushed: T, Popped: \u0000\n",
            "Pushed: h, Popped: \u0000\n",
            "Pushed: e, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: q, Popped: \u0000\n",
            "Pushed: u, Popped: \u0000\n",
            "Pushed: i, Popped: \u0000\n",
            "Pushed: c, Popped: \u0000\n",
            "Pushed: k, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: b, Popped: \u0000\n",
            "Pushed: r, Popped: \u0000\n",
            "Pushed: o, Popped: \u0000\n",
            "Pushed: w, Popped: \u0000\n",
            "Pushed: n, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: f, Popped: \u0000\n",
            "Pushed: o, Popped: \u0000\n",
            "Pushed: x, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: j, Popped: \u0000\n",
            "Pushed: u, Popped: \u0000\n",
            "Pushed: m, Popped: \u0000\n",
            "Pushed: p, Popped: \u0000\n",
            "Pushed: e, Popped: \u0000\n",
            "Pushed: d, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: o, Popped: \u0000\n",
            "Pushed: v, Popped: \u0000\n",
            "Pushed: e, Popped: \u0000\n",
            "Pushed: r, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: t, Popped: \u0000\n",
            "Pushed: h, Popped: \u0000\n",
            "Pushed: e, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: l, Popped: \u0000\n",
            "Pushed: a, Popped: \u0000\n",
            "Pushed: z, Popped: \u0000\n",
            "Pushed: y, Popped: \u0000\n",
            "Pushed:  , Popped: \u0000\n",
            "Pushed: d, Popped: \u0000\n",
            "Pushed: o, Popped: \u0000\n",
            "Pushed: g, Popped: \u0000\n",
            "\n",
            "Pushed: \u0000, Popped: g\n",
            "Pushed: \u0000, Popped: o\n",
            "Pushed: \u0000, Popped: d\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: y\n",
            "Pushed: \u0000, Popped: z\n",
            "Pushed: \u0000, Popped: a\n",
            "Pushed: \u0000, Popped: l\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: e\n",
            "Pushed: \u0000, Popped: h\n",
            "Pushed: \u0000, Popped: t\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: r\n",
            "Pushed: \u0000, Popped: e\n",
            "Pushed: \u0000, Popped: v\n",
            "Pushed: \u0000, Popped: o\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: d\n",
            "Pushed: \u0000, Popped: e\n",
            "Pushed: \u0000, Popped: p\n",
            "Pushed: \u0000, Popped: m\n",
            "Pushed: \u0000, Popped: u\n",
            "Pushed: \u0000, Popped: j\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: x\n",
            "Pushed: \u0000, Popped: o\n",
            "Pushed: \u0000, Popped: f\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: n\n",
            "Pushed: \u0000, Popped: w\n",
            "Pushed: \u0000, Popped: o\n",
            "Pushed: \u0000, Popped: r\n",
            "Pushed: \u0000, Popped: b\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: k\n",
            "Pushed: \u0000, Popped: c\n",
            "Pushed: \u0000, Popped: i\n",
            "Pushed: \u0000, Popped: u\n",
            "Pushed: \u0000, Popped: q\n",
            "Pushed: \u0000, Popped:  \n",
            "Pushed: \u0000, Popped: e\n",
            "Pushed: \u0000, Popped: h\n",
            "Pushed: \u0000, Popped: T\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Thank you for sharing the results. Here's what I observe:\n",
        "\n",
        "1. The **Basic Pup Operations** and **Overflow Test** sections work as expected.\n",
        "2. The **Underflow Test** now terminates correctly.\n",
        "3. The **Recognizable Test** showcases the functionality of the `Pup` function. The sentence \"The quick brown fox jumped over the lazy dog\" is pushed onto the stack. As the stack was initially empty, you see `�` (representing `#0`) for every pop during the push operations.\n",
        "4. In the second half of the **Recognizable Test**, we're trying to pop off every character from the stack. The stack is emptied in reverse order, which is expected behavior for a stack. Again, the `�` character represents a push of `#0` onto the stack, which is our signal to pop a character.\n",
        "\n",
        "The results are consistent with the expected behavior of a stack. The characters are pushed onto the stack in the order they appear in the sentence, and they are popped off in the reverse order. The `�` character simply represents our method of signaling a pop operation, and it's the visual representation of a non-printable character (`#0`).\n",
        "\n",
        "If you'd like, we can modify the output to replace `�` with a more user-friendly representation, such as `<empty>` or any other placeholder of your choice. Would you like to proceed with that modification?"
      ],
      "metadata": {
        "id": "gYD0lJDDD8WP"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ykyuX7Oe_Gph"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}