Tam olarak 4 A, 4 B, 4 Cve 4 Dgibi bir 4 x 4 metin ızgarası alan bir program veya işlev yazın , örneğin:

ACDC
BBCA
BADD
ABCD

ABCDVar herhangi bir düzende olabilir, ancak her zaman, her 4 olacaktır. Girişin geçerli olduğunu varsayabilirsiniz. İstenirse, takip eden bir yeni hattının olduğunu ve / veya okuma sırasındaki bir satır olarak geldiğini varsayabilirsiniz, örn ACDCBBCABADDABCD. İsterseniz, isterseniz karakterleri sırasıyla veya ABCDile değiştirebilirsiniz (ancak hepsi bu kadar).01231234

Metin ızgarası herhangi bir yansıtıcı veya dönme simetrisi formuna sahipse, gerçek bir değer çıktılayın. özellikle:

• Merkezi bir yatay simetri çizgisi varsa. Örneğin

  BACD
  BACD 
  BACD \___ bottom mirrors top
  BACD /
  

• Merkezi bir dikey simetri çizgisi varsa. Örneğin

  BCCB
  DAAD
  CAAC
  BDDB
    \/___ right mirrors left
  

• Çapraz bir simetri çizgisi varsa (her iki yönde). Örneğin

       ___ diagonally mirrored
      /
  ABDC
  BACD
  DCAB
  CDBA
      \___ diagonally mirrored
  

• 90 ° dönme simetrisi varsa. Örneğin

  BDAB
  ACCD    same if rotated 90 degrees (or 180 or 270)
  DCCA
  BADB
  

• 180 ° dönme simetrisi varsa. Örneğin

  DBCA
  BDCA    same if rotated 180 degrees
  ACDB
  ACBD
  

(Çeviri simetrisinin burada devreye girmediğine dikkat edin.)

Izgara yukarıda belirtilen simetrilerden birine sahip değilse sahte bir değer verin. örneğin ilk örnek ızgara.

Bayt cinsinden en kısa kod kazanır.

CJam, 16 bayt

{{z_W%_}4*;])e=}

Girdiyi yığının üstüne dört dizenin bir listesi olarak bekleyen ve 0asimetrik girişler için bir (sahte) ve simetrik girişler için pozitif bir tamsayı (truthy) bırakan adsız bir blok.

Burada test et. Veya tam bir test takımı çalıştırın.

açıklama

Karenin simetrileri, 8. düzlem grubunun ( karenin sadece 4 dönüşü ve karenin yansıyan bazı sürümünün aynı 4 dönüşü olduğu) eleman grubudur . Tek bir permütasyonun tekrar tekrar uygulanmasından bu grubun oluşturulması mümkün değildir. Ancak iki yansıma her zaman biraz döndürür. Dolayısıyla, tüm grup iki yansıma arasında dört kez değişerek üretilebilir. (İki yansımanın 0 veya 180 değil, 90 derece veya 270 derece dönüş verdiğinden emin olmalıyız.)

Zorluk, giriş karesinin diğer 7 simetriden birine eşit olup olmadığını soruyor. Yani bu cevap sadece hepsini üretir ve daha sonra girdinin diğerleri arasında olup olmadığını kontrol eder.

{      e# Run this block 4 times.
  z_   e# Transpose the grid and duplicate it. (This is one type of reflection.)
  W%_  e# Reverse the lines and duplicate it. (This is another type of
       e# reflection. Together they rotate the grid by 90 degrees.)
}4*    e# The last element will be the original grid again.
;      e# Discard one copy of that original grid.
]      e# Wrap all symmetries in a list.
)      e# Pull off the original grid.
e=     e# Count how many times it appears among the other symmetries.

Tekrarlanan uygulamanın tüm simetrileri nasıl ürettiğini zve W%ürettiğini görmek için, bu "şemaya" bakınız:

     0123
     4567
     89ab
     cdef

     original

 z   048c       W%       37bf
-->  159d  ----------->  26ae
     26ae                159d
     37bf                048c

     diag. refl.         rot. 90 degrees ccw

 z   3210       W%       fedc
-->  7654  ----------->  ba98
     ba98                7654
     fedc                3210

     vert. refl.        rot. 180 degrees

 z   fb73       W%       c840
-->  ea62  ----------->  d951
     d951                ea62
     c840                fb73

     antidiag. refl.     rot. 270 degrees ccw

 z   cdef       W%       0123
-->  89ab  ----------->  4567
     4567                89ab
     0123                cdef

     horiz. refl.        original

Pyth, 11 bayt

<7.u?%Y2CN_

Test odası

Bu Martin'in devrik ve ters tekniğini kullanır, ancak bir bükülme ile. Diğer çözümler açıkça 8 adet simetrinin hepsini oluştururken, orijinalin görünüş sayısını sayarken, bu program Pyth'in .ufonksiyonunu kullanır .

.uFonksiyon "tekrar bulunana kadar uygula" dir. Bu durumda, tekrarlama gerçekleşene kadar dönüşümlü olarak dönüşümlü ve tersine döndükten sonra sonuçları bir liste halinde topladık. Daha sonra, son 7 değeri kaldırdım, bu yüzden sadece simetri yoksa geri kalan bir değer olacak ve ilk tekrarlama tüm 8 yansıma ve tekrarlamalardan sonra gerçekleşti.

Açıklama:

<7.u?%Y2CN_
<7.u?%Y2CN_NQ    Implicit variables
                 Q = eval(input())
  .u        Q    Starting with Q, apply the following until a repeat occurs, 
                 then accumulate all values into a list.
    ?%Y2         If the iteration number is odd
        CN       Transpose
          _N     Else reverse
<7               Remove the last 7 results

05AB1E , 13 bayt

4Fø€JÂD}\\)¹å

açıklama

Martin tarafından CJam cevabında ustalıkla açıklanan yöntemi kullanır .

4F     }       # 4 times do:
  ø€J          # zip and join each
     ÂD        # bifurcate, duplicate
        \\     # delete the top 2 items on the stack
          )    # wrap stack in list
           ¹å  # check if input is in that list

Çevrimiçi deneyin

Perl, 61 60 bayt

İçin +3 içerir -p0a

STDIN'e giriş karesini verin, simetri olmadan 0 yazar, aksi halde bazı pozitif sayılar

./symmetry.pl
DBCA
BDCA
ACDB
ACBD
^D

symmetry.pl:

#!/usr/bin/perl -p0a
s,.,chop$F[$i++/($j-4?1:4)%4],eg;$\+=$$_++;++$j<8&&redo}{

Dyalog APL , 37 19 17 bayt

@ngn 20 byte düşürdü!

8>≢(∪⊢,⌽¨,⍉¨)⍣≡⊂⎕

TryAPL çevrimiçi!

Brachylog , 38 36 bayt

@eL:1fbeL
(L;?:raL)(.;L$\.;L$/.;Lr.)

Çevrimiçi deneyin!

Bu girdi olarak dizelerin bir listesini bekler. Bu ya true.da yazdırır false..

açıklama

• Ana tahmin:

  @eL    Split each line into a list of chars ; call that list of lists L
  :1f    Find all symmetries
  b      Remove the first one (the identity)
  eL     L is an element of that list of symmetries
  

• Öngörü 1: Çıkış, girişin 8 simetrisinden biridir.

  (
      L             L = Input
  ;             Or
      ?:raL         L = reverse all lines of the input
  )
  (
      .             Output = L
  ;             Or
      L$\.          Output = transpose of L    
  ;             Or
      L$/.          Output = antitranspose of L
  ;             Or
      Lr.           Output = reverse of L
  )
  

TSQL, 229 bayt

TSQL'in döndürme için yerleşik bir özelliği olmadığını unutmayın;

golfed:

DECLARE @1 char(16)=
'BCCBDAADCAACBDDB'

,@i INT=0,@ varchar(16)=''WHILE @i<16SELECT @+=substring(@1,@i*4%16+@i/4+1,1),@i+=1SELECT sign(count(*))FROM(SELECT LEFT(x,8)a,RIGHT(x,4)b,substring(x,9,4)c FROM(values(@1),(@))x(x))x WHERE c+b=reverse(a)or a=reverse(b+c)or a=b+c

Ungolfed:

DECLARE @1 char(16)=
'BCCBDAADCAACBDDB'

,@i INT=0,@ varchar(16)=''
WHILE @i<16
  SELECT @+=substring(@1,@i*4%16+@i/4+1,1),@i+=1

SELECT sign(count(*))
FROM
  (SELECT LEFT(x,8)a,RIGHT(x,4)b,substring(x,9,4)c
   FROM(values(@1),(@))x(x))x
WHERE c+b=reverse(a)or a=reverse(b+c)or a=b+c

Keman

Python 2, 154 146 bayt

Gerekli dönüşümlerden herhangi birinin numpy dizileri kullanarak orijinaline eşit olup olmadığını kontrol eder. Giriş dört karakterli bir liste olarak alınır.

from numpy import*
A=array(map(list,input()))
R=rot90
T=transpose(A)
print any([all(A==Z)for Z in(A[:,::-1],A[::-1],R(A),R(A,2),R(A,3),T,R(T,2))])

Çevrimiçi deneyin

Girdiyi tek bir dize olarak almak, ile bir karakter daha uzundur A=array(list(input())).reshape(4,4). A[:,::-1]aynıdır fliplr(A). A[::-1]aynıdır flipud(A).

Python 3, 99 bayt

def f(x):
 t=x;c=[]
 for i in range(7):*t,=[map(''.join,zip(*t)),t[::-1]][i%2];c+=t,
 return x in c

Girdileri, argüman yoluyla, bir dizge ve geri dönüş listesine Trueya Falseda ilgili bir listeye alan bir işlev .

Bu MartinEnder en @ aynı yaklaşımı kullanır cevap .

Nasıl çalışır

def f(x)                Function with input list of strings x
 t=x;c=[]               Initilaise temporary square t and combination list c
 for i in range(7):...  For i in range [0,6]:
 [...][i%2]              If i is even:
 zip(*t)                  transpose(t)
 *t,=map(''.join,...)     t = t with each line concatenated (such that t is in the same
                          format as x)
                         Else:
 *t,=t[::-1]              t = reverse(t)
 c+=t,                   Append t to c
 return x in c           Return True if x is in c else return False

Ideone'da dene

JavaScript (ES6), 131 bayt

s=>[...`0101010`].map(c=>+c?``+b.reverse():`${b=b.map((s,i)=>s.replace(/./g,(_,j)=>b[j][i]))}`,b=a=s.match(/..../g)).includes(``+a)

Doğrudan 4 dizeden oluşan bir dizi iletirseniz 17 bayt kaldırılabilir. Bit-twiddling (giriş "0123301223011230"biçiminde) denedim ama bu beni 199 baytı aldı:

s=>[...'0101010'].map(c=>r=+c?r<<24&255<<24|r<<8&255<<16|r>>8&255<<8|r>>>24:r&0xc0300c03|r<<6&806093568|r<<12&3075<<16|r<<18&3<<24|r>>6&0xc0300c|r>>12&49200|r>>18&192,r=n=parseInt(s,4)|0).includes(n)