Meydan okuma

Herhangi bir formatta tic-tac-toe kurulu verildiğinde, geçerli olup olmadığını belirleyin. Bir tahta tic-tac-toe oyunun bir sonucu olabilir, o zaman geçerlidir. Örneğin, bu pano geçerlidir:

XOX
OXO
XOX

XXX
XXO
OOO

Giriş

• Bir tam (9/9) tic tac toe kurulu (oyun değil sonuç).

kurallar

• Giriş formatı, tüm 512 olası giriş kartlarını gösterebilmelidir. Belirsiz / net değilse, oluşturma talimatlarıyla birlikte belirtilmelidir. Kurulun işaretlerini ayrı ayrı belirtmelisiniz.
• Biri geçerlilik, diğeri geçersizlik için iki olası çıktı olmalıdır.
• Tahtanın boş noktaları olmadığını varsayabilirsiniz.

Test durumları

Geçerli:

XOX
OXO
XOX

XOX
XOX
OXO

XOO
OOX
OXX

OXO
XOX
OXO

Geçersiz:

XXX
XXX
XXX

OOO
OOO
OOO

XXX
OOO
XXX

OOO
OOX
XXX

XXO
OXO
OOX

Biraz yardım?

Bir yönetim kurulu (bu zorluk için) yalnızca aşağıdaki iki koşul geçerli olduğunda ve geçerli olduğunda geçerli sayılır:

• 5 X ve 4 O veya 4 X ve 5 O vardır. Örneğin,

  XXX
  OXO
  XXX

  geçersiz sayılır, çünkü 7 X ve 2 Os vardır.
• Sadece 5 işareti olan oyuncu kazanmış veya hiçbiri kazanmamış. Örneğin,

  XXX
  OOO
  OOX

  geçersiz sayılır, çünkü Os sırası veya s sırası Xönce oluşturulacaktır. İki oyuncu aynı anda sırasını alamazlar.

Şu anki galibi ...

... ais523'ün Jelly cevabı , şaşırtıcı bir 26 baytta !

Jöle , 26 bayt

ṢŒrṪ4=$$Ðfx3ðœ-µẆm€6R¤;/µL

Çevrimiçi deneyin!

Giriş formatı biraz sıra dışı; anakartı temsil eden bir dizedir, ancak Windows newlines ile (satırbaşını takip eder). Örneğin XXO\r\nOXO\r\nOOX,. (Aslında, satırlar arasındaki iki karakterlik dolgu dizeleri çalışır, ancak Windows yeni satırları diğer seçeneklerden çok daha savunmasızdır.)

Temel fikir, girdide 4 kez görünen karakterleri arayacağımız, ancak orijinal dizgede üç tane eşit aralıklı oluşum bulunmadığıdır. 3 × 3 ızgara çizgileri arasında iki veya daha fazla dolgu karakteri varken, tüm yatay, dikey ve çapraz çizgiler eşit aralıklarla yerleştirilir, ancak diğer hiçbir eşit aralıklı çizginin üç öğesi olamaz.

Açıklama:

ðVe µs'nin zincir ayırıcılar her bağımsız olan birden fazla parçaya programı bölünmüş. İşleri biraz daha netleştirmek için onları aşağıdaki boşluklarla değiştirdim.

ṢŒrṪ4=$$Ðfx3 œ- Ẇm€6R¤;/ L
Ṣ                           sorted version of the input
 Œr                         run-length-encode it
        Ðf                  keep only elements where
   Ṫ                        delete the last element, and it was
    4=                      equal to 4
      $$                    parse Ṫ4= as a group
          x3                repeat each element three times

                Ẇ           all sublists of the input
                 m€         take every nth element of each (€) sublist
                   6R       for each n in 1..6
                     ¤      parse 6R as a group
                      ;/    flatten one level (m€ creates a nested structure)

             œ-             multiset difference
                         L  length of that difference

Başka bir deyişle, girişte tam olarak dört kez görünen karakterlerin listesini buluruz ve bunlardan her birinin üç kopyasından oluşan bir liste yaparız; orijinal dizgede eşit aralıklarla yerleştirilen tüm alt dizgelerin listesini buluruz; ve ikinciyi ilk çıkartan çıkarırsak, sonucun 1 uzunluğuna sahip olmasını istiyoruz (yani, bir oyuncu dört kez oynadı ancak kazanamadı). 3 × 3'lük bir şebekedeyken ve her karenin dolu olduğundan, her iki oyuncunun da dört kez oynamasının imkansız olduğunu unutmayın. Jelly'te 1, truthy, 0 ise falsey, dolayısıyla sonuçta oluşan listeyi bir booleya dönüştürmek için özel bir şey yapmamız gerekmez. ( Gerekir µL, çünkü aksi takdirde her ikisi de mümkün olabilir “XXX”ve “OOO”gerçeğe uygun çıktı değerleri olur ve soru, geçerli tüm panoların aynı çıktıyı vermesini gerektirir.)

JavaScript (ES6), 88 87 bayt

s=>(a=[...s]).sort()[5]-a[3]&[7,56,73,84,146,273,292,448].every(j=>j&i,i=`0b`+s^~-a[4])

Girdiyi 9 0ve 1karakterlerden oluşan bir dizge olarak alır ve geçersiz 1, geçerli 0için döndürür Karakterleri sıraya göre sıralarız. Ortadaki üç karakter şimdi aynıysa, o zaman bir parçadan çok fazla olduğu için tahta geçersizdir. Aksi takdirde, orijinal kartı 0s'den daha fazla varsa, bitleri çevirerek ikili hale getiririz 1. Bu noktada tahta 0üç çizgiye sahip değilse geçerlidir , bu yüzden sekiz çizginin tümünü bir bit maskesi dizisi ile test ediyoruz. Düzenleme: @ETHproductions sayesinde 1 bayt kaydedildi.

Python 3, 131 127 125 100 96 bayt

Farklı algoritmik bir yaklaşım için (ve bu çok baytlı golf dillerine yerleşik sıkıştırma ile gerçekten uygun olanı için), kartın geçerli olup olmadığını hesaplamak yerine, her bir bitin gösterilip gösterilmeyeceğini temsil eden 512 bitlik bir sayı alalım. belirli bir tahta geçerlidir veya geçerli değildir ve kartı temsil eden ikili bir değere geçer. Ayrıca, simetri nedeniyle, masanın ikinci yarısı bir grup sıfırla birlikte elimine edilebilir:

def z(b):return int('agqozfx67wwye6rxr508ch2i8qicekpreqkap0725pk',36)<<24&1<<b+(b>255)*(511-b-b)

Test değeri:

X X X
O X O
X X X

İkili değer olarak temsil edilir 0b111010111ve kart geçerliyse, işlev sıfır olmayan bir değer döndürür.

Toplu iş, 140 bayt

@set/aXXX=OOO=O=0
@for %%l in (%* %1%2%3 %1%4%7 %1%5%9 %2%5%8 %3%5%7 %3%6%9 %4%5%6 %7%8%9)do @set/a%%l+=1
@cmd/cset/a!XXX*!(O-=5)+!OOO*!~O

Girdiyi dokuz ayrı komut satırı argümanı olarak alır ve 1geçerli ve 0geçersiz için çıktılar . Veya Oortogonal çizgisinin kaç kez olduğunu izleyerek çalışır . Elverişli bir şekilde Batch, dolaylı olarak tamsayı aritmetiği yapmamıza izin veriyor, bu yüzden biz artmıyoruz, bunun yerine bazı değişkenleri (sadece belirtilen üç değişkenle ilgilenmemize rağmen) Daha sonra kazanmadığını ve beş saniye olduğunu veya kazanmadığını ve dört saniye olduğunu test etmemiz gerekiyor .OOOXXX%%lXOOO

Mathematica, 82 75 bayt

Martin Ender'e 7 bayt kaydettiği için teşekkürler!

t=Total;3<(b=#~t~2)<6&&{t[c=If[b>4,1-#,#]],t/@c,Tr@c,Tr@Reverse@c}~FreeQ~3&

3x3 iç içe geçmiş 1s ve 0s listesinin giriş ve çıkış olarak alındığı isimsiz fonksiyon Trueveya False.

TotalFonksiyonun kullanışlı esnekliğini kullanır (burada golf oynar t): örnek bir dizi verildiğinde e = { {1,2,3} , {4,5,6} , {7,8,9} }, komut t[e]üç vektörü toplar (burada elde edilir {12,15,18}); komut, t/@eher bir alt listeyi ayrı ayrı toplar (burada gelir {6,15,24}); ve komut e~t~2dokuz öğenin toplamını (burada verir 45) toplar .

İlk önce 3<(b=#~t~2)<6toplam 1 sayının 4 veya 5 olup olmadığını test ediyoruz ; eğer değilse ile çıkarız False. Öyleyse, c=If[b>4,1-#,#]beş tane değil, dört tane olmak üzere zorlamak için kullanıyoruz . Daha sonra sütun toplamlarını t[c], satır toplamlarını t/@c, ana köşegenin Tr@ctoplamını ve karşıt köşegenin toplamını hesaplar ve bu hesaplanan toplamlarda herhangi bir düzeyde görünüp görünmediğini kontrol etmek için Tr@Reverse~ckullanırız .~FreeQ~33

Eğlenceli yan not: Bu sitedeki görünüşlerin çoğundan farklı olarak, burada Trtek boyutlu bir listeyi toplamak için değil, aslında iki boyutlu bir matrisin izini hesaplamak için tasarlandığı gibi kullanılır!

Pyth - 36 bayt

Ben diagas eklerim ve onun yerine iki tane ternar kullanırım.

JsM+sCBQm@VdU3_BQ?q5KssQ*FJ?qK4!}3JZ

Test odası

JavaScript (ES6), 101 bayt

Girdiyi 9 bitlik ikili maske olarak alır X = 1ve burada O = 0(MSB = sol üst hücre, LSB = sağ alt hücre).

n=>[7,56,73,84,146,273,292,448,o=x=0].map((m,i)=>(c-=n>>i&1,m&n^m?m&n||o++:m&&x++),c=4)&&!(c|x&&~c|o)

Test durumları

let f =

n=>[7,56,73,84,146,273,292,448,o=x=0].map((m,i)=>(c-=n>>i&1,m&n^m?m&n||o++:m&&x++),c=4)&&!(c|x&&~c|o)

// valid
console.log(f(0b101010101));
console.log(f(0b101101010));
console.log(f(0b100001011));
console.log(f(0b010101010));

// invalid
console.log(f(0b111111111));
console.log(f(0b000000000));
console.log(f(0b111000111));
console.log(f(0b000001111));
console.log(f(0b110010001));

Python 2, 158 132 109 92 91 123 bayt

def v(b):f=sum(b,());w={x[0]for x in b+zip(*b)+[f[::4],f[-3:1:-2]]if len(set(x))==1};return sum(map(`b`.count,w))==len(w)*5

Girdi, her biri üç dize dizge içeren bir liste / dizilimdir, örneğin:
[('X', 'O', 'X'), ('O', 'X', 'O'), ('X', 'O', 'X')]

Maltysen'in cevabına göre köşegenleri görmezden gelerek bazı baytlar kaydedildi, bu da aşağıdaki ifadeyi kısalttı.

Kaydetmek için teşekkürler @vaultah 17 18 bayt.

Köşegenleri kontrol etmek gerekliydi, bu da yukarıdaki tasarrufların çoğunu ortadan kaldırdı.

Burada dene.

açıklama

def v(b):
  f=sum(b,())
  w={x[0]for x in b+zip(*b)+[f[::4],f[-3:1:-2]]if len(set(x))==1}
  return sum(map(`b`.count,w))==len(w)*5

fdilimleme için düzleştirilmiş girdidir.
wkazanan dizileri olan karakterleri içerir.
Her kazanma karakterinin oluşumunu sayın, eğer wboşsa 0 veya boşsa 5 olur len(w). Her ikisi de bir kazanma sırasına sahip olduğunda 10 toplamı imkansız olur. 5 olan kazanan kaybeden 4 anlamına gelir.> 5 kazanan bir dizilim olmadan sahip olamazsınız.

R, 88 82 bayt

x=scan();`if`(sum(x)%in%4:5,all(apply(combn(which(x==(sum(x)<5)),3),2,sum)!=15),F)

1'den 9'a kadar olan 3 tam sayı kombinasyonunun 15'e kadar olan toplamı aşağıda gösterilen karenin sıraları / sütunları / çaprazlarıdır.

2 7 6
9 5 1
4 3 8

Bu fonksiyon girdiyi bir "bo" vektörü olarak alır, "X" için T, "O" için F ise kartın düzleştirilmiş bir temsilidir. AMA, bunlar yeniden sıralandı, böylece dizinleri sıradaki karedeki sayı ile aynıydı (2,7,6,9,5,1,4,3,8). Bu sıra, tahtanın normal şekilde düzleştirilmesi ve daha sonra c ile dilimlenmesiyle elde edilebilir (6,1,8,7,5,3,2,9,4). Yani bu

X O X
O X O
X O X

olarak temsil edilir:

c(T, F, T, F, T, F, T, F, T)[c(6,1,8,7,5,3,2,9,4)]

hangisi:

c(F, T, F, T, T, T, F, T, F)

Önce işlev, tam olarak dört işareti olan bir oyuncu olup olmadığını belirler. Öyleyse, işlev bu oyuncunun bir satırda üçe sahip olup olmadığını belirlemek için 15'e eklenmiş şeyleri kullanır.

Giriş olarak geleneksel olarak düzleştirilmiş bir pano almak istiyorsanız, kod bunun yerine şöyle görünür:

f=function(x)ifelse(sum(x)%in%4:5,all(apply(combn(c(2,7,6,9,5,1,4,3,8)[which(x==(sum(x)<5))],3),2,sum)!=15),F)

Ben bu işte yeniyim, tavsiyeler çok iyi olurdu.

JavaScript (ES6), 145 139 131 127 bayt

s=>!(q="XO"[s.split`O`.length-5])|![...s].some((c,i)=>c==q&!/(.)(\1|..(\1|.(\1|.\1.).)..)\1/.test(s.slice(0,i)+0+s.slice(i+1)))

Boşluklu bir dize gibi giriş yapın "XOX OXO XOX". Geçerli bir 1pano için geçersiz bir tahta çıktıları 0. Bu tabii ki en iyi teknik değil, en azından JavaScript ile değil ...

Bu temel olarak aşağıdakilerin ikisinin de geçerli olup olmadığını kontrol eder:

• Tam olarak 4 veya 5 Osaniye var, VE
• kaldırıldığında kararsız bir oyun oluşturan 5 örnek parçanın en az biri var.

Düzenli ifade, bir oyuna karar verilip verilmediğini kontrol etmektir. Her bir çifti ayıran 0 (satır), 2 (sağ alt köşegen), 3 (sütun) veya 4 (sol alt köşegen) karakter ile, bir karakterden üçü uzunluktaki herhangi bir koşu varsa, bir tahta ile eşleşir.

Test pasajı

f=s=>!(q="XO"[s.split`O`.length-5])|![...s].some((c,i)=>c==q&!/(.)(\1|..(\1|.(\1|.\1.).)..)\1/.test(s.slice(0,i)+0+s.slice(i+1)))

g=s=>console.log(f(s))

// Valid boards (outputs 0)
g("XOX OXO XOX")
g("XOX XOX OXO")
g("XOO OOX OXX")
g("OXO XOX OXO")

// Invalid boards (outputs 1)
g("XXX XXX XXX")
g("OOO OOO OOO")
g("XXX OOO XXX")
g("OOO OOX XXX")
g("XXO OXO OOX")

Ruby, 104 99 91 bayt

->x{[7,56,448,292,146,73,84,273].none?{|y|b=x.to_i 2;((a=x.count'1')==4?b:a==5?~b:7)&y==y}}

Giriş formatı: panoyu temsil eden 9 sembolden oluşan ikili dize (0s ve 1s), örneğin ilk test durumu 101010101. İlk önce bir ikili sayıya dönüştürün, popcountun 4 veya 5 olup olmadığını kontrol edin, 5 ise sayıyı ters çevirin, böylece her zaman 4 oluruz.

TL; DR : 4 işareti olan oyuncu kazanırsa false döndür, aksi takdirde doğrudur.

Yorumlarınız için teşekkürler Jordan,

Başka bir bayttan tasarruf edecek UTF-8 dizesini çoğaltamıyorum.

Perl 6 , 103 99 bayt

{my \c=%(.flat.Bag.invert)<5>;?all c,|(.[0]===c if [eq] $_ for |.flat[<0 4 8>,<2 4 6>],|$_,|.&zip)}

Bir liste gibi kabul eden (('X','O','X'), ('O','X','O'), ('X','O','X'))ve bir Bool döndüren bir lambda.

Bu gibi çalışır:

1. Hangi işaretin tam olarak 5 kez göründüğünü kontrol edin ve içinde saklayın c. (Tam olarak 5 kez hiçbir işaret görünmezse, bu bir sahte değer içerir)
2. Tüm köşegenleri, satırları ve sütunları tekrarlayın ve "kazanan" olanları filtreleyin (yani, üç harfin de eşit olduğu yerler) .
3. cGerçek olup olmadığını kontrol edin ve her kazanan çizginin türünde olduğunu kontrol edin c.

PHP, 125 bayt

for($p=$n=$argv[1];$p;$p/=2)$i+=$p&1;foreach([7,56,448,73,146,292,273,84]as$m)$n&$m^$m?$n&$m||$o++:$x++;echo!$x|!$o&&2>$i^=4;

Arnauld ile aynı düşünceye sahibim : 4 ya da 5 bit ayarlanmışsa Xya Oda hiç kimsede çizgi bulunmuyorsa ( ya da ikisinde birden yok) tahta geçerlidir .

Alandan girdiyi ve ile olanı değiştirmek Xiçin , çizgileri birleştirin ve binary'i ondalık sayıya dönüştürün, komut satırı argümanı olarak verin.1O0

1geçerli için yazdırır ; geçersiz için boş çıktı. İle koş -r.

Yıkmak

// count set bits
for($p=$n=$argv[1];$p;$p/=2)$i+=$p&1;
    /* ($p/=2 takes longer than $p>>=1, but eventually
       $p will come close enough to 0 for the loop to finish */
// count streaks for X and O
foreach([7,56,448,73,146,292,273,84]as$m)
    $n&$m^$m            // ($n masked with streak)!=streak <=> no streak for X
        ?$n&$m||$o++    // true: O has a streak if ($n masked with streak) is empty
        :$x++;          // false: X has a streak
echo!$x|!$o&&2>$i^=4;   // valid if not both have a streak
                        // AND $i is 4 or 5 (toggle 4 -> result 0 or 1)

Swift, 178 bayt

func t(i:String)->Bool{let r=i.characters.filter({$0=="X"}).count;let g=i.characters.split(separator:"\n").map(String.init).contains;return(r==5||r==4)&&(!g("XXX") && !g("OOO"))}

ES6 (Javacript), 130, 138, 117 bayt

DÜZENLEMELER:

• @Neil'den gelen mükemmel tavsiyeler sayesinde 21 byte kapalı!
• İlk sürüm bir hataya açıktı, şimdi +8 baytlık bir maliyetle düzeltilmeli. (İşaretlediğiniz için teşekkürler @ETHproductions)

Aşırı derecede düz bir yaklaşım. Muhtemelen biraz daha golf oynayabilir.

Girdiyi 9 ayrı argüman, 1es ve 0es olarak kabul eder.

• 1 , X içindir
• 0 , O içindir

Bağımsız Değişkenler: 1-3 - ilk satır, 4-6 - ikinci satır, 7-9 - üçüncü satır.

golfed

(a,b,c,d,e,f,g,h,j)=>![a+b+c,d+e+f,g+h+j,a+d+g,b+e+h,c+f+j,a+e+j,g+e+c,7].some(x=>x=="7777307777"[a+b+c+d+e+f+g+h+j])

İnteraktif "Test Yatağı"

var a=b=c=d=e=f=g=h=j=0;

T=(a,b,c,d,e,f,g,h,j)=>![a+b+c,d+e+f,g+h+j,a+d+g,b+e+h,c+f+j,a+e+j,g+e+c,7].some(x=>x=="7777307777"[a+b+c+d+e+f+g+h+j]);

function test() {
  if(T(a,b,c,d,e,f,g,h,j)) {
     grid.style.backgroundColor='green';
     msg.innerHTML="GOOD"
  } else {
     grid.style.backgroundColor='red';
     msg.innerHTML="BAD"
  }
}

<table id=grid style="background: red">
<thead>
  <tr>
     <td id=msg align="center" colspan="3">BAD</td>
    </tr>
  </thead>
  <tr>
      <td><input type="checkbox" onchange="a=this.checked*1;test();" id="ca"/></td>
      <td><input type="checkbox" onchange="b=this.checked*1;test();" id="cb"/></td>
      <td><input type="checkbox" onchange="c=this.checked*1;test();" id="cc"/></td>
    </tr>
    <tr>
      <td><input type="checkbox" onchange="d=this.checked*1;test();" id="cd"/></td>
      <td><input type="checkbox" onchange="e=this.checked*1;test();" id="ce"/></td>
      <td><input type="checkbox" onchange="f=this.checked*1;test();" id="cf"/></td>
    </tr>
    <tr>
      <td><input type="checkbox" onchange="g=this.checked*1;test();" id="cg"/></td>
      <td><input type="checkbox" onchange="h=this.checked*1;test();" id="ch"/></td>
      <td><input type="checkbox" onchange="j=this.checked*1;test();" id="cj"/></td>
    </tr>
 </table>