خوارزميات الحاسوب وقابلية القسمة

⚡ تحسين الأداء والسرعة

🚀 كيف تُحسن قابلية القسمة أداء الخوارزميات؟

قابلية القسمة تلعب دوراً محورياً في تحسين الخوارزميات من خلال تقليل عدد العمليات المطلوبة وتحسين استخدام الذاكرة.

🐌 الطريقة التقليدية

فحص جميع الأعداد واحداً تلو الآخر

O(n)

⚡ استخدام قابلية القسمة

فحص الأعداد بناءً على خصائص القسمة

O(√n)

🎯 التحسين المتقدم

دمج عدة معايير للحصول على أفضل أداء

O(log n)

💡 مثال عملي: إيجاد الأعداد الأولية

// الطريقة الساذجة - بطيئة
function isPrimeNaive(n) {
    for (let i = 2; i < n; i++) {
        if (n % i === 0) return false;
    }
    return true;
}

// الطريقة المحسنة - استخدام قابلية القسمة
function isPrimeOptimized(n) {
    if (n < 2) return false;
    if (n === 2) return true;
    if (n % 2 === 0) return false; // فحص القسمة على 2
    
    for (let i = 3; i <= Math.sqrt(n); i += 2) {
        if (n % i === 0) return false;
    }
    return true;
}
                        

📊 مقارنة الأداء

فحص العدد 1,000,000:

الطريقة التقليدية: 999,998 عملية

الطريقة المحسنة: 500 عملية

تحسن بنسبة: 99.95%

🔍

البحث السريع

استخدام معايير القسمة لتسريع عمليات البحث في قواعد البيانات

🧮

العمليات الحسابية

تحسين حسابات المضاعفات والقواسم في النظم الرقمية

⚙️

إدارة الذاكرة

تنظيم الذاكرة بناءً على أحجام قابلة للقسمة

🔐 خوارزميات التجزئة (Hashing)

🗝️ دور قابلية القسمة في التجزئة

خوارزميات التجزئة تستخدم عمليات القسمة لتوزيع البيانات بشكل متساوٍ وتجنب التصادمات.

1️⃣ Division Method

استخدام باقي القسمة لتحديد موقع البيانات

h(k) = k mod m

2️⃣ اختيار الرقم الأولي

استخدام أعداد أولية كحجم للجدول لتقليل التصادمات

m = prime number

3️⃣ Multiplication Method

دمج الضرب والقسمة للحصول على توزيع أفضل

h(k) = ⌊m(kA mod 1)⌋

🔧 مثال: Hash Table Implementation

class HashTable {
    constructor(size = 53) { // حجم أولي
        this.keyMap = new Array(size);
    }
    
    hash(key) {
        let total = 0;
        let WEIRD_PRIME = 31;
        
        for (let char of key) {
            let value = char.charCodeAt(0) - 96;
            total = (total * WEIRD_PRIME + value) % this.keyMap.length;
        }
        return total;
    }
    
    set(key, value) {
        let index = this.hash(key);
        if (!this.keyMap[index]) {
            this.keyMap[index] = [];
        }
        this.keyMap[index].push([key, value]);
    }
}
                        

                        🎯 لماذا الأعداد الأولية؟

                        الأعداد الأولية تقلل احتمالية التصادمات لأنها لا تشارك عوامل مع أرقام أخرى

طريقة التجزئة	التعقد الزمني	معدل التصادمات	الاستخدام المثالي
Division Method	O(1)	متوسط	التطبيقات البسيطة
Multiplication Method	O(1)	منخفض	النظم المعقدة
Universal Hashing	O(1)	منخفض جداً	الأنظمة الحساسة

📊 ضغط البيانات

🗜️ قابلية القسمة في ضغط البيانات

خوارزميات الضغط تستفيد من الأنماط الرياضية والقسمة لتقليل حجم البيانات بكفاءة.

🎵

ضغط الصوت

استخدام FFT والقسمة على ترددات معينة

DSP

🖼️

ضغط الصور

تقسيم الصورة لبلوكات 8x8 في JPEG

DCT

📹

ضغط الفيديو

تنبؤ الحركة باستخدام أنماط القسمة

H.264

📄

ضغط النصوص

خوارزميات Huffman وLempel-Ziv

LZW

🔍 مثال: Run-Length Encoding

function runLengthEncode(data) {
    let encoded = '';
    let count = 1;
    
    for (let i = 1; i < data.length; i++) {
        if (data[i] === data[i-1]) {
            count++;
        } else {
            // استخدام القسمة لتحسين التخزين
            if (count % 2 === 0) {
                encoded += data[i-1] + count/2 + data[i-1] + count/2;
            } else {
                encoded += data[i-1] + count;
            }
            count = 1;
        }
    }
    return encoded;
}
                        

📈 نسب الضغط

نصوص: 50-60%

صور: 80-95%

فيديو: 95-99%

🔄 توزيع الحمولة

⚖️ استخدام القسمة في توزيع الأحمال

أنظمة توزيع الحمولة تستخدم عمليات القسمة لتوزيع الطلبات بشكل متساوٍ على الخوادم.

🎯 Round Robin with Modulo

استخدام باقي القسمة لتوزيع الطلبات دورياً

server = request_id mod total_servers

🎲 Consistent Hashing

استخدام hash functions مع القسمة للتوزيع المتسق

position = hash(key) mod ring_size

📊 Weighted Distribution

توزيع بناءً على قوة الخوادم باستخدام النسب

weight = server_capacity / total_capacity

🔧 مثال: Load Balancer

class LoadBalancer {
    constructor(servers) {
        this.servers = servers;
        this.current = 0;
    }
    
    // Round Robin using modulo
    getNextServer() {
        const server = this.servers[this.current];
        this.current = (this.current + 1) % this.servers.length;
        return server;
    }
    
    // Hash-based distribution
    getServerByKey(key) {
        const hash = this.simpleHash(key);
        const index = hash % this.servers.length;
        return this.servers[index];
    }
    
    simpleHash(key) {
        let hash = 0;
        for (let char of key) {
            hash = hash * 31 + char.charCodeAt(0);
        }
        return Math.abs(hash);
    }
}
                        

🔄 Round Robin

بسيط وسريع، مناسب للخوادم المتساوية

O(1)

🎲 Hash-based

توزيع متسق، مناسب للتطبيقات الحساسة

O(1)

📊 Weighted

مراعاة قوة الخوادم، توزيع عادل

O(log n)

🔗 الحوسبة المتوازية

⚡ تقسيم المهام للمعالجة المتوازية

الحوسبة المتوازية تعتمد على تقسيم المشاكل الكبيرة إلى أجزاء أصغر يمكن معالجتها بشكل متزامن.

🧩

تقسيم البيانات

تقسيم المصفوفات والبيانات الكبيرة

Data Parallelism

🔄

تقسيم المهام

توزيع العمليات المختلفة على معالجات

Task Parallelism

🌐

الحوسبة الموزعة

تقسيم العمل عبر شبكة من الحاسبات

Distributed

💡 مثال: Parallel Matrix Multiplication

// تقسيم ضرب المصفوفات على عدة خيوط
function parallelMatrixMultiply(A, B, numThreads) {
    const n = A.length;
    const C = Array(n).fill().map(() => Array(n).fill(0));
    
    // تقسيم الصفوف على الخيوط
    const rowsPerThread = Math.ceil(n / numThreads);
    const threads = [];
    
    for (let t = 0; t < numThreads; t++) {
        const startRow = t * rowsPerThread;
        const endRow = Math.min(startRow + rowsPerThread, n);
        
        threads.push(
            new Worker(function() {
                for (let i = startRow; i < endRow; i++) {
                    for (let j = 0; j < n; j++) {
                        for (let k = 0; k < n; k++) {
                            C[i][j] += A[i][k] * B[k][j];
                        }
                    }
                }
            })
        );
    }
    
    return C;
}
                        

📊 تسريع الأداء

معالجة مصفوفة 1000x1000:

خيط واحد: 60 ثانية

4 خيوط: 18 ثانية

8 خيوط: 12 ثانية

تحسن: 5x أسرع

نوع التوازي	التعقد	الكفاءة	التطبيق الأمثل
Data Parallel	O(n/p)	عالية	معالجة الصور
Task Parallel	O(log n)	متوسطة	الخوارزميات المعقدة
Pipeline	O(n + p)	عالية جداً	معالجة البيانات المستمرة

                        ⚡ قانون أمدال: السرعة النظرية المثلى = 1 / ((1-p) + p/n)

                        حيث p = النسبة المتوازية، n = عدد المعالجات

💻 خوارزميات الحاسوب وقابلية القسمة