Merge branch 'canbula:master' into master

icelal-kskn · web-flow · commit 8b98efffd889 · 2024-10-19T11:21:06.000+03:00
diff --git a/Week02/types_mustafa_ceylan.py b/Week02/types_mustafa_ceylan.py
@@ -0,0 +1,4 @@
+my_int = 35
+my_float = 21.35
+my_bool = False
+my_complex= 14j
diff --git a/Week03/pyramid_ahmetyusuf_dursun.py b/Week03/pyramid_ahmetyusuf_dursun.py
@@ -0,0 +1,10 @@
+def calculate_pyramid_height(number_of_blocks) :
+    height=0    
+    i=1
+    while number_of_blocks>0 :
+        number_of_blocks-=i
+        i+=1
+        height+=1
+        if(number_of_blocks -i < 0):
+            break
+    return height            
diff --git a/Week03/pyramid_bilal_ayakdas.py b/Week03/pyramid_bilal_ayakdas.py
@@ -0,0 +1,21 @@
+def calculate_pyramid_height(number_of_blocks: int) -> int:
+    """
+    Calculate the height of a pyramid given the number of blocks.
+    :param number_of_blocks: The total number of blocks available to build the pyramid.
+    :type number_of_blocks: int
+    :raises ValueError: If the number of blocks is less than or equal to 0.
+    :return: The maximum height of the pyramid that can be built.
+    :rtype: int
+    """
+    if number_of_blocks <= 0:
+        raise ValueError("Number of blocks must be greater than 0")
+    
+    height, layer = 0, 1
+    
+    while number_of_blocks >= layer:
+        number_of_blocks -= layer
+        height += 1
+        layer += 1
+        
+    return height
+
diff --git a/Week03/pyramid_cagan_atan.py b/Week03/pyramid_cagan_atan.py
@@ -0,0 +1,11 @@
+def calculate_pyramid_height(number_of_blocks : int) -> int:
+    if number_of_blocks < 0:
+        raise ValueError("The number of blocks must be a non-negative integer.")
+    height = 0
+    while number_of_blocks > 0:
+        height += 1
+        number_of_blocks -= height
+    # If the number of blocks is negative (the layer is missing blocks), the height is decremented by 1.
+    if number_of_blocks < 0:
+        height -= 1
+    return height
diff --git a/Week03/pyramid_enes_dogan.py b/Week03/pyramid_enes_dogan.py
@@ -0,0 +1,8 @@
+def calculate_pyramid_height(number_of_blocks):
+    height = 0
+
+    while number_of_blocks >= (height + 1):
+        height += 1
+        number_of_blocks -= height
+
+    return height
diff --git a/Week03/pyramid_eren_malkoc.py b/Week03/pyramid_eren_malkoc.py
@@ -0,0 +1,14 @@
+# max block , height
+# 1 , 1
+# 3 , 2
+# 6 , 3
+# 10 , 4
+
+def calculate_pyramid_height(number_of_blocks):
+    height = 0
+
+    while number_of_blocks >= height + 1:  
+        height += 1
+        number_of_blocks -= height
+
+    return height
diff --git a/Week03/pyramid_furkan_bulut.py b/Week03/pyramid_furkan_bulut.py
@@ -0,0 +1,34 @@
+def calculate_pyramid_height(number_of_blocks):
+    """
+    Calculate the height of a pyramid that can be built with a given number of blocks.
+
+    The function determines how many complete layers (height) can be formed
+    using the provided number of blocks. Each layer requires a number of blocks
+    equal to the layer number (1 block for the first layer, 2 blocks for the
+    second layer, etc.).
+
+    :param number_of_blocks: The total number of blocks available to build the pyramid.
+    :type number_of_blocks: int
+    :return: The maximum height of the pyramid that can be built.
+    :rtype: int
+
+    :raises ValueError: If `number_of_blocks` is less than 0.
+
+    Example:
+
+    calculate_pyramid_height(6)
+    3
+    calculate_pyramid_height(20)
+    5
+    """
+    if number_of_blocks < 0:
+        raise ValueError("Number of blocks must be non-negative.")
+
+    height_of_pyramid = 0
+    block_counter = 0
+
+    while number_of_blocks >= (block_counter + (height_of_pyramid + 1)):
+        block_counter += height_of_pyramid + 1
+        height_of_pyramid += 1
+
+    return height_of_pyramid
diff --git a/Week03/pyramid_hamza_kiziltoprak.py b/Week03/pyramid_hamza_kiziltoprak.py
@@ -0,0 +1,10 @@
+def calculate_pyramid_height(number_of_blocks):
+    height = 0    
+    i = 1
+    while number_of_blocks > 0:
+        number_of_blocks -= i
+        i += 1
+        height += 1
+        if number_of_blocks - i < 0:
+            break
+    return height
diff --git a/Week03/pyramid_ipek_naz_sipahi.py b/Week03/pyramid_ipek_naz_sipahi.py
@@ -0,0 +1,7 @@
+def calculate_pyramid_height(number_of_blocks):
+    height = 0 
+    total_blocks = 0  # Total number of blocks used so far
+    while total_blocks + (height + 1) <= number_of_blocks: 
+        height += 1  
+        total_blocks += height  # Add the number of blocks in the new level to the total
+    return height 
diff --git a/Week03/pyramid_mert_durgun.py b/Week03/pyramid_mert_durgun.py
@@ -0,0 +1,10 @@
+def calculate_pyramid_height(blocks):
+    
+    height = 0
+    blocks_needed = 1
+    
+    while blocks >= blocks_needed:
+        blocks -= blocks_needed
+        height += 1
+        blocks_needed += 1
+    return height
diff --git a/Week03/pyramid_ufuk_dilek.py b/Week03/pyramid_ufuk_dilek.py
@@ -0,0 +1,10 @@
+def calculate_pyramid_height(number_of_blocks):
+    iteration = 0
+    total = 0
+    while True:
+        if number_of_blocks < total:
+            break
+        else:
+            iteration += 1
+            total += iteration
+    return iteration - 1
diff --git a/Week03/sequences_ahmetyusuf_dursun.py b/Week03/sequences_ahmetyusuf_dursun.py
@@ -0,0 +1,12 @@
+def remove_duplicates (seq:list) -> list :
+    return list(set(seq))
+
+def list_counts(seq:list) -> dict :
+    n = seq.count
+    ndict={}
+    for i in remove_duplicates(seq) :
+        ndict[i]=n(i)
+    return ndict
+
+def reverse_dict(d:dict) -> dict:
+    return {v: k for k, v in d.items()}
diff --git a/Week03/sequences_bilal_ayakdas.py b/Week03/sequences_bilal_ayakdas.py
@@ -0,0 +1,23 @@
+def remove_duplicates(seq: list) -> list:
+    """
+    This function removes duplicates from a list
+    """
+    return list(set(seq))
+
+def list_counts(seq: list) -> dict:
+    """
+    This function counts the number of occurrences of each item in a list.
+    """
+    counts = {}
+    for item in seq:
+        if item in counts:
+            counts[item] += 1
+        else:
+            counts[item] = 1
+    return counts
+
+def reverse_dict(d: dict) -> dict:
+    """
+    This function reverses the keys and values of a dictionary.
+    """
+    return {v: k for k, v in d.items()}
diff --git a/Week03/sequences_enes_dogan.py b/Week03/sequences_enes_dogan.py
@@ -0,0 +1,25 @@
+def remove_duplicates(seq: list) -> list:
+    """
+    This function removes duplicates from a list.
+    """
+    return list(set(seq))
+
+
+def list_counts(seq: list) -> dict:
+    """
+    This function counts the number of occurrences of each item in a list.
+    """
+    counts = {}
+    for item in seq:
+        if item in counts:
+            counts[item] += 1
+        else:
+            counts[item] = 1
+    return counts
+    
+
+def reverse_dict(d: dict) -> dict:
+    """
+    This function reverses the keys and values of a dictionary.
+    """
+    return {value: key for (key, value) in d.items()}
diff --git a/Week03/sequences_eren_malkoc.py b/Week03/sequences_eren_malkoc.py
@@ -0,0 +1,11 @@
+def remove_duplicates(seq: list) -> list:
+
+    return list(set(seq))
+
+def list_counts(seq: list) -> dict:
+    
+    return {i: seq.count(i) for i in set(seq)}
+
+def reverse_dict(d: dict) -> dict:
+
+    return {v: k for k, v in d.items()}
diff --git a/Week03/sequences_furkan_bulut.py b/Week03/sequences_furkan_bulut.py
@@ -0,0 +1,18 @@
+def remove_duplicates(seq: list) -> list:
+    """
+    This function removes duplicates from a list.
+    """
+    return list(set(seq))
+
+def list_counts(seq: list) -> dict:
+    """
+    This function counts the number of occurrences of each item in a list.
+    """
+    return {i: seq.count(i) for i in seq}
+
+def reverse_dict(d: dict) -> dict:
+    """
+    This function reverses the keys and values of a dictionary.
+    """
+    return {v: k for k, v in d.items()}
+
diff --git a/Week03/sequences_soner_basak.py b/Week03/sequences_soner_basak.py
@@ -0,0 +1,19 @@
+def remove_duplicates(seq: list) -> list:
+    """
+    This function removes duplicates from a list.
+    """
+    return list(set(seq))
+
+def list_counts(seq: list) -> dict:
+    """
+    This function counts the number of
+    occurrences of each item in a list.
+    """
+    return {num: seq.count(num) for num in seq}
+
+def reverse_dict(d: dict) -> dict:
+    """
+    This function reverses the keys
+    and values of a dictionary.
+    """
+    return {v: k for (k, v) in d.items()}
diff --git a/Week03/sequences_ufuk_dilek.py b/Week03/sequences_ufuk_dilek.py
@@ -0,0 +1,18 @@
+
+def remove_duplicates(seq: list) -> list:
+    return list(set(seq))
+
+
+def list_counts(seq: list) -> dict:
+    result = dict.fromkeys(seq, 0)
+    for i in seq:
+        result[i] += 1
+    return result
+
+
+def reverse_dict(d: dict) -> dict:
+    result = {}
+    for i in d.items():
+        result[i[1]] = i[0]
+    return result
+
diff --git a/Week04/decorators_cagan_atan.py b/Week04/decorators_cagan_atan.py
@@ -0,0 +1,25 @@
+import tracemalloc
+import time
+
+
+def performance(func):
+    performance.counter = 0
+    performance.total_time = 0
+    performance.total_mem = 0
+
+    def _wrapper(*args, **kwargs):
+        performance.counter += 1
+        start_time = time.time()
+        tracemalloc.start()
+        snapshot1 = tracemalloc.take_snapshot()
+        result = func(*args, **kwargs)
+        snapshot2 = tracemalloc.take_snapshot()
+        tracemalloc.stop()
+        end_time = time.time()
+
+        performance.total_time += end_time - start_time
+        performance.total_mem += snapshot2.compare_to(snapshot1, "lineno")[0].size_diff
+
+        return result
+
+    return _wrapper
diff --git a/Week04/decorators_furkan_bulut.py b/Week04/decorators_furkan_bulut.py
@@ -0,0 +1,81 @@
+import time
+import tracemalloc
+
+def performance(fn):
+    """
+    Decorator to measure performance metrics of a function.
+
+    This decorator tracks the execution time and memory usage of the decorated
+    function, printing the results after each call.
+
+    :param fn: The function to be decorated.
+    :returns: A wrapped function that tracks performance metrics.
+    :raises Exception: If an error occurs during the execution of the decorated function.
+    """
+
+    setattr(performance, 'counter', 0)
+    setattr(performance, 'total_time', 0.0)
+    setattr(performance, 'total_mem', 0.0)
+
+    def _performance(*args, **kwargs):
+        """
+        Wrapper function that measures execution time and memory usage.
+
+        :param args: Positional arguments to be passed to the decorated function.
+        :param kwargs: Keyword arguments to be passed to the decorated function.
+        """
+        counter = getattr(performance, 'counter')
+        total_time = getattr(performance, 'total_time')
+        total_mem = getattr(performance, 'total_mem')
+
+        counter += 1
+        setattr(performance, 'counter', counter)
+
+        tracemalloc.start()
+        start_time = time.time()
+
+        try:
+            fn(*args, **kwargs)
+        except Exception as e:
+            print(f"Error occurred: {e}")
+        finally:
+            end_time = time.time()
+            current, peak = tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+
+            elapsed_time = end_time - start_time
+            memory_usage = peak
+
+            total_time += elapsed_time
+            total_mem += memory_usage
+
+            setattr(performance, 'total_time', total_time)
+            setattr(performance, 'total_mem', total_mem)
+
+            print_results(fn.__name__, elapsed_time, memory_usage, counter, total_time, total_mem)
+
+    return _performance
+
+def print_results(func_name, elapsed_time, memory_usage, counter, total_time, total_mem):
+    """
+    Display the performance results of the decorated function.
+
+    This function prints the name of the function being measured, the elapsed time,
+    memory usage, and the total statistics over all calls.
+
+    :param func_name: The name of the function being measured.
+    :param elapsed_time: The time taken for the function to execute, in seconds.
+    :param memory_usage: The peak memory usage during the function execution, in bytes.
+    :param counter: Number of times the decorated function has been called.
+    :param total_time: Total execution time of the decorated function.
+    :param total_mem: Total peak memory usage of the decorated function.
+    """
+    results = (
+        f"Function Name: {func_name}\n"
+        f"Number of Calls: {counter}\n"
+        f"Elapsed Time: {elapsed_time:.6f} seconds\n"
+        f"Memory Usage: {memory_usage / 1024:.2f} KB\n"
+        f"Total Time: {total_time:.6f} seconds\n"
+        f"Total Memory Usage: {total_mem / 1024:.2f} KB\n"
+    )
+    print(results)
diff --git a/Week04/decorators_soner_basak.py b/Week04/decorators_soner_basak.py
diff --git a/Week04/decorators_zeki_akgul.py b/Week04/decorators_zeki_akgul.py
diff --git a/Week04/functions_cagan_atan.py b/Week04/functions_cagan_atan.py
diff --git a/Week04/functions_furkan_bulut.py b/Week04/functions_furkan_bulut.py
diff --git a/Week04/functions_soner_basak.py b/Week04/functions_soner_basak.py
diff --git a/Week04/functions_ufuk_dilek.py b/Week04/functions_ufuk_dilek.py
diff --git a/Week04/functions_zeki_akgul.py b/Week04/functions_zeki_akgul.py
