diff --git a/00_Setup/test.ipynb b/00_Setup/test.ipynb new file mode 100644 index 0000000..99877a3 --- /dev/null +++ b/00_Setup/test.ipynb @@ -0,0 +1,348 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SymbolSecurityGICS_SectorhqincludedFounded
0MMM3MIndustrialsSaint Paul, Minnesota09.08.19761902
1AOSA. O. SmithIndustrialsMilwaukee, Wisconsin26.07.20171916
2ABTAbbottHealth CareNorth Chicago, Illinois31.03.19641888
3ABBVAbbVieHealth CareNorth Chicago, Illinois31.12.20122013 (1888)
4ABMDAbiomedHealth CareDanvers, Massachusetts31.05.20181981
.....................
498YUMYum! BrandsConsumer DiscretionaryLouisville, Kentucky06.10.19971997
499ZBRAZebra TechnologiesInformation TechnologyLincolnshire, Illinois23.12.20191969
500ZBHZimmer BiometHealth CareWarsaw, Indiana07.08.20011927
501ZIONZions BancorporationFinancialsSalt Lake City, Utah22.06.20011873
502ZTSZoetisHealth CareParsippany, New Jersey21.06.20131952
\n", + "

503 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " Symbol Security GICS_Sector \\\n", + "0 MMM 3M Industrials \n", + "1 AOS A. O. Smith Industrials \n", + "2 ABT Abbott Health Care \n", + "3 ABBV AbbVie Health Care \n", + "4 ABMD Abiomed Health Care \n", + ".. ... ... ... \n", + "498 YUM Yum! Brands Consumer Discretionary \n", + "499 ZBRA Zebra Technologies Information Technology \n", + "500 ZBH Zimmer Biomet Health Care \n", + "501 ZION Zions Bancorporation Financials \n", + "502 ZTS Zoetis Health Care \n", + "\n", + " hq included Founded \n", + "0 Saint Paul, Minnesota 09.08.1976 1902 \n", + "1 Milwaukee, Wisconsin 26.07.2017 1916 \n", + "2 North Chicago, Illinois 31.03.1964 1888 \n", + "3 North Chicago, Illinois 31.12.2012 2013 (1888) \n", + "4 Danvers, Massachusetts 31.05.2018 1981 \n", + ".. ... ... ... \n", + "498 Louisville, Kentucky 06.10.1997 1997 \n", + "499 Lincolnshire, Illinois 23.12.2019 1969 \n", + "500 Warsaw, Indiana 07.08.2001 1927 \n", + "501 Salt Lake City, Utah 22.06.2001 1873 \n", + "502 Parsippany, New Jersey 21.06.2013 1952 \n", + "\n", + "[503 rows x 6 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Part 2\n", + "import pandas as pd\n", + "import numpy as np\n", + "s_p_500 = pd.read_csv(\"companies_no_subindustry.csv\")\n", + "s_p_500 = pd.DataFrame(s_p_500)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 09.08.1976\n", + "1 26.07.2017\n", + "2 31.03.1964\n", + "3 31.12.2012\n", + "4 31.05.2018\n", + " ... \n", + "498 06.10.1997\n", + "499 23.12.2019\n", + "500 07.08.2001\n", + "501 22.06.2001\n", + "502 21.06.2013\n", + "Name: included, Length: 503, dtype: object\n" + ] + }, + { + "data": { + "text/plain": [ + "45" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#1.\n", + "print(s_p_500[\"included\"])\n", + "(pd.isnull(s_p_500[\"included\"]) == True).sum()\n", + "#45 of them\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8201 days 12:15:35.747791976 is the average\n", + "25 Altria\n", + "31 American Electric Power\n", + "72 Boeing\n", + "77 Bristol Myers Squibb\n", + "86 Campbell Soup Company\n", + "93 Caterpillar Inc.\n", + "105 Chevron Corporation\n", + "118 The Coca-Cola Company\n", + "120 Colgate-Palmolive\n", + "124 ConocoPhillips\n", + "138 CVS Health\n", + "143 John Deere\n", + "159 DTE Energy\n", + "167 Edison International\n", + "174 Entergy\n", + "187 Exelon\n", + "191 ExxonMobil\n", + "204 Ford Motor Company\n", + "216 General Dynamics\n", + "225 Halliburton\n", + "226 Hartford (The)\n", + "231 Hershey's\n", + "245 IBM\n", + "254 International Paper\n", + "274 Kimberly-Clark\n", + "279 Kroger\n", + "310 Merck & Co.\n", + "342 Norfolk Southern Railway\n", + "368 PepsiCo\n", + "370 Pfizer\n", + "378 PPG Industries\n", + "381 Procter & Gamble\n", + "385 Public Service Enterprise Group\n", + "413 Sealed Air\n", + "423 Southern Company\n", + "460 Union Pacific Corporation\n", + "496 Xcel Energy\n", + "Name: Security, dtype: object are oldest\n", + "hi\n", + "48 Arch Capital Group\n", + "Name: Security, dtype: object is youngest\n" + ] + } + ], + "source": [ + "#2.\n", + "s_p_458 = s_p_500.dropna(axis=0, subset= [\"included\"])\n", + "s_p_458['included']= pd.to_datetime(s_p_458[\"included\"], dayfirst=True,errors='coerce')\n", + "#print(s_p_458)\n", + "print(pd.to_datetime('today') - s_p_458['included'].mean(), \"is the average\")\n", + "print(s_p_458[\"Security\"][s_p_458[\"included\"] == s_p_458['included'].min()], \"are oldest\")\n", + "#there is several oldes\n", + "print(s_p_458[\"Security\"][s_p_458[\"included\"] == s_p_458['included'].max()], \"is youngest\")\n", + "#one youngest\n", + "#print(s_p_458['included'].max())" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "3.\n", + "s_p_458[\"GICS_Sector\"].value_counts()\n", + "s_p_458[\"GICS_Sector\"].value_counts().plot(kind=\"pie\")\n", + "#s_p_458.groupby(\"GICS_Sector\").value_counts().plot(kind = \"hist\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Untitled-1.ipynb b/Untitled-1.ipynb new file mode 100644 index 0000000..02eddfd --- /dev/null +++ b/Untitled-1.ipynb @@ -0,0 +1,613 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1000, 3908]\n" + ] + } + ], + "source": [ + "nums = [1,2,6,9,1000,3908]\n", + "target = 4908\n", + "list = \"\"\n", + "for i in nums:\n", + " if list != \"\":\n", + " break\n", + " for j in nums:\n", + " if i != j:\n", + " sum = i + j\n", + " if sum == target:\n", + " list = [i,j]\n", + " print(list)\n", + " break\n", + " else:\n", + " continue\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 4]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def sumaaa(čísla, target):\n", + " check = []\n", + " for i,y in enumerate(čísla):\n", + " if check:\n", + " break\n", + " for j, k in enumerate(čísla[i+1:]):\n", + " sum = y + k\n", + " if sum == target:\n", + " check = [i, i+j+1]\n", + " break\n", + " return check\n", + "\n", + "sumaaa([2,3,6,12,1], 7)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "čísla = [-1, 0, 1, 2, -1, -4]\n", + "for index1, i in enumerate(nums[:-2]):\n", + " for index2, j in enumerate(nums[index1 + 1:-1]):\n", + " for index3, k in enumerate(nums[index1 + index2 + 2:]):\n", + " print(i, j, k)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def jetamlist(list, sublist):\n", + " for i in list:\n", + " if sorted(i) == sorted(sublist):\n", + " return True\n", + " break\n", + " return False\n", + "\n", + "jetamlist([[3,5],[4,3]], [3,4])" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'List' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mdeeesch\\PythonDataIES\\Untitled-1.ipynb Cell 4\u001b[0m line \u001b[0;36m4\n\u001b[0;32m 1\u001b[0m nums \u001b[39m=\u001b[39m [\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m,\u001b[39m0\u001b[39m,\u001b[39m1\u001b[39m,\u001b[39m2\u001b[39m,\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m,\u001b[39m-\u001b[39m\u001b[39m4\u001b[39m]\n\u001b[0;32m 2\u001b[0m result \u001b[39m=\u001b[39m []\n\u001b[1;32m----> 4\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mSolution\u001b[39;00m:\n\u001b[0;32m 5\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mthreeSum\u001b[39m(\u001b[39mself\u001b[39m, nums: List[\u001b[39mint\u001b[39m]) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m List[List[\u001b[39mint\u001b[39m]]:\n\u001b[0;32m 6\u001b[0m result \u001b[39m=\u001b[39m []\n", + "\u001b[1;32mdeeesch\\PythonDataIES\\Untitled-1.ipynb Cell 4\u001b[0m line \u001b[0;36m5\n\u001b[0;32m 4\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mSolution\u001b[39;00m:\n\u001b[1;32m----> 5\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mthreeSum\u001b[39m(\u001b[39mself\u001b[39m, nums: List[\u001b[39mint\u001b[39m]) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m List[List[\u001b[39mint\u001b[39m]]:\n\u001b[0;32m 6\u001b[0m result \u001b[39m=\u001b[39m []\n\u001b[0;32m 7\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mjetamlist\u001b[39m(\u001b[39mlist\u001b[39m, sublist):\n", + "\u001b[1;31mNameError\u001b[0m: name 'List' is not defined" + ] + } + ], + "source": [ + "nums = [-1,0,1,2,-1,-4]\n", + "result = []\n", + "\n", + "class Solution:\n", + " def threeSum(self, čísla: List[int]) -> List[List[int]]:\n", + " result = []\n", + " def jetamlist(list, sublist):\n", + " for i in list:\n", + " if sorted(i) == sorted(sublist):\n", + " return True\n", + " break\n", + " return False\n", + " for index1, i in enumerate(nums[:-2]):\n", + " for index2, j in enumerate(nums[index1 + 1:-1]):\n", + " for index3, k in enumerate(nums[index1 + index2 +2:]):\n", + " if (i + j + k == 0):\n", + " if (jetamlist(result, [i,j,k])==False):\n", + " result.append([i,j,k])\n", + " return result\n", + "\n", + "#return result\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def odlistovani(list, sublist):\n", + " for i in list:\n", + " if sorted(i) == sorted(sublist):\n", + " return True\n", + "\n", + "odlistovani([[-1, 0, 1], [-1, 2, -1], [0, 1, -1]], [2,-1,-1])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[-1, -1, 2], [-1, 0, 1], [-4, 2, 2]]" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers = [-1,0,1,2,-1,-4]\n", + "def sum_3(list_of_numbers):\n", + " answer = []\n", + " def sum_2(nums, target2):\n", + " slovnik = {}\n", + " seznam = []\n", + " for i in range(len(nums)):\n", + " diff = target2 - nums[i]\n", + " if diff in slovnik:\n", + " seznam = [slovnik[diff],nums[i]]\n", + " else:\n", + " slovnik[nums[i]] = nums[i]\n", + " return seznam\n", + " for target in range(len(nums)):\n", + " dvojčíslí = sorted(sum_2(nums = list_of_numbers, target2= -nums[target]))\n", + " if dvojčíslí != []:\n", + " dvojčíslí.append(nums[target])\n", + " if not(sorted(dvojčíslí) in answer):\n", + " answer.append(sorted(dvojčíslí))\n", + " return answer\n", + "sum_3(list_of_numbers = numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[-1, 0, 1], [-1, -1, 2]]" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers = [-1,0,1,2,-1,-4]\n", + "def sum_3(list_of_numbers):\n", + " answer = []\n", + " def sum_2(nums, target2, pozice):\n", + " slovnik = {}\n", + " seznam = []\n", + " for i in range(len(nums)):\n", + " if i != pozice:\n", + " diff = target2 - nums[i]\n", + " if diff in slovnik:\n", + " seznam = [slovnik[diff],nums[i]]\n", + " else:\n", + " slovnik[nums[i]] = nums[i]\n", + " else:\n", + " break\n", + " return seznam\n", + " for target in range(len(nums)):\n", + " dvojčíslí = sorted(sum_2(nums = list_of_numbers, target2= -nums[target], pozice = target))\n", + " if dvojčíslí != []:\n", + " dvojčíslí.append(nums[target])\n", + " if not(sorted(dvojčíslí) in answer):\n", + " answer.append(sorted(dvojčíslí))\n", + " return answer\n", + "sum_3(list_of_numbers = numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[-1, 0, 1], [-3, 1, 2], [-4, 1, 3], [-4, 0, 4]]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers = [-1,0,1,2,-1,-4,-2,-3,3,0,4]\n", + "def sum_3(list_of_numbers):\n", + " list_of_numbers = sorted(list_of_numbers)\n", + " answer = []\n", + " def sum_2(nums, target2, pozice):\n", + " slovnik = {}\n", + " seznam = []\n", + " for i in range(len(nums)):\n", + " if i != pozice:\n", + " diff = target2 - nums[i]\n", + " if diff in slovnik:\n", + " seznam = [slovnik[diff],nums[i]]\n", + " else:\n", + " slovnik[nums[i]] = nums[i]\n", + " else:\n", + " break\n", + " return seznam\n", + " for target in range(len(list_of_numbers)):\n", + " dvojčíslí = (sum_2(nums = list_of_numbers, target2= -list_of_numbers[target], pozice = target))\n", + " if dvojčíslí != []:\n", + " dvojčíslí.append(list_of_numbers[target])\n", + " if not((dvojčíslí) in answer):\n", + " answer.append((dvojčíslí))\n", + " return answer\n", + "sum_3(list_of_numbers = numbers)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-4, 1, 3], [-4, 0, 4], [-3, 1, 2], [-3, 0, 3], [-3, -1, 4], [-2, 0, 2], [-2, -1, 3], [-1, 0, 1], [-1, -1, 2]]\n" + ] + } + ], + "source": [ + "def sum_3(list_of_numbers):\n", + " list_of_numbers = sorted(list_of_numbers)\n", + " answer = []\n", + " for target in range(len(list_of_numbers)):\n", + " # Use a set to keep track of visited numbers\n", + " visited = set()\n", + " dvojčíslí = []\n", + " for i in range(len(list_of_numbers)):\n", + " if i != target:\n", + " diff = -list_of_numbers[target] - list_of_numbers[i]\n", + " if diff in visited:\n", + " dvojčíslí = [list_of_numbers[i], diff, list_of_numbers[target]]\n", + " if not (sorted(dvojčíslí) in sorted(answer)):\n", + " answer.append(sorted(dvojčíslí))\n", + " visited.add(list_of_numbers[i])\n", + " \n", + " return answer\n", + "\n", + "numbers = [-1, 0, 1, 2, -1, -4, -2, -3, 3, 0, 4]\n", + "result = sum_3(numbers)\n", + "print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 5]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from typing import List\n", + "class Solution:\n", + " def twoSum(self, nums: List[int], target: int) -> List[int]:\n", + " check = []\n", + " for i,y in enumerate(nums):\n", + " if check:\n", + " break\n", + " for j, k in enumerate(nums):\n", + " if i != j:\n", + " sum = y + k\n", + " if sum == target:\n", + " check = [i, j]\n", + " break\n", + " return check\n", + "solution = Solution()\n", + "solution.twoSum([1,2,6,9,1000,3908],4908)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{-1: 0, 0: -1, 1: -1, 2: -3, 3: 0, 4: -2, 5: -10}\n" + ] + } + ], + "source": [ + "dictio = {-1: 0, 0: 1, 1: 2}\n", + "for i in range(len(numbers)):\n", + " dictio[i] = numbers[i] - i\n", + "print(dictio)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{1: 90}]\n" + ] + }, + { + "data": { + "text/plain": [ + "{2: 9, 4: 1, 5: -10}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mydict = {}\n", + "nums = [1,3,3,9]\n", + "def in_dict(vector, dictionary):\n", + " for index, hodnota in enumerate(vector):\n", + " dictionary[index] = hodnota\n", + " return dictionary\n", + "in_dict(vector=nums, dictionary= mydict)\n", + "\n", + "#for index1, number1 in enumerate(nums):\n", + "# for index2, number2 in enumerate(nums):\n", + " # for index3, number3 in enumerate(nums):\n", + " # sum = number1+number2+number3\n", + " # print(sum)\n", + "\n", + "def součet(number1, number2, number3, index1, index2, index3):\n", + " sum = number1+number2+number3\n", + " if (sum == 0):\n", + " mydict = {index1:number1, index2:number2, index3:number3}\n", + " return mydict\n", + "\n", + "def add_dict(value,list_of_dict):\n", + " list_of_dict.append(value)\n", + "my_dict = {1:90}\n", + "list_of_dict = []\n", + "add_dict(my_dict, list_of_dict)\n", + "print(list_of_dict)\n", + "#return in_dict(vector=nums, dictionary= mydict)\n", + "\n", + "součet(9,1,-10, 2,4,5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 + 8 + 9 = 22\n", + "2 + 3 + 9 = 14\n", + "4 + 7 + 8 = 19\n", + "2 + 5 + 9 = 16\n", + "5 + 7 + 8 = 20\n", + "6 + 8 + 9 = 23\n", + "1 + 3 + 7 = 11\n", + "1 + 5 + 7 = 13\n", + "2 + 3 + 5 = 10\n", + "5 + 7 + 9 = 21\n", + "1 + 8 + 9 = 18\n", + "2 + 6 + 7 = 15\n", + "4 + 7 + 9 = 20\n", + "5 + 6 + 7 = 18\n", + "7 + 8 + 9 = 24\n", + "1 + 4 + 6 = 11\n", + "2 + 4 + 9 = 15\n", + "1 + 4 + 7 = 12\n", + "2 + 3 + 8 = 13\n", + "1 + 6 + 7 = 14\n", + "2 + 4 + 5 = 11\n", + "3 + 5 + 6 = 14\n", + "2 + 5 + 8 = 15\n", + "3 + 6 + 9 = 18\n", + "1 + 7 + 8 = 16\n", + "2 + 6 + 9 = 17\n", + "2 + 8 + 9 = 19\n", + "1 + 4 + 8 = 13\n", + "1 + 6 + 8 = 15\n", + "2 + 4 + 6 = 12\n", + "3 + 5 + 7 = 15\n", + "6 + 7 + 8 = 21\n", + "1 + 4 + 9 = 14\n", + "1 + 6 + 9 = 16\n", + "2 + 4 + 7 = 13\n", + "3 + 5 + 8 = 16\n", + "1 + 2 + 3 = 6\n", + "1 + 4 + 5 = 10\n", + "4 + 6 + 8 = 18\n", + "2 + 6 + 8 = 16\n", + "4 + 5 + 8 = 17\n", + "1 + 2 + 4 = 7\n", + "5 + 6 + 8 = 19\n", + "3 + 4 + 8 = 15\n", + "4 + 5 + 9 = 18\n", + "5 + 6 + 9 = 20\n", + "1 + 7 + 9 = 17\n", + "3 + 4 + 9 = 16\n", + "3 + 4 + 5 = 12\n", + "1 + 2 + 6 = 9\n", + "4 + 5 + 6 = 15\n", + "2 + 7 + 8 = 17\n", + "1 + 2 + 7 = 10\n", + "1 + 3 + 8 = 12\n", + "1 + 5 + 8 = 14\n", + "1 + 3 + 4 = 8\n", + "1 + 2 + 8 = 11\n", + "2 + 4 + 8 = 14\n", + "3 + 4 + 6 = 13\n", + "3 + 5 + 9 = 17\n", + "4 + 5 + 7 = 16\n", + "2 + 7 + 9 = 18\n", + "4 + 6 + 9 = 19\n", + "3 + 4 + 7 = 14\n", + "4 + 8 + 9 = 21\n", + "1 + 2 + 9 = 12\n", + "3 + 7 + 9 = 19\n", + "1 + 2 + 5 = 8\n", + "1 + 3 + 6 = 10\n", + "1 + 5 + 6 = 12\n", + "2 + 3 + 4 = 9\n", + "2 + 3 + 6 = 11\n", + "2 + 5 + 6 = 13\n", + "3 + 6 + 7 = 16\n", + "3 + 8 + 9 = 20\n", + "4 + 6 + 7 = 17\n", + "6 + 7 + 9 = 22\n", + "1 + 3 + 9 = 13\n", + "1 + 5 + 9 = 15\n", + "2 + 3 + 7 = 12\n", + "2 + 5 + 7 = 14\n", + "3 + 6 + 8 = 17\n", + "1 + 3 + 5 = 9\n", + "3 + 7 + 8 = 18\n" + ] + } + ], + "source": [ + "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9] # Replace this with your list of numbers\n", + "\n", + "result = set() # Use a set to store unique combinations of sums\n", + "\n", + "for i in range(len(numbers)):\n", + " for j in range(i + 1, len(numbers)):\n", + " for k in range(j + 1, len(numbers)):\n", + " sum_of_three = numbers[i] + numbers[j] + numbers[k]\n", + " result.add((numbers[i], numbers[j], numbers[k], sum_of_three))\n", + "\n", + "\n", + "\n", + "\n", + "# Now 'result' contains unique combinations of three numbers and their sum\n", + "for combination in result:\n", + " num1, num2, num3, total = combination\n", + " print(f\"{num1} + {num2} + {num3} = {total}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "check = []\n", + "for i in nums:\n", + " if check:\n", + " break\n", + " for j in nums:\n", + " if i != j:\n", + " sum = i + j\n", + " if sum == target:\n", + " check = [i,j]\n", + " break\n", + "return check" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pokus.md b/pokus.md new file mode 100644 index 0000000..d0ebdf6 --- /dev/null +++ b/pokus.md @@ -0,0 +1 @@ +nazdar diff --git a/test.ipynb b/test.ipynb new file mode 100644 index 0000000..1921f30 --- /dev/null +++ b/test.ipynb @@ -0,0 +1,44 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid decimal literal (738235741.py, line 2)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Cell \u001b[1;32mIn[3], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m pd.read_csv(https://ies-python-midterm.s3.eu-central-1.amazonaws.com/companies/companies_no _subindustry.csv)\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid decimal literal\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "pd.read_csv(https://ies-python-midterm.s3.eu-central-1.amazonaws.com/companies/companies_no _subindustry.csv)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}