تابع Hash یک کلید را به عنوان ورودی می گیرد و یک مقدار عددی منحصر به فرد به نام کد Hash تولید می کند که به عنوان یک شاخص برای یک عنصر داده خاص عمل می کند. این فرآیند نگاشت قطعی است، به این معنی که یک کلید همیشه به همان شاخص Hash می شود و جستجو و بازیابی سریع مقادیر را تسهیل می کند.

ما از جداول Hash برای نگاشت سریع کلیدها به مکان های خاص در آرایه استفاده می کنیم. هدف تابع Hash توزیع مناسب کلیدها در بین شاخص‌های آرایه، به حداقل رساندن برخوردها (موقعیت‌هایی که چندین کلید به یک شاخص نگاشت می‌شوند) است.

جداول Hash در سناریوهایی که به ذخیره سازی و بازیابی کارآمد جفت های کلید-مقدار مورد نیاز است - برای مثال، سیستم های حافظه پنهان، رایج هستند. علاوه بر این، ما از جداول Hash در وظایف پردازش داده ها مانند نمایه سازی و حذف مجدد استفاده می کنیم.

📣👨‍💻 @AlgorithmDesign_DataStructuer

شبه کد ضرب دو عدد با استفاده از الگورتیم Divide and Conquer
📣👨‍💻 @AlgorithmDesign_DataStructuer

def Divide_remaining(m,n):
    if m < n:
        return m
    else:
        return Divide_remaining(m-n,n)


m = int(input("Enter the number of elements in the list: "))
n = int(input("Enter the number of elements to be divided: "))

print("The remainder of dividing m by n :" , Divide_remaining(m,n))

✅کد بازگشتی باقی مانده تقسیم m بر n

📣👨‍💻 @AlgorithmDesign_DataStructuer

الگوریتم فلوید (Floyd's algorithm) یکی از الگوریتم‌های معروف برای محاسبه کوتاه‌ترین مسیرها در گراف‌ها است. این الگوریتم به نام دانشمند ریاضی و کامپیوتری "رابرت فلوید" نام‌گذاری شده است.

در این الگوریتم، فرض می‌شود که وزن هر یال می‌تواند منفی یا مثبت باشد. هدف این الگوریتم پیدا کردن کوتاه‌ترین مسیرها بین هر دو رأس از رأس‌های گراف است.

مراحل اصلی الگوریتم فلوید عبارتند از:

1. ماتریس وزن: ابتدا یک ماتریس وزن به نام D را تعریف می‌کنیم که در آن D[i][j] وزن کوتاه‌ترین مسیر بین رأس i و j است. این ماتریس در ابتدا برابر با وزن‌های یال‌های گراف است و برای یال‌هایی که میان دو رأس مستقیماً وجود ندارد (به جز خود رأس با خودش)، مقدار بی نهایت یا مقدار زیادی معرفی می‌شود.

2. الگوریتم اصلی: برای هر سه رأس i، j و k، الگوریتم مقدار D[i][j] را با استفاده از فرمول زیر به‌روزرسانی می‌کند:

D[i][j] = min(D[i][j], D[i][k] + D[k][j])

به عبارت دیگر، فرض می‌کنیم که ما به‌روزرسانی D[i][j] را انجام داده‌ایم و k رأسی است که از i به j مسیر می‌دهد. حالا ما وزن کوتاه‌ترین مسیر بین i و j را با استفاده از مقدار فعلی آن (D[i][j]) و وزن مسیر i به k به‌علاوه وزن مسیر k به j (D[i][k] + D[k][j]) محاسبه می‌کنیم. اگر این مقدار کمتر از مقدار فعلی D[i][j] باشد، D[i][j] را به‌روزرسانی می‌کنیم.

3. پایان الگوریتم: بعد از اجرای مرحله 2 برای همه سه رأس i، j و k، ماتریس D به‌روز شده و حاوی اطلاعات کوتاه‌ترین مسیرهای بین هر زوج رأس است.

الگوریتم فلوید بسیار موثر است و با زمان اجرای O(V^3) انجام می‌شود، که در آن V تعداد رئوس گراف است. این الگوریتم به خوبی با وزن‌های منفی کار می‌کند، به شرطی که هیچ دور منفی در گراف وجود نداشته باشد، زیرا این الگوریتم قادر به تشخیص دورهای منفی نمی‌باشد و ممکن است در صورت وجود دور منفی به مقدار بی نهایت یا عدد بسیار بزرگی همگرا شود.
📣👨‍💻 @AlgorithmDesign_DataStructuer

برخی از لایه ها یا مراحل مهم برای الگوریتم CNN،

1. لایه پیچشی (مهمترین لایه در CNN)
2. عملکرد فعال سازی (افزایش قدرت، به خصوص لایه ReLu)

3. ادغام (کاهش ابعاد مانند PCA)

4. مسطح کردن (تبدیل فرم ماتریس به تک ستون بزرگ)

5. لایه فعال سازی - لایه SOFTMAX (لایه خروجی بیشتر، توزیع احتمال)

6. اتصال کامل (بستگی به هدف/متغیر وابسته دارد)

📣👨‍💻 @AlgorithmDesign_DataStructuer

def reverse(s):
    if s == "":
        return s
    else:
        return reverse(s[1:]) + s[0]

s = "Hello"
print("The original string is:", s)
print("The reversed string(using recursion) is:", reverse(s))

کد بازگشتی معکوس کردن رشته

📣👨‍💻 @AlgorithmDesign_DataStructuer

Greedy_knapack(n,W, p[1…n], w[1…n])
{
x=0; profit=0;
rw=W
for i=1 to n do
{
   if wi<rw then
     x[i]=1;
     rw=rw-wi;
   else
     break;
}
x[i]= 𝑟𝑤/𝑤𝑖;
profit= profit+p[i]*x[i];
}

الگوریتم کوله‌پشتی کسری (Fractional Knapsack Algorithm) یک الگوریتم زمان واقعی و محاسباتی برای حل مسئله کوله‌پشتی است. در این مسئله، ما یک کوله‌پشتی داریم که ظرفیت مشخصی دارد و می‌خواهیم اجناسی را درون آن بگذاریم به‌طوری که ارزش کلی اجناس درون کوله‌پشتی بیشینه شود. هر جنس دارای وزن و ارزش مشخصی است.

الگوریتم کوله‌پشتی کسری به این صورت است:

1. محاسبه نسبت ارزش به وزن (value/weight) برای هر جنس.
2. مرتب کردن اجناس بر اساس این نسبت.
3. از اجناس با بیشترین نسبت ارزش به وزن شروع به گذاشتن درون کوله‌پشتی می‌کنیم. اگر می‌توانیم همه‌ی اجناس را بگیریم، آنگاه همه‌ی آن‌ها را می‌گیریم. در غیر این صورت، قسمتی از آخرین جنسی که می‌توانیم درون کوله‌پشتی قرار دهیم را قطعه‌بندی می‌کنیم و به صورت جزئی از آن را می‌گذاریم.

الگوریتمی بالا این الگوریتم به ازای هر جنس، محاسبه می‌کند که چقدر از آن جنس می‌تواند بگیرد و این کار را به ترتیب جنس‌ها انجام می‌دهد. در نهایت، مقدار سود کلی که می‌توان با قراردادن اجناس داخل کوله‌پشتی بدست آورد، محاسبه می‌شود.

این الگوریتم در مسائلی که بهینه‌سازی نسبت به جمعیت جواب‌ها کارآمد است، اما در برخی موارد ممکن است بهینه نباشد.
مرتبه زمانی این الگوریتم O(n log n) می باشد.

📣👨‍💻 @AlgorithmDesign_DataStructuer

import torch

# Scalar
scalar = torch.tensor(7)
print(scalar)

# Vector
vector = torch.tensor([7 , 4])
print(vector)

# Matrix
matrix = torch.tensor([[7, 10], [4, 3] , [5, 1]])
print(matrix)

# Tensor
tensor = torch.tensor([[[1, 2, 3],
                        [3, 6, 9],
                        [2, 4, 5]]])
print(tensor)

با استفاده از کتابخانه torch می توانیم به راحتی 4 عمل بالا را نیز انجام دهیم که در شبکه های عصبی بسیار زیاد از این 4 عمل نیز استفاده می شود.

📣👨‍💻 @AlgorithmDesign_DataStructuer

def reverse_sum(n , m):
    if n <= 1 or m <= 1:
        return 1
    return n+m*reverse_sum(n-1 , m // 2)    

print(reverse_sum(2 ,3))
output 5

کد بازگشتی حاصل جمع دو عدد n و m

📣👨‍💻 @AlgorithmDesign_DataStructuer

مراحل الگوریتم کروسکال (Kruskal's algorithm)

1️⃣یال ها را به ترتیب صعودی وزن در نظر بگیر.
2️⃣کم وزن ترین یال باقیمانده را به درخت T اضافه کن , مگر آنکه این کار باعث اینجاد دور شود.

🚨به مثال بالا توجه کنید.

📣👨‍💻 @AlgorithmDesign_DataStructuer

import numpy as np 

A = np.array([[1 , 2] , [3 , 4] , [5 , 6]])
B = np.array([[2 , 1] , [0 , 1] , [3 ,2]])

C = A + B
print("sum of arrays A and B is : ", C)

sum of arrays A and B is : [[3 3]
[3 5]
[8 8]]
مجموع دو ماتریس با استفاده از کتاب خانه numpy

📣👨‍💻 @AlgorithmDesign_DataStructuer

رابطه بازگشتی فیبوناچی یک رابطه همگن می باشد که آن را میتوان به صورت معادله درجه دوم نوشت و پس از به دست آوردن ریشه های آن میتوان اعداد فیبوناچی را با رابطه بسیار ساده تر و کم هزینه تر به دست آورد.

📣👨‍💻 @AlgorithmDesign_DataStructuer

import numpy as np 

a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652],
              [0.54627315, 0.05093587, 0.40067661, 0.55645993],
              [0.12697628, 0.82485143, 0.26590556, 0.56917101]])
# Sum of all elements
print(a.sum())
output = 4.8595784

# Find the minimum value
print(a.min())
output = 0.05093587

# Find the maximum value
print(a.max())
output = 0.82485143

# Find the mean value
print(a.mean())
output = 0.40496518

sum:
⬅️این محاسبه مجموع تمام عناصر موجود در آرایه را انجام می دهد.
main:
⬅️این محاسبه مقدار کمینه در آرایه را انجام می دهد.
max:
⬅️این محاسبه مقدار بیشینه در آرایه را انجام می دهد.
mean:
⬅️این محاسبه میانگین تمام عناصر در آرایه را انجام می دهد.

📣👨‍💻 @AlgorithmDesign_DataStructuer

📚کتاب "یادگیری عمیق" به زبان فارسی + کار با Pytorch

📣👨‍💻 @AlgorithmDesign_DataStructuer