kornevma/docs/1/main.py

@@ -0,0 +1,349 @@
+import random
+import time
+import csv
+import sys
+
+sys.setrecursionlimit(10**8)#прикалюха 6 вылетаел
+
+def mk(name, phone):
+    return {"name": name, "phone": phone}
+
+def ll_create_node(record):
+    return [record, None]
+
+def ll_insert(ll_head, record):
+    new_node = ll_create_node(record)
+    new_node[1] = ll_head[0]
+    ll_head[0] = new_node
+
+def ll_find(ll_head, name):
+    cur = ll_head[0]
+    while cur:
+        if cur[0]["name"] == name:
+            return cur[0]
+        cur = cur[1]
+    return None
+
+def ll_delete(ll_head, name):
+    cur = ll_head[0]
+    prev = None
+    while cur:
+        if cur[0]["name"] == name:
+            if prev:
+                prev[1] = cur[1]
+            else:
+                ll_head[0] = cur[1]
+            return True
+        prev = cur
+        cur = cur[1]
+    return False
+
+def ll_list_all(ll_head):
+    res = []
+    cur = ll_head[0]
+    while cur:
+        res.append(cur[0])
+        cur = cur[1]
+    return res
+
+def ht_hash(name, size):
+    return hash(name) % size
+
+def ht_insert(table, record):
+    idx = ht_hash(record["name"], len(table))
+    new_node = ll_create_node(record)
+    new_node[1] = table[idx]
+    table[idx] = new_node
+
+def ht_find(table, name):
+    idx = ht_hash(name, len(table))
+    cur = table[idx]
+    while cur:
+        if cur[0]["name"] == name:
+            return cur[0]
+        cur = cur[1]
+    return None
+
+def ht_delete(table, name):
+    idx = ht_hash(name, len(table))
+    cur = table[idx]
+    prev = None
+    while cur:
+        if cur[0]["name"] == name:
+            if prev:
+                prev[1] = cur[1]
+            else:
+                table[idx] = cur[1]
+            return True
+        prev = cur
+        cur = cur[1]
+    return False
+
+def ht_list_all(table):
+    res = []
+    for head in table:
+        cur = head
+        while cur:
+            res.append(cur[0])
+            cur = cur[1]
+    return res
+
+def bst_create_node(record):
+    return [record, None, None]
+
+def bst_insert(root, record):
+    if root is None:
+        return bst_create_node(record)
+    if record["name"] < root[0]["name"]:
+        root[1] = bst_insert(root[1], record)
+    elif record["name"] > root[0]["name"]:
+        root[2] = bst_insert(root[2], record)
+    else:
+        root[0] = record
+    return root
+
+def bst_find(root, name):
+    if root is None:
+        return None
+    if name == root[0]["name"]:
+        return root[0]
+    elif name < root[0]["name"]:
+        return bst_find(root[1], name)
+    else:
+        return bst_find(root[2], name)
+
+def bst_find_min(node):
+    while node[1] is not None:
+        node = node[1]
+    return node
+
+def bst_delete(root, name):
+    if root is None:
+        return None
+    if name < root[0]["name"]:
+        root[1] = bst_delete(root[1], name)
+    elif name > root[0]["name"]:
+        root[2] = bst_delete(root[2], name)
+    else:
+        if root[1] is None:
+            return root[2]
+        elif root[2] is None:
+            return root[1]
+        else:
+            succ = bst_find_min(root[2])
+            root[0] = succ[0]
+            root[2] = bst_delete(root[2], succ[0]["name"])
+    return root
+
+def bst_list_all(root):
+    def inorder(node):
+        if node is None:
+            return []
+        return inorder(node[1]) + [node[0]] + inorder(node[2])
+    return inorder(root)
+
+def tmr(func):
+    def wrapper(*args, **kwargs):
+        start = time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = time.perf_counter() - start
+        return result, elapsed
+    return wrapper
+
+@tmr
+def ins_ll(ll_head, records):
+    for rec in records:
+        ll_insert(ll_head, rec)
+
+@tmr
+def fnd_ll(ll_head, names):
+    for name in names:
+        ll_find(ll_head, name)
+
+@tmr
+def del_ll(ll_head, names):
+    for name in names:
+        ll_delete(ll_head, name)
+
+@tmr
+def ins_ht(table, records):
+    for rec in records:
+        ht_insert(table, rec)
+
+@tmr
+def fnd_ht(table, names):
+    for name in names:
+        ht_find(table, name)
+
+@tmr
+def del_ht(table, names):
+    for name in names:
+        ht_delete(table, name)
+
+@tmr
+def ins_bst(root, records):
+    for rec in records:
+        root = bst_insert(root, rec)
+    return root
+
+@tmr
+def fnd_bst(root, names):
+    for name in names:
+        bst_find(root, name)
+
+@tmr
+def del_bst(root, names):
+    for name in names:
+        root = bst_delete(root, name)
+    return root
+
+def gen(n, seed=42):
+    random.seed(seed)
+    recs = []
+    for i in range(n):
+        name = f"user_{i:05d}"
+        phone = random.randint(1000000, 9999999)
+        recs.append(mk(name, phone))
+    return recs
+
+def prep(recs, ecnt=100, mcnt=10):
+    alln = [r["name"] for r in recs]
+    ex = random.sample(alln, ecnt)
+    ms = [f"none_{i}" for i in range(mcnt)]
+    sn = ex + ms
+    dn = random.sample(alln, 50)
+    return sn, dn
+
+def prm(n):
+    if n < 2: return False
+    if n % 2 == 0: return n == 2
+    d = 3
+    while d * d <= n:
+        if n % d == 0: return False
+        d += 2
+    return True
+
+def nxtprm(n):
+    while not prm(n):
+        n += 1
+    return n
+
+def bench(n=10000, rpts=5):
+    recs = gen(n)
+    shuf = recs.copy()
+    random.shuffle(shuf)
+    srt = sorted(recs, key=lambda r: r["name"])
+
+    snms, dnms = prep(recs)
+
+    htsz = nxtprm(2 * n)
+
+    exps = [
+        {
+            "name": "linkedlist",
+            "init_empty": lambda: [None],
+            "insert": ins_ll,
+            "find": fnd_ll,
+            "delete": del_ll,
+        },
+        {
+            "name": "hashtable",
+            "init_empty": lambda: [None] * htsz,
+            "insert": ins_ht,
+            "find": fnd_ht,
+            "delete": del_ht,
+        },
+        {
+            "name": "bst",
+            "init_empty": lambda: None,
+            "insert": ins_bst,
+            "find": fnd_bst,
+            "delete": del_bst,
+        },
+    ]
+
+    res = []
+
+    for e in exps:
+        sn = e["name"]
+        for mn, recs_set in [("shuffled", shuf), ("sorted", srt)]:
+            for rp in range(1, rpts + 1):
+                st = e["init_empty"]()
+
+                if sn == "bst":
+                    st, ti = e["insert"](st, recs_set)
+                else:
+                    _, ti = e["insert"](st, recs_set)
+
+                _, tf = e["find"](st, snms)
+
+                if sn == "bst":
+                    st, td = e["delete"](st, dnms)
+                else:
+                    _, td = e["delete"](st, dnms)
+
+                res.append([sn, mn, "insert", rp, ti])
+                res.append([sn, mn, "find", rp, tf])
+                res.append([sn, mn, "delete", rp, td])
+
+    with open("results.csv", "w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(["тип", "режим", "операция", "повтор", "время"])
+        w.writerows(res)
+
+    from collections import defaultdict
+    agg = defaultdict(list)
+    for row in res:
+        k = (row[0], row[1], row[2])
+        agg[k].append(row[4])
+    print("\n5 повторов в ср:")
+    print(f"{'тип':<15} {'режим':<10} {'операция':<10} {'срдений':<10}")
+    for k, times in sorted(agg.items()):
+        avg = sum(times) / len(times)
+        print(f"{k[0]:<15} {k[1]:<10} {k[2]:<10} {avg:<10.6f}")
+
+    return res, agg
+
+def plot(agg):
+    try:
+        import matplotlib.pyplot as plt
+    except ImportError:
+        print("матплотлтб скачать")
+        return
+
+    sts = ["linkedlist", "hashtable", "bst"]
+    mds = ["shuffled", "sorted"]
+    ops = ["insert", "find", "delete"]
+
+    fig, axes = plt.subplots(1, 3, figsize=(16, 5))
+    fig.suptitle("сравенние", fontsize=14)
+
+    for oi, op in enumerate(ops):
+        ax = axes[oi]
+        data = []
+        for s in sts:
+            for m in mds:
+                k = (s, m, op)
+                avg = sum(agg[k]) / len(agg[k]) if k in agg else 0
+                data.append(avg)
+        x = range(len(sts))
+        width = 0.35
+        svals = [data[i*2] for i in range(len(sts))]
+        svals2 = [data[i*2+1] for i in range(len(sts))]
+
+        ax.bar([i - width/2 for i in x], svals, width, label='shuffled')
+        ax.bar([i + width/2 for i in x], svals2, width, label='sorted')
+        ax.set_xticks(x)
+        ax.set_xticklabels(sts)
+        ax.set_title(op)
+        ax.set_ylabel('время (sec)')
+        ax.legend()
+
+    plt.tight_layout()
+    plt.savefig("kortinko.png")
+    plt.show()
+    print("zibka kortinko.png")
+
+if __name__ == "__main__":
+    res, agg = bench(n=10000, rpts=5)
+    plot(agg)

kornevma/docs/results.csv

@@ -0,0 +1,91 @@
+тип,режим,операция,повтор,время
+linkedlist,shuffled,insert,1,0.00348759995540604
+linkedlist,shuffled,find,1,0.10299369995482266
+linkedlist,shuffled,delete,1,0.06881969998357818
+linkedlist,shuffled,insert,2,0.002795599983073771
+linkedlist,shuffled,find,2,0.11420650000218302
+linkedlist,shuffled,delete,2,0.050943999958690256
+linkedlist,shuffled,insert,3,0.003374699968844652
+linkedlist,shuffled,find,3,0.09485340001992881
+linkedlist,shuffled,delete,3,0.04981170000974089
+linkedlist,shuffled,insert,4,0.002937599958386272
+linkedlist,shuffled,find,4,0.0926941999932751
+linkedlist,shuffled,delete,4,0.04564540000865236
+linkedlist,shuffled,insert,5,0.0032468000426888466
+linkedlist,shuffled,find,5,0.09445199999026954
+linkedlist,shuffled,delete,5,0.06562509998911992
+linkedlist,sorted,insert,1,0.004829699988476932
+linkedlist,sorted,find,1,0.05208860000129789
+linkedlist,sorted,delete,1,0.06792090000817552
+linkedlist,sorted,insert,2,0.0030329000437632203
+linkedlist,sorted,find,2,0.09589699999196455
+linkedlist,sorted,delete,2,0.024623799952678382
+linkedlist,sorted,insert,3,0.0023055000347085297
+linkedlist,sorted,find,3,0.05262780003249645
+linkedlist,sorted,delete,3,0.035465800028759986
+linkedlist,sorted,insert,4,0.003455400001257658
+linkedlist,sorted,find,4,0.06551479996414855
+linkedlist,sorted,delete,4,0.0368536000023596
+linkedlist,sorted,insert,5,0.0036825999850407243
+linkedlist,sorted,find,5,0.05081029998837039
+linkedlist,sorted,delete,5,0.02609110000776127
+hashtable,shuffled,insert,1,0.008456900017336011
+hashtable,shuffled,find,1,7.070001447573304e-05
+hashtable,shuffled,delete,1,3.9300008211284876e-05
+hashtable,shuffled,insert,2,0.0068731000064872205
+hashtable,shuffled,find,2,6.079999729990959e-05
+hashtable,shuffled,delete,2,3.4599972423166037e-05
+hashtable,shuffled,insert,3,0.008831500017549843
+hashtable,shuffled,find,3,6.859999848529696e-05
+hashtable,shuffled,delete,3,5.959998816251755e-05
+hashtable,shuffled,insert,4,0.009147099975962192
+hashtable,shuffled,find,4,5.989999044686556e-05
+hashtable,shuffled,delete,4,3.470003139227629e-05
+hashtable,shuffled,insert,5,0.006436199997551739
+hashtable,shuffled,find,5,4.67000063508749e-05
+hashtable,shuffled,delete,5,2.6500027161091566e-05
+hashtable,sorted,insert,1,0.0056028999970294535
+hashtable,sorted,find,1,7.159996312111616e-05
+hashtable,sorted,delete,1,3.060000017285347e-05
+hashtable,sorted,insert,2,0.006678299978375435
+hashtable,sorted,find,2,0.00012290000449866056
+hashtable,sorted,delete,2,3.4299970138818026e-05
+hashtable,sorted,insert,3,0.005322600016370416
+hashtable,sorted,find,3,4.8499961849302053e-05
+hashtable,sorted,delete,3,2.600002335384488e-05
+hashtable,sorted,insert,4,0.006450399989262223
+hashtable,sorted,find,4,7.379997987300158e-05
+hashtable,sorted,delete,4,4.780001472681761e-05
+hashtable,sorted,insert,5,0.0060063999844715
+hashtable,sorted,find,5,5.689996760338545e-05
+hashtable,sorted,delete,5,3.120000474154949e-05
+bst,shuffled,insert,1,0.05349189997650683
+bst,shuffled,find,1,0.0005713000427931547
+bst,shuffled,delete,1,0.0002283000503666699
+bst,shuffled,insert,2,0.05809580005006865
+bst,shuffled,find,2,0.00046800001291558146
+bst,shuffled,delete,2,0.00030310003785416484
+bst,shuffled,insert,3,0.05402979999780655
+bst,shuffled,find,3,0.0005937999812886119
+bst,shuffled,delete,3,0.0002316000172868371
+bst,shuffled,insert,4,0.0533465999760665
+bst,shuffled,find,4,0.000450699997600168
+bst,shuffled,delete,4,0.00031700002728030086
+bst,shuffled,insert,5,0.05407660000491887
+bst,shuffled,find,5,0.0004341000458225608
+bst,shuffled,delete,5,0.0002673999988473952
+bst,sorted,insert,1,24.01944399997592
+bst,sorted,find,1,0.2082300999900326
+bst,sorted,delete,1,0.11376300000119954
+bst,sorted,insert,2,24.020037700014655
+bst,sorted,find,2,0.21519700001226738
+bst,sorted,delete,2,0.1168955999892205
+bst,sorted,insert,3,23.98331290000351
+bst,sorted,find,3,0.20412800001213327
+bst,sorted,delete,3,0.16615210002055392
+bst,sorted,insert,4,24.231940899975598
+bst,sorted,find,4,0.2066795999999158
+bst,sorted,delete,4,0.13191749999532476
+bst,sorted,insert,5,23.72923769999761
+bst,sorted,find,5,0.22344960004556924
+bst,sorted,delete,5,0.11515349999535829

kornevma/main.py

@@ -1,146 +0,0 @@
-import random
-import time
-import sys
-
-def mr(name, phone):
-    return {"name": name, "phone": phone}
-
-#llист
-def ll_create_node(record):
-    return [record, None]
-
-def ll_insert(ll_head, record):
-    new_node = ll_create_node(record)
-    new_node[1] = ll_head[0]
-    ll_head[0] = new_node
-
-def ll_find(ll_head, name):
-    cur = ll_head[0]
-    while cur:
-        if cur[0]["name"] == name:
-            return cur[0]
-        cur = cur[1]
-    return None
-
-def ll_delete(ll_head, name):
-    cur = ll_head[0]
-    prev = None
-    while cur:
-        if cur[0]["name"] == name:
-            if prev:
-                prev[1] = cur[1]
-            else:
-                ll_head[0] = cur[1]
-            return True
-        prev = cur
-        cur = cur[1]
-    return False
-
-def ll_list_all(ll_head):
-    res = []
-    cur = ll_head[0]
-    while cur:
-        res.append(cur[0])
-        cur = cur[1]
-    return res
-
-#ht
-def ht_hash(name, size):
-    return hash(name) % size
-def ht_insert(table, record):
-    idx = ht_hash(record["name"], len(table))
-    new_node = ll_create_node(record)
-    new_node[1] = table[idx]
-    table[idx] = new_node
-
-def ht_find(table, name):
-    idx = ht_hash(name, len(table))
-    cur = table[idx]
-    while cur:
-        if cur[0]["name"] == name:
-            return cur[0]
-        cur = cur[1]
-    return None
-
-def ht_delete(table, name):
-    idx = ht_hash(name, len(table))
-    cur = table[idx]
-    prev = None
-    while cur:
-        if cur[0]["name"] == name:
-            if prev:
-                prev[1] = cur[1]
-            else:
-                table[idx] = cur[1]
-            return True
-        prev = cur
-        cur = cur[1]
-    return False
-
-def ht_list_all(table):
-    res = []
-    for head in table:
-        cur = head
-        while cur:
-            res.append(cur[0])
-            cur = cur[1]
-    return res
-
-
-# bst
-def bst_create_node(record):
-    return [record, None, None]
-
-def bst_insert(root, record):
-    if root is None:
-        return bst_create_node(record)
-    if record["name"] < root[0]["name"]:
-        root[1] = bst_insert(root[1], record)
-    elif record["name"] > root[0]["name"]:
-        root[2] = bst_insert(root[2], record)
-    else: #мб
-        root[0] = record
-    return root
-
-def bst_find(root, name):
-    if root is None:
-        return None
-    if name == root[0]["name"]:
-        return root[0]
-    elif name < root[0]["name"]:
-        return bst_find(root[1], name)
-    else:
-        return bst_find(root[2], name)
-
-def bst_find_min(node):
-    while node[1] is not None:
-        node = node[1]
-    return node
-
-def bst_delete(root, name):
-    if root is None:
-        return None
-    if name < root[0]["name"]:
-        root[1] = bst_delete(root[1], name)
-    elif name > root[0]["name"]:
-        root[2] = bst_delete(root[2], name)
-    else:
-
-        if root[1] is None:
-            return root[2]
-        elif root[2] is None:
-            return root[1]
-        else:
-            succ = bst_find_min(root[2])
-            root[0] = succ[0]
-            root[2] = bst_delete(root[2], succ[0]["name"])
-    return root
-
-def bst_list_all(root):
-    def inorder(node):
-        if node is None:
-            return []
-        return inorder(node[1]) + [node[0]] + inorder(node[2])
-    return inorder(root)
-if __name__ == "__main__":
-    print('cba')