1.8.4

check_i18n.js

@@ -0,0 +1,37 @@
+
+const fs = require('fs');
+
+const fileContent = fs.readFileSync('src/composables/useI18n.js', 'utf8');
+
+// Extract the messages object
+const match = fileContent.match(/const messages = ({[\s\S]*?});/);
+if (!match) {
+  console.error('Could not find messages object');
+  process.exit(1);
+}
+
+// We need to make the string valid JS to eval it.
+// It seems the content inside `const messages = { ... };` is valid JS object notation.
+// But we need to be careful about imports or other things if we were to `eval` the whole file.
+// We'll just `eval` the object part.
+
+const messagesStr = match[1];
+const messages = eval(`(${messagesStr})`);
+
+const enKeys = Object.keys(messages.en);
+const languages = Object.keys(messages);
+
+const missing = {};
+
+languages.forEach(lang => {
+  if (lang === 'en') return;
+  
+  const langKeys = Object.keys(messages[lang]);
+  const missingKeys = enKeys.filter(k => !langKeys.includes(k));
+  
+  if (missingKeys.length > 0) {
+    missing[lang] = missingKeys;
+  }
+});
+
+console.log(JSON.stringify(missing, null, 2));

difficulty_simulation_results.csv

@@ -0,0 +1,118 @@
+size,density,avg_solved_percent,min_solved_percent,max_solved_percent,avg_time_ms
+5,0.1,89.40,36.00,100.00,0.03
+5,0.2,74.20,8.00,100.00,0.04
+5,0.3,74.20,0.00,100.00,0.04
+5,0.4,80.80,8.00,100.00,0.03
+5,0.5,96.80,68.00,100.00,0.03
+5,0.6,97.60,84.00,100.00,0.03
+5,0.7,99.20,84.00,100.00,0.03
+5,0.8,100.00,100.00,100.00,0.02
+5,0.9,100.00,100.00,100.00,0.02
+10,0.1,56.60,19.00,86.00,0.04
+10,0.2,19.80,0.00,51.00,0.05
+10,0.3,15.75,0.00,73.00,0.07
+10,0.4,54.05,0.00,100.00,0.13
+10,0.5,91.80,59.00,100.00,0.17
+10,0.6,99.80,96.00,100.00,0.07
+10,0.7,99.80,96.00,100.00,0.05
+10,0.8,100.00,100.00,100.00,0.04
+10,0.9,100.00,100.00,100.00,0.02
+15,0.1,37.04,13.33,61.78,0.05
+15,0.2,9.78,0.00,26.67,0.03
+15,0.3,1.89,0.00,8.00,0.03
+15,0.4,11.82,0.00,61.33,0.08
+15,0.5,68.20,2.67,100.00,0.14
+15,0.6,99.56,96.44,100.00,0.09
+15,0.7,99.78,97.33,100.00,0.07
+15,0.8,100.00,100.00,100.00,0.05
+15,0.9,100.00,100.00,100.00,0.03
+20,0.1,22.59,5.00,41.50,0.04
+20,0.2,3.25,0.00,14.50,0.04
+20,0.3,0.56,0.00,5.00,0.04
+20,0.4,1.46,0.00,3.25,0.07
+20,0.5,36.75,1.25,99.00,0.26
+20,0.6,99.80,99.00,100.00,0.23
+20,0.7,99.95,99.00,100.00,0.13
+20,0.8,100.00,100.00,100.00,0.09
+20,0.9,100.00,100.00,100.00,0.05
+25,0.1,16.00,7.84,32.80,0.06
+25,0.2,0.00,0.00,0.00,0.04
+25,0.3,0.05,0.00,0.64,0.06
+25,0.4,0.89,0.00,9.44,0.12
+25,0.5,19.13,1.12,96.48,0.35
+25,0.6,99.25,94.88,100.00,0.50
+25,0.7,99.90,99.36,100.00,0.24
+25,0.8,100.00,100.00,100.00,0.15
+25,0.9,99.97,99.36,100.00,0.08
+30,0.1,7.99,0.00,16.00,0.08
+30,0.2,0.17,0.00,3.33,0.07
+30,0.3,0.00,0.00,0.00,0.08
+30,0.4,0.38,0.00,4.11,0.18
+30,0.5,5.42,0.78,21.44,0.41
+30,0.6,99.42,94.78,100.00,0.94
+30,0.7,99.93,99.56,100.00,0.42
+30,0.8,100.00,100.00,100.00,0.22
+30,0.9,100.00,100.00,100.00,0.13
+35,0.1,5.65,0.00,13.80,0.11
+35,0.2,0.14,0.00,2.86,0.10
+35,0.3,0.00,0.00,0.00,0.13
+35,0.4,0.13,0.00,0.57,0.22
+35,0.5,4.42,0.41,23.18,0.56
+35,0.6,91.11,8.41,100.00,1.58
+35,0.7,99.97,99.67,100.00,0.60
+35,0.8,100.00,100.00,100.00,0.33
+35,0.9,100.00,100.00,100.00,0.17
+40,0.1,2.73,0.00,9.81,0.13
+40,0.2,0.00,0.00,0.00,0.13
+40,0.3,0.00,0.00,0.00,0.18
+40,0.4,0.03,0.00,0.31,0.27
+40,0.5,2.14,0.00,9.56,0.69
+40,0.6,91.44,22.31,100.00,2.92
+40,0.7,99.99,99.75,100.00,0.84
+40,0.8,100.00,100.00,100.00,0.43
+40,0.9,100.00,100.00,100.00,0.24
+45,0.1,1.78,0.00,4.69,0.17
+45,0.2,0.00,0.00,0.00,0.17
+45,0.3,0.00,0.00,0.00,0.24
+45,0.4,0.01,0.00,0.15,0.33
+45,0.5,1.44,0.40,5.14,0.96
+45,0.6,81.72,6.02,100.00,5.28
+45,0.7,99.94,99.41,100.00,1.28
+45,0.8,100.00,100.00,100.00,0.64
+45,0.9,100.00,100.00,100.00,0.30
+50,0.1,1.70,0.00,5.92,0.20
+50,0.2,0.00,0.00,0.00,0.23
+50,0.3,0.00,0.00,0.00,0.30
+50,0.4,0.01,0.00,0.16,0.38
+50,0.5,0.51,0.00,1.80,0.90
+50,0.6,73.26,5.60,100.00,7.94
+50,0.7,99.96,99.76,100.00,1.63
+50,0.8,100.00,100.00,100.00,0.83
+50,0.9,100.00,100.00,100.00,0.41
+60,0.1,0.17,0.00,1.67,0.24
+60,0.2,0.00,0.00,0.00,0.35
+60,0.3,0.00,0.00,0.00,0.50
+60,0.4,0.00,0.00,0.06,0.64
+60,0.5,0.23,0.00,1.67,1.24
+60,0.6,35.02,1.33,100.00,10.76
+60,0.7,99.97,99.83,100.00,2.96
+60,0.8,100.00,100.00,100.00,1.27
+60,0.9,100.00,100.00,100.00,0.62
+70,0.1,0.14,0.00,1.43,0.34
+70,0.2,0.00,0.00,0.00,0.54
+70,0.3,0.00,0.00,0.00,0.76
+70,0.4,0.00,0.00,0.00,0.96
+70,0.5,0.04,0.00,0.29,1.49
+70,0.6,16.40,1.00,99.71,22.21
+70,0.7,99.97,99.73,100.00,4.92
+70,0.8,100.00,99.92,100.00,2.03
+70,0.9,100.00,100.00,100.00,0.89
+80,0.1,0.00,0.00,0.00,0.44
+80,0.2,0.00,0.00,0.00,0.78
+80,0.3,0.00,0.00,0.00,1.07
+80,0.4,0.00,0.00,0.00,1.34
+80,0.5,0.01,0.00,0.08,1.97
+80,0.6,1.21,0.41,2.30,3.92
+80,0.7,99.98,99.94,100.00,7.79
+80,0.8,100.00,100.00,100.00,3.14
+80,0.9,100.00,100.00,100.00,1.31

difficulty_simulation_results.json

@@ -0,0 +1,938 @@
+[
+  {
+    "size": 5,
+    "density": 0.1,
+    "avgSolved": 89.4,
+    "minSolved": 36,
+    "maxSolved": 100,
+    "avgTime": 0.031666799999999905
+  },
+  {
+    "size": 5,
+    "density": 0.2,
+    "avgSolved": 74.2,
+    "minSolved": 8,
+    "maxSolved": 100,
+    "avgTime": 0.03671869999999924
+  },
+  {
+    "size": 5,
+    "density": 0.3,
+    "avgSolved": 74.2,
+    "minSolved": 0,
+    "maxSolved": 100,
+    "avgTime": 0.04439559999999983
+  },
+  {
+    "size": 5,
+    "density": 0.4,
+    "avgSolved": 80.8,
+    "minSolved": 8,
+    "maxSolved": 100,
+    "avgTime": 0.0317166499999999
+  },
+  {
+    "size": 5,
+    "density": 0.5,
+    "avgSolved": 96.8,
+    "minSolved": 68,
+    "maxSolved": 100,
+    "avgTime": 0.0309604000000002
+  },
+  {
+    "size": 5,
+    "density": 0.6,
+    "avgSolved": 97.6,
+    "minSolved": 84,
+    "maxSolved": 100,
+    "avgTime": 0.031464499999999875
+  },
+  {
+    "size": 5,
+    "density": 0.7,
+    "avgSolved": 99.2,
+    "minSolved": 84,
+    "maxSolved": 100,
+    "avgTime": 0.03086874999999978
+  },
+  {
+    "size": 5,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.01615615000000048
+  },
+  {
+    "size": 5,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.02271474999999956
+  },
+  {
+    "size": 10,
+    "density": 0.1,
+    "avgSolved": 56.6,
+    "minSolved": 19,
+    "maxSolved": 86,
+    "avgTime": 0.042958299999999915
+  },
+  {
+    "size": 10,
+    "density": 0.2,
+    "avgSolved": 19.8,
+    "minSolved": 0,
+    "maxSolved": 51,
+    "avgTime": 0.050141749999999874
+  },
+  {
+    "size": 10,
+    "density": 0.3,
+    "avgSolved": 15.75,
+    "minSolved": 0,
+    "maxSolved": 73,
+    "avgTime": 0.06852290000000014
+  },
+  {
+    "size": 10,
+    "density": 0.4,
+    "avgSolved": 54.05,
+    "minSolved": 0,
+    "maxSolved": 100,
+    "avgTime": 0.12701870000000018
+  },
+  {
+    "size": 10,
+    "density": 0.5,
+    "avgSolved": 91.8,
+    "minSolved": 59,
+    "maxSolved": 100,
+    "avgTime": 0.16561034999999985
+  },
+  {
+    "size": 10,
+    "density": 0.6,
+    "avgSolved": 99.8,
+    "minSolved": 96,
+    "maxSolved": 100,
+    "avgTime": 0.07136649999999882
+  },
+  {
+    "size": 10,
+    "density": 0.7,
+    "avgSolved": 99.8,
+    "minSolved": 96,
+    "maxSolved": 100,
+    "avgTime": 0.04808134999999893
+  },
+  {
+    "size": 10,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.03795824999999979
+  },
+  {
+    "size": 10,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.024952100000000855
+  },
+  {
+    "size": 15,
+    "density": 0.1,
+    "avgSolved": 37.044444444444444,
+    "minSolved": 13.333333333333334,
+    "maxSolved": 61.77777777777778,
+    "avgTime": 0.045045850000000345
+  },
+  {
+    "size": 15,
+    "density": 0.2,
+    "avgSolved": 9.777777777777775,
+    "minSolved": 0,
+    "maxSolved": 26.666666666666668,
+    "avgTime": 0.034581349999998776
+  },
+  {
+    "size": 15,
+    "density": 0.3,
+    "avgSolved": 1.8888888888888886,
+    "minSolved": 0,
+    "maxSolved": 8,
+    "avgTime": 0.029402199999999823
+  },
+  {
+    "size": 15,
+    "density": 0.4,
+    "avgSolved": 11.822222222222223,
+    "minSolved": 0,
+    "maxSolved": 61.33333333333333,
+    "avgTime": 0.07898965000000047
+  },
+  {
+    "size": 15,
+    "density": 0.5,
+    "avgSolved": 68.19999999999999,
+    "minSolved": 2.666666666666667,
+    "maxSolved": 100,
+    "avgTime": 0.1374602999999997
+  },
+  {
+    "size": 15,
+    "density": 0.6,
+    "avgSolved": 99.55555555555554,
+    "minSolved": 96.44444444444444,
+    "maxSolved": 100,
+    "avgTime": 0.09379159999999978
+  },
+  {
+    "size": 15,
+    "density": 0.7,
+    "avgSolved": 99.77777777777779,
+    "minSolved": 97.33333333333334,
+    "maxSolved": 100,
+    "avgTime": 0.07072704999999928
+  },
+  {
+    "size": 15,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.050104250000000405
+  },
+  {
+    "size": 15,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.031362550000000766
+  },
+  {
+    "size": 20,
+    "density": 0.1,
+    "avgSolved": 22.5875,
+    "minSolved": 5,
+    "maxSolved": 41.5,
+    "avgTime": 0.04363335000000035
+  },
+  {
+    "size": 20,
+    "density": 0.2,
+    "avgSolved": 3.25,
+    "minSolved": 0,
+    "maxSolved": 14.499999999999998,
+    "avgTime": 0.03823525000000103
+  },
+  {
+    "size": 20,
+    "density": 0.3,
+    "avgSolved": 0.5625,
+    "minSolved": 0,
+    "maxSolved": 5,
+    "avgTime": 0.03880414999999786
+  },
+  {
+    "size": 20,
+    "density": 0.4,
+    "avgSolved": 1.4625,
+    "minSolved": 0,
+    "maxSolved": 3.25,
+    "avgTime": 0.06692695000000129
+  },
+  {
+    "size": 20,
+    "density": 0.5,
+    "avgSolved": 36.75,
+    "minSolved": 1.25,
+    "maxSolved": 99,
+    "avgTime": 0.25872084999999884
+  },
+  {
+    "size": 20,
+    "density": 0.6,
+    "avgSolved": 99.8,
+    "minSolved": 99,
+    "maxSolved": 100,
+    "avgTime": 0.2258772000000004
+  },
+  {
+    "size": 20,
+    "density": 0.7,
+    "avgSolved": 99.95,
+    "minSolved": 99,
+    "maxSolved": 100,
+    "avgTime": 0.13418124999999997
+  },
+  {
+    "size": 20,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.09264785000000053
+  },
+  {
+    "size": 20,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.05307699999999756
+  },
+  {
+    "size": 25,
+    "density": 0.1,
+    "avgSolved": 16.000000000000004,
+    "minSolved": 7.84,
+    "maxSolved": 32.800000000000004,
+    "avgTime": 0.05678540000000112
+  },
+  {
+    "size": 25,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.04278334999999842
+  },
+  {
+    "size": 25,
+    "density": 0.3,
+    "avgSolved": 0.048,
+    "minSolved": 0,
+    "maxSolved": 0.64,
+    "avgTime": 0.05884794999999983
+  },
+  {
+    "size": 25,
+    "density": 0.4,
+    "avgSolved": 0.8880000000000001,
+    "minSolved": 0,
+    "maxSolved": 9.44,
+    "avgTime": 0.11761245000000287
+  },
+  {
+    "size": 25,
+    "density": 0.5,
+    "avgSolved": 19.128000000000007,
+    "minSolved": 1.1199999999999999,
+    "maxSolved": 96.48,
+    "avgTime": 0.3490229000000021
+  },
+  {
+    "size": 25,
+    "density": 0.6,
+    "avgSolved": 99.24799999999998,
+    "minSolved": 94.88,
+    "maxSolved": 100,
+    "avgTime": 0.49611459999999996
+  },
+  {
+    "size": 25,
+    "density": 0.7,
+    "avgSolved": 99.904,
+    "minSolved": 99.36,
+    "maxSolved": 100,
+    "avgTime": 0.23916465000000073
+  },
+  {
+    "size": 25,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.14604994999999973
+  },
+  {
+    "size": 25,
+    "density": 0.9,
+    "avgSolved": 99.96799999999999,
+    "minSolved": 99.36,
+    "maxSolved": 100,
+    "avgTime": 0.08385419999999896
+  },
+  {
+    "size": 30,
+    "density": 0.1,
+    "avgSolved": 7.988888888888889,
+    "minSolved": 0,
+    "maxSolved": 16,
+    "avgTime": 0.08026245000000073
+  },
+  {
+    "size": 30,
+    "density": 0.2,
+    "avgSolved": 0.16666666666666669,
+    "minSolved": 0,
+    "maxSolved": 3.3333333333333335,
+    "avgTime": 0.06999999999999887
+  },
+  {
+    "size": 30,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.08285835000000005
+  },
+  {
+    "size": 30,
+    "density": 0.4,
+    "avgSolved": 0.3777777777777777,
+    "minSolved": 0,
+    "maxSolved": 4.111111111111112,
+    "avgTime": 0.1756041499999988
+  },
+  {
+    "size": 30,
+    "density": 0.5,
+    "avgSolved": 5.4222222222222225,
+    "minSolved": 0.7777777777777778,
+    "maxSolved": 21.444444444444443,
+    "avgTime": 0.41105620000000015
+  },
+  {
+    "size": 30,
+    "density": 0.6,
+    "avgSolved": 99.41666666666669,
+    "minSolved": 94.77777777777779,
+    "maxSolved": 100,
+    "avgTime": 0.9417500999999995
+  },
+  {
+    "size": 30,
+    "density": 0.7,
+    "avgSolved": 99.93333333333335,
+    "minSolved": 99.55555555555556,
+    "maxSolved": 100,
+    "avgTime": 0.41628955000000334
+  },
+  {
+    "size": 30,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.22320620000000133
+  },
+  {
+    "size": 30,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.13331460000000134
+  },
+  {
+    "size": 35,
+    "density": 0.1,
+    "avgSolved": 5.653061224489796,
+    "minSolved": 0,
+    "maxSolved": 13.795918367346937,
+    "avgTime": 0.11177699999999931
+  },
+  {
+    "size": 35,
+    "density": 0.2,
+    "avgSolved": 0.14285714285714285,
+    "minSolved": 0,
+    "maxSolved": 2.857142857142857,
+    "avgTime": 0.09598544999999917
+  },
+  {
+    "size": 35,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.1290145000000038
+  },
+  {
+    "size": 35,
+    "density": 0.4,
+    "avgSolved": 0.1346938775510204,
+    "minSolved": 0,
+    "maxSolved": 0.5714285714285714,
+    "avgTime": 0.21904799999999797
+  },
+  {
+    "size": 35,
+    "density": 0.5,
+    "avgSolved": 4.424489795918367,
+    "minSolved": 0.40816326530612246,
+    "maxSolved": 23.183673469387756,
+    "avgTime": 0.5596769500000022
+  },
+  {
+    "size": 35,
+    "density": 0.6,
+    "avgSolved": 91.1061224489796,
+    "minSolved": 8.408163265306122,
+    "maxSolved": 100,
+    "avgTime": 1.5827311000000024
+  },
+  {
+    "size": 35,
+    "density": 0.7,
+    "avgSolved": 99.9673469387755,
+    "minSolved": 99.67346938775509,
+    "maxSolved": 100,
+    "avgTime": 0.5970167499999988
+  },
+  {
+    "size": 35,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.33084175000000327
+  },
+  {
+    "size": 35,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.1685022000000032
+  },
+  {
+    "size": 40,
+    "density": 0.1,
+    "avgSolved": 2.734375,
+    "minSolved": 0,
+    "maxSolved": 9.8125,
+    "avgTime": 0.13156869999999826
+  },
+  {
+    "size": 40,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.13052910000000112
+  },
+  {
+    "size": 40,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.17675199999999905
+  },
+  {
+    "size": 40,
+    "density": 0.4,
+    "avgSolved": 0.03125,
+    "minSolved": 0,
+    "maxSolved": 0.3125,
+    "avgTime": 0.26616039999999686
+  },
+  {
+    "size": 40,
+    "density": 0.5,
+    "avgSolved": 2.14375,
+    "minSolved": 0,
+    "maxSolved": 9.5625,
+    "avgTime": 0.694316649999999
+  },
+  {
+    "size": 40,
+    "density": 0.6,
+    "avgSolved": 91.44375,
+    "minSolved": 22.3125,
+    "maxSolved": 100,
+    "avgTime": 2.9244042000000006
+  },
+  {
+    "size": 40,
+    "density": 0.7,
+    "avgSolved": 99.9875,
+    "minSolved": 99.75,
+    "maxSolved": 100,
+    "avgTime": 0.8381519999999967
+  },
+  {
+    "size": 40,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.4339062999999925
+  },
+  {
+    "size": 40,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.2375938000000076
+  },
+  {
+    "size": 45,
+    "density": 0.1,
+    "avgSolved": 1.7827160493827159,
+    "minSolved": 0,
+    "maxSolved": 4.691358024691358,
+    "avgTime": 0.1660813500000046
+  },
+  {
+    "size": 45,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.1715666999999968
+  },
+  {
+    "size": 45,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.23760415000000706
+  },
+  {
+    "size": 45,
+    "density": 0.4,
+    "avgSolved": 0.012345679012345678,
+    "minSolved": 0,
+    "maxSolved": 0.14814814814814814,
+    "avgTime": 0.333931249999992
+  },
+  {
+    "size": 45,
+    "density": 0.5,
+    "avgSolved": 1.439506172839506,
+    "minSolved": 0.39506172839506176,
+    "maxSolved": 5.135802469135802,
+    "avgTime": 0.9644125499999916
+  },
+  {
+    "size": 45,
+    "density": 0.6,
+    "avgSolved": 81.71851851851852,
+    "minSolved": 6.0246913580246915,
+    "maxSolved": 100,
+    "avgTime": 5.281324949999998
+  },
+  {
+    "size": 45,
+    "density": 0.7,
+    "avgSolved": 99.94074074074075,
+    "minSolved": 99.4074074074074,
+    "maxSolved": 100,
+    "avgTime": 1.2768960000000107
+  },
+  {
+    "size": 45,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.638566650000007
+  },
+  {
+    "size": 45,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.3004915999999923
+  },
+  {
+    "size": 50,
+    "density": 0.1,
+    "avgSolved": 1.7,
+    "minSolved": 0,
+    "maxSolved": 5.92,
+    "avgTime": 0.20294785000000387
+  },
+  {
+    "size": 50,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.23199789999999892
+  },
+  {
+    "size": 50,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.29876259999999205
+  },
+  {
+    "size": 50,
+    "density": 0.4,
+    "avgSolved": 0.008,
+    "minSolved": 0,
+    "maxSolved": 0.16,
+    "avgTime": 0.38459799999998834
+  },
+  {
+    "size": 50,
+    "density": 0.5,
+    "avgSolved": 0.5099999999999999,
+    "minSolved": 0,
+    "maxSolved": 1.7999999999999998,
+    "avgTime": 0.8961771499999941
+  },
+  {
+    "size": 50,
+    "density": 0.6,
+    "avgSolved": 73.258,
+    "minSolved": 5.6000000000000005,
+    "maxSolved": 100,
+    "avgTime": 7.937735449999991
+  },
+  {
+    "size": 50,
+    "density": 0.7,
+    "avgSolved": 99.96399999999998,
+    "minSolved": 99.76,
+    "maxSolved": 100,
+    "avgTime": 1.6324250000000062
+  },
+  {
+    "size": 50,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.8293270000000064
+  },
+  {
+    "size": 50,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.41459575000000654
+  },
+  {
+    "size": 60,
+    "density": 0.1,
+    "avgSolved": 0.16666666666666669,
+    "minSolved": 0,
+    "maxSolved": 1.6666666666666667,
+    "avgTime": 0.2432124999999928
+  },
+  {
+    "size": 60,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.35082704999999237
+  },
+  {
+    "size": 60,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.49827310000000014
+  },
+  {
+    "size": 60,
+    "density": 0.4,
+    "avgSolved": 0.0027777777777777775,
+    "minSolved": 0,
+    "maxSolved": 0.05555555555555555,
+    "avgTime": 0.6393062499999985
+  },
+  {
+    "size": 60,
+    "density": 0.5,
+    "avgSolved": 0.23055555555555554,
+    "minSolved": 0,
+    "maxSolved": 1.6666666666666667,
+    "avgTime": 1.2402395500000012
+  },
+  {
+    "size": 60,
+    "density": 0.6,
+    "avgSolved": 35.01805555555556,
+    "minSolved": 1.3333333333333335,
+    "maxSolved": 100,
+    "avgTime": 10.759754149999992
+  },
+  {
+    "size": 60,
+    "density": 0.7,
+    "avgSolved": 99.96944444444445,
+    "minSolved": 99.83333333333333,
+    "maxSolved": 100,
+    "avgTime": 2.964204100000029
+  },
+  {
+    "size": 60,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 1.2736664999999903
+  },
+  {
+    "size": 60,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.6249353999999812
+  },
+  {
+    "size": 70,
+    "density": 0.1,
+    "avgSolved": 0.14285714285714285,
+    "minSolved": 0,
+    "maxSolved": 1.4285714285714286,
+    "avgTime": 0.34277719999998907
+  },
+  {
+    "size": 70,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.5435105000000249
+  },
+  {
+    "size": 70,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.7600602999999865
+  },
+  {
+    "size": 70,
+    "density": 0.4,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.9591250999999943
+  },
+  {
+    "size": 70,
+    "density": 0.5,
+    "avgSolved": 0.04081632653061225,
+    "minSolved": 0,
+    "maxSolved": 0.2857142857142857,
+    "avgTime": 1.491010399999982
+  },
+  {
+    "size": 70,
+    "density": 0.6,
+    "avgSolved": 16.403061224489797,
+    "minSolved": 1,
+    "maxSolved": 99.71428571428571,
+    "avgTime": 22.21432699999999
+  },
+  {
+    "size": 70,
+    "density": 0.7,
+    "avgSolved": 99.96836734693878,
+    "minSolved": 99.73469387755102,
+    "maxSolved": 100,
+    "avgTime": 4.92020829999999
+  },
+  {
+    "size": 70,
+    "density": 0.8,
+    "avgSolved": 99.99591836734695,
+    "minSolved": 99.91836734693878,
+    "maxSolved": 100,
+    "avgTime": 2.0306394499999554
+  },
+  {
+    "size": 70,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 0.8882499500000336
+  },
+  {
+    "size": 80,
+    "density": 0.1,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.4418666499999858
+  },
+  {
+    "size": 80,
+    "density": 0.2,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 0.7795667999999978
+  },
+  {
+    "size": 80,
+    "density": 0.3,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 1.0745101999999747
+  },
+  {
+    "size": 80,
+    "density": 0.4,
+    "avgSolved": 0,
+    "minSolved": 0,
+    "maxSolved": 0,
+    "avgTime": 1.3407041500000105
+  },
+  {
+    "size": 80,
+    "density": 0.5,
+    "avgSolved": 0.0125,
+    "minSolved": 0,
+    "maxSolved": 0.078125,
+    "avgTime": 1.9724897000000283
+  },
+  {
+    "size": 80,
+    "density": 0.6,
+    "avgSolved": 1.21484375,
+    "minSolved": 0.40625,
+    "maxSolved": 2.296875,
+    "avgTime": 3.9163123999999927
+  },
+  {
+    "size": 80,
+    "density": 0.7,
+    "avgSolved": 99.978125,
+    "minSolved": 99.9375,
+    "maxSolved": 100,
+    "avgTime": 7.790070799999967
+  },
+  {
+    "size": 80,
+    "density": 0.8,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 3.1350061999999754
+  },
+  {
+    "size": 80,
+    "density": 0.9,
+    "avgSolved": 100,
+    "minSolved": 100,
+    "maxSolved": 100,
+    "avgTime": 1.3134414999999535
+  }
+]

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "vue-nonograms-solid",
-  "version": "1.7.0",
+  "version": "1.8.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "vue-nonograms-solid",
-      "version": "1.7.0",
+      "version": "1.8.4",
       "dependencies": {
         "fireworks-js": "^2.10.8",
         "flag-icons": "^7.5.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-nonograms-solid",
-  "version": "1.7.0",
+  "version": "1.8.4",
   "type": "module",
   "scripts": {
     "dev": "vite",

scripts/add_simulation_translations.cjs

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+
+const filePath = path.join(__dirname, '../src/composables/useI18n.js');
+let content = fs.readFileSync(filePath, 'utf8');
+
+const newKeys = {
+    'custom.simulationHelp': 'How is this calculated?',
+    'custom.hideMap': 'Hide difficulty map',
+    'custom.showMap': 'Show difficulty map',
+    'simulation.title': 'Difficulty Simulation',
+    'simulation.status.ready': 'Ready',
+    'simulation.status.stopped': 'Stopped',
+    'simulation.status.completed': 'Completed',
+    'simulation.status.simulating': 'Simulating {size}x{size} @ {density}%',
+    'simulation.start': 'Start Simulation',
+    'simulation.stop': 'Stop',
+    'simulation.table.size': 'Size',
+    'simulation.table.density': 'Density',
+    'simulation.table.solved': 'Solved (Logic)',
+    'simulation.empty': 'Press Start to run Monte Carlo simulation'
+};
+
+const lines = content.split('\n');
+const processedLines = [];
+let currentLang = null;
+
+for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    
+    // Detect start of language block
+    const startMatch = line.match(/^\s{2}(['"]?[\w-]+['"]?): \{/);
+    if (startMatch) {
+        currentLang = startMatch[1].replace(/['"]/g, '');
+    }
+
+    // Detect end of language block
+    if (currentLang && (line.trim() === '},' || line.trim() === '}')) {
+        if (currentLang !== 'pl' && currentLang !== 'en') {
+            // Ensure previous line has comma
+            if (processedLines.length > 0) {
+                let lastLine = processedLines[processedLines.length - 1];
+                if (!lastLine.trim().endsWith(',') && !lastLine.trim().endsWith('{')) {
+                    processedLines[processedLines.length - 1] = lastLine + ',';
+                }
+            }
+
+            // Append new keys
+            Object.entries(newKeys).forEach(([key, value]) => {
+                processedLines.push(`    '${key}': '${value}',`);
+            });
+        }
+        currentLang = null;
+    }
+    
+    processedLines.push(line);
+}
+
+const finalContent = processedLines.join('\n');
+fs.writeFileSync(filePath, finalContent);
+console.log('Successfully added simulation translations to all languages.');

scripts/add_simulation_translations.js

@@ -0,0 +1,97 @@
+
+const fs = require('fs');
+const path = require('path');
+
+const filePath = path.join(__dirname, '../src/composables/useI18n.js');
+let content = fs.readFileSync(filePath, 'utf8');
+
+const newKeys = {
+    'custom.simulationHelp': 'How is this calculated?',
+    'simulation.title': 'Difficulty Simulation',
+    'simulation.status.ready': 'Ready',
+    'simulation.status.stopped': 'Stopped',
+    'simulation.status.completed': 'Completed',
+    'simulation.status.simulating': 'Simulating {size}x{size} @ {density}%',
+    'simulation.start': 'Start Simulation',
+    'simulation.stop': 'Stop',
+    'simulation.table.size': 'Size',
+    'simulation.table.density': 'Density',
+    'simulation.table.solved': 'Solved (Logic)',
+    'simulation.empty': 'Press Start to run Monte Carlo simulation'
+};
+
+// Regex to match the end of a language block
+// Matches "  }," or "  }" at the start of a line
+const blockEndRegex = /^(\s{2})\},?$/gm;
+
+let newContent = content.replace(blockEndRegex, (match, indent, offset) => {
+    // Determine which language we are closing
+    const precedingText = content.substring(0, offset);
+    const langMatch = precedingText.match(/^\s{2}(\w+([-]\w+)?): \{/gm);
+    
+    if (!langMatch) return match;
+    const currentLangLine = langMatch[langMatch.length - 1];
+    const currentLang = currentLangLine.match(/^\s{2}(\w+([-]\w+)?): \{/)[1];
+
+    // Skip pl and en as they are already updated
+    if (currentLang === 'pl' || currentLang === 'en') {
+        return match;
+    }
+
+    // Check if the previous line has a comma
+    // We need to look at the lines before the match
+    // This is tricky with replace callback. 
+    // Easier strategy: Just insert the keys. 
+    // If the file is well formatted, the last item might or might not have a comma.
+    // But we can ensure *our* inserted block starts with a comma if needed? 
+    // No, standard JS objects need comma after previous item.
+    
+    // Let's assume we simply inject before the closing brace.
+    // We'll add a comma to the previous line if it doesn't have one?
+    // That's hard with regex replace on the closing brace only.
+    
+    // Alternative: Split by lines and process.
+    return match; // Placeholder, we will process by lines below.
+});
+
+const lines = content.split('\n');
+const processedLines = [];
+let currentLang = null;
+
+for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    
+    // Detect start of language block
+    const startMatch = line.match(/^\s{2}(['"]?[\w-]+['"]?): \{/);
+    if (startMatch) {
+        currentLang = startMatch[1].replace(/['"]/g, '');
+    }
+
+    // Detect end of language block
+    if (currentLang && (line.trim() === '},' || line.trim() === '}')) {
+        if (currentLang !== 'pl' && currentLang !== 'en') {
+            // Ensure previous line has comma
+            if (processedLines.length > 0) {
+                let lastLine = processedLines[processedLines.length - 1];
+                if (!lastLine.trim().endsWith(',') && !lastLine.trim().endsWith('{')) {
+                    processedLines[processedLines.length - 1] = lastLine + ',';
+                }
+            }
+
+            // Append new keys
+            Object.entries(newKeys).forEach(([key, value]) => {
+                processedLines.push(`    '${key}': '${value}',`);
+            });
+            
+            // Remove trailing comma from last inserted item if we want strictly JSON-like (but JS allows it)
+            // It's fine to leave it.
+        }
+        currentLang = null;
+    }
+    
+    processedLines.push(line);
+}
+
+const finalContent = processedLines.join('\n');
+fs.writeFileSync(filePath, finalContent);
+console.log('Successfully added simulation translations to all languages.');

scripts/simulate_difficulty.js

@@ -0,0 +1,75 @@
+
+import fs from 'fs';
+import path from 'path';
+import { generateRandomGrid, calculateHints } from '../src/utils/puzzleUtils.js';
+import { solvePuzzle } from '../src/utils/solver.js';
+
+const OUTPUT_FILE = 'difficulty_simulation_results.json';
+const CSV_FILE = 'difficulty_simulation_results.csv';
+
+// Configuration
+const SIZES = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80]; // Steps of 5 up to 50, then 10
+const DENSITIES = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];
+const SAMPLES_PER_POINT = 20; // Adjust based on time/accuracy needs
+
+console.log('Starting Monte Carlo Simulation for Nonogram Difficulty...');
+console.log(`Config: Sizes=${SIZES.length}, Densities=${DENSITIES.length}, Samples=${SAMPLES_PER_POINT}`);
+
+const results = [];
+const csvRows = ['size,density,avg_solved_percent,min_solved_percent,max_solved_percent,avg_time_ms'];
+
+const startTime = Date.now();
+
+for (const size of SIZES) {
+    for (const density of DENSITIES) {
+        let totalSolved = 0;
+        let minSolved = 100;
+        let maxSolved = 0;
+        let totalTime = 0;
+
+        process.stdout.write(`Simulating Size: ${size}x${size}, Density: ${density} ... `);
+
+        for (let i = 0; i < SAMPLES_PER_POINT; i++) {
+            const t0 = performance.now();
+            
+            // 1. Generate
+            const grid = generateRandomGrid(size, density);
+            const { rowHints, colHints } = calculateHints(grid);
+            
+            // 2. Solve
+            const { percentSolved } = solvePuzzle(rowHints, colHints);
+            
+            const t1 = performance.now();
+            
+            totalSolved += percentSolved;
+            minSolved = Math.min(minSolved, percentSolved);
+            maxSolved = Math.max(maxSolved, percentSolved);
+            totalTime += (t1 - t0);
+        }
+
+        const avgSolved = totalSolved / SAMPLES_PER_POINT;
+        const avgTime = totalTime / SAMPLES_PER_POINT;
+
+        results.push({
+            size,
+            density,
+            avgSolved,
+            minSolved,
+            maxSolved,
+            avgTime
+        });
+
+        csvRows.push(`${size},${density},${avgSolved.toFixed(2)},${minSolved.toFixed(2)},${maxSolved.toFixed(2)},${avgTime.toFixed(2)}`);
+        
+        console.log(`Avg Solved: ${avgSolved.toFixed(1)}%`);
+    }
+}
+
+const totalDuration = (Date.now() - startTime) / 1000;
+console.log(`Simulation complete in ${totalDuration.toFixed(1)}s`);
+
+// Save results
+fs.writeFileSync(OUTPUT_FILE, JSON.stringify(results, null, 2));
+fs.writeFileSync(CSV_FILE, csvRows.join('\n'));
+
+console.log(`Results saved to ${OUTPUT_FILE} and ${CSV_FILE}`);

src/App.vue

@@ -8,6 +8,7 @@ import StatusPanel from './components/StatusPanel.vue';
 import GuidePanel from './components/GuidePanel.vue';
 import WinModal from './components/WinModal.vue';
 import CustomGameModal from './components/CustomGameModal.vue';
+import SimulationView from './components/SimulationView.vue';
 import FixedBar from './components/FixedBar.vue';
 import ReloadPrompt from './components/ReloadPrompt.vue';
 
@@ -15,6 +16,7 @@ import ReloadPrompt from './components/ReloadPrompt.vue';
 const store = usePuzzleStore();
 const { t, locale, setLocale, locales } = useI18n();
 const showCustomModal = ref(false);
+const showSimulation = ref(false);
 const showGuide = ref(false);
 const deferredPrompt = ref(null);
 const canInstall = ref(false);
@@ -173,7 +175,8 @@ onUnmounted(() => {
     <!-- Modals Teleport -->
     <Teleport to="body">
       <WinModal v-if="store.isGameWon" />
-      <CustomGameModal v-if="showCustomModal" @close="showCustomModal = false" />
+      <CustomGameModal v-if="showCustomModal" @close="showCustomModal = false" @open-simulation="showSimulation = true" />
+      <SimulationView v-if="showSimulation" @close="showSimulation = false" />
       <ReloadPrompt />
     </Teleport>
   </main>

src/components/CustomGameModal.vue

@@ -1,10 +1,11 @@
 <script setup>
-import { ref, computed, onMounted, watch, nextTick } from 'vue';
+import { ref, computed, onMounted, onUnmounted, watch, nextTick } from 'vue';
 import { usePuzzleStore } from '@/stores/puzzle';
 import { useI18n } from '@/composables/useI18n';
 import { calculateDifficulty } from '@/utils/puzzleUtils';
+import { HelpCircle } from 'lucide-vue-next';
 
-const emit = defineEmits(['close']);
+const emit = defineEmits(['close', 'open-simulation']);
 const store = usePuzzleStore();
 const { t } = useI18n();
 
@@ -13,6 +14,7 @@ const fillRate = ref(50);
 const errorMsg = ref('');
 const difficultyCanvas = ref(null);
 const isDragging = ref(false);
+const cachedBackground = ref(null);
 
 const drawMap = () => {
   const canvas = difficultyCanvas.value;
@@ -24,46 +26,42 @@ const drawMap = () => {
   // Clear
   ctx.clearRect(0, 0, width, height);
 
-  // Draw Gradient Background
+  // Use cached background if available
-  // Optimization: Create an image data once if static, but here it's small enough.
+  if (cachedBackground.value) {
-  const imgData = ctx.createImageData(width, height);
+      ctx.putImageData(cachedBackground.value, 0, 0);
-  const data = imgData.data;
+  } else {
+      // Draw Gradient Background (Heavy calculation)
+      const imgData = ctx.createImageData(width, height);
+      const data = imgData.data;
 
-  // Ranges:
+      // Ranges:
-  // X: Fill Rate 10% -> 90%
+      // X: Fill Rate 10% -> 90%
-  // Y: Size 5 -> 80
+      // Y: Size 5 -> 80
-  
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      // Map x, y to fillRate, size
-      // y=0 -> size 80 (top), y=height -> size 5 (bottom)
-      // x=0 -> fill 10%, x=width -> fill 90%
       
-      const normalizedX = x / width;
+      for (let y = 0; y < height; y++) {
-      const normalizedY = 1 - (y / height); // 0 at bottom, 1 at top
+        for (let x = 0; x < width; x++) {
-      
+          const normalizedX = x / width;
-      const fRate = 0.1 + normalizedX * 0.8; // 0.1 to 0.9
+          const normalizedY = 1 - (y / height); // 0 at bottom, 1 at top
-      const sSize = 5 + normalizedY * 75;    // 5 to 80
+          
-      
+          const fRate = 0.1 + normalizedX * 0.8; // 0.1 to 0.9
-      const { value } = calculateDifficulty(fRate, sSize);
+          const sSize = 5 + normalizedY * 75;    // 5 to 80
-      
+          
-      // Color Mapping:
+          const { value } = calculateDifficulty(fRate, sSize);
-      // Green (0%) -> Yellow (50%) -> Red (100%)
+          
-      // Hue: 120 -> 0
+          // Color Mapping
-      const hue = 120 * (1 - value / 100);
+          const hue = 120 * (1 - value / 100);
-      
+          const [r, g, b] = hslToRgb(hue / 360, 1, 0.5);
-      // Convert HSL to RGB (Simplified)
+          
-      // Saturation 100%, Lightness 50%
+          const index = (y * width + x) * 4;
-      const [r, g, b] = hslToRgb(hue / 360, 1, 0.5);
+          data[index] = r;
-      
+          data[index + 1] = g;
-      const index = (y * width + x) * 4;
+          data[index + 2] = b;
-      data[index] = r;
+          data[index + 3] = 255; // Alpha
-      data[index + 1] = g;
+        }
-      data[index + 2] = b;
+      }
-      data[index + 3] = 255; // Alpha
+      ctx.putImageData(imgData, 0, 0);
-    }
+      cachedBackground.value = imgData;
   }
-  ctx.putImageData(imgData, 0, 0);
 
   // Draw current position
   // Map current fillRate/size to x,y
@@ -139,6 +137,9 @@ const updateFromEvent = (e) => {
 const startDrag = (e) => {
     isDragging.value = true;
     updateFromEvent(e);
+    // Add global listeners for mouse to handle dragging outside canvas
+    window.addEventListener('mousemove', onDrag);
+    window.addEventListener('mouseup', stopDrag);
 };
 
 const onDrag = (e) => {
@@ -148,13 +149,22 @@ const onDrag = (e) => {
 
 const stopDrag = () => {
     isDragging.value = false;
+    window.removeEventListener('mousemove', onDrag);
+    window.removeEventListener('mouseup', stopDrag);
 };
 
+onUnmounted(() => {
+    window.removeEventListener('mousemove', onDrag);
+    window.removeEventListener('mouseup', stopDrag);
+});
+
 const showAdvanced = ref(false);
 
 const toggleAdvanced = () => {
     showAdvanced.value = !showAdvanced.value;
     if (showAdvanced.value) {
+        // Reset cache when opening to ensure size is correct if canvas resized
+        cachedBackground.value = null; 
         nextTick(drawMap);
     }
 };
@@ -270,12 +280,9 @@ const confirm = () => {
         <div class="map-section" v-if="showAdvanced">
             <canvas 
                 ref="difficultyCanvas" 
-                width="200" 
+                width="400" 
-                height="200"
+                height="400"
                 @mousedown="startDrag"
-                @mousemove="onDrag"
-                @mouseup="stopDrag"
-                @mouseleave="stopDrag"
                 @touchstart.prevent="startDrag"
                 @touchmove.prevent="onDrag"
                 @touchend="stopDrag"
@@ -284,7 +291,12 @@ const confirm = () => {
       </div>
 
       <div class="difficulty-indicator">
-        <div class="label">{{ t('custom.difficulty') }}</div>
+        <div class="label-row">
+            <div class="label">{{ t('custom.difficulty') }}</div>
+            <button class="help-btn" @click="emit('open-simulation')" :title="t('custom.simulationHelp') || 'How is this calculated?'">
+                <HelpCircle class="icon-sm" />
+            </button>
+        </div>
         <div class="difficulty-row">
             <div class="level" :style="{ color: difficultyColor }">{{ t(`difficulty.${difficultyInfo.level}`) }}</div>
             <div class="percentage" :style="{ color: difficultyColor }">({{ difficultyInfo.value }}%)</div>
@@ -293,7 +305,7 @@ const confirm = () => {
 
       <div class="advanced-toggle">
           <button class="btn-text" @click="toggleAdvanced">
-              {{ showAdvanced ? 'Ukryj mapę trudności' : 'Pokaż mapę trudności' }}
+              {{ showAdvanced ? t('custom.hideMap') : t('custom.showMap') }}
           </button>
       </div>
       
@@ -365,6 +377,8 @@ const confirm = () => {
 }
 
 canvas {
+    width: 400px;
+    height: 400px;
     border: 2px solid var(--panel-border);
     border-radius: 8px;
     box-shadow: 0 0 20px rgba(0, 242, 255, 0.1);
@@ -372,6 +386,14 @@ canvas {
     background: #000;
 }
 
+@media (max-width: 600px) {
+    canvas {
+        width: 100%;
+        height: auto;
+        aspect-ratio: 1;
+    }
+}
+
 h2 {
   font-size: 2rem;
   color: var(--accent-cyan);
@@ -457,6 +479,34 @@ input[type="range"]::-moz-range-thumb {
     gap: 5px;
 }
 
+.label-row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.help-btn {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    padding: 4px;
+    border-radius: 50%;
+    transition: color 0.3s, background 0.3s;
+}
+
+.help-btn:hover {
+    color: var(--accent-cyan);
+    background: rgba(0, 242, 255, 0.1);
+}
+
+.icon-sm {
+    width: 16px;
+    height: 16px;
+}
+
 .difficulty-row {
     display: flex;
     flex-direction: row;

src/components/SimulationView.vue

@@ -0,0 +1,320 @@
+
+<script setup>
+import { ref, computed } from 'vue';
+import { generateRandomGrid, calculateHints } from '@/utils/puzzleUtils';
+import { solvePuzzle } from '@/utils/solver';
+import { useI18n } from '@/composables/useI18n';
+import { X, Play, Square, RotateCcw } from 'lucide-vue-next';
+
+const emit = defineEmits(['close']);
+const { t } = useI18n();
+
+const SIZES = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]; 
+const DENSITIES = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];
+const SAMPLES_PER_POINT = 10; // Reduced for web performance demo
+
+const isRunning = ref(false);
+const progress = ref(0);
+const currentStatus = ref('');
+const results = ref([]);
+const simulationSpeed = ref(1); // 1 = Normal, 2 = Fast (less render updates)
+
+let stopRequested = false;
+
+const displayStatus = computed(() => {
+    if (!currentStatus.value) return t('simulation.status.ready');
+    return currentStatus.value;
+});
+
+const startSimulation = async () => {
+    if (isRunning.value) return;
+    isRunning.value = true;
+    stopRequested = false;
+    results.value = [];
+    progress.value = 0;
+
+    const totalSteps = SIZES.length * DENSITIES.length;
+    let stepCount = 0;
+
+    for (const size of SIZES) {
+        for (const density of DENSITIES) {
+            if (stopRequested) {
+                currentStatus.value = t('simulation.status.stopped');
+                isRunning.value = false;
+                return;
+            }
+
+            currentStatus.value = t('simulation.status.simulating', { 
+                size: size, 
+                density: (density * 100).toFixed(0) 
+            });
+            
+            let totalSolved = 0;
+            
+            // Run samples
+            for (let i = 0; i < SAMPLES_PER_POINT; i++) {
+                const grid = generateRandomGrid(size, density);
+                const { rowHints, colHints } = calculateHints(grid);
+                const { percentSolved } = solvePuzzle(rowHints, colHints);
+                totalSolved += percentSolved;
+                
+                // Yield to UI every few samples to keep it responsive
+                if (i % 2 === 0) await new Promise(r => setTimeout(r, 0));
+            }
+
+            const avgSolved = totalSolved / SAMPLES_PER_POINT;
+            
+            results.value.unshift({
+                size,
+                density,
+                avgSolved: avgSolved.toFixed(1)
+            });
+
+            stepCount++;
+            progress.value = (stepCount / totalSteps) * 100;
+        }
+    }
+
+    isRunning.value = false;
+    currentStatus.value = t('simulation.status.completed');
+};
+
+const stopSimulation = () => {
+    stopRequested = true;
+};
+
+const getRowColor = (solved) => {
+    if (solved >= 90) return 'color-easy';
+    if (solved >= 60) return 'color-harder';
+    if (solved >= 30) return 'color-hardest';
+    return 'color-extreme';
+};
+
+</script>
+
+<template>
+  <div class="modal-overlay" @click.self="emit('close')">
+    <div class="modal glass-panel">
+      <div class="header">
+        <h2>{{ t('simulation.title') }}</h2>
+        <button class="close-btn" @click="emit('close')">
+            <X />
+        </button>
+      </div>
+      
+      <div class="content">
+        <div class="controls">
+            <div class="status-bar">
+                <div class="status-text">{{ displayStatus }}</div>
+                <div class="progress-track">
+                    <div class="progress-fill" :style="{ width: progress + '%' }"></div>
+                </div>
+            </div>
+            
+            <div class="actions">
+                <button v-if="!isRunning" class="btn-neon" @click="startSimulation">
+                    <Play class="icon" /> {{ t('simulation.start') }}
+                </button>
+                <button v-else class="btn-neon secondary" @click="stopSimulation">
+                    <Square class="icon" /> {{ t('simulation.stop') }}
+                </button>
+            </div>
+        </div>
+
+        <div class="results-container">
+            <table class="results-table">
+                <thead>
+                    <tr>
+                        <th>{{ t('simulation.table.size') }}</th>
+                        <th>{{ t('simulation.table.density') }}</th>
+                        <th>{{ t('simulation.table.solved') }}</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr v-for="(row, idx) in results" :key="idx" :class="getRowColor(row.avgSolved)">
+                        <td>{{ row.size }}x{{ row.size }}</td>
+                        <td>{{ (row.density * 100).toFixed(0) }}%</td>
+                        <td>{{ row.avgSolved }}%</td>
+                    </tr>
+                </tbody>
+            </table>
+            <div v-if="results.length === 0" class="empty-state">
+                {{ t('simulation.empty') }}
+            </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100vw;
+  height: 100vh;
+  background: var(--modal-overlay);
+  backdrop-filter: blur(5px);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 3000;
+  animation: fadeIn 0.3s ease;
+}
+
+.modal {
+  padding: 30px;
+  width: 90%;
+  max-width: 600px;
+  height: 80vh;
+  display: flex;
+  flex-direction: column;
+  border: 1px solid var(--accent-cyan);
+  box-shadow: 0 0 50px rgba(0, 242, 255, 0.2);
+}
+
+.header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+h2 {
+    color: var(--accent-cyan);
+    margin: 0;
+    font-size: 1.5rem;
+}
+
+.close-btn {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    padding: 5px;
+}
+
+.close-btn:hover {
+    color: var(--text-color);
+}
+
+.content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+    overflow: hidden;
+}
+
+.controls {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+    padding-bottom: 15px;
+    border-bottom: 1px solid var(--panel-border);
+}
+
+.status-bar {
+    display: flex;
+    flex-direction: column;
+    gap: 5px;
+}
+
+.status-text {
+    font-size: 0.9rem;
+    color: var(--text-muted);
+}
+
+.progress-track {
+    width: 100%;
+    height: 4px;
+    background: var(--panel-bg-strong);
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.progress-fill {
+    height: 100%;
+    background: var(--accent-cyan);
+    transition: width 0.3s ease;
+}
+
+.actions {
+    display: flex;
+    justify-content: flex-end;
+}
+
+.btn-neon {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 16px;
+    font-size: 0.9rem;
+}
+
+.icon {
+    width: 16px;
+    height: 16px;
+}
+
+.results-container {
+    flex: 1;
+    overflow-y: auto;
+    background: rgba(0, 0, 0, 0.2);
+    border-radius: 8px;
+    padding: 10px;
+}
+
+.results-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.9rem;
+}
+
+.results-table th {
+    text-align: left;
+    padding: 8px;
+    color: var(--text-muted);
+    border-bottom: 1px solid var(--panel-border);
+    position: sticky;
+    top: 0;
+    background: var(--panel-bg);
+}
+
+.results-table td {
+    padding: 8px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.color-easy { color: #33ff33; }
+.color-harder { color: #ffff33; }
+.color-hardest { color: #ff9933; }
+.color-extreme { color: #ff3333; }
+
+.empty-state {
+    padding: 40px;
+    text-align: center;
+    color: var(--text-muted);
+    font-style: italic;
+}
+
+/* Scrollbar styling */
+.results-container::-webkit-scrollbar {
+  width: 8px;
+}
+
+.results-container::-webkit-scrollbar-track {
+  background: rgba(0, 0, 0, 0.1);
+}
+
+.results-container::-webkit-scrollbar-thumb {
+  background: var(--panel-border);
+  border-radius: 4px;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+</style>

src/utils/puzzleUtils.js

@@ -53,35 +53,78 @@ export function generateRandomGrid(size, density = 0.5) {
 }
 
 export function calculateDifficulty(density, size = 10) {
-    // Shannon Entropy: H(x) = -x*log2(x) - (1-x)*log2(1-x)
+    // Data derived from Monte Carlo Simulation (Logical Solver)
-    // Normalized to 0-1 range (since max entropy at 0.5 is 1)
+    // Format: { size: [solved_pct_at_0.1, ..., solved_pct_at_0.9] }
+    // Densities: 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9
+    const SIM_DATA = {
+        5:  [89, 74, 74, 81, 97, 98, 99, 100, 100],
+        10: [57, 20, 16, 54, 92, 100, 100, 100, 100],
+        15: [37, 10, 2, 12, 68, 100, 100, 100, 100],
+        20: [23, 3, 1, 2, 37, 100, 100, 100, 100],
+        25: [16, 0, 0, 1, 19, 99, 100, 100, 100],
+        30: [8, 0, 0, 0, 5, 99, 100, 100, 100],
+        35: [6, 0, 0, 0, 4, 91, 100, 100, 100],
+        40: [3, 0, 0, 0, 2, 91, 100, 100, 100],
+        45: [2, 0, 0, 0, 1, 82, 100, 100, 100],
+        50: [2, 0, 0, 0, 1, 73, 100, 100, 100],
+        60: [0, 0, 0, 0, 0, 35, 100, 100, 100],
+        70: [0, 0, 0, 0, 0, 16, 100, 100, 100],
+        80: [0, 0, 0, 0, 0, 1, 100, 100, 100]
+    };
+
+    // Helper to get interpolated value from array
+    const getSimulatedSolvedPct = (s, d) => {
+        // Find closest sizes
+        const sizes = Object.keys(SIM_DATA).map(Number).sort((a, b) => a - b);
+        let sLower = sizes[0];
+        let sUpper = sizes[sizes.length - 1];
+        
+        for (let i = 0; i < sizes.length - 1; i++) {
+            if (s >= sizes[i] && s <= sizes[i+1]) {
+                sLower = sizes[i];
+                sUpper = sizes[i+1];
+                break;
+            }
+        }
+        
+        // Clamp density to 0.1 - 0.9
+        const dClamped = Math.max(0.1, Math.min(0.9, d));
+        // Index in array: 0.1 -> 0, 0.9 -> 8
+        const dIndex = (dClamped - 0.1) * 10;
+        const dLowerIdx = Math.floor(dIndex);
+        const dUpperIdx = Math.ceil(dIndex);
+        const dFraction = dIndex - dLowerIdx;
+
+        // Bilinear Interpolation
+        
+        // 1. Interpolate Density for Lower Size
+        const rowLower = SIM_DATA[sLower];
+        const valLower = rowLower[dLowerIdx] * (1 - dFraction) + (rowLower[dUpperIdx] || rowLower[dLowerIdx]) * dFraction;
+        
+        // 2. Interpolate Density for Upper Size
+        const rowUpper = SIM_DATA[sUpper];
+        const valUpper = rowUpper[dLowerIdx] * (1 - dFraction) + (rowUpper[dUpperIdx] || rowUpper[dLowerIdx]) * dFraction;
+        
+        // 3. Interpolate Size
+        if (sLower === sUpper) return valLower;
+        const sFraction = (s - sLower) / (sUpper - sLower);
+        
+        return valLower * (1 - sFraction) + valUpper * sFraction;
+    };
+
+    const solvedPct = getSimulatedSolvedPct(size, density);
     
-    // Avoid log(0)
+    // Difficulty Score: Inverse of Solved Percent
-    if (density <= 0 || density >= 1) return { level: 'easy', value: 0 };
+    // 100% Solved -> 0 Difficulty
-    
+    // 0% Solved -> 100 Difficulty
-    const entropy = -density * Math.log2(density) - (1 - density) * Math.log2(1 - density);
+    const value = Math.round(100 - solvedPct);
-    
-    // Difficulty score combines entropy (complexity) and size (scale)
-    // We use sqrt(size) to dampen the effect of very large grids, 
-    // ensuring that density still plays a major role.
-    // Normalized against max size (80)
-    const sizeFactor = Math.sqrt(size / 80);
-    const score = entropy * sizeFactor * 100;
-    const value = Math.round(score);
     
     // Thresholds
     let level = 'easy';
-    if (value >= 80) level = 'extreme';
+    if (value >= 90) level = 'extreme';     // < 10% Solved
-    else if (value >= 60) level = 'hardest';
+    else if (value >= 60) level = 'hardest'; // < 40% Solved
-    else if (value >= 40) level = 'harder';
+    else if (value >= 30) level = 'harder';  // < 70% Solved
-    else if (value >= 20) level = 'medium'; // Using 'medium' key if available, or we need to add it?
+    else level = 'easy';                     // > 70% Solved
-    // Wait, useI18n only has: easy, harder, hardest, extreme.
-    // Let's stick to those keys but adjust ranges.
-    
-    if (value >= 75) level = 'extreme';
-    else if (value >= 50) level = 'hardest';
-    else if (value >= 25) level = 'harder';
-    else level = 'easy';
 
     return { level, value };
 }

src/utils/solver.js

@@ -0,0 +1,278 @@
+
+/**
+ * Represents the state of a cell in the solver.
+ * -1: Unknown
+ *  0: Empty
+ *  1: Filled
+ */
+
+/**
+ * Solves a single line (row or column) based on hints and current knowledge.
+ * Uses the "Left-Right Overlap" algorithm to find common filled cells.
+ * Also identifies definitely empty cells (reachable by no block).
+ * 
+ * @param {number[]} currentLine - Array of -1, 0, 1
+ * @param {number[]} hints - Array of block lengths
+ * @returns {number[]} - Updated line (or null if contradiction/impossible - though shouldn't happen for valid puzzles)
+ */
+function solveLine(currentLine, hints) {
+    const length = currentLine.length;
+    
+    // If no hints, all must be empty
+    if (hints.length === 0 || (hints.length === 1 && hints[0] === 0)) {
+        return Array(length).fill(0);
+    }
+
+    // Helper to check if a block can be placed at start index
+    const canPlace = (line, start, blockSize) => {
+        if (start + blockSize > line.length) return false;
+        // Check if any cell in block is 0 (Empty) -> Invalid
+        for (let i = start; i < start + blockSize; i++) {
+            if (line[i] === 0) return false;
+        }
+        // Check boundaries (must be separated by empty or edge)
+        if (start > 0 && line[start - 1] === 1) return false;
+        if (start + blockSize < line.length && line[start + blockSize] === 1) return false;
+        return true;
+    };
+
+    // 1. Calculate Left-Most Positions
+    const leftPositions = [];
+    let currentIdx = 0;
+    for (let hIndex = 0; hIndex < hints.length; hIndex++) {
+        const block = hints[hIndex];
+        // Find first valid position
+        while (currentIdx <= length - block) {
+            if (canPlace(currentLine, currentIdx, block)) {
+                // Verify we can fit remaining blocks
+                // Simple heuristic: do we have enough space? 
+                // A full recursive check is better but slower. 
+                // For "Logical Solver" we assume valid placement is possible if we respect current constraints.
+                // However, strictly, we need to know if there is *any* valid arrangement starting here.
+                // Let's use a recursive check with memoization for "can fit rest".
+                if (canFitRest(currentLine, currentIdx + block + 1, hints, hIndex + 1)) {
+                    leftPositions.push(currentIdx);
+                    currentIdx += block + 1; // Move past this block + 1 space
+                    break;
+                }
+            }
+            currentIdx++;
+        }
+        if (leftPositions.length <= hIndex) return null; // Impossible
+    }
+
+    // 2. Calculate Right-Most Positions (by reversing line and hints)
+    // This is symmetrical to Left-Most.
+    // Instead of implementing reverse logic, we can just reverse inputs, run left-most, and reverse back.
+    // But we need to respect the "currentLine" constraints which might be asymmetric.
+    
+    // Actually, "Right-Most" is just "Left-Most" on the reversed grid.
+    const reversedLine = [...currentLine].reverse();
+    const reversedHints = [...hints].reverse();
+    const rightPositionsReversed = [];
+    
+    currentIdx = 0;
+    for (let hIndex = 0; hIndex < reversedHints.length; hIndex++) {
+        const block = reversedHints[hIndex];
+        while (currentIdx <= length - block) {
+            if (canPlace(reversedLine, currentIdx, block)) {
+                if (canFitRest(reversedLine, currentIdx + block + 1, reversedHints, hIndex + 1)) {
+                    rightPositionsReversed.push(currentIdx);
+                    currentIdx += block + 1;
+                    break;
+                }
+            }
+            currentIdx++;
+        }
+        if (rightPositionsReversed.length <= hIndex) return null;
+    }
+    
+    // Convert reversed positions to actual indices
+    // index in reversed = length - 1 - (original_index + block_size - 1)
+    // original_start = length - 1 - (reversed_start + block_size - 1) = length - reversed_start - block_size
+    const rightPositions = rightPositionsReversed.map((rStart, i) => {
+        const block = reversedHints[i];
+        return length - rStart - block;
+    }).reverse();
+
+
+    // 3. Intersect
+    const newLine = [...currentLine];
+    
+    // Fill intersection
+    for (let i = 0; i < hints.length; i++) {
+        const l = leftPositions[i];
+        const r = rightPositions[i];
+        const block = hints[i];
+        
+        // If overlap exists: [r, l + block - 1]
+        // Example: Block 5. Left: 2, Right: 4.
+        // Left:  ..XXXXX...
+        // Right: ....XXXXX.
+        // Overlap:   ..XXX...
+        // Indices: max(l, r) to min(l+block, r+block) - 1 ?
+        // Range is [r, l + block - 1] (inclusive)
+        
+        if (r < l + block) {
+            for (let k = r; k < l + block; k++) {
+                newLine[k] = 1;
+            }
+        }
+    }
+
+    // Determine Empty cells?
+    // A cell is empty if it is not covered by ANY block in ANY valid configuration.
+    // This is harder with just L/R limits.
+    // However, we can use the "Simple Glue" logic:
+    // If a cell is outside the range [LeftLimit[i], RightLimit[i] + block] for ALL i, it's empty.
+    // Wait, indices are not strictly partitioned. Block 1 could be at 0 or 10.
+    // But logic dictates order.
+    // Range of block i is [LeftPositions[i], RightPositions[i] + hints[i]].
+    // If a cell k is not in ANY of these ranges, it is 0.
+    
+    // Mask of possible filled cells
+    const possibleFilled = Array(length).fill(false);
+    for (let i = 0; i < hints.length; i++) {
+        for (let k = leftPositions[i]; k < rightPositions[i] + hints[i]; k++) {
+            possibleFilled[k] = true;
+        }
+    }
+    
+    for (let k = 0; k < length; k++) {
+        if (!possibleFilled[k]) {
+            newLine[k] = 0;
+        }
+    }
+
+    return newLine;
+}
+
+// Memoized helper for checking if hints fit
+const memo = new Map();
+function canFitRest(line, startIndex, hints, hintIndex) {
+    // Optimization: If hints are empty, we just need to check if remaining line has no '1's
+    if (hintIndex >= hints.length) {
+        for (let i = startIndex; i < line.length; i++) {
+            if (line[i] === 1) return false;
+        }
+        return true;
+    }
+
+    // Key for memoization (primitive approach)
+    // In a full solver, we'd pass a cache. For single line, maybe overkill, but safe.
+    // let key = `${startIndex}-${hintIndex}`; 
+    // Skipping memo for now as line lengths are small (<80) and recursion depth is low.
+    
+    const remainingLen = line.length - startIndex;
+    // Min space needed: sum of hints + (hints.length - 1) spaces
+    // Calculate lazily or precalc?
+    let minSpace = 0;
+    for(let i=hintIndex; i<hints.length; i++) minSpace += hints[i] + (i < hints.length - 1 ? 1 : 0);
+    
+    if (remainingLen < minSpace) return false;
+
+    const block = hints[hintIndex];
+    // Try to find *any* valid placement for this block
+    // We only need ONE valid path to return true.
+    for (let i = startIndex; i <= line.length - minSpace; i++) { // Optimization on upper bound?
+         // Check placement
+         let valid = true;
+         // Block
+         for (let k = 0; k < block; k++) {
+             if (line[i+k] === 0) { valid = false; break; }
+         }
+         if (!valid) continue;
+         
+         // Boundary before (checked by loop start usually, but strictly:
+         if (i > 0 && line[i-1] === 1) valid = false; // Should have been handled by caller or skip
+         // Wait, the caller (loop) iterates i. 
+         // If i > startIndex, we implied space at i-1.
+         // If line[i-1] is 1, we can't place here if we skipped it.
+         // Actually, if we skip a '1', that's invalid.
+         // So we can't just skip '1's.
+         
+         // Correct logic:
+         // We iterate i. If we pass a '1' at index < i, that 1 is orphaned -> Invalid path.
+         // So we can only scan forward as long as we don't skip a '1'.
+         
+         let skippedOne = false;
+         for (let x = startIndex; x < i; x++) {
+             if (line[x] === 1) { skippedOne = true; break; }
+         }
+         if (skippedOne) break; // Cannot go further right, we left a 1 behind.
+         
+         // Boundary after
+         if (i + block < line.length && line[i+block] === 1) valid = false;
+         
+         if (valid) {
+             // Recurse
+             if (canFitRest(line, i + block + 1, hints, hintIndex + 1)) return true;
+         }
+    }
+    
+    return false;
+}
+
+
+/**
+ * Solves the puzzle using logical iteration.
+ * @param {number[][]} rowHints 
+ * @param {number[][]} colHints 
+ * @returns {object} { solvedGrid: number[][], percentSolved: number }
+ */
+export function solvePuzzle(rowHints, colHints) {
+    const rows = rowHints.length;
+    const cols = colHints.length;
+    
+    // Initialize grid with -1
+    let grid = Array(rows).fill(null).map(() => Array(cols).fill(-1));
+    
+    let changed = true;
+    let iterations = 0;
+    const MAX_ITER = 100; // Safety break
+    
+    while (changed && iterations < MAX_ITER) {
+        changed = false;
+        iterations++;
+        
+        // Rows
+        for (let r = 0; r < rows; r++) {
+            const newLine = solveLine(grid[r], rowHints[r]);
+            if (newLine) {
+                for (let c = 0; c < cols; c++) {
+                    if (grid[r][c] !== newLine[c]) {
+                        grid[r][c] = newLine[c];
+                        changed = true;
+                    }
+                }
+            }
+        }
+        
+        // Cols
+        for (let c = 0; c < cols; c++) {
+            const currentCol = grid.map(row => row[c]);
+            const newCol = solveLine(currentCol, colHints[c]);
+            if (newCol) {
+                for (let r = 0; r < rows; r++) {
+                    if (grid[r][c] !== newCol[r]) {
+                        grid[r][c] = newCol[r];
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    
+    // Calculate solved %
+    let solvedCount = 0;
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            if (grid[r][c] !== -1) solvedCount++;
+        }
+    }
+    
+    return {
+        solvedGrid: grid,
+        percentSolved: (solvedCount / (rows * cols)) * 100
+    };
+}