script.js

let exercisesData = {};
let currentLevel = 1;
let currentExerciseIndex = 0;
let currentExercises = [];

// عناصر DOM
const levelsSection = document.getElementById('levelsSection');
const exerciseSection = document.getElementById('exerciseSection');
const levelTitle = document.getElementById('levelTitle');
const exerciseId = document.getElementById('exerciseId');
const difficultyBadge = document.getElementById('difficultyBadge');
const exerciseTitle = document.getElementById('exerciseTitle');
const exerciseText = document.getElementById('exerciseText');
const hintSection = document.getElementById('hintSection');
const hintContent = document.getElementById('hintContent');
const solutionSection = document.getElementById('solutionSection');
const solutionContent = document.getElementById('solutionContent');
const answerInput = document.getElementById('answerInput');
const hintBtn = document.getElementById('hintBtn');
const solutionBtn = document.getElementById('solutionBtn');
const checkBtn = document.getElementById('checkBtn');
const nextBtn = document.getElementById('nextBtn');
const backBtn = document.getElementById('backBtn');
const prevExercise = document.getElementById('prevExercise');
const nextExercise = document.getElementById('nextExercise');
const exerciseCounter = document.getElementById('exerciseCounter');
const modal = document.getElementById('checkResultModal');
const modalIcon = document.getElementById('modalIcon');
const modalMessage = document.getElementById('modalMessage');

// تحميل بيانات التمارين
fetch('exercises.json')
    .then(response => response.json())
    .then(data => {
        exercisesData = data;
        console.log('تم تحميل التمارين بنجاح');
    })
    .catch(error => 
        console.error('خطأ في تحميل التمارين:', error));
        // بيانات احتياطية في حالة فشل التحميل
        exercisesData = {
  "1": [
    {
      "id": 1,
      "titre": "مجموع رقمين",
      "texte": "اكتب برنامجاً يقرأ رقمين صحيحين من المستخدم ويطبع مجموعهما.",
      "difficulte": "سهل",
      "hint": "استخدم دالة scanf لقراءة الأرقام والمتغيرات من نوع int.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int num1, num2, sum;\n    printf(\"أدخل الرقم الأول: \");\n    scanf(\"%d\", &num1);\n    printf(\"أدخل الرقم الثاني: \");\n    scanf(\"%d\", &num2);\n    sum = num1 + num2;\n    printf(\"مجموع %d و %d هو: %d\\n\", num1, num2, sum);\n    return 0;\n}"
    },
    {
      "id": 2,
      "titre": "الرقم زوجي أم فردي",
      "texte": "اكتب برنامجاً يقرر ما إذا كان الرقم المدخل زوجياً أم فردياً.",
      "difficulte": "سهل",
      "hint": "استخدم عامل باقي القسمة % للتحقق من قابلية القسمة على 2.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int num;\n    printf(\"أدخل رقماً: \");\n    scanf(\"%d\", &num);\n    if (num % 2 == 0) {\n        printf(\"%d هو رقم زوجي\\n\", num);\n    } else {\n        printf(\"%d هو رقم فردي\\n\", num);\n    }\n    return 0;\n}"
    },
    {
      "id": 3,
      "titre": "أكبر رقمين",
      "texte": "اكتب برنامجاً يقرأ رقمين ويطبع الرقم الأكبر.",
      "difficulte": "سهل",
      "hint": "استخدم جملة if-else لمقارنة الرقمين.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int a, b;\n    printf(\"أدخل الرقم الأول: \");\n    scanf(\"%d\", &a);\n    printf(\"أدخل الرقم الثاني: \");\n    scanf(\"%d\", &b);\n    if (a > b) {\n        printf(\"الرقم الأكبر هو: %d\\n\", a);\n    } else if (b > a) {\n        printf(\"الرقم الأكبر هو: %d\\n\", b);\n    } else {\n        printf(\"الرقمان متساويان\\n\");\n    }\n    return 0;\n}"
    },
    {
      "id": 4,
      "titre": "جدول ضرب",
      "texte": "اكتب برنامجاً يطبع جدول ضرب رقم معين (من 1 إلى 10).",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for للتكرار من 1 إلى 10.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int num;\n    printf(\"أدخل رقماً لطباعة جدول ضربه: \");\n    scanf(\"%d\", &num);\n    for (int i = 1; i <= 10; i++) {\n        printf(\"%d × %d = %d\\n\", num, i, num * i);\n    }\n    return 0;\n}"
    },
    {
      "id": 5,
      "titre": "مجموع الأرقام من 1 إلى N",
      "texte": "اكتب برنامجاً يحسب مجموع الأرقام من 1 إلى N (حيث N يدخله المستخدم).",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for أو الصيغة الرياضية N*(N+1)/2.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int n, sum = 0;\n    printf(\"أدخل رقماً N: \");\n    scanf(\"%d\", &n);\n    for (int i = 1; i <= n; i++) {\n        sum += i;\n    }\n    printf(\"مجموع الأرقام من 1 إلى %d هو: %d\\n\", n, sum);\n    return 0;\n}"
    },
    {
      "id": 6,
      "titre": "عاملي (Factorial)",
      "texte": "اكتب برنامجاً يحسب عاملي رقم (n!) حيث n يدخله المستخدم.",
      "difficulte": "متوسط",
      "hint": "العاملي هو حاصل ضرب جميع الأرقام من 1 إلى n.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int n;\n    long long factorial = 1;\n    printf(\"أدخل رقماً: \");\n    scanf(\"%d\", &n);\n    for (int i = 1; i <= n; i++) {\n        factorial *= i;\n    }\n    printf(\"%d! = %lld\\n\", n, factorial);\n    return 0;\n}"
    },
    {
      "id": 7,
      "titre": "عدّ الأرقام الزوجية",
      "texte": "اكتب برنامجاً يقرأ 10 أرقام من المستخدم ويطبع كم عدد الأرقام الزوجية.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for وعداد لتخزين عدد الأرقام الزوجية.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int num, count = 0;\n    printf(\"أدخل 10 أرقام:\\n\");\n    for (int i = 0; i < 10; i++) {\n        printf(\"رقم %d: \", i+1);\n        scanf(\"%d\", &num);\n        if (num % 2 == 0) count++;\n    }\n    printf(\"عدد الأرقام الزوجية هو: %d\\n\", count);\n    return 0;\n}"
    },
    {
      "id": 8,
      "titre": "الرقم الأولي",
      "texte": "اكتب برنامجاً يتحقق مما إذا كان الرقم المدخل أولياً أم لا.",
      "difficulte": "صعب",
      "hint": "الرقم الأولي يقبل القسمة فقط على 1 وعلى نفسه.",
      "solution": "#include <stdio.h>\n#include <math.h>\n\nint main() {\n    int num, isPrime = 1;\n    printf(\"أدخل رقماً: \");\n    scanf(\"%d\", &num);\n    if (num <= 1) isPrime = 0;\n    else {\n        for (int i = 2; i <= sqrt(num); i++) {\n            if (num % i == 0) {\n                isPrime = 0;\n                break;\n            }\n        }\n    }\n    if (isPrime) printf(\"%d هو رقم أولي\\n\", num);\n    else printf(\"%d ليس رقم أولي\\n\", num);\n    return 0;\n}"
    },
    {
      "id": 9,
      "titre": "عكس الرقم",
      "texte": "اكتب برنامجاً يعكس أرقام رقم معين (مثال: 1234 يصبح 4321).",
      "difficulte": "صعب",
      "hint": "استخدم حلقة while لاستخراج الأرقام من اليمين وبناء الرقم المعكوس.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int num, reversed = 0, remainder;\n    printf(\"أدخل رقماً: \");\n    scanf(\"%d\", &num);\n    int original = num;\n    while(num != 0) {\n        remainder = num % 10;\n        reversed = reversed * 10 + remainder;\n        num /= 10;\n    }\n    printf(\"الرقم الأصلي: %d\\n\", original);\n    printf(\"الرقم المعكوس: %d\\n\", reversed);\n    return 0;\n}"
    },
    {
      "id": 10,
      "titre": "فيبوناتشي",
      "texte": "اكتب برنامجاً يطبع أول n أرقام من متتالية فيبوناتشي.",
      "difficulte": "صعب",
      "hint": "متتالية فيبوناتشي تبدأ بـ 0, 1 وكل رقم تالٍ هو مجموع الرقمين السابقين.",
      "solution": "#include <stdio.h>\n\nint main() {\n    int n, t1=0, t2=1, nextTerm;\n    printf(\"أدخل عدد الحدود: \");\n    scanf(\"%d\", &n);\n    printf(\"متتالية فيبوناتشي: \");\n    for(int i=1;i<=n;i++) {\n        if(i==1){printf(\"%d, \", t1); continue;}\n        if(i==2){printf(\"%d, \", t2); continue;}\n        nextTerm = t1+t2;\n        t1=t2; t2=nextTerm;\n        if(i==n) printf(\"%d\\n\", nextTerm);\n        else printf(\"%d, \", nextTerm);\n    }\n    return 0;\n}"
    },
    {
      "id": 11,
      "titre": "مجموع الأرقام الزوجية من 1 إلى N",
      "texte": "اكتب برنامجاً يحسب مجموع الأرقام الزوجية من 1 إلى N.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for مع شرط للتحقق من الزوجية.",
      "solution": "#include <stdio.h>\n\nint main(){\n    int n, sum=0;\n    printf(\"أدخل N: \"); scanf(\"%d\", &n);\n    for(int i=1;i<=n;i++){if(i%2==0) sum+=i;}\n    printf(\"مجموع الأرقام الزوجية من 1 إلى %d هو: %d\\n\", n, sum);\n    return 0;\n}"
    },
    {
      "id": 12,
      "titre": "الرقم الأكبر في ثلاثة أرقام",
      "texte": "اكتب برنامجاً يقرأ ثلاثة أرقام ويطبع الأكبر.",
      "difficulte": "متوسط",
      "hint": "استخدم if-else متعدد للمقارنة.",
      "solution": "#include <stdio.h>\nint main(){int a,b,c; printf(\"أدخل ثلاثة أرقام: \"); scanf(\"%d %d %d\", &a,&b,&c); int max=a; if(b>max) max=b; if(c>max) max=c; printf(\"الأكبر هو: %d\\n\", max); return 0;}"
    },
    {
      "id": 13,
      "titre": "الأرقام الفردية من 1 إلى N",
      "texte": "اكتب برنامجاً يطبع كل الأرقام الفردية من 1 إلى N.",
      "difficulte": "سهل",
      "hint": "استخدم حلقة for وشرط للتحقق من الفردية.",
      "solution": "#include <stdio.h>\nint main(){int n; printf(\"أدخل N: \"); scanf(\"%d\", &n); for(int i=1;i<=n;i++){if(i%2!=0) printf(\"%d \", i);} printf(\"\\n\"); return 0;}"
    },
    {
      "id": 14,
      "titre": "مجموع الأرقام الفردية من 1 إلى N",
      "texte": "اكتب برنامجاً يحسب مجموع الأرقام الفردية من 1 إلى N.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for مع شرط i%2!=0.",
      "solution": "#include <stdio.h>\nint main(){int n,sum=0; printf(\"أدخل N: \"); scanf(\"%d\", &n); for(int i=1;i<=n;i++){if(i%2!=0) sum+=i;} printf(\"مجموع الأرقام الفردية من 1 إلى %d هو: %d\\n\", n,sum); return 0;}"
    },
    {
      "id": 15,
      "titre": "عدد الأحرف في كلمة",
      "texte": "اكتب برنامجاً يقرأ كلمة ويحسب عدد الأحرف فيها.",
      "difficulte": "سهل",
      "hint": "استخدم حلقة while حتى تصل إلى نهاية السلسلة \\0.",
      "solution": "#include <stdio.h>\n#include <string.h>\nint main(){char str[100]; printf(\"أدخل كلمة: \"); scanf(\"%s\", str); printf(\"عدد الأحرف: %lu\\n\", strlen(str)); return 0;}"
    },
    {
      "id": 16,
      "titre": "الرقم الأكبر في مصفوفة",
      "texte": "اكتب برنامجاً يقرأ مصفوفة من 5 أرقام ويطبع الرقم الأكبر.",
      "difficulte": "متوسط",
      "hint": "افترض أن أول عنصر هو الأكبر ثم قارن مع باقي العناصر.",
      "solution": "#include <stdio.h>\nint main(){int arr[5]; printf(\"أدخل 5 أرقام:\\n\"); for(int i=0;i<5;i++){scanf(\"%d\", &arr[i]);} int max=arr[0]; for(int i=1;i<5;i++){if(arr[i]>max) max=arr[i];} printf(\"الأكبر هو: %d\\n\", max); return 0;}"
    },
    {
      "id": 17,
      "titre": "جمع عناصر مصفوفة",
      "texte": "اكتب برنامجاً يحسب مجموع عناصر مصفوفة من 5 أرقام.",
      "difficulte": "سهل",
      "hint": "استخدم حلقة for لجمع العناصر.",
      "solution": "#include <stdio.h>\nint main(){int arr[5], sum=0; printf(\"أدخل 5 أرقام:\\n\"); for(int i=0;i<5;i++){scanf(\"%d\", &arr[i]); sum+=arr[i];} printf(\"مجموع العناصر: %d\\n\", sum); return 0;}"
    },
    {
      "id": 18,
      "titre": "البحث الخطي في مصفوفة",
      "texte": "اكتب برنامجاً يبحث عن رقم معين في مصفوفة ويطبع موقعه (أو -1 إذا لم يوجد).",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for لمقارنة كل عنصر بالرقم المطلوب.",
      "solution": "#include <stdio.h>\nint main(){int arr[5]; printf(\"أدخل 5 أرقام:\\n\"); for(int i=0;i<5;i++){scanf(\"%d\", &arr[i]);} int target, pos=-1; printf(\"أدخل الرقم المطلوب البحث عنه: \"); scanf(\"%d\", &target); for(int i=0;i<5;i++){if(arr[i]==target){pos=i; break;}} printf(\"الموقع: %d\\n\", pos); return 0;}"
    },
    {
      "id": 19,
      "titre": "جدول الضرب لمصفوفة",
      "texte": "اكتب برنامجاً يطبع جدول ضرب كل عنصر في مصفوفة من 5 أرقام.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for متداخلة: واحدة على عناصر المصفوفة وأخرى على جدول الضرب.",
      "solution": "#include <stdio.h>\nint main(){int arr[5]; printf(\"أدخل 5 أرقام:\\n\"); for(int i=0;i<5;i++){scanf(\"%d\", &arr[i]); for(int j=1;j<=10;j++){printf(\"%d × %d = %d\\n\", arr[i], j, arr[i]*j);}} return 0;}"
    },
    {
      "id": 20,
      "titre": "المتوسط الحسابي لمصفوفة",
      "texte": "اكتب برنامجاً يحسب المتوسط الحسابي لعناصر مصفوفة من 5 أرقام.",
      "difficulte": "متوسط",
      "hint": "اجمع العناصر ثم اقسم على عددها.",
      "solution": "#include <stdio.h>\nint main(){int arr[5]; int sum=0; printf(\"أدخل 5 أرقام:\\n\"); for(int i=0;i<5;i++){scanf(\"%d\", &arr[i]); sum+=arr[i];} printf(\"المتوسط الحسابي: %f\\n\", sum/5.0); return 0;}"
    }
  ],


  "2": [
    {
      "id": 1,
      "titre": "مجموع عناصر مصفوفة ديناميكية",
      "texte": "اكتب برنامجاً يقرأ N أرقام من المستخدم ويحسب مجموعها.",
      "difficulte": "متوسط",
      "hint": "استخدم مصفوفة بحجم N تقرأه من المستخدم وحلقة for للجمع.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int *arr = (int*)malloc(n*sizeof(int));\n    int sum=0;\n    for(int i=0;i<n;i++){ printf(\"رقم %d: \", i+1); scanf(\"%d\", &arr[i]); sum+=arr[i];}\n    printf(\"مجموع الأرقام: %d\\n\", sum);\n    free(arr);\n    return 0;\n}"
    },
    {
      "id": 2,
      "titre": "الحد الأدنى والأقصى في مصفوفة",
      "texte": "اكتب برنامجاً يجد أصغر وأكبر رقم في مصفوفة من N أرقام.",
      "difficulte": "متوسط",
      "hint": "ابدأ بافتراض أن العنصر الأول هو الأصغر والأكبر ثم قارنه مع البقية.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int *arr=(int*)malloc(n*sizeof(int));\n    for(int i=0;i<n;i++){scanf(\"%d\", &arr[i]);}\n    int min=arr[0], max=arr[0];\n    for(int i=1;i<n;i++){if(arr[i]<min) min=arr[i]; if(arr[i]>max) max=arr[i];}\n    printf(\"الأصغر: %d, الأكبر: %d\\n\", min,max);\n    free(arr);\n    return 0;\n}"
    },
    {
      "id": 3,
      "titre": "عكس مصفوفة",
      "texte": "اكتب برنامجاً يعكس ترتيب عناصر مصفوفة من N أرقام.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة لتبادل العناصر من البداية والنهاية.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int *arr=(int*)malloc(n*sizeof(int));\n    for(int i=0;i<n;i++){scanf(\"%d\", &arr[i]);}\n    for(int i=0;i<n/2;i++){int temp=arr[i]; arr[i]=arr[n-1-i]; arr[n-1-i]=temp;}\n    printf(\"المصفوفة بعد العكس: \");\n    for(int i=0;i<n;i++) printf(\"%d \", arr[i]);\n    printf(\"\\n\");\n    free(arr);\n    return 0;\n}"
    },
    {
      "id": 4,
      "titre": "فرز مصفوفة تصاعدياً",
      "texte": "اكتب برنامجاً يرتب مصفوفة من N أرقام تصاعدياً.",
      "difficulte": "صعب",
      "hint": "يمكنك استخدام فرز الفقاعات (Bubble Sort) أو أي خوارزمية فرز بسيطة.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int *arr=(int*)malloc(n*sizeof(int));\n    for(int i=0;i<n;i++){scanf(\"%d\", &arr[i]);}\n    for(int i=0;i<n-1;i++){\n        for(int j=0;j<n-i-1;j++){\n            if(arr[j]>arr[j+1]){\n                int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp;\n            }\n        }\n    }\n    printf(\"المصفوفة بعد الفرز: \"); for(int i=0;i<n;i++) printf(\"%d \", arr[i]);\n    printf(\"\\n\"); free(arr); return 0;\n}"
    },
    {
      "id": 5,
      "titre": "البحث الثنائي",
      "texte": "اكتب برنامجاً للبحث عن رقم في مصفوفة مرتبة باستخدام البحث الثنائي.",
      "difficulte": "صعب",
      "hint": "تأكد أن المصفوفة مرتبة، ثم استخدم حلقات while لتحديد موقع الرقم.",
      "solution": "#include <stdio.h>\nint main(){\n    int arr[]={1,3,5,7,9}; int target; printf(\"أدخل الرقم للبحث عنه: \"); scanf(\"%d\", &target);\n    int left=0, right=4, found=-1;\n    while(left<=right){ int mid=(left+right)/2; if(arr[mid]==target){found=mid; break;} else if(arr[mid]<target) left=mid+1; else right=mid-1;}\n    printf(\"الموقع: %d\\n\", found);\n    return 0;\n}"
    },
    {
      "id": 6,
      "titre": "جمع مصفوفتين",
      "texte": "اكتب برنامجاً يجمع عنصر بعنصر لمصفوفتين متساويتين الحجم.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for.",
      "solution": "#include <stdio.h>\nint main(){\n    int a[3],b[3],sum[3];\n    printf(\"أدخل عناصر المصفوفة الأولى: \"); for(int i=0;i<3;i++) scanf(\"%d\", &a[i]);\n    printf(\"أدخل عناصر المصفوفة الثانية: \"); for(int i=0;i<3;i++) scanf(\"%d\", &b[i]);\n    for(int i=0;i<3;i++) sum[i]=a[i]+b[i];\n    printf(\"مجموع المصفوفتين: \"); for(int i=0;i<3;i++) printf(\"%d \", sum[i]); printf(\"\\n\");\n    return 0;\n}"
    },
    {
      "id": 7,
      "titre": "عناصر مشتركة بين مصفوفتين",
      "texte": "اكتب برنامجاً يجد الأرقام المشتركة بين مصفوفتين.",
      "difficulte": "صعب",
      "hint": "استخدم حلقة مزدوجة لمقارنة كل عنصر من المصفوفة الأولى مع الثانية.",
      "solution": "#include <stdio.h>\nint main(){\n    int a[3],b[3]; printf(\"أدخل المصفوفة الأولى: \"); for(int i=0;i<3;i++) scanf(\"%d\", &a[i]);\n    printf(\"أدخل المصفوفة الثانية: \"); for(int i=0;i<3;i++) scanf(\"%d\", &b[i]);\n    printf(\"العناصر المشتركة: \");\n    for(int i=0;i<3;i++) for(int j=0;j<3;j++) if(a[i]==b[j]) printf(\"%d \", a[i]);\n    printf(\"\\n\"); return 0;\n}"
    },
    {
      "id": 8,
      "titre": "مجموع أرقام مصفوفة ثنائية الأبعاد",
      "texte": "اكتب برنامجاً يحسب مجموع عناصر مصفوفة 2x2.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقتين متداخلتين للتكرار على الصفوف والأعمدة.",
      "solution": "#include <stdio.h>\nint main(){\n    int mat[2][2], sum=0;\n    printf(\"أدخل عناصر المصفوفة 2x2:\\n\");\n    for(int i=0;i<2;i++) for(int j=0;j<2;j++) scanf(\"%d\", &mat[i][j]);\n    for(int i=0;i<2;i++) for(int j=0;j<2;j++) sum+=mat[i][j];\n    printf(\"مجموع العناصر: %d\\n\", sum);\n    return 0;\n}"
    },
    {
      "id": 9,
      "titre": "ضرب مصفوفتين 2x2",
      "texte": "اكتب برنامجاً لضرب مصفوفتين 2x2.",
      "difficulte": "صعب",
      "hint": "الضرب يتطلب حلقة ثلاثية أو صيغة مباشرة لكل عنصر.",
      "solution": "#include <stdio.h>\nint main(){\n    int a[2][2], b[2][2], c[2][2];\n    printf(\"أدخل المصفوفة الأولى 2x2:\\n\"); for(int i=0;i<2;i++) for(int j=0;j<2;j++) scanf(\"%d\", &a[i][j]);\n    printf(\"أدخل المصفوفة الثانية 2x2:\\n\"); for(int i=0;i<2;i++) for(int j=0;j<2;j++) scanf(\"%d\", &b[i][j]);\n    for(int i=0;i<2;i++) for(int j=0;j<2;j++) c[i][j]=a[i][0]*b[0][j]+a[i][1]*b[1][j];\n    printf(\"نتيجة الضرب:\\n\"); for(int i=0;i<2;i++){for(int j=0;j<2;j++) printf(\"%d \", c[i][j]); printf(\"\\n\");}\n    return 0;\n}"
    },
    {
      "id": 10,
      "titre": "مجموع أرقام فردية في مصفوفة",
      "texte": "اكتب برنامجاً يحسب مجموع الأرقام الفردية في مصفوفة N عنصر.",
      "difficulte": "متوسط",
      "hint": "استخدم شرط if للتحقق من الفردية داخل حلقة for.",
      "solution": "#include <stdio.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int arr[n], sum=0;\n    for(int i=0;i<n;i++){scanf(\"%d\", &arr[i]); if(arr[i]%2!=0) sum+=arr[i];}\n    printf(\"مجموع الأرقام الفردية: %d\\n\", sum);\n    return 0;\n}"
    },
    {
      "id": 11,
      "titre": "حذف عنصر من مصفوفة",
      "texte": "اكتب برنامجاً لحذف عنصر معين من مصفوفة N عنصر.",
      "difficulte": "صعب",
      "hint": "انقل كل العناصر بعد العنصر المحذوف بمقدار موقعه.",
      "solution": "#include <stdio.h>\nint main(){\n    int n, pos; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int arr[n]; for(int i=0;i<n;i++) scanf(\"%d\", &arr[i]);\n    printf(\"أدخل موقع العنصر للحذف: \"); scanf(\"%d\", &pos);\n    for(int i=pos;i<n-1;i++) arr[i]=arr[i+1];\n    printf(\"المصفوفة بعد الحذف: \"); for(int i=0;i<n-1;i++) printf(\"%d \", arr[i]); printf(\"\\n\");\n    return 0;\n}"
    },
    {
      "id": 12,
      "titre": "إدراج عنصر في مصفوفة",
      "texte": "اكتب برنامجاً لإدراج عنصر في موقع معين داخل مصفوفة N عنصر.",
      "difficulte": "صعب",
      "hint": "انقل كل العناصر بعد الموقع بمقدار واحد للوراء قبل الإدراج.",
      "solution": "#include <stdio.h>\nint main(){\n    int n, pos, val; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int arr[n+1]; for(int i=0;i<n;i++) scanf(\"%d\", &arr[i]);\n    printf(\"أدخل موقع الإدراج والقيمة: \"); scanf(\"%d %d\", &pos, &val);\n    for(int i=n;i>pos;i--) arr[i]=arr[i-1]; arr[pos]=val;\n    printf(\"المصفوفة بعد الإدراج: \"); for(int i=0;i<=n;i++) printf(\"%d \", arr[i]); printf(\"\\n\");\n    return 0;\n}"
    },
    {
      "id": 13,
      "titre": "عدد مرات تكرار رقم في مصفوفة",
      "texte": "اكتب برنامجاً يحسب كم مرة يظهر رقم معين في مصفوفة N عنصر.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for وشرط if لمقارنة كل عنصر بالرقم المطلوب.",
      "solution": "#include <stdio.h>\nint main(){\n    int n, num, count=0; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int arr[n]; for(int i=0;i<n;i++) scanf(\"%d\", &arr[i]);\n    printf(\"أدخل الرقم للبحث: \"); scanf(\"%d\", &num);\n    for(int i=0;i<n;i++) if(arr[i]==num) count++;\n    printf(\"عدد مرات التكرار: %d\\n\", count);\n    return 0;\n}"
    },
    {
      "id": 14,
      "titre": "التحقق من وجود مصفوفة مرآتية",
      "texte": "اكتب برنامجاً يتحقق إذا كانت مصفوفة N عنصر مرآتية.",
      "difficulte": "متوسط",
      "hint": "قارن العنصر i مع العنصر N-1-i لكل i من 0 إلى N/2.",
      "solution": "#include <stdio.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام N: \"); scanf(\"%d\", &n);\n    int arr[n]; for(int i=0;i<n;i++) scanf(\"%d\", &arr[i]);\n    int palindrome=1;\n    for(int i=0;i<n/2;i++) if(arr[i]!=arr[n-1-i]){palindrome=0; break;}\n    if(palindrome) printf(\"المصفوفة مرآتية\\n\"); else printf(\"ليست مرآتية\\n\");\n    return 0;\n}"
    },
    {
      "id": 15,
      "titre": "مجموع أرقام جدول الضرب",
      "texte": "اكتب برنامجاً يعرض جدول الضرب من 1 إلى N ويحسب مجموع كل النتائج.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقتين for متداخلتين.",
      "solution": "#include <stdio.h>\nint main(){\n    int n, sum=0; printf(\"أدخل N: \"); scanf(\"%d\", &n);\n    for(int i=1;i<=n;i++){\n        for(int j=1;j<=n;j++){ sum+=i*j; printf(\"%d \", i*j); }\n        printf(\"\\n\");\n    }\n    printf(\"مجموع جدول الضرب: %d\\n\", sum);\n    return 0;\n}"
    },
    {
      "id": 16,
      "titre": "التحقق من عدد أولي",
      "texte": "اكتب برنامجاً يتحقق إذا كان رقم N أولياً.",
      "difficulte": "متوسط",
      "hint": "اقسم N على الأعداد من 2 إلى N-1 للتحقق.",
      "solution": "#include <stdio.h>\nint main(){\n    int n, prime=1; printf(\"أدخل رقم: \"); scanf(\"%d\", &n);\n    if(n<2) prime=0;\n    for(int i=2;i*i<=n;i++) if(n%i==0){prime=0; break;}\n    if(prime) printf(\"الرقم أولي\\n\"); else printf(\"الرقم ليس أولي\\n\");\n    return 0;\n}"
    },
    {
      "id": 17,
      "titre": "أكبر رقم أولي في مصفوفة",
      "texte": "اكتب برنامجاً يجد أكبر رقم أولي في مصفوفة N عنصر.",
      "difficulte": "صعب",
      "hint": "استخدم دالة للتحقق من الأولية لكل عنصر ثم قارن مع أكبر قيمة.",
      "solution": "#include <stdio.h>\nint isPrime(int n){ if(n<2) return 0; for(int i=2;i*i<=n;i++) if(n%i==0) return 0; return 1; }\nint main(){\n    int n; printf(\"أدخل N: \"); scanf(\"%d\", &n);\n    int arr[n]; for(int i=0;i<n;i++) scanf(\"%d\", &arr[i]);\n    int maxPrime=-1; for(int i=0;i<n;i++) if(isPrime(arr[i]) && arr[i]>maxPrime) maxPrime=arr[i];\n    if(maxPrime!=-1) printf(\"أكبر رقم أولي: %d\\n\", maxPrime); else printf(\"لا يوجد أرقام أولية\\n\");\n    return 0;\n}"
    },
    
    {
      "id": 18,
      "titre": "حساب المضروب (Factorial)",
      "texte": "اكتب برنامجاً يحسب مضروب رقم N (N!).",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة for أو دالة recursive.",
      "solution": "#include <stdio.h>\nint main(){\n    int n; printf(\"أدخل رقم: \"); scanf(\"%d\", &n);\n    int fact=1;\n    for(int i=1;i<=n;i++) fact*=i;\n    printf(\"%d! = %d\\n\", n, fact);\n    return 0;\n}"
    },
    {
      "id": 19,
      "titre": "سلسلة فيبوناتشي",
      "texte": "اكتب برنامجاً يعرض أول N أرقام من سلسلة فيبوناتشي.",
      "difficulte": "متوسط",
      "hint": "ابدأ ب 0 و1 ثم اجمع الرقمين السابقين للحصول على الرقم التالي.",
      "solution": "#include <stdio.h>\nint main(){\n    int n; printf(\"أدخل عدد الأرقام: \"); scanf(\"%d\", &n);\n    int a=0, b=1, c;\n    for(int i=1;i<=n;i++){\n        printf(\"%d \", a);\n        c=a+b; a=b; b=c;\n    }\n    printf(\"\\n\");\n    return 0;\n}"
    },
    {
      "id": 20,
      "titre": "مجموع أرقام رقم",
      "texte": "اكتب برنامجاً يحسب مجموع أرقام رقم مدخل من المستخدم.",
      "difficulte": "متوسط",
      "hint": "استخدم عملية القسمة والباقي لاستخراج كل رقم.",
      "solution": "#include <stdio.h>\nint main(){\n    int n; printf(\"أدخل رقم: \"); scanf(\"%d\", &n);\n    int sum=0;\n    while(n>0){ sum += n%10; n/=10; }\n    printf(\"مجموع الأرقام: %d\\n\", sum);\n    return 0;\n}"
    }
  ],

  "3": [
    {
      "id": 1,
      "titre": "العاملية بالعودية",
      "texte": "اكتب دالة عودية (recursive) لحساب عاملي رقم (n!).",
      "difficulte": "متوسط",
      "hint": "الحالة الأساسية: factorial(0) = 1، والحالة العودية: factorial(n) = n * factorial(n-1).",
      "solution": "#include <stdio.h>\nlong long factorial(int n){ if(n<=1) return 1; return n*factorial(n-1); }\nint main(){ int num; printf(\"أدخل رقماً: \"); scanf(\"%d\", &num);\nprintf(\"%d! = %lld\\n\", num, factorial(num)); return 0; }"
    },
    {
      "id": 2,
      "titre": "فيبوناتشي بالعودية",
      "texte": "اكتب دالة عودية لحساب حد فيبوناتشي رقم n.",
      "difficulte": "متوسط",
      "hint": "Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2) مع Fibonacci(0)=0, Fibonacci(1)=1.",
      "solution": "#include <stdio.h>\nint fibonacci(int n){ if(n<=1) return n; return fibonacci(n-1)+fibonacci(n-2); }\nint main(){ int n; printf(\"أدخل رقم الحد: \"); scanf(\"%d\", &n);\nprintf(\"Fibonacci(%d) = %d\\n\", n, fibonacci(n)); return 0; }"
    },
    {
      "id": 3,
      "titre": "ترتيب الفقاعات (Bubble Sort)",
      "texte": "اكتب برنامجاً يرتب مصفوفة باستخدام خوارزمية Bubble Sort.",
      "difficulte": "صعب",
      "hint": "قارن كل عنصرين متجاورين وبدل إذا كانا بترتيب خاطئ. كرر حتى تصبح المصفوفة مرتبة.",
      "solution": "#include <stdio.h>\nvoid bubbleSort(int arr[], int n){ for(int i=0;i<n-1;i++){ for(int j=0;j<n-i-1;j++){ if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } }\nint main(){ int arr[]={64,34,25,12,22,11,90}; int n=sizeof(arr)/sizeof(arr[0]); printf(\"قبل الترتيب: \"); for(int i=0;i<n;i++) printf(\"%d \",arr[i]); bubbleSort(arr,n); printf(\"\\nبعد الترتيب: \"); for(int i=0;i<n;i++) printf(\"%d \",arr[i]); printf(\"\\n\"); return 0; }"
    },
    {
      "id": 4,
      "titre": "ترتيب الإدراج (Insertion Sort)",
      "texte": "طبق خوارزمية Insertion Sort لترتيب مصفوفة.",
      "difficulte": "صعب",
      "hint": "قم ببناء المصفوفة المرتبة تدريجياً بأخذ عنصر واحد وإدراجه في المكان المناسب.",
      "solution": "#include <stdio.h>\nvoid insertionSort(int arr[], int n){ for(int i=1;i<n;i++){ int key=arr[i], j=i-1; while(j>=0 && arr[j]>key){ arr[j+1]=arr[j]; j--; } arr[j+1]=key; } }\nint main(){ int arr[]={12,11,13,5,6}; int n=sizeof(arr)/sizeof(arr[0]); printf(\"قبل الترتيب: \"); for(int i=0;i<n;i++) printf(\"%d \",arr[i]); insertionSort(arr,n); printf(\"\\nبعد الترتيب: \"); for(int i=0;i<n;i++) printf(\"%d \",arr[i]); printf(\"\\n\"); return 0; }"
    },
    {
      "id": 5,
      "titre": "ترتيب الدمج (Merge Sort)",
      "texte": "طبق خوارزمية Merge Sort لترتيب مصفوفة.",
      "difficulte": "صعب جدا",
      "hint": "قسّم المصفوفة إلى نصفين، رتب كل نصف recursively، ثم ادمج النصفين المرتبين.",
      "solution": "#include <stdio.h>\nvoid merge(int arr[], int l, int m, int r){ int n1=m-l+1,n2=r-m,L[n1],R[n2]; for(int i=0;i<n1;i++) L[i]=arr[l+i]; for(int j=0;j<n2;j++) R[j]=arr[m+1+j]; int i=0,j=0,k=l; while(i<n1 && j<n2){ if(L[i]<=R[j]) arr[k++]=L[i++]; else arr[k++]=R[j++]; } while(i<n1) arr[k++]=L[i++]; while(j<n2) arr[k++]=R[j++]; }\nvoid mergeSort(int arr[], int l, int r){ if(l<r){ int m=l+(r-l)/2; mergeSort(arr,l,m); mergeSort(arr,m+1,r); merge(arr,l,m,r); } }\nint main(){ int arr[]={38,27,43,3,9,82,10}; int n=sizeof(arr)/sizeof(arr[0]); printf(\"قبل الترتيب: \"); for(int i=0;i<n;i++) printf(\"%d \",arr[i]); mergeSort(arr,0,n-1); printf(\"\\nبعد الترتيب: \"); for(int i=0;i<n;i++) printf(\"%d \",arr[i]); printf(\"\\n\"); return 0; }"
    },
    {
      "id": 6,
      "titre": "مكدس Stack بسيط",
      "texte": "اكتب برنامجاً يعرّف مكدس من 5 عناصر مع push و pop و عرض العناصر.",
      "difficulte": "متوسط",
      "hint": "استخدم مصفوفة و index لتتبع أعلى عنصر.",
      "solution": "#include <stdio.h>\n#define SIZE 5\nint stack[SIZE], top=-1;\nvoid push(int x){ if(top<SIZE-1) stack[++top]=x; else printf(\"المكدس ممتلئ\\n\"); }\nint pop(){ if(top>=0) return stack[top--]; else { printf(\"المكدس فارغ\\n\"); return -1; } }\nint main(){ push(10); push(20); push(30); for(int i=top;i>=0;i--) printf(\"%d \", stack[i]); printf(\"\\nPop: %d\\n\", pop()); return 0; }"
    },
    {
      "id": 7,
      "titre": "قائمة مرتبطة Linked List",
      "texte": "انشئ قائمة مرتبطة من 3 عقد واطبع كل عناصرها.",
      "difficulte": "متوسط",
      "hint": "استخدم struct لكل عقدة و next pointer.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nint main(){ struct Node* head=(struct Node*)malloc(sizeof(struct Node)); head->data=10;\nhead->next=(struct Node*)malloc(sizeof(struct Node)); head->next->data=20;\nhead->next->next=(struct Node*)malloc(sizeof(struct Node)); head->next->next->data=30;\nhead->next->next->next=NULL;\nstruct Node* temp=head; while(temp){ printf(\"%d \", temp->data); temp=temp->next; } printf(\"\\n\"); return 0; }"
    },
    {
      "id": 8,
      "titre": "إدراج في Linked List",
      "texte": "أضف عقدة جديدة برقم 15 في بداية القائمة المرتبطة السابقة.",
      "difficulte": "متوسط",
      "hint": "غيّر head ليشير إلى العقدة الجديدة.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nint main(){ struct Node* head=(struct Node*)malloc(sizeof(struct Node)); head->data=10;\nhead->next=(struct Node*)malloc(sizeof(struct Node)); head->next->data=20;\nhead->next->next=NULL;\nstruct Node* newNode=(struct Node*)malloc(sizeof(struct Node)); newNode->data=15; newNode->next=head; head=newNode;\nstruct Node* temp=head; while(temp){ printf(\"%d \", temp->data); temp=temp->next; } printf(\"\\n\"); return 0; }"
    },
    {
      "id": 9,
      "titre": "حذف من Linked List",
      "texte": "احذف العقدة الأولى من القائمة المرتبطة.",
      "difficulte": "متوسط",
      "hint": "غيّر head ليشير إلى next للعقدة الحالية.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nint main(){ struct Node* head=(struct Node*)malloc(sizeof(struct Node)); head->data=10;\nhead->next=(struct Node*)malloc(sizeof(struct Node)); head->next->data=20;\nhead->next->next=NULL;\nstruct Node* temp=head; head=head->next; free(temp);\ntemp=head; while(temp){ printf(\"%d \", temp->data); temp=temp->next; } printf(\"\\n\"); return 0; }"
    },
    {
      "id": 10,
      "titre": "هيكلة Struct للطالب",
      "texte": "عرف Struct باسم Student يحتوي على name و age و grade واطبع معلومات طالب.",
      "difficulte": "متوسط",
      "hint": "استخدم struct مع نقطة . للوصول للحقول.",
      "solution": "#include <stdio.h>\nstruct Student{ char name[20]; int age; float grade; };\nint main(){ struct Student s1={\"Ali\",20,15.5}; printf(\"الاسم: %s\\nالعمر: %d\\nالمعدل: %.2f\\n\", s1.name,s1.age,s1.grade); return 0; }"
    },
    {
      "id": 11,
      "titre": "هيكلة Struct و Pointer",
      "texte": "استخدم Pointer للوصول لمعلومات الطالب في struct.",
      "difficulte": "صعب",
      "hint": "استخدم -> بدل . للوصول للحقل عبر Pointer.",
      "solution": "#include <stdio.h>\nstruct Student{ char name[20]; int age; float grade; };\nint main(){ struct Student s1={\"Sara\",21,16.5}; struct Student *ptr=&s1;\nprintf(\"الاسم: %s\\nالعمر: %d\\nالمعدل: %.2f\\n\", ptr->name,ptr->age,ptr->grade); return 0; }"
    },
    {
      "id": 12,
      "titre": "شجرة ثنائية Binary Tree",
      "texte": "انشئ شجرة ثنائية من 3 عقد واطبع العناصر Preorder.",
      "difficulte": "صعب",
      "hint": "استخدم struct Node مع left و right pointers.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* left; struct Node* right; };\nvoid preorder(struct Node* root){ if(root){ printf(\"%d \", root->data); preorder(root->left); preorder(root->right); } }\nint main(){ struct Node* root=(struct Node*)malloc(sizeof(struct Node)); root->data=1;\nroot->left=(struct Node*)malloc(sizeof(struct Node)); root->left->data=2; root->right=(struct Node*)malloc(sizeof(struct Node)); root->right->data=3;\nroot->left->left=root->left->right=root->right->left=root->right->right=NULL;\npreorder(root); printf(\"\\n\"); return 0; }"
    },
  
  
    {
      "id": 13,
      "titre": "Stack مع العمليات Push و Pop و Peek",
      "texte": "اصنع مكدس ديناميكي يمكنه استقبال 10 عناصر وعرض أعلى عنصر بدون حذفه.",
      "difficulte": "متوسط",
      "hint": "استخدم مصفوفة و top index و دالة peek لطباعة العنصر الأعلى.",
      "solution": "#include <stdio.h>\n#define SIZE 10\nint stack[SIZE], top=-1;\nvoid push(int x){ if(top<SIZE-1) stack[++top]=x; else printf(\"Stack Full\\n\"); }\nint pop(){ if(top>=0) return stack[top--]; else { printf(\"Stack Empty\\n\"); return -1; } }\nint peek(){ if(top>=0) return stack[top]; else { printf(\"Stack Empty\\n\"); return -1; } }\nint main(){ push(5); push(10); push(15); printf(\"Top element: %d\\n\", peek()); printf(\"Pop: %d\\n\", pop()); printf(\"Top element: %d\\n\", peek()); return 0; }"
    },
    {
      "id": 14,
      "titre": "حلقات متداخلة Looping 1–10",
      "texte": "اطبع جدول الضرب من 1 إلى 10 باستخدام حلقات متداخلة.",
      "difficulte": "سهل",
      "hint": "استخدم for داخل for لطباعة i*j.",
      "solution": "#include <stdio.h>\nint main(){ for(int i=1;i<=10;i++){ for(int j=1;j<=10;j++) printf(\"%d\\t\", i*j); printf(\"\\n\"); } return 0; }"
    },
    {
      "id": 15,
      "titre": "حذف عنصر معين من Linked List",
      "texte": "احذف العقدة التي تحتوي على القيمة 20 من القائمة المرتبطة.",
      "difficulte": "متوسط",
      "hint": "اعثر على العقدة السابقة للعقدة المراد حذفها ثم وصلها بالعقدة التالية.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nint main(){ struct Node* head=(struct Node*)malloc(sizeof(struct Node)); head->data=10;\nhead->next=(struct Node*)malloc(sizeof(struct Node)); head->next->data=20;\nhead->next->next=(struct Node*)malloc(sizeof(struct Node)); head->next->next->data=30; head->next->next->next=NULL;\nstruct Node* temp=head; struct Node* prev=NULL;\nwhile(temp && temp->data!=20){ prev=temp; temp=temp->next; }\nif(temp){ prev->next=temp->next; free(temp); }\ntemp=head; while(temp){ printf(\"%d \", temp->data); temp=temp->next; } printf(\"\\n\"); return 0; }"
    },
    {
      "id": 16,
      "titre": "إدراج عنصر في Binary Tree",
      "texte": "أضف عنصر 4 لشجرة ثنائية موجودة بها 1,2,3.",
      "difficulte": "صعب",
      "hint": "ابدأ من الجذر وقارن لإدراج في اليسار أو اليمين حسب القيمة.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* left; struct Node* right; };\nstruct Node* newNode(int data){ struct Node* node=(struct Node*)malloc(sizeof(struct Node)); node->data=data; node->left=node->right=NULL; return node; }\nstruct Node* insert(struct Node* root, int data){ if(!root) return newNode(data);\nif(data<root->data) root->left=insert(root->left,data); else root->right=insert(root->right,data);\nreturn root; }\nvoid inorder(struct Node* root){ if(root){ inorder(root->left); printf(\"%d \", root->data); inorder(root->right); } }\nint main(){ struct Node* root=newNode(2); root=insert(root,1); root=insert(root,3); root=insert(root,4); inorder(root); printf(\"\\n\"); return 0; }"
    },
    {
      "id": 17,
      "titre": "Tree Traversals: Preorder, Inorder, Postorder",
      "texte": "اطبع جميع أنواع Traversals لشجرة ثنائية بها 1,2,3,4,5.",
      "difficulte": "صعب جدا",
      "hint": "استخدم دوال recursive لكل نوع Traversal.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* left; struct Node* right; };\nstruct Node* newNode(int data){ struct Node* node=(struct Node*)malloc(sizeof(struct Node)); node->data=data; node->left=node->right=NULL; return node; }\nvoid preorder(struct Node* root){ if(root){ printf(\"%d \",root->data); preorder(root->left); preorder(root->right); } }\nvoid inorder(struct Node* root){ if(root){ inorder(root->left); printf(\"%d \",root->data); inorder(root->right); } }\nvoid postorder(struct Node* root){ if(root){ postorder(root->left); postorder(root->right); printf(\"%d \",root->data); } }\nint main(){ struct Node* root=newNode(1); root->left=newNode(2); root->right=newNode(3);\nroot->left->left=newNode(4); root->left->right=newNode(5);\nprintf(\"Preorder: \"); preorder(root); printf(\"\\nInorder: \"); inorder(root); printf(\"\\nPostorder: \"); postorder(root); printf(\"\\n\"); return 0; }"
    },
    {
      "id": 18,
      "titre": "Count Nodes in Linked List",
      "texte": "احسب عدد العقد في قائمة مرتبطة تحتوي على 5 عناصر.",
      "difficulte": "متوسط",
      "hint": "استخدم حلقة while للمرور على كل عقدة وزيادة العداد.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nint main(){ struct Node* head=(struct Node*)malloc(sizeof(struct Node)); head->data=1;\nstruct Node* temp=head; for(int i=2;i<=5;i++){ temp->next=(struct Node*)malloc(sizeof(struct Node)); temp=temp->next; temp->data=i; } temp->next=NULL;\nint count=0; temp=head; while(temp){ count++; temp=temp->next; } printf(\"عدد العقد: %d\\n\", count); return 0; }"
    },
    {
      "id": 19,
      "titre": "Reverse Linked List",
      "texte": "اقلب قائمة مرتبطة تحتوي على 1→2→3→4→5.",
      "difficulte": "صعب",
      "hint": "استخدم 3 مؤشرات: prev, curr, next لتغيير الاتجاه.",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nint main(){ struct Node* head=(struct Node*)malloc(sizeof(struct Node)); head->data=1;\nstruct Node* temp=head; for(int i=2;i<=5;i++){ temp->next=(struct Node*)malloc(sizeof(struct Node)); temp=temp->next; temp->data=i; } temp->next=NULL;\nstruct Node *prev=NULL, *curr=head, *next=NULL;\nwhile(curr){ next=curr->next; curr->next=prev; prev=curr; curr=next; } head=prev;\ntemp=head; while(temp){ printf(\"%d \", temp->data); temp=temp->next; } printf(\"\\n\"); return 0; }"
    },
    {
      "id": 20,
      "titre": "Stack باستخدام Linked List",
      "texte": "انشئ مكدس ديناميكي باستخدام Linked List وادخل 3 عناصر ثم احذف واحد.",
      "difficulte": "صعب جدا",
      "hint": "استخدم struct Node و head كمؤشر للقمة (top).",
      "solution": "#include <stdio.h>\n#include <stdlib.h>\nstruct Node{ int data; struct Node* next; };\nstruct Node* top=NULL;\nvoid push(int x){ struct Node* node=(struct Node*)malloc(sizeof(struct Node)); node->data=x; node->next=top; top=node; }\nint pop(){ if(!top){ printf(\"Stack Empty\\n\"); return -1; } int val=top->data; struct Node* temp=top; top=top->next; free(temp); return val; }\nint main(){ push(10); push(20); push(30); printf(\"Pop: %d\\n\", pop()); struct Node* temp=top; while(temp){ printf(\"%d \", temp->data); temp=temp->next; } printf(\"\\n\"); return 0; }"
    }
  ]
}


// التعامل مع اختيار المستوى
document.querySelectorAll('.level-card').forEach(card => {
    card.addEventListener('click', () => {
        const level = card.dataset.level;
        currentLevel = parseInt(level);
        loadLevel(currentLevel);
    });
});

// تحميل تمارين المستوى المحدد
function loadLevel(level) {
    if (exercisesData[level]) {
        currentExercises = exercisesData[level];
        currentExerciseIndex = 0;
        
        // تحديث العنوان
        const levelNames = ['', 'المبتدئين', 'المتوسط', 'المتقدم'];
        levelTitle.textContent = `Algorithmique ${level} - ${levelNames[level]}`;
        
        // إخفاء/إظهار الأقسام
        levelsSection.classList.add('hidden');
        exerciseSection.classList.remove('hidden');
        
        // عرض التمرين الأول
        displayExercise(currentExerciseIndex);
    }
}

// عرض التمرين
function displayExercise(index) {
    const exercise = currentExercises[index];
    if (!exercise) return;
    
    exerciseId.textContent = `تمرين #${exercise.id}`;
    exerciseTitle.textContent = exercise.titre;
    exerciseText.textContent = exercise.texte;
    
    // تحديث شارة الصعوبة
    difficultyBadge.textContent = exercise.difficulte;
    let difficultyValue = 1;
    if (exercise.difficulte === 'متوسط') difficultyValue = 2;
    if (exercise.difficulte === 'صعب' || exercise.difficulte === 'صعب جداً') difficultyValue = 3;
    difficultyBadge.setAttribute('data-difficulty', difficultyValue);
    
    // إخفاء التلميح والحل
    hintSection.classList.add('hidden');
    solutionSection.classList.add('hidden');
    
    // تحديث العداد
    exerciseCounter.textContent = `${index + 1} / ${currentExercises.length}`;
    
    // تحديث أزرار التنقل
    prevExercise.disabled = index === 0;
    nextExercise.disabled = index === currentExercises.length - 1;
}

// إظهار التلميح
hintBtn.addEventListener('click', () => {
    const exercise = currentExercises[currentExerciseIndex];
    if (exercise && exercise.hint) {
        hintContent.textContent = exercise.hint;
        hintSection.classList.remove('hidden');
    }
});

// إظهار الحل
solutionBtn.addEventListener('click', () => {
    const exercise = currentExercises[currentExerciseIndex];
    if (exercise && exercise.solution) {
        solutionContent.textContent = exercise.solution;
        solutionSection.classList.remove('hidden');
    }
});

// التحقق من الإجابة
checkBtn.addEventListener('click', () => {
    const answer = answerInput.value.trim();
    
    if (!answer) {
        showModal('info', 'الرجاء كتابة إجابة أولاً');
        return;
    }
    
    // تحقق بسيط (يمكن تطويره لاحقاً)
    if (answer.length < 10) {
        showModal('error', 'الإجابة قصيرة جداً. حاول كتابة كود كامل');
    } else {
        showModal('success', 'إجابة جيدة! يمكنك مقارنتها مع الحل');
    }
});

// إظهار التمرين التالي
nextBtn.addEventListener('click', () => {
    const randomIndex = Math.floor(Math.random() * currentExercises.length);
    currentExerciseIndex = randomIndex;
    displayExercise(currentExerciseIndex);
    answerInput.value = '';
    hintSection.classList.add('hidden');
    solutionSection.classList.add('hidden');
});

// العودة للمستويات
backBtn.addEventListener('click', () => {
    levelsSection.classList.remove('hidden');
    exerciseSection.classList.add('hidden');
});

// التنقل بين التمارين
prevExercise.addEventListener('click', () => {
    if (currentExerciseIndex > 0) {
        currentExerciseIndex--;
        displayExercise(currentExerciseIndex);
        answerInput.value = '';
        hintSection.classList.add('hidden');
        solutionSection.classList.add('hidden');
    }
});

nextExercise.addEventListener('click', () => {
    if (currentExerciseIndex < currentExercises.length - 1) {
        currentExerciseIndex++;
        displayExercise(currentExerciseIndex);
        answerInput.value = '';
        hintSection.classList.add('hidden');
        solutionSection.classList.add('hidden');
    }
});

// إظهار النافذة المنبثقة
function showModal(type, message) {
    modalIcon.className = 'modal-icon ' + type;
    
    let iconHtml = '';
    if (type === 'success') iconHtml = '<i class="fas fa-check-circle"></i>';
    else if (type === 'error') iconHtml = '<i class="fas fa-times-circle"></i>';
    else iconHtml = '<i class="fas fa-info-circle"></i>';
    
    modalIcon.innerHTML = iconHtml;
    modalMessage.textContent = message;
    
    modal.style.display = 'flex';
}

// إغلاق النافذة المنبثقة
window.closeModal = function() {
    modal.style.display = 'none';
};

// إغلاق النافذة عند النقر خارجها
window.addEventListener('click', (e) => {
    if (e.target === modal) {
        modal.style.display = 'none';
    }
});

// تمرير تلقائي لأعلى عند تغيير التمرين
function scrollToTop() {
    window.scrollTo({
        top: 0,
        behavior: 'smooth'
    });
}

// إضافة تأثيرات حركية للبطاقات
document.querySelectorAll('.exercise-card').forEach(card => {
    card.addEventListener('mouseenter', () => {
        card.style.transform = 'scale(1.02)';
    });
    
    card.addEventListener('mouseleave', () => {
        card.style.transform = 'scale(1)';
    });
});

// حفظ تقدم المستخدم في localStorage
function saveProgress() {
    const progress = {
        level: currentLevel,
        exerciseIndex: currentExerciseIndex
    };
    localStorage.setItem('algorithmProgress', JSON.stringify(progress));
}

// تحميل التقدم المحفوظ
function loadProgress() {
    const saved = localStorage.getItem('algorithmProgress');
    if (saved) {
        const progress = JSON.parse(saved);
        if (progress.level && progress.exerciseIndex !== undefined) {
            if (confirm('هل تريد متابعة من حيث توقفت سابقاً؟')) {
                currentLevel = progress.level;
                currentExerciseIndex = progress.exerciseIndex;
                loadLevel(currentLevel);
            }
        }
    }
}

// استدعاء تحميل التقدم عند بدء التشغيل
window.addEventListener('load', () => {
    setTimeout(loadProgress, 500);
});

// حفظ التقدم عند تغيير التمرين
function updateProgress() {
    saveProgress();
};

{
    saveProgress();
// إضافة حفظ التقدم للأحداث المناسبة
nextExercise.addEventListener('click', updateProgress);
prevExercise.addEventListener('click', updateProgress);
nextBtn.addEventListener('click', updateProgress);
};