testCaseGenerator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "63fbd677-ff3d-449d-911f-08a2ef70dbad",
   "metadata": {},
   "source": [
    "importing required libraries\n",
    "random to generate random variables\n",
    "os to create files and folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4d20e6b5-0d36-429d-9c6e-c557fd88de73",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random\n",
    "import os\n",
    "import string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "166f93b4-0244-458c-94b8-ac16282c57de",
   "metadata": {},
   "source": [
    "this function will first enter testCasesCount in one line line and then one random integer value and then add it to one line of file and repeat it testCasesCount times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4f799e5e-7238-4790-a800-c857a9a57cee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createInputs(fileHandle, testCasesCount):\n",
    "    fileHandle.write(str(testCasesCount))\n",
    "    fileHandle.write('\\n')\n",
    "    for i in range (testCasesCount):\n",
    "        n = random.randint(0,60)\n",
    "        fileHandle.write(str(n))\n",
    "        fileHandle.write('\\n')\n",
    "        k = random.randint(0,100)\n",
    "        fileHandle.write(str(k))\n",
    "        fileHandle.write('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a1bbc65a-5486-423e-9384-9b654ed33455",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createInputsString(fileHandle, testCasesCount):\n",
    "    fileHandle.write(str(testCasesCount))\n",
    "    fileHandle.write('\\n')\n",
    "    for i in range (testCasesCount):\n",
    "        #length of sring\n",
    "        n = random.randint(0,100)\n",
    "        str1 = ''.join(random.choice(string.ascii_lowercase) for _ in range(n))\n",
    "        str2 = ''.join(random.choice(string.ascii_lowercase) for _ in range(n))\n",
    "        fileHandle.write(str(n))\n",
    "        fileHandle.write('\\n')\n",
    "        fileHandle.write(str1)\n",
    "        fileHandle.write('\\n')\n",
    "        fileHandle.write(str2)\n",
    "        fileHandle.write('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d6d4dc3-c60a-4f66-86f0-55617bf7aee5",
   "metadata": {},
   "source": [
    "this function will first enter testCasesCount in one line then repeat following tasks testCasesCount\n",
    "-->enter size of array in file\n",
    "-->create an array of required size\n",
    "-->enter generated array in the file\n",
    "\n",
    "now you can alter it as per your need, like entering multiple arrays and their size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "35658505-32e8-4f8d-b44a-f28f8bf66246",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createInputsArray(fileHandle, testCasesCount):\n",
    "    fileHandle.write(str(testCasesCount) + \"\\n\")\n",
    "    for _ in range(testCasesCount):\n",
    "        \n",
    "        #randomizing length of array\n",
    "        power = random.randint(0,5)\n",
    "        upperBound = 10**power\n",
    "        arraySize = random.randint(1, 300)\n",
    "\n",
    "        #writing array size in file\n",
    "        fileHandle.write(str(arraySize) + \"\\n\")\n",
    "\n",
    "        #creating array of size array size\n",
    "        array = [random.randint(0,2) for _ in range(arraySize)]\n",
    "\n",
    "        #converting array created to one string\n",
    "        array_str = \" \".join(map(str, array))\n",
    "\n",
    "        #writing this string in file\n",
    "        fileHandle.write(array_str + \"\\n\")\n",
    "\n",
    "        #as per question in consideration adding another line         \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b32bfb1c-67d0-4465-b2e5-eb2381553b4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createInputsMatrix(fileHandle, testCasesCount):\n",
    "    fileHandle.write(str(testCasesCount) + \"\\n\")\n",
    "    for _ in range(testCasesCount):\n",
    "        \n",
    "        #randomizing length of array\n",
    "        power = random.randint(0,5)\n",
    "        upperBound = 10**power\n",
    "        rows = random.randint(1, 100)\n",
    "        columns = random.randint(1,100)\n",
    "        #writing array size in file\n",
    "        fileHandle.write(str(rows) + \" \" + str(columns) + \"\\n\")\n",
    "\n",
    "        #creating array of size array size\n",
    "        array = [[random.randint(0,1) for _ in range(columns)] for i in range (rows)]\n",
    "\n",
    "        #converting array created to one string\n",
    "        matrix_str = '\\n'.join([' '.join(map(str, row)) for row in array])\n",
    "\n",
    "        #writing this string in file\n",
    "        fileHandle.write(matrix_str + \"\\n\")\n",
    "\n",
    "        #as per question in consideration adding another line         \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2979341b-9d76-4855-b571-cd76282d1bbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createOutputsArray(filehandleOutput, fileHandleInput):\n",
    "    testCasesCount = int(fileHandleInput.readline())\n",
    "    for i in range (testCasesCount):\n",
    "        length = int(fileHandleInput.readline())\n",
    "        array = list(map(int, fileHandleInput.readline().strip().split()))\n",
    "        \n",
    "        ans = solve(array)\n",
    "        ans_str  = \" \".join(map(str,ans))\n",
    "        filehandleOutput.write(str(ans_str) + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "01a99436-2680-441e-9c44-9df99b7a9159",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createOutputsMatrix(filehandleOutput, fileHandleInput):\n",
    "    testCasesCount = int(fileHandleInput.readline())\n",
    "    \n",
    "    for i in range (testCasesCount):\n",
    "        rows,columns = map(int, fileHandleInput.readline().split())\n",
    "\n",
    "        #matrix initialization\n",
    "        matrix = []\n",
    "        for _ in range(rows):\n",
    "            row = list(map(int, fileHandleInput.readline().split()))\n",
    "            matrix.append(row)\n",
    "        \n",
    "        ans = solve(matrix)\n",
    "        if ans:\n",
    "            ans_str = 'True'\n",
    "        else:\n",
    "            ans_str = 'False'\n",
    "        filehandleOutput.write(str(ans_str) + \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f3722eb-8c37-4389-a9fd-d2aefdb7735b",
   "metadata": {},
   "source": [
    "createOutputs take two filehandles one in which you have your test cases and one in which you want to store your outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f4f472c4-4eb4-44d6-9b27-aa62dcced788",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createOutputs(fileHandleOutput, fileHandleInput):\n",
    "    testCasesCount = int(fileHandleInput.readline())\n",
    "    for i in range (testCasesCount):\n",
    "        n = fileHandleInput.readline().strip()\n",
    "        k = fileHandleInput.readline().strip()\n",
    "        output = solve(int(n),int(k))\n",
    "        \n",
    "        fileHandleOutput.write(str(output))\n",
    "        fileHandleOutput.write('\\n')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6f4a18d2-74bf-417b-bf8a-0b36d76b7d4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createOutputsString(fileHandleOutput, fileHandleInput):\n",
    "    testCasesCount = int(fileHandleInput.readline())\n",
    "    for i in range (testCasesCount):\n",
    "        n = fileHandleInput.readline().strip()\n",
    "        str1 = fileHandleInput.readline().strip()\n",
    "        str2 = fileHandleInput.readline().strip()\n",
    "        output = solve(n,str1,str2)\n",
    "        \n",
    "        fileHandleOutput.write(output)\n",
    "        fileHandleOutput.write('\\n')\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa2686c8-4497-4ed2-b9b7-6ce973f56dec",
   "metadata": {},
   "source": [
    "solve function is where you define your output logic or solution to the problem you are creating test cases for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f1717407-7b99-49b2-9cfc-b291632696e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\ndef solve(tokens, power):\\n    tokens.sort()\\n    dp = [0] * (power + 1)\\n    \\n    for token in tokens:\\n        for p in range(power, token - 1, -1):\\n            dp[p] = max(dp[p], dp[p - token] + 1)\\n        \\n        for p in range(token, power + 1):\\n            dp[p - token] = max(dp[p - token], dp[p] - 1)\\n    \\n    return dp[0]\\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "def solve(tokens, power):\n",
    "    tokens.sort()\n",
    "    dp = [0] * (power + 1)\n",
    "    \n",
    "    for token in tokens:\n",
    "        for p in range(power, token - 1, -1):\n",
    "            dp[p] = max(dp[p], dp[p - token] + 1)\n",
    "        \n",
    "        for p in range(token, power + 1):\n",
    "            dp[p - token] = max(dp[p - token], dp[p] - 1)\n",
    "    \n",
    "    return dp[0]\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8819edf1-12cd-492d-8bca-5dead47669c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\n#sahil loves bananas solution\\ndef max_elem(arr):\\n    maxi = float('-inf')\\n    for num in arr:\\n        maxi = max(maxi, num)\\n    return maxi\\n\\ndef req_time(piles, h):\\n    time = 0\\n    for pile in piles:\\n        time += math.ceil(pile / h)\\n    return time\\n\\ndef solve(piles, h):\\n    s = 1\\n    e = max_elem(piles)\\n    while s <= e:\\n        mid = s + (e - s) // 2\\n        total_hours = req_time(piles, mid)\\n        if total_hours <= h:\\n            e = mid - 1\\n        else:\\n            s = mid + 1\\n    return s\\n\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "#sahil loves bananas solution\n",
    "def max_elem(arr):\n",
    "    maxi = float('-inf')\n",
    "    for num in arr:\n",
    "        maxi = max(maxi, num)\n",
    "    return maxi\n",
    "\n",
    "def req_time(piles, h):\n",
    "    time = 0\n",
    "    for pile in piles:\n",
    "        time += math.ceil(pile / h)\n",
    "    return time\n",
    "\n",
    "def solve(piles, h):\n",
    "    s = 1\n",
    "    e = max_elem(piles)\n",
    "    while s <= e:\n",
    "        mid = s + (e - s) // 2\n",
    "        total_hours = req_time(piles, mid)\n",
    "        if total_hours <= h:\n",
    "            e = mid - 1\n",
    "        else:\n",
    "            s = mid + 1\n",
    "    return s\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5e258c0d-7f5a-4551-9da7-8b471d134900",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\n#THE ELUSIVE PATTERN “132”\\ndef solve(nums):\\n    stack = []\\n    n = len(nums)\\n    s3 = float('-inf')\\n    for i in range(n - 1, -1, -1):\\n        if nums[i] < s3:\\n            return True\\n        else:\\n            while stack and nums[i] > stack[-1]:\\n                s3 = stack.pop()\\n            stack.append(nums[i])\\n    return False\\n\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "#THE ELUSIVE PATTERN “132”\n",
    "def solve(nums):\n",
    "    stack = []\n",
    "    n = len(nums)\n",
    "    s3 = float('-inf')\n",
    "    for i in range(n - 1, -1, -1):\n",
    "        if nums[i] < s3:\n",
    "            return True\n",
    "        else:\n",
    "            while stack and nums[i] > stack[-1]:\n",
    "                s3 = stack.pop()\n",
    "            stack.append(nums[i])\n",
    "    return False\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "daba5f45-7437-40d2-be2b-46b2bdcafe10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n#sort colors\\ndef solve(nums):\\n    n = len(nums)\\n    l, m, h = 0, 0, n - 1\\n    while m <= h:\\n        if nums[m] == 1:\\n            m += 1\\n        elif nums[m] == 0:\\n            nums[l], nums[m] = nums[m], nums[l]\\n            l += 1\\n            m += 1\\n        else:\\n            nums[m], nums[h] = nums[h], nums[m]\\n            h -= 1\\n    return nums\\n'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "#sort colors\n",
    "def solve(nums):\n",
    "    n = len(nums)\n",
    "    l, m, h = 0, 0, n - 1\n",
    "    while m <= h:\n",
    "        if nums[m] == 1:\n",
    "            m += 1\n",
    "        elif nums[m] == 0:\n",
    "            nums[l], nums[m] = nums[m], nums[l]\n",
    "            l += 1\n",
    "            m += 1\n",
    "        else:\n",
    "            nums[m], nums[h] = nums[h], nums[m]\n",
    "            h -= 1\n",
    "    return nums\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6ebb66b0-80c4-4b52-8d31-6b48e00782c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(N,A,B):\n",
    "    \n",
    "    A_sorted = sorted(A)\n",
    "    B_sorted = sorted(B)\n",
    "    \n",
    "    possible = all(A_sorted[i] != B_sorted[i] for i in range(len(A_sorted)))\n",
    "    \n",
    "    return(\"Yes\" if possible else \"No\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3b5ac54-9d5e-49af-aef9-d1c5c6586877",
   "metadata": {},
   "source": [
    "main function where you are creating your directories and defining questions number etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9002e4f5-7ecb-434b-8f87-ad65b077276d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    inputDirectory = \"C:\\\\Users\\\\MOKSHIT\\\\Desktop\\\\namespace\\\\AlgoRumble\\\\inputs\\\\\"\n",
    "    outputDirectory = \"C:\\\\Users\\\\MOKSHIT\\\\Desktop\\\\namespace\\\\AlgoRumble\\\\outputs\\\\\"\n",
    "    quesName = \"JyotiCheckString\"\n",
    "    testCasesFileCount = 30\n",
    "    for i in range(testCasesFileCount):\n",
    "        \n",
    "        #defining path to folder where current questions' input output will be saved will be saved\n",
    "        inputFileDirectory = os.path.join(inputDirectory, str(quesName))\n",
    "        outputFileDirectory = os.path.join(outputDirectory, str(quesName))\n",
    "        \n",
    "        #checking if folder already exists if not then create for input and output\n",
    "        if not os.path.exists(inputFileDirectory):\n",
    "            os.makedirs(inputFileDirectory)\n",
    "\n",
    "        if not os.path.exists(outputFileDirectory):\n",
    "            os.makedirs(outputFileDirectory)\n",
    "\n",
    "        #defining path for each testCase file\n",
    "        inputFilePath = os.path.join(inputFileDirectory, f'input{i}.txt')\n",
    "        outputFilePath = os.path.join(outputFileDirectory, f'output{i}.txt')\n",
    "\n",
    "        #this variable stores the value of t(number of test case) for each testCase file\n",
    "        minTestCaseCount=1\n",
    "        maxTestCaseCount=10\n",
    "        testCasesCount = random.randint(minTestCaseCount,maxTestCaseCount)\n",
    "        \n",
    "        with open(inputFilePath, 'w') as fileHandle:\n",
    "\n",
    "            createInputsString(fileHandle, testCasesCount)\n",
    "\n",
    "            #createInputs(fileHandle, testCasesCount)\n",
    "\n",
    "        with open(outputFilePath, 'w') as fileHandleOutput, open(inputFilePath, 'r') as fileHandleInput:\n",
    "            \n",
    "            #calling function to create outputs\n",
    "            createOutputsString(fileHandleOutput, fileHandleInput)\n",
    "\n",
    "            #createOutputs(fileHandleOutput, fileHandleInput)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bff44e85-49b5-4909-a55f-1cc4282bc207",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}