up

intro/Task102Test.py

@@ -9,7 +9,7 @@ Napisz funkcję `add_three_numbers` zwracającą sumę trzech liczb całkowitych
 NAME: add_three_numbers
 PARAMS: int, int, int
 RETURN: int
-POINTS: 3
+POINTS: 1
 """
 
 import unittest

intro/Task103Test.py

@@ -12,7 +12,7 @@ liczba 0.
 NAME: probability
 PARAMS: double
 RETURN: double
-POINTS: 2
+POINTS: 1
 
 """
 

intro/Task104Test.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 104
+
+Napisz funkcję `sum_from_one_to_n` zwracającą sume kwadratów liczb od 1 do `n`.
+Jeśli podany argument jest mniejszy od 1 powinna być zwracana wartość 0.
+
+NAME: sum_from_one_to_n
+PARAMS: int
+RETURN: int
+POINTS: 1
+"""
+
+import unittest
+from Task104 import sum_from_one_to_n
+
+class Task104Test(unittest.TestCase):
+    """Testy do zadania 104"""
+
+    def test_special_cases(self):
+        """Testy przypadków szczególnych."""
+        self.assertEqual(sum_from_one_to_n(-100), 0)
+        self.assertEqual(sum_from_one_to_n(-1), 0)
+        self.assertEqual(sum_from_one_to_n(0), 0)
+        self.assertEqual(sum_from_one_to_n(1), 1)
+        self.assertEqual(sum_from_one_to_n(2), 5)
+
+    def test_regular(self):
+        """Testy dla kilku liczb"""
+        self.assertEqual(sum_from_one_to_n(3), 14)
+        self.assertEqual(sum_from_one_to_n(4), 30)
+
+
+if __name__ == '__main__':
+    unittest.main()

intro/Task105Test.py

@@ -0,0 +1,50 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 105
+
+Napisz funkcję `is_almost_prime(number, limit)` sprawdzającą, czy
+podana liczba nie dzieli się przez żadną liczbę z zakresu od 2 do
+`limit`. Dla liczb ujemnych powinna zostać zwrócona wartość `True`.
+
+NAME: is_almost_prime
+PARAMS: int, int
+RETURN: bool
+POINTS: 1
+"""
+
+import unittest
+from Task105 import is_almost_prime
+
+class Task105Test(unittest.TestCase):
+    """Testy do zadania 105"""
+
+    def test_simple(self):
+        """Proste testy"""
+        self.assertTrue(is_almost_prime(35, 4))
+        self.assertFalse(is_almost_prime(35, 5))
+        self.assertFalse(is_almost_prime(35, 100))
+        self.assertTrue(is_almost_prime(17, 4))
+        self.assertTrue(is_almost_prime(17, 16))
+        self.assertFalse(is_almost_prime(17, 17))
+        self.assertFalse(is_almost_prime(17, 100))
+        self.assertFalse(is_almost_prime(16, 2))
+        self.assertFalse(is_almost_prime(16, 5))
+        self.assertFalse(is_almost_prime(16, 13))
+        self.assertFalse(is_almost_prime(16, 101))
+
+    def test_special_cases(self):
+        """Testy przypadków szczególnych."""
+        self.assertTrue(is_almost_prime(-1, 10))
+        self.assertFalse(is_almost_prime(0, 8))
+        self.assertTrue(is_almost_prime(1, 6))
+        self.assertFalse(is_almost_prime(2, 2))
+
+    def test_negatives(self):
+        """Testy dla liczb ujemnych."""
+        self.assertTrue(is_almost_prime(-5, 100))
+        self.assertTrue(is_almost_prime(-13, 5))
+
+if __name__ == '__main__':
+    unittest.main()

intro/Task106Test.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python2
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 106
+
+Napisz funkcję freq_dic(sequence), która zlicza liczbę wystąpień
+elementów dla dowolnego typu sekwencyjnego. Funkcja powinna zwracać
+słownik, w którym klucze odpowiadają elementom, a wartości liczbie
+elementów. Dla łańcucha "abracadabra" wynikiem jest:
+
+{"a":5, "b":2, "c":1, "d":1, "r":2}
+
+NAME: freq_dic
+PARAMS: sequence
+RETURN: dictionary
+POINTS: 1
+"""
+
+import unittest
+from Task106 import freq_dic
+
+class Task106Test(unittest.TestCase):
+    """Testy do zadania 106"""
+
+    def test_string(self):
+        """Test na napisie."""
+        self.assertEqual(freq_dic("abracadabra"), {"a": 5, "b": 2, "c": 1, "d": 1, "r": 2})
+
+    def test_number_list(self):
+        """Test na liście liczb."""
+        self.assertEqual(freq_dic([1, 1, 2, 1, 10, 20, 2]), {1: 3, 2: 2, 10: 1, 20: 1})
+
+    def test_tuple(self):
+        """Test na krotce."""
+        self.assertEqual(freq_dic((1, 2, 3, 1)), {1: 2, 2: 1, 3: 1})
+
+    def test_empty(self):
+        """Test na pustej liście."""
+        self.assertEqual(freq_dic([]), { })
+
+if __name__ == '__main__':
+    unittest.main()

intro/Task107Test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 107
+
+Napisz funkcję `list_squared(list)` zwracającą sumę kwadratów
+zadanych liczb. Dla listy pustej powinna zostać zwrócona wartość zero.
+
+NAME: list_squared
+PARAMS: list
+RETURN: obj
+POINTS: 1
+"""
+
+import unittest
+from Task107 import list_squared
+
+class Task107Test(unittest.TestCase):
+    """Testy do zadania 107"""
+
+    def test_simple(self):
+        """Prosty test."""
+        self.assertEqual(list_squared([3, 0, -1, 2]), 14),
+
+    def test_empty(self):
+        """Test na pustej liście."""
+        self.assertEqual(list_squared([]), 0),
+
+    def test_singleton(self):
+        """Test na liście jednoelementowej."""
+        self.assertEqual(list_squared([-4]), 16)
+
+    def test_two_elements(self):
+        """Test na liście dwuelementowej."""
+        self.assertEqual(list_squared([100, -100]), 20000)
+        self.assertEqual(list_squared([2, 10]), 104)
+
+if __name__ == '__main__':
+    unittest.main()

intro/Task108Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 108
+
+Napisz funkcję `leet_speak`, która podmienia w podanym napisie
+niektóre litery na podobnie wyglądające cyfry: 'e' na '3', 'l' na '1',
+'o' na '0', 't' na '7'. Np. `leet('leet')` powinno zwrócić '1337'.
+
+NAME: leet_speak
+PARAMS: string
+RETURN: string
+POINTS: 1
+"""
+
+import unittest
+from Task108 import leet_speak
+
+class Task108Test(unittest.TestCase):
+    """Testy do zadania 108."""
+
+    def test_special_cases(self):
+        """Przypadki szczególne."""
+        self.assertEqual(leet_speak(''), '')
+        self.assertEqual(leet_speak('x'), 'x')
+        self.assertEqual(leet_speak('o'), '0')
+        self.assertEqual(leet_speak('banan'), 'banan')
+        self.assertEqual(leet_speak('1337'), '1337')
+        self.assertEqual(leet_speak('admin1'), 'admin1')
+
+    def test_standard_cases(self):
+        """Standardowe przypadki."""
+        self.assertEqual(leet_speak('leet'), '1337')
+        self.assertEqual(leet_speak('mouse'), 'm0us3')
+        self.assertEqual(leet_speak('do not want'), 'd0 n07 wan7')
+
+if __name__ == '__main__':
+    unittest.main()

intro/Task109Test.dat.txt

@@ -0,0 +1,8 @@
+raz
+dwa
+YES
+cztery
+YES
+YES
+YES
+tego YES nie liczyć

intro/Task109Test.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 109
+
+Napisz funkcję `count_yes_lines(filename)`, która po podaniu nazwy pliku
+tekstowego `filename` zwraca liczbę wierszy w pliku zawierających
+(wyłącznie) napis "YES" (i znak końca wiersza).
+
+NAME: count_yes_lines
+PARAMS: string
+RETURN: int
+POINTS: 1
+"""
+import unittest
+from Task109 import count_yes_lines
+
+class Task109Test(unittest.TestCase):
+    """Testy do zadania 109."""
+
+    def test_on_self(self):
+        """Testy na samym sobie."""
+        self.failUnlessEqual(count_yes_lines("Task109Test.py"), 0)
+
+    def test_simple(self):
+        """Testy na prostym pliku."""
+        self.failUnlessEqual(count_yes_lines("Task109Test.dat.txt"), 4)
+
+if __name__ == '__main__':
+    unittest.main()

intro/Task110Test.dat.in.txt

@@ -0,0 +1,6 @@
+this is a string
+Ala ma kota
+blablabla
+
+nic
+pies, czyli kot

intro/Task110Test.dat.out.txt

@@ -0,0 +1,6 @@
+4 2 1 6
+3 2 4
+9
+
+3
+5 5 3

intro/Task110Test.py

@@ -0,0 +1,46 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 110
+
+Napisz funkcję `words_to_length(infile, outfile)`, która wczytując
+wiersze z pliku `infile` i wypisując je do pliku `outfile`, zamienia
+wyrazy na liczbę odpowiadającą długości wyrazu. Np. wiersz `this is a
+string` zostanie zamieniony na `4 2 1 6`. Zakładamy, że wyrazy
+oddzielone są spacjami (np. dla `pies, czyli kot` powinno wyjść `5 5
+3`).
+
+NAME: word_to_length
+PARAMS: file, file
+RETURN: string
+POINTS: 1
+"""
+
+import unittest
+from Task110 import word_to_length
+
+class Task110Test(unittest.TestCase):
+    """Testy do zadania 110"""
+
+    def test(self):
+        """Prosty test przez porównanie z oczekiwanym wyjściem."""
+        infile = open("Task110Test.dat.in.txt", 'r')
+
+        out1  = open("Task110Test.out.txt", 'w')
+        word_to_length(infile, out1)
+        infile.close()
+        out1.close()
+
+        out1  = open("Task110Test.out.txt", 'r')
+        out2  = open("Task110Test.dat.out.txt", 'r')
+
+        for line1 in out1:
+            line2 = out2.readline()
+            self.assertEqual( line1, line2 )
+
+        out1.close()
+        out2.close()
+
+if __name__ == '__main__':
+    unittest.main()