Arabic

You're looking at domain 'mysudoko-dp3jfdvxqd0k.edgeone.app' on the application-focused generic top-level domain (.app), featuring subdomain 'mysudoko-dp3jfdvxqd0k'. Its registrable label 'edgeone' stretches across 7 characters containing 4 vowels alongside three consonants. Segmentation suggests 2 words: edge, one. Average segment length settles at 3.5 characters. No strong language cues emerged from the frequency lists.

html/e6/36/e6369cec-34fa-4272-b776-fc76952c65bd.html.gz

17b5b8456d7f57d2adbfc8881d379ae83c369ba21ad46816f5a180d370cb7d49

viewport

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


/* =========================================================
   1) أدوات أساسية لمحرّك السودوكو
   ========================================================= */

// تحويل الموضع (صف، عمود) إلى فهرس مصفوفة مسطّحة من 81 خلية
const idx = (r, c) => r * 9 + c;

/**
 * يتحقق إن كان وضع "val" في الخلية (r,c) صالحًا حسب قواعد السودوكو
 * (لا تكرار في الصف، العمود، أو الصندوق 3x3)
 */
function isValidPlacement(board, r, c, val) {
  for (let i = 0; i < 9; i++) {
    if (board[idx(r, i)] === val) return false; // نفس الصف
    if (board[idx(i, c)] === val) return false; // نفس العمود
  }
  const br = Math.floor(r / 3) * 3;
  const bc = Math.floor(c / 3) * 3;
  for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      if (board[idx(br + i, bc + j)] === val) return false; // نفس الصندوق
    }
  }
  return true;
}

// خلط مصفوفة (Fisher-Yates) للحصول على عشوائية حقيقية
function shuffle(arr) {
  for (let i = arr.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
  return arr;
}

/**
 * يولّد شبكة سودوكو كاملة وصحيحة (81 خانة) باستخدام
 * التراجع العكسي (Backtracking) مع ترتيب عشوائي للأرقام
 * في كل خلية، لضمان نتيجة مختلفة كل مرة.
 */
function generateFullBoard() {
  const board = new Array(81).fill(0);

  function fill(pos) {
    if (pos === 81) return true; // اكتملت كل الخلايا بنجاح
    const r = Math.floor(pos / 9);
    const c = pos % 9;
    const nums = shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9]);

    for (const n of nums) {
      if (isValidPlacement(board, r, c, n)) {
        board[idx(r, c)] = n;
        if (fill(pos + 1)) return true;
        board[idx(r, c)] = 0; // تراجع
      }
    }
    return false;
  }

  fill(0);
  return board;
}

/**
 * يعدّ عدد الحلول الممكنة لشبكة معطاة، ويتوقف فور بلوغ "limit"
 * (نستخدمها للتأكد أن اللغز الناتج له حل واحد فقط).
 * تُستخدم استراتيجية MRV (اختيار الخلية الأقل عددًا من الاحتمالات)
 * لتسريع البحث.
 */
function countSolutions(board, limit) {
  let count = 0;

  function findBestCell() {
    let best = -1, bestOptions = null;
    for (let p = 0; p < 81; p++) {
      if (board[p] !== 0) continue;
      const r = Math.floor(p / 9), c = p % 9;
      const options = [];
      for (let n = 1; n <= 9; n++) {
        if (isValidPlacement(board, r, c, n)) options.push(n);
      }
      if (options.length === 0) return { p: -1, options: [] }; // طريق مسدود
      if (best === -1 || options.length < bestOptions.length) {
        best = p; bestOptions = options;
        if (options.length === 1) break; // لا يمكن أن يكون أفضل من هذا
      }
    }
    return { p: best, options: bestOptions || [] };
  }

  function solve() {
    if (count >= limit) return;
    const { p, options } = findBestCell();
    if (p === -1 && options.length === 0) {
      // تحقّق: إن لم تبقَ خلايا فارغة، فهذا حل كامل
      if (board.every(v => v !== 0)) { count++; }
      return;
    }
    const r = Math.floor(p / 9), c = p % 9;
    for (const n of options) {
      board[p] = n;
      solve();
      board[p] = 0;
      if (count >= limit) return;
    }
  }

  solve();
  return count;
}

/**
 * يولّد لغزًا (شبكة بها خانات فارغة) من شبكة كاملة،
 * مع ضمان أن اللغز يملك حلاً واحدًا فقط.
 * "targetRemovals" = العدد المطلوب إزالته (يحدد مستوى الصعوبة).
 */
function createPuzzle(fullBoard, targetRemovals) {
  const puzzle = fullBoard.slice();
  const positions = shuffle([...Array(81).keys()]);
  let removed = 0;

  for (const p of positions) {
    if (removed >= targetRemovals) break;
    const backup = puzzle[p];
    puzzle[p] = 0;

    const testBoard = puzzle.slice();
    const solutions = countSolutions(testBoard, 2);

    if (solutions === 1) {
      removed++;
    } else {
      puzzle[p] = backup; // أعد القيمة، لأن إزالتها تخلق أكثر من حل
    }
  }
  return puzzle;
}

// إعدادات مستويات الصعوبة: عدد الخلايا المراد إخفاؤها (من 81)
const DIFFICULTY_SETTINGS = {
  easy:   { removals: 35, label: "سهل" },
  medium: { removals: 45, label: "متوسط" },
  hard:   { removals: 52, label: "صعب" },
  expert: { removals: 58, label: "خبير" }
};


/* =========================================================
   2) حالة اللعبة والعناصر
   ========================================================= */
let solutionBoard = [];   // الحل الكامل (81 خانة)
let puzzleBoard = [];     // اللغز الأصلي (0 = فارغ) — لا يتغير
let userBoard = [];       // ما يدخله المستخدم حاليًا
let selectedCell = -1;    // فهرس الخلية المختارة حاليًا
let timerInterval = null;
let secondsElapsed = 0;

const boardEl = document.getElementById('board');
const messageEl = document.getElementById('message');
const difficultySelect = document.getElementById('difficulty');
const difficultyStamp = document.getElementById('difficultyStamp');
const statLevel = document.getElementById('statLevel');
const statGiven = document.getElementById('statGiven');
const statEmpty = document.getElementById('statEmpty');
const statTime = document.getElementById('statTime');


/* =========================================================
   3) بناء الشبكة في الصفحة (مرة واحدة)
   ========================================================= */
function buildBoardDOM() {
  boardEl.innerHTML = '';
  for (let r = 0; r < 9; r++) {
    for (let c = 0; c < 9; c++) {
      const cell = document.createElement('div');
      cell.className = 'cell';
      cell.dataset.row = r;
      cell.dataset.col = c;

      // إضافة حدود غامقة لفصل الصناديق 3x3
      if (c % 3 === 2 && c !== 8) cell.classList.add('border-right');
      if (r % 3 === 2 && r !== 8) cell.classList.add('border-bottom');

      const input = document.createElement('input');
      input.type = 'text';
      input.inputMode = 'numeric';
      input.maxLength = 1;
      input.setAttribute('aria-label', `صف ${r + 1} عمود ${c + 1}`);

      input.addEventListener('focus', () => selectCell(idx(r, c)));
      input.addEventListener('click', () => selectCell(idx(r, c)));
      input.addEventListener('keydown', (e) => handleKeyDown(e, r, c));
      input.addEventListener('input', (e) => handleDigitInput(e, r, c));

      cell.appendChild(input);
      boardEl.appendChild(cell);
    }
  }
}

function getCellEl(p) {
  return boardEl.children[p];
}
function getInputEl(p) {
  return getCellEl(p).querySelector('input');
}


/* =========================================================
   4) بدء لغز جديد
   ========================================================= */
function newGame() {
  setMessage('', '');
  const diff = difficultySelect.value;
  const settings = DIFFICULTY_SETTINGS[diff];

  solutionBoard = generateFullBoard();
  puzzleBoard = createPuzzle(solutionBoard, settings.removals);
  userBoard = puzzleBoard.slice();
  selectedCell = -1;

  renderBoard();
  updateStats(settings);
  difficultyStamp.querySelector('span').innerHTML = `مستوى<br>${settings.label}`;

  resetTimer();
  startTimer();

  setMessage('لغز جديد جاهز — حظًا موفقًا!', 'info');
}

/* رسم الشبكة بالكامل بناءً على userBoard و puzzleBoard */
function renderBoard() {
  for (let p = 0; p < 81; p++) {
    const cellEl = getCellEl(p);
    const input = getInputEl(p);
    const given = puzzleBoard[p] !== 0;

    cellEl.classList.remove('selected', 'peer', 'same-value', 'error');

    if (given) {
      input.value = puzzleBoard[p];
      input.disabled = true;
    } else {
      input.value = userBoard[p] === 0 ? '' : userBoard[p];
      input.disabled = false;
    }
  }
}

function updateStats(settings) {
  const given = puzzleBoard.filter(v => v !== 0).length;
  statLevel.textContent = settings.label;
  statGiven.textContent = given;
  statEmpty.textContent = 81 - given;
}


/* =========================================================
   5) التفاعل مع الخلايا
   ========================================================= */
function selectCell(p) {
  selectedCell = p;
  highlightRelated(p);
}

function highlightRelated(p) {
  const r = Math.floor(p / 9), c = p % 9;
  const val = userBoard[p] || puzzleBoard[p];
  const br = Math.floor(r / 3) * 3, bc = Math.floor(c / 3) * 3;

  for (let i = 0; i < 81; i++) {
    const cellEl = getCellEl(i);
    cellEl.classList.remove('selected', 'peer', 'same-value');

    const ir = Math.floor(i / 9), ic = i % 9;
    const sameRow = ir === r;
    const sameCol = ic === c;
    const sameBox = (Math.floor(ir / 3) * 3 === br) && (Math.floor(ic / 3) * 3 === bc);

    if (i === p) {
      cellEl.classList.add('selected');
    } else if (sameRow || sameCol || sameBox) {
      cellEl.classList.add('peer');
    }

    // تمييز كل الخلايا التي تحتوي على نفس القيمة
    const iVal = userBoard[i] || puzzleBoard[i];
    if (val !== 0 && iVal === val && i !== p) {
      cellEl.classList.add('same-value');
    }
  }
}

/* التعامل مع لوحة المفاتيح: أرقام، حذف، أسهم */
function handleKeyDown(e, r, c) {
  const p = idx(r, c);
  if (puzzleBoard[p] !== 0) {
    // خلية معطاة: السماح فقط بالتنقل
  }

  if (e.key >= '1' && e.key <= '9') {
    e.preventDefault();
    setCellValue(p, parseInt(e.key, 10));
  } else if (['Backspace', 'Delete', '0'].includes(e.key)) {
    e.preventDefault();
    setCellValue(p, 0);
  } else if (e.key.startsWith('Arrow')) {
    e.preventDefault();
    let nr = r, nc = c;
    if (e.key === 'ArrowUp') nr = (r + 8) % 9;
    if (e.key === 'ArrowDown') nr = (r + 1) % 9;
    // ملاحظة: الاتجاه RTL لا يؤثر على منطق الأسهم في الشبكة
    if (e.key === 'ArrowLeft') nc = (c + 1) % 9;
    if (e.key === 'ArrowRight') nc = (c + 8) % 9;
    getInputEl(idx(nr, nc)).focus();
  }
}

/* التعامل مع الإدخال المباشر (لمس / موبايل) */
function handleDigitInput(e, r, c) {
  const p = idx(r, c);
  const raw = e.target.value.replace(/[^1-9]/g, '');
  e.target.value = raw.slice(-1);
  setCellValue(p, raw ? parseInt(raw.slice(-1), 10) : 0);
}

/* تحديث قيمة خلية (إن لم تكن من الخلايا المعطاة) */
function setCellValue(p, val) {
  if (puzzleBoard[p] !== 0) return; // لا يمكن تعديل الأرقام الأصلية

  userBoard[p] = val;
  const input = getInputEl(p);
  input.value = val === 0 ? '' : val;
  getCellEl(p).classList.remove('error');

  selectCell(p);

  // تحقق فوري من الفوز عند امتلاء الشبكة
  if (userBoard.every(v => v !== 0)) {
    checkSolution(true);
  }
}

/* لوحة الأرقام الجانبية */
document.getElementById('numpad').addEventListener('click', (e) => {
  const btn = e.target.closest('button[data-num]');
  if (!btn || selectedCell === -1) return;
  const num = parseInt(btn.dataset.num, 10);
  setCellValue(selectedCell, num);
  getInputEl(selectedCell).focus();
});


/* =========================================================
   6) التحقق / التلميح / الحل / التصفير
   ========================================================= */
function checkSolution(isAutoCheck = false) {
  let errors = 0;
  let filled = 0;

  for (let p = 0; p < 81; p++) {
    const cellEl = getCellEl(p);
    cellEl.classList.remove('error');

    if (puzzleBoard[p] !== 0) { filled++; continue; }
    if (userBoard[p] === 0) continue;

    filled++;
    if (userBoard[p] !== solutionBoard[p]) {
      cellEl.classList.add('error');
      errors++;
    }
  }

  if (filled < 81) {
    if (errors === 0) {
      setMessage(`لا توجد أخطاء حتى الآن — بقي ${81 - filled} خلية. استمر!`, 'ok');
    } else {
      setMessage(`تم العثور على ${errors} خطأ مظلَّل بالأحمر. حاول تصحيحها.`, 'bad');
    }
    return;
  }

  // الشبكة مكتملة بالكامل
  if (errors === 0) {
    setMessage('🎉 تهانينا! لقد حللت اللغز بشكل صحيح بالكامل.', 'ok');
    stopTimer();
  } else {
    setMessage(`الشبكة مكتملة لكن بها ${errors} خطأ. صحّح الخلايا الحمراء.`, 'bad');
  }
}

/* تلميح: يضع رقمًا صحيحًا في خلية فارغة عشوائية */
function giveHint() {
  const empties = [];
  for (let p = 0; p < 81; p++) {
    if (puzzleBoard[p] === 0 && userBoard[p] !== solutionBoard[p]) empties.push(p);
  }
  if (empties.length === 0) {
    setMessage('لا توجد خلايا متبقية لإعطاء تلميح لها.', 'info');
    return;
  }
  const p = empties[Math.floor(Math.random() * empties.length)];
  setCellValue(p, solutionBoard[p]);
  setMessage('تم وضع تلميح في إحدى الخلايا الفارغة.', 'info');

  if (userBoard.every(v => v !== 0)) checkSolution(true);
}

/* إظهار الحل الكامل */
function revealSolution() {
  for (let p = 0; p < 81; p++) {
    if (puzzleBoard[p] === 0) {
      userBoard[p] = solutionBoard[p];
      const input = getInputEl(p);
      input.value = solutionBoard[p];
      getCellEl(p).classList.remove('error');
    }
  }
  setMessage('تم إظهار الحل الكامل لهذا اللغز.', 'info');
  stopTimer();
}

/* تصفير اللغز الحالي (دون توليد لغز جديد) */
function resetPuzzle() {
  userBoard = puzzleBoard.slice();
  selectedCell = -1;
  renderBoard();
  resetTimer();
  startTimer();
  setMessage('تمت إعادة تعيين اللغز إلى حالته الأصلية.', 'info');
}


/* =========================================================
   7) المؤقت
   ========================================================= */
function startTimer() {
  stopTimer();
  timerInterval = setInterval(() => {
    secondsElapsed++;
    const m = String(Math.floor(secondsElapsed / 60)).padStart(2, '0');
    const s = String(secondsElapsed % 60).padStart(2, '0');
    statTime.textContent = `${m}:${s}`;
  }, 1000);
}
function stopTimer() {
  if (timerInterval) clearInterval(timerInterval);
  timerInterval = null;
}
function resetTimer() {
  secondsElapsed = 0;
  statTime.textContent = '00:00';
}


/* =========================================================
   8) رسائل التنبيه
   ========================================================= */
function setMessage(text, type) {
  messageEl.textContent = text;
  messageEl.className = type || '';
}


/* =========================================================
   9) ربط الأزرار وبدء التشغيل
   ========================================================= */
document.getElementById('newGameBtn').addEventListener('click', newGame);
document.getElementById('checkBtn').addEventListener('click', () => checkSolution(false));
document.getElementById('hintBtn').addEventListener('click', giveHint);
document.getElementById('solveBtn').addEventListener('click', revealSolution);
document.getElementById('resetBtn').addEventListener('click', resetPuzzle);
document.getElementById('printBtn').addEventListener('click', () => window.print());
difficultySelect.addEventListener('change', newGame);

// بناء الشبكة وبدء أول لغز عند تحميل الصفحة
buildBoardDOM();
newGame();


سودوكو — دفتر الألغاز

✅ Low Risk - https://mysudoko-dp3jfdvxqd0k.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
2	43.152.26.58	Singapore	AS139341ACE
2	1	-	-

Security Scan Report: mysudoko-dp3jfdvxqd0k.edgeone.app

Summary

AI Security Verdict

Low Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History