Advertisement
krysik

Untitled

Dec 13th, 2018
425
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 11.40 KB | None | 0 0
  1. from math import sqrt
  2.  
  3. def zad1(operacja, a, b):
  4.     """
  5.        1. Dodawanie
  6.        2. Odejmowanie
  7.        3. Mnozenie
  8.        4. Dzielenie
  9.        5. Dzielenie calkowite
  10.        6. Dzielenie z reszta
  11.        7. pierwiastkowanie, tylko druga potega
  12.        8. potegowanie
  13.    """
  14.     if operacja == 1:
  15.         return a + b
  16.     elif operacja == 2:
  17.         return a - b
  18.     elif operacja == 3:
  19.         return a * b
  20.     elif operacja == 4:
  21.         return a / b
  22.     elif operacja == 5:
  23.         return a // b
  24.     elif operacja == 6:
  25.         return a % b
  26.     elif operacja == 7:
  27.         return sqrt(b)
  28.     elif operacja == 8:
  29.         return a**b
  30. print("====Zad 1====")
  31. print(zad1(1,10,20))
  32. print("=====")
  33. print(zad1(2,20,10))
  34. print("=====")
  35. print(zad1(8,2,5))
  36. print("=====")
  37. print(zad1(7,2,16))
  38. print("=====")
  39. print(zad1(5,9,4))
  40.  
  41. def zad2(operacja, a, b):
  42.     """
  43.        +. Dodawanie
  44.        -. Odejmowanie
  45.        *. Mnozenie
  46.        /. Dzielenie
  47.        //. Dzielenie calkowite
  48.        %. Dzielenie z reszta
  49.        p. pierwiastkowanie, tylko druga potega
  50.        ^. potegowanie
  51.    """
  52.     if operacja == "+":
  53.         return a + b
  54.     elif operacja == "-":
  55.         return a - b
  56.     elif operacja == "*":
  57.         return a * b
  58.     elif operacja == "/":
  59.         return a / b
  60.     elif operacja == "//":
  61.         return a // b
  62.     elif operacja == "%":
  63.         return a % b
  64.     elif operacja == "p":
  65.         return sqrt(b)
  66.     elif operacja == "^":
  67.         return a**b
  68. # nie wiem czemu zwraca NONE
  69. print("====Zad 2====")
  70. print(zad1("+",10,20))
  71. print("=====")
  72. print(zad1("-",20,10))
  73. print("=====")
  74. print(zad1("^",2,5))
  75. print("=====")
  76. print(zad1("p",2,16))
  77. print("=====")
  78. print(zad1("//",9,4))
  79.  
  80.  
  81. def zad3(znak):
  82.     samogloski = ('a', 'o', 'u', 'e', 'i', 'y')
  83.     samogloski_wielkie = ('A', 'O', 'U', 'E', 'I', 'Y')
  84.     if znak.isdigit():
  85.         return "cyfra"
  86.     elif znak.isupper():
  87.         if znak in samogloski_wielkie:
  88.             return "Wielka litera, samogloska"
  89.         else:
  90.             return "Wielka litera, spolgloska"
  91.     elif znak.islower():
  92.         if znak in samogloski:
  93.             return "Mala litera, samogloska"
  94.         else:
  95.             return "Mala litera, spolgloska"
  96.     else:
  97.         return "inny znak"
  98. print("====Zad 3====")
  99. print(zad3("B"))
  100. print(zad3("G"))
  101. print(zad3("a"))
  102. print(zad3("7"))
  103. print(zad3("*"))
  104.  
  105. def zad4(n):
  106.     pass
  107.  
  108. def zad5(n):
  109.     dzielniki = []
  110.     for i in range(n):
  111.         i+=1
  112.         if n % i == 0:
  113.             dzielniki.append(i)
  114.     for k in dzielniki:
  115.         print(k,"", end="")
  116.  
  117. print("====Zad 5====")
  118. zad5(4)
  119. print("\n=====")
  120. zad5(7)
  121. print("\n====")
  122. zad5(12)
  123. print("\n====")
  124. zad5(1)
  125. print("\n")
  126. def zad6(n):
  127.     ilosc_dzielnikow = 0
  128.     for i in range(n):
  129.         i+=1
  130.         if n % i == 0:
  131.             ilosc_dzielnikow += 1
  132.     return ilosc_dzielnikow
  133.  
  134. print("====Zad 6====")
  135. print(zad6(4))
  136. print("=====")
  137. print(zad6(7))
  138. print("=====")
  139. print(zad6(12))
  140. print("=====")
  141. print(zad6(1))
  142.  
  143. def zad7(n):
  144.     dzielniki = []
  145.     i = 0        
  146.     while i<n:
  147.         i+=1
  148.         if n % i ==0:
  149.             dzielniki.append(i)
  150.             dzielniki.append(-i)
  151.     for k in dzielniki:
  152.         print(k,"", end="")
  153.  
  154. print("====Zad 7====")
  155. zad7(4)
  156. print("\n=====")
  157. zad7(7)
  158. print("\n=====")
  159. zad7(12)
  160. print("\n===== DLA 4")
  161. zad7(-4) # nie dziala dla liczb ujemnych
  162.  
  163. def zad8(n):
  164.     if n == 1:
  165.         return "ani pierwsza ani złożona"
  166.  
  167. def zad9(a,b):
  168.     for i in range(a+1, b):
  169.         print(i)
  170.  
  171. print("====Zad 9====")
  172. zad9(4,7)
  173. print("=====")
  174. zad9(10,12)
  175. print("=====")
  176. zad9(-4,2)
  177.  
  178. def zad10(n, znak):
  179.     # Petla FOR
  180.     for i in range(n):
  181.         for k in range(n):
  182.             print(znak, end="")
  183.         print("\n")
  184.     # Petla WHILE
  185.     i = 0
  186.     while i < n:
  187.         k=0
  188.         while k < n:
  189.             print(znak, end="")
  190.             k+=1
  191.         print("\n")
  192.         i+=1
  193. print("====Zad 10====")
  194. print(zad10(4,"x"))
  195. print("=====")
  196. print(zad10(3,"a"))
  197.  
  198. def zad11(n, znak):
  199.     for i in range(n):
  200.         i+=1
  201.         print(znak*i)
  202.  
  203. zad11(4,"x")
  204. print("=====")
  205. zad11(3, "a")
  206.  
  207.  
  208. def zad12(n, znak, znak2):
  209.     for i in range(n):
  210.         for k in range(n):
  211.             k+=1
  212.             if k % 2 == 0:
  213.                 print(znak2, end="")
  214.             else:
  215.                 print(znak, end="")
  216.             #print(k, end="")
  217.         print('\n')
  218.  
  219.  
  220. zad12(4, "x", "o")
  221. print("======")
  222. zad12(5, "@", "_")
  223.  
  224.  
  225. def zad15(n):
  226.     liczby = []
  227.     if n < 0:
  228.         return "Błąd"
  229.     else:      
  230.         for i in range(n):
  231.             i+=1
  232.             liczby.append(i)
  233.         return liczby
  234.  
  235. print("====Zad 15====")
  236. print(zad15(4))
  237. print("=====")
  238. print(zad15(-3))
  239. print("=====")
  240. print(zad15(0))
  241. print("=====")
  242. print(zad15(1))
  243.  
  244. def zad16(n):
  245.     kwadraty = []
  246.     if n < 0:
  247.         return "Błąd"
  248.     else:      
  249.         for i in range(n):
  250.             i+=1
  251.             kwadraty.append(i**2)
  252.         return kwadraty
  253.  
  254. print("====Zad 16====")
  255. print(zad16(5))
  256. print("=====")
  257. print(zad16(-5))
  258. print("=====")
  259. print(zad16(0))
  260. print("=====")
  261. print(zad16(1))
  262.  
  263. def zad17(n):
  264.     if n < 0:
  265.         return "Błąd"
  266.     else:        
  267.         liczby = []
  268.         for i in range(n, 0, -1):
  269.             liczby.append(i)
  270.         return liczby
  271.  
  272. print("====Zad 17====")
  273. print(zad17(5))
  274. print("=====")
  275. print(zad17(-3))
  276. print("=====")
  277. print(zad17(0))
  278. print("=====")
  279. print(zad17(1))
  280.  
  281. # cos nie dziala
  282. def zad18(n):
  283.     liczby = []
  284.     while len(liczby) == n:
  285.         print("dodaj")
  286.         if i % 2 == 0:
  287.             liczby.append(i)
  288.     return liczby
  289.  
  290. print("====Zad 18====")
  291. print(zad18(5))
  292.  
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299.    
  300.  
  301.  
  302.  
  303.        
  304. from math import sqrt
  305.  
  306. def zad1(operacja, a, b):
  307.     """
  308.        1. Dodawanie
  309.        2. Odejmowanie
  310.        3. Mnozenie
  311.        4. Dzielenie
  312.        5. Dzielenie calkowite
  313.        6. Dzielenie z reszta
  314.        7. pierwiastkowanie, tylko druga potega
  315.        8. potegowanie
  316.    """
  317.     if operacja == 1:
  318.         return a + b
  319.     elif operacja == 2:
  320.         return a - b
  321.     elif operacja == 3:
  322.         return a * b
  323.     elif operacja == 4:
  324.         return a / b
  325.     elif operacja == 5:
  326.         return a // b
  327.     elif operacja == 6:
  328.         return a % b
  329.     elif operacja == 7:
  330.         return sqrt(b)
  331.     elif operacja == 8:
  332.         return a**b
  333. print("====Zad 1====")
  334. print(zad1(1,10,20))
  335. print("=====")
  336. print(zad1(2,20,10))
  337. print("=====")
  338. print(zad1(8,2,5))
  339. print("=====")
  340. print(zad1(7,2,16))
  341. print("=====")
  342. print(zad1(5,9,4))
  343.  
  344. def zad2(operacja, a, b):
  345.     """
  346.        +. Dodawanie
  347.        -. Odejmowanie
  348.        *. Mnozenie
  349.        /. Dzielenie
  350.        //. Dzielenie calkowite
  351.        %. Dzielenie z reszta
  352.        p. pierwiastkowanie, tylko druga potega
  353.        ^. potegowanie
  354.    """
  355.     if operacja == "+":
  356.         return a + b
  357.     elif operacja == "-":
  358.         return a - b
  359.     elif operacja == "*":
  360.         return a * b
  361.     elif operacja == "/":
  362.         return a / b
  363.     elif operacja == "//":
  364.         return a // b
  365.     elif operacja == "%":
  366.         return a % b
  367.     elif operacja == "p":
  368.         return sqrt(b)
  369.     elif operacja == "^":
  370.         return a**b
  371. # nie wiem czemu zwraca NONE
  372. print("====Zad 2====")
  373. print(zad1("+",10,20))
  374. print("=====")
  375. print(zad1("-",20,10))
  376. print("=====")
  377. print(zad1("^",2,5))
  378. print("=====")
  379. print(zad1("p",2,16))
  380. print("=====")
  381. print(zad1("//",9,4))
  382.  
  383.  
  384. def zad3(znak):
  385.     samogloski = ('a', 'o', 'u', 'e', 'i', 'y')
  386.     samogloski_wielkie = ('A', 'O', 'U', 'E', 'I', 'Y')
  387.     if znak.isdigit():
  388.         return "cyfra"
  389.     elif znak.isupper():
  390.         if znak in samogloski_wielkie:
  391.             return "Wielka litera, samogloska"
  392.         else:
  393.             return "Wielka litera, spolgloska"
  394.     elif znak.islower():
  395.         if znak in samogloski:
  396.             return "Mala litera, samogloska"
  397.         else:
  398.             return "Mala litera, spolgloska"
  399.     else:
  400.         return "inny znak"
  401. print("====Zad 3====")
  402. print(zad3("B"))
  403. print(zad3("G"))
  404. print(zad3("a"))
  405. print(zad3("7"))
  406. print(zad3("*"))
  407.  
  408. def zad4(n):
  409.     pass
  410.  
  411. def zad5(n):
  412.     dzielniki = []
  413.     for i in range(n):
  414.         i+=1
  415.         if n % i == 0:
  416.             dzielniki.append(i)
  417.     for k in dzielniki:
  418.         print(k,"", end="")
  419.  
  420. print("====Zad 5====")
  421. zad5(4)
  422. print("\n=====")
  423. zad5(7)
  424. print("\n====")
  425. zad5(12)
  426. print("\n====")
  427. zad5(1)
  428. print("\n")
  429. def zad6(n):
  430.     ilosc_dzielnikow = 0
  431.     for i in range(n):
  432.         i+=1
  433.         if n % i == 0:
  434.             ilosc_dzielnikow += 1
  435.     return ilosc_dzielnikow
  436.  
  437. print("====Zad 6====")
  438. print(zad6(4))
  439. print("=====")
  440. print(zad6(7))
  441. print("=====")
  442. print(zad6(12))
  443. print("=====")
  444. print(zad6(1))
  445.  
  446. def zad7(n):
  447.     dzielniki = []
  448.     i = 0        
  449.     while i<n:
  450.         i+=1
  451.         if n % i ==0:
  452.             dzielniki.append(i)
  453.             dzielniki.append(-i)
  454.     for k in dzielniki:
  455.         print(k,"", end="")
  456.  
  457. print("====Zad 7====")
  458. zad7(4)
  459. print("\n=====")
  460. zad7(7)
  461. print("\n=====")
  462. zad7(12)
  463. print("\n===== DLA 4")
  464. zad7(-4) # nie dziala dla liczb ujemnych
  465.  
  466. def zad8(n):
  467.     if n == 1:
  468.         return "ani pierwsza ani złożona"
  469.  
  470. def zad9(a,b):
  471.     for i in range(a+1, b):
  472.         print(i)
  473.  
  474. print("====Zad 9====")
  475. zad9(4,7)
  476. print("=====")
  477. zad9(10,12)
  478. print("=====")
  479. zad9(-4,2)
  480.  
  481. def zad10(n, znak):
  482.     # Petla FOR
  483.     for i in range(n):
  484.         for k in range(n):
  485.             print(znak, end="")
  486.         print("\n")
  487.     # Petla WHILE
  488.     i = 0
  489.     while i < n:
  490.         k=0
  491.         while k < n:
  492.             print(znak, end="")
  493.             k+=1
  494.         print("\n")
  495.         i+=1
  496. print("====Zad 10====")
  497. print(zad10(4,"x"))
  498. print("=====")
  499. print(zad10(3,"a"))
  500.  
  501. def zad11(n, znak):
  502.     for i in range(n):
  503.         i+=1
  504.         print(znak*i)
  505.  
  506. zad11(4,"x")
  507. print("=====")
  508. zad11(3, "a")
  509.  
  510.  
  511. def zad12(n, znak, znak2):
  512.     for i in range(n):
  513.         for k in range(n):
  514.             k+=1
  515.             if k % 2 == 0:
  516.                 print(znak2, end="")
  517.             else:
  518.                 print(znak, end="")
  519.             #print(k, end="")
  520.         print('\n')
  521.  
  522.  
  523. zad12(4, "x", "o")
  524. print("======")
  525. zad12(5, "@", "_")
  526.  
  527.  
  528. def zad15(n):
  529.     liczby = []
  530.     if n < 0:
  531.         return "Błąd"
  532.     else:      
  533.         for i in range(n):
  534.             i+=1
  535.             liczby.append(i)
  536.         return liczby
  537.  
  538. print("====Zad 15====")
  539. print(zad15(4))
  540. print("=====")
  541. print(zad15(-3))
  542. print("=====")
  543. print(zad15(0))
  544. print("=====")
  545. print(zad15(1))
  546.  
  547. def zad16(n):
  548.     kwadraty = []
  549.     if n < 0:
  550.         return "Błąd"
  551.     else:      
  552.         for i in range(n):
  553.             i+=1
  554.             kwadraty.append(i**2)
  555.         return kwadraty
  556.  
  557. print("====Zad 16====")
  558. print(zad16(5))
  559. print("=====")
  560. print(zad16(-5))
  561. print("=====")
  562. print(zad16(0))
  563. print("=====")
  564. print(zad16(1))
  565.  
  566. def zad17(n):
  567.     if n < 0:
  568.         return "Błąd"
  569.     else:        
  570.         liczby = []
  571.         for i in range(n, 0, -1):
  572.             liczby.append(i)
  573.         return liczby
  574.  
  575. print("====Zad 17====")
  576. print(zad17(5))
  577. print("=====")
  578. print(zad17(-3))
  579. print("=====")
  580. print(zad17(0))
  581. print("=====")
  582. print(zad17(1))
  583.  
  584. # cos nie dziala
  585. def zad18(n):
  586.     liczby = []
  587.     while len(liczby) == n:
  588.         print("dodaj")
  589.         if i % 2 == 0:
  590.             liczby.append(i)
  591.     return liczby
  592.  
  593. print("====Zad 18====")
  594. print(zad18(5))
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement