Bu Alcazar'ı benim için çöz


39

Son zamanlarda Alcazar adlı bir oyun oynuyorum. Amacınız bir kapıdan girmek, tüm karelerden geçmek ve başka bir kapıdan çıkmak olan bir tahta oyunudur. Tek kurallar:

  • Bir kez girin, bir kez bırakın;
  • Tüm karelerden geçin;
  • Bir kareden bir kereden fazla geçmeyin

Aşağıdaki resim bir Alcazar panosuna ve sağında çözülmüş bulmacanın bir örneğini göstermektedir (elbette bu kolay bir seçimdir):

Örnek Alcazar Yapboz

Daha fazla bulmacayı http://www.theincrediblecompany.com/try-alcazar adresinde bulabilir ve oyunu PlayStore'da indirebilirsiniz (PS: Bir reklam değil).

Benim sorunum, bir seviye hariç neredeyse oyunu bitirdim. Bunu çözmenin bir yolunu bulamıyorum. Ben teklif mücadeledir Yani: herhangi bir normal çözen bir algoritma oluşturmak 1 çözülebilir 2 Alcazar seviyesini.

Tabii ki, kimsenin görüntüyü okumak ve bulmacayı çözmek için bir görüntü yorumlayıcısı kurmasını istemiyorum (ya da ben?). Böylece yukarıdaki bulmacayı kutu çizim karakterlerini kullanarak yeniden çizdim. Bulmaca ve çözümü şöyle olurdu:

╔═══════╗         ╔═══════╗
║▒ ▒ ▒ ▒║         ║┌─┐ ┌─┐║
║     ║ ║         ║│ │ │║│║
╣▒ ▒ ▒║▒╠         ╣│ └─┘║└╠
║ ══╦═╩═╣         ║│══╦═╩═╣
║▒ ▒║▒ ▒║         ║└─┐║┌─┐║
║   ║   ║   ==>   ║  │║│ │║
╣▒ ▒║▒ ▒║         ╣┐ │║│ │║
║ ║ ║   ║         ║│║│║│ │║
╣▒║▒ ▒ ▒║         ╣│║└─┘ │║
║ ║     ║         ║│║    │║
║▒ ▒ ▒ ▒║         ║└─────┘║
╚═══════╝         ╚═══════╝

Yukarıdaki tahtada doldurulacak hücreler.

Hücreler arasında dikey ve yatay bir gab olduğu gözlemlenebilir. Çünkü duvarları eklemek için hücreler arasına bir boşluk koymak zorunda kaldım. Bu, tek önemli hücrelerin, her bir hücrenin üstünde, altında, solunda ve sağında olduğu anlamına gelir. Çaprazlar bilgi kaybı olmadan kaldırılabilir. Örneğin, aşağıdaki panoda her ikisi de aynı bulmacayı temsil eder:

╔════╩╗         ═ ═ ╩ 
║▒ ▒ ▒║        ║▒ ▒ ▒║
║ ═══ ║           ═   
║▒ ▒ ▒║   ==   ║▒ ▒ ▒║
║     ║               
║▒ ▒ ▒║        ║▒ ▒ ▒║
╚╦════╝         ╦═ ══ 

Bu aynı zamanda çözümler için de geçerlidir. Yani, hücreleri bağlamak gerekli değildir:

╔════╩╗        ╔════╩╗        ╔════╩╗
║▒ ▒ ▒║        ║┌───┘║        ║┌ ─ ┘║
║ ═══ ║        ║│═══ ║        ║ ═══ ║
║▒ ▒ ▒║   ==   ║└───┐║   =>   ║└ ─ ┐║
║     ║        ║    │║        ║     ║
║▒ ▒ ▒║        ║┌───┘║        ║┌ ─ ┘║
╚╦════╝        ╚╦════╝        ╚╦════╝

Yukarıdaki örnekte, her iki çözüm de aynı anlama gelir.

Evet, test durumları. İşte buradalar:

Bulmaca 1

╔════╩╗        ╔════╩╗
║▒ ▒ ▒║        ║┌ ─ ┘║
║ ═══ ║        ║ ═══ ║
║▒ ▒ ▒║   =>   ║└ ─ ┐║
║     ║        ║     ║
║▒ ▒ ▒║        ║┌ ─ ┘║
╚╦════╝        ╚╦════╝

2. Bulmaca

╔═════╗        ╔═════╗
║▒ ▒ ▒║        ║┌ ─ ┐║
║   ║ ║        ║   ║ ║
╣▒ ▒║▒║        ╣└ ┐║│║
║ ║ ║ ║   =>   ║ ║ ║ ║
╣▒║▒ ▒╠        ╣┐║│ │╠
║ ║   ║        ║ ║   ║
║▒ ▒ ▒║        ║└ ┘ │║
╚════╦╝        ╚════╦╝

Yapboz 3

╔════╩══╗        ╔════╩══╗
║▒ ▒ ▒ ▒║        ║┌ ┐ └ ┐║
║ ║   ║ ║        ║ ║   ║ ║
╣▒║▒ ▒║▒╠        ╣┘║└ ┐║│╠
║ ╚══ ║ ║        ║ ╚══ ║ ║
║▒ ▒ ▒ ▒╠   =>   ║┌ ─ ┘ │╠
║   ═══ ║        ║   ═══ ║
║▒ ▒ ▒ ▒║        ║│ ┌ ┐ │║
║   ║   ║        ║   ║   ║
║▒ ▒║▒ ▒║        ║└ ┘║└ ┘║
╚═══╩═══╝        ╚═══╩═══╝

bulmaca 4

╔═══════╗        ╔═══════╗
║▒ ▒ ▒ ▒║        ║┌ ┐ ┌ ┐║
║     ║ ║        ║     ║ ║
╣▒ ▒ ▒║▒╠        ╣│ └ ┘║└╠
║ ══╦═╩═╣        ║ ══╦═╩═╣
║▒ ▒║▒ ▒║        ║└ ┐║┌ ┐║
║   ║   ║   =>   ║   ║   ║
╣▒ ▒║▒ ▒║        ╣┐ │║│ │║
║ ║ ║   ║        ║ ║ ║   ║
╣▒║▒ ▒ ▒║        ╣│║└ ┘ │║
║ ║     ║        ║ ║     ║
║▒ ▒ ▒ ▒║        ║└ ─ ─ ┘║
╚═══════╝        ╚═══════╝

5. Bulmaca

╔══╩══════╗        ╔══╩══════╗
║▒ ▒ ▒ ▒ ▒║        ║┌ ─ ┐ ┌ ┐║
║   ║     ║        ║   ║     ║
║▒ ▒║▒ ▒ ▒╠        ║└ ┐║└ ┘ │╠
║   ╠════ ║        ║   ╠════ ║
║▒ ▒║▒ ▒ ▒║   =>   ║┌ ┘║┌ ─ ┘║
║   ║     ║        ║   ║     ║
║▒ ▒║▒ ▒ ▒╠        ║└ ┐║└ ─ ─╠
║   ╠═════╣        ║   ╠═════╣
║▒ ▒║▒ ▒ ▒║        ║┌ ┘║┌ ─ ┐║
║   ║     ║        ║   ║     ║
║▒ ▒ ▒ ▒ ▒║        ║└ ─ ┘ ┌ ┘║
╚══╦═══╦══╝        ╚══╦═══╦══╝

Bulmaca 6

╔═══════════╗        ╔═══════════╗
║▒ ▒ ▒ ▒ ▒ ▒║        ║┌ ┐ ┌ ┐ ┌ ┐║
║           ║        ║           ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║│ └ ┘ └ ┘ │║
║       ═══ ║        ║       ═══ ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║└ ┐ ┌ ─ ─ ┘║
║     ═══   ║        ║     ═══   ║
╣▒ ▒ ▒ ▒ ▒ ▒╠   =>   ╣┐ │ │ ┌ ┐ ┌╠
║           ║        ║           ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║│ │ │ │ │ │║
║   ║   ║   ║        ║   ║   ║   ║
║▒ ▒║▒ ▒║▒ ▒║        ║│ │║│ │║│ │║
║   ║   ║   ║        ║   ║   ║   ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║└ ┘ └ ┘ └ ┘║
╚═══════════╝        ╚═══════════╝

Yapboz 7

╔════╩════════╦╩╗        ╔════╩════════╦╩╗
║▒ ▒ ▒ ▒ ▒ ▒ ▒║▒║        ║┌ ─ ─ ─ ─ ─ ┐║│║
║ ║       ║   ║ ║        ║ ║       ║   ║ ║
║▒║▒ ▒ ▒ ▒║▒ ▒ ▒║        ║│║┌ ─ ─ ┐║┌ ┘ │║
║ ║ ║ ═══ ║     ║        ║ ║ ║ ═══ ║     ║
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒╠        ║│ │║┌ ─ ┘ └ ┐ │╠
║   ║           ║        ║   ║           ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║│ │ └ ┐ ┌ ┐ └ ┘║
║     ║ ║     ══╣        ║     ║ ║     ══╣
║▒ ▒ ▒║▒║▒ ▒ ▒ ▒║        ║│ └ ┐║│║│ └ ─ ┐║
║     ║ ║       ║        ║     ║ ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║│ ┌ ┘ │ └ ┐ ┌ ┘║
║           ║ ══╣   =>   ║           ║ ══╣
║▒ ▒ ▒ ▒ ▒ ▒║▒ ▒║        ║└ ┘ ┌ ┘ ┌ ┘║└ ┐║
╠══       ║ ╚══ ║        ╠══       ║ ╚══ ║
║▒ ▒ ▒ ▒ ▒║▒ ▒ ▒║        ║┌ ┐ └ ┐ │║┌ ─ ┘║
║     ║ ║ ║     ║        ║     ║ ║ ║     ║
║▒ ▒ ▒║▒║▒ ▒ ▒ ▒║        ║│ └ ┐║│║│ └ ─ ┐║
║ ║   ║ ║ ╔══   ║        ║ ║   ║ ║ ╔══   ║
║▒║▒ ▒ ▒ ▒║▒ ▒ ▒║        ║│║┌ ┘ │ │║┌ ┐ │║
║ ║     ║ ║     ║        ║ ║     ║ ║     ║
║▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║        ║│ └ ─ ┘║└ ┘ │ │║
║       ╚══     ║        ║       ╚══     ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║└ ─ ─ ─ ─ ─ ┘ │║
╚════╦═╦═╦═════╦╝        ╚════╦═╦═╦═════╦╝

Yapboz 8 (Üzgünüm, buna gerçekten bir çözümüm yok)

╔══╩╦══╩═══╩═╩═╩═══╩╗
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
║   ║               ║
╣▒ ▒║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
║   ╚══ ╔══     ╔═══╣
╣▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║▒ ▒╠
║       ║   ╔══ ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
║           ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒╠
║           ║       ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
║   ╔═══╗   ╚══     ║
╣▒ ▒║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒║
║   ║   ║           ║
╣▒ ▒║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒╠
║ ══╝   ║       ╔══ ║
║▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║▒ ▒║
║   ══╗ ╚══ ╔══ ║   ║
╣▒ ▒ ▒║▒ ▒ ▒║▒ ▒ ▒ ▒╠
║     ║     ║   ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║▒ ▒║
║   ═══   ══╗   ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
╠══ ║       ║   ╔══ ║
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒║▒ ▒╠
║   ╚══ ║   ║   ║   ║
╣▒ ▒ ▒ ▒║▒ ▒║▒ ▒ ▒ ▒╠
║       ║   ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
╚══╦═══╦═══╦═╦═╦═╦═╦╝

Giriş

Kodunuzun girişi, aşağıdaki kurallara uyduğu sürece herhangi bir gösterime sahip olabilir:

  1. Grafiksel bir giriş olmalı. Bu nedenle, örneğin bir koordinat listesini okumak mümkün değildir.

  2. Yatay duvarlar, dikey duvarlar ve kapılar farklı olmalı ve görünür bir karakterden yapılmalıdır (boş karakter yok).

  3. Boşlukları ile değiştirilebilir. Sadece onları vurgulamak için farklı bir karakter kullandım.

Çıktı

Çıktı, bu kurallara uyduğu sürece herhangi bir gösterime de sahip olabilir:

  1. Grafiksel bir çıktı olmalıdır. Yani, kişi ona bakarak yolu görebilir.

  2. Bir numaralı kural, yol karakterlerinin farklı olduğunu gösterir. Yani, en az 6 yol karakteri olacak; yatay, dikey ve köşeler.

  3. Cevabın geçerli olması için, çıktı tüm hücrelerin (benim temsilime göre ) doldurulmuş olduğu girdiyle (açıkça) aynı panoda olmalıdır . Hücreler arasındaki boşlukları doldurmak isteğe bağlıdır.

puanlama

Bu , yani bayt cinsinden en kısa kod kazanır.

1 İsteğe bağlı hücreleri ve tünelleri olan bazı Alcazar seviyeleri vardır. Bunlar dikkate alınmayacak.

2 İmkansız bazı Alcazar panoları var.


2
Programım 8. bulmaca için bir çözüm bulamıyor. Çözülebilir olduğuna emin misiniz? Belki biraz yazım hatası?
edc65

1
@ edc65 burada aynı - # 8 için çözüm yok
ngn 17:17

Yanıtlar:


5

Python 3 , 809 728 723 714 693 688 684 663 657 641 639 627 610 571 569 bayt

Düzenle: @Felipe Nardi Batista sayesinde 55 bayt kaydedildi

Son test senaryosunu TIO'da 60 saniye içinde çalıştırmaz, ancak yine de doğru çalışması gerekir. Yol için bir koordinat listesi döndürür. Baytların bazı 400'ü, veri listelerini G / Ç'den almak için kullanılır.

A=enumerate
I,J="═║"
B=range
L=len
K=-1
Z=1,0
X=0,1
C=K,0
V=0,K
E=lambda a,b,p:(((a,b)in d)*L(p)==H*h)*p or max([E(q+a,w+b,p+[(q+a,w+b)])for q,w in y[a][b]if~-((q+a,w+b)in p)*-h>w+b>K<q+a<H]+[[]])
x=input().split("\n")
h=L(x[0])//2
H=L(x)//2
y=[[{C,Z,V,X}for i in B(h)]for j in B(H)]
d=[]
exec('d+=[(%s,i)for i,a in A(x[%s][1::2])if I<a]\nfor i,u in A(x[%s:%s:2]):\n d+=[(i,0)]*(J<u[0])+[(i,h-1)]*(J<u[K])\n for j,w in A(u[%s:%s:2]):\n  if"%s"==w:y[i][j]-={%s};y[i+%s][j+%s]-={%s}\n'*2%(0,*X,"",2,K,J,X,*X,V,H-1,K,2,K,1,"",I,Z,*Z,C))
print(max(E(*D,[D])for D in d))

Çevrimiçi deneyin!


@HalvardHummel Eh, meydan okuma kötü formülasyonu için üzgünüm. Bu yüzden aşağıdakileri öneriyorum. Puan bayt sayısı ile çalıştırma süresi çarpılarak hesaplanır, böylece hem çalıştırma süresi hem de bayt sayısı ödüllendirilir. Ne düşünüyorsun?
Phelype Oleinik 14:17

1
@PhelypeOleinik Bunun çok iyi bir puanlama sistemi olduğunu sanmıyorum. Coed golf tutulması daha iyi bir çözüm, ancak gerçekten bir çözüm arıyorsanız, bunun daha verimli olacak şekilde değiştirilebileceğinden eminim.
caird coinheringaahing 14:17

@cairdcoinheringaahing En zarif çözümün olduğu gibi kalması gerektiğini biliyorum. Ancak 8x12'lük bir bulmaca tahtasını çözmek için “günler hatta aylar” alan bir algoritma bir şekilde verimsiz değil mi? Gördüğüm gibi, sorunu biraz daha kısa sürede çözen bir algoritma ödüllendirilmeli, biraz daha uzun olsa bile.
Phelype Oleinik 15:17

3
@PhelypeOleinik Kodun "etkinliği" alakasız. Kısa kod yazmamız için bize meydan okudunuz ve bu, mücadelenizin temeli. Programın karışıma girme hızını eklemek sadece gereksiz şeyleri zorlaştırır ve saçma puanlar için de kullanılabilir. Özel puanlama sistemleri işe yaramadı. Kısa kod istiyorsanız, kod-golf sorusu yapın. Hızlı kod istiyorsanız, en hızlı kod sorusunu yapın. Onları birlikte karıştırmaya çalışmak iyi bir fikir değil.
LyricLy

Sizin de exec(...)dize olarak temsil beş yeni satır var \n, 5 * 2 = 10 bayt. Üçlü tırnaklı bir dize kullanmak, 4 bayt ( ...''...''...) ekler, ancak daha sonra gerçek yeni satır karakterleri kullanılabildiğinden 5 baytı kaldırır. Toplamda bu bir bayttan tasarruf sağlayabilir.
Jonathan Frech

5

APL (Dyalog Classic) , 319 bayt

iNj←⍳1+n←×/N←⌊2÷⍨⍴a←⎕⋄e←↑⊃,/{(,~'#='∊⍨a[(⍵⌽⍳2)∘+¨2×⍳N+⍵=⍳2])/,2,/[⍵]⊃,[⍵]/n i n}¨⍳2
r←{e g c←⍵⋄d←+/j∘.=∊g⋄e⌿⍨←(≠/c[e])∧2>⌈/d[e]⋄n≡≢g:gj/⍨d=10≡≢e:02>⌊/d+D←+/j∘.=,e:0⋄u←,¯1↑e←e[⍒⌊/D[e];]⋄e↓⍨←¯1⋄0≢r←∇e(g⍪u)(c-(-/c[u])×c=c[⊃u]):r⋄∇e g c}e(0e)j
a[1+2×⍳N]←' ??┌?─┐┬?└│├┘┴┤┼'[2⊥(↑(⊂i),¨¨{⊖∘⍉⍣⍵⊢n⍪¯1↓⌽∘⍉⍣⍵⊢i}¨⍳4)∊↓r⍪⌽r]
a

Çevrimiçi deneyin!

Klasik karakter grubuna sığmak için giriş =#F7LJ<>^v.yerine kullanılır .═║╔╗╚╝╣╠╩╦▒

Sonuncusu hariç tüm test durumları birkaç saniye içinde geçer.

Son test bilgisayarımda 47 dakika sürüyor ve çözüm üretmiyor.

Ortaya çıkan yol bir köşeye yakın bir kapı kullandığında yanlış bir şekilde yapılabilir (iz, sanki fazladan hayali bir kapıdan geçip geçiyormuş gibi), ancak yine de ayırt edilebilir ve belirsizdir.


Çok iyi! Eğer sorabilirsem, kodunuz çözmek için hangi yaklaşımı kullanır? Kapsamlı arama veya daha zarif bir şey? Ayrıca, dediğim gibi, son bulmacayı elle çözmedim. Adım adım açık bir çözümü yoktur ve el ile çözerken bile bazı cevapları bulmak için bir tahmin yapmayı gerektirir. Bu bulmaca orijinal oyuna dahil edilmiştir, ancak bir çözümü olmayabilir, bu yüzden muhtemelen dikkate alınmamalıdır.
Phelype Oleinik 18:17

1
@PhelypeOleinik Evet, oldukça karmaşık bir exhastive arama. Mevcut çözümleri hızlı bir şekilde bulmasının nedeni, ilk önce daha muhtemel olan durumu denemesidir (vs grafikte belirli bir kenarı olmadan - sezgiselim iki köşenin dereceleridir, daha düşüktür). Son durumda korkunç bir şekilde performans göstermesinin nedeni, tüm olasılıkları yine de sınaması ve özyinelemeyi yalnızca belirgin çelişkilerle ertelemesidir. Sınırlı dereceli (ne4 komşular) grafiklerin özel durumu için bile iyi Hamilton-yolu algoritmaları olduğu görünmüyor.
ngn

3

JavaScript (ES6), 274 bayt

Çok satırlı bir dize olarak giriş yapın, her satır yeni satır karakteriyle sonlandırılır. Kapılar '2' karakteriyle işaretlenmiştir.

'1' karakteri ile işaretlenmiş yolun bulunduğu çok satırlı bir dizge olarak çıktı, kolayca ayırt edilebilir.

Bu, tüm yolları deneyen ve takılı kaldığında ters takılan bir Derinlik İlk Arama'dır. Hiç verimli değil, fakat 1 .. 6'dan 1 dakikadan daha az bir sürede yap-bozları çözebilir.

z=>(w=z.search`
`+1,t=(w-2)*(z.length/w-1)/4,z=[...z],R=(p,l,q)=>[1,-1,w,-w].some(d=>l<t?z[q=p+d]<1&z[q+d]<1&&(R(q+d,++z[q]+l)||--z[q]):z[p+d]>1&&--z[p+d],++z[p])||--z[p],z.some((c,i)=>-c&&(x=i%w,R(i<w?i+w:x?x>w-3?i-1:i-w:i+1,--z[i])||++z[i]*0))&&z.join``.replace(/0/g,' '))

Daha az golf oynadı

z => (
  w = z.search`\n`+1, // board width and offset to next row
  t = (w-2)*(z.length/w-1)/4, // total size of board, number of cells that must be filled
  z = [...z], // convert string to array
  d = [1, -1, w, -w], // delta to next position in all directions
  // recursive search
  // given a current position, try to move in all directions
  // if the board is not full, look for an emoty cell
  // if the board is full, look for a door
  R = (p, // current position
       l, // fill level
       q  // parameter used as a local variable
      ) => (
        ++z[p], // mark current position
        // .some will terminate early if the called function returns true
        // in case of return true the recursive function returns all way up leaving the path marked
        // in case of return false we need to unmark path and backtrack
        d.some( d => // for each direction, offset in d
          l < t // check if board is full
          ? z[q=p+d] < 1 & z[q+d] < 1 // not full, try to advance 
            && (++z[q], // mark intermediate cell
                R(q+d, 1+l) // recursive call incrementing fill level
                || --z[q] // if R return false, backtrack: unmark intermediate cell
               )
          : z[p+d] > 1 && --z[p+d]
        ) // full, ok only if I find a door nearby
        || --z[p], // if some returns false, unmark and backtrak
  // look for doors and for each door call R 
  // when R returns true, stop and return the marked board
  // if R returns false for each door, no solution, return false
  z.some((c,i) => 
   -c && // if numeric and != 0
    (x = i%w,
     z[i]=1, // marking starting position (door)
     R(i<w ? i+w : x ? x > w-3 ? i-1 : i-w : i+1, 1)
     || (z[i] = 2, false) // if R returned false, unmark a return false
    ) 
  ) && z.join``.replace(/0/g,' ') 
)

Test snippet'inin içinde (7) bulmacayı bir dakikadan daha kısa sürede çözen bir kısıtlama içeren bir DFS kullanan bir çözüm var (bilgisayarımda). Yapboz 8'in bir çözümü yok. Kısıtlamalar:

  • Tüm boş hücrelere mevcut hücreden erişilebilir olmalıdır - boş alan iki bölüme ayrılmamalıdır
  • Ulaşılabilir bir kapı olmalı
  • Bir hücre yapılandırması birden fazla kez keşfedilemez
  • Yalnızca bir bitişik boş hücreye sahip bir hücreyi atlayamıyorum

Ölçek

Dikkat edin, bulmaca 7, herhangi bir tarayıcıda javascript uygulaması için zaman aşımının çok ötesindedir (Kısa ve Yavaş çözücü kullanarak)

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.