Bu soru, "Godel, Escher, Bach" kitabının kapağından esinlenmiştir:

Buradaki zorluk, verilen üç harfin üç taraftan okunabilecek bir 3D heykel üretip üretemeyeceğini söyleyen bir işlev yazmaktır.

Bu alıştırma için kullanabileceğiniz tek harf 26 5px * 5px bitmap'tir:

Veya ikili (A'dan Z'ye):

01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111

Heykel aşağıdaki sırayla üç harften oluşur:

• üstüne bir harf
• soldaki iki harf
• sağdaki üç harf
• birinci harfin alt kısmı ikinci harfin üst kısmına bağlanır.

Örnek:

İşleviniz, üç büyük harf (üç harf veya üç harf bir harf) giriş olarak kabul edebilir ve karşılık gelen heykelin var olup olmadığını söyleyen bir boolean (doğru / yanlış veya 0/1) çıktısı alabilirsiniz.

Örnek:

f("B","E","G") // true  (because if you "sculpt out" B on top + E on the left + G on the right, and watch the three sides of the sculpture, you'll see exactly B, E and G as they are defined)
f("B","G","E") // false (because if you "sculpt out" B on top + G on the left + E on the right, and watch the three sides of the sculpture, you won't see a complete G and a complete E. Their shapes bother each other)

Not: Heykel "uçan pikseller" (hiçbir şeye bağlı küpler veya küpler grubu) içermesine rağmen doğru olabilirsiniz.

Standart boşluklar uygulanır.

Daha doğrusu, üç harften başka harici girdi kullanamazsınız ve 17576 olası cevabı kaynak kodunuzda sabitleyemezsiniz.

Herhangi bir dilde karakterlerde en kısa cevap kazanır!

İyi eğlenceler :)

Mathematica 423

"Nasıl engelleme çalışıyor" adlı bir bölüm ekledim.

Ungolfed

(* Alfabenin ikili verileri, içinde tek bir dize olarak depolanır s. varsİçe aktarır ve diziye dönüştürür.)

vars=IntegerDigits[#,10,5]&/@Transpose[ImportString[s,"Table"]];
get[char_]:=(ToCharacterCode[char]-64)[[1]];
cube=Flatten[Table[{i,j,k},{i,5},{j,5},{k,5}],2];

(* character slice along axis *)
slice[char_,layer_,axis_,bit_]:=Insert[(Reverse@#),layer,axis]&/@Position[Reverse@vars[[get[char]]],bit]

(* cuboid assembly  *)
charBlocks[{char_,axis_,bit_}]:=Flatten[Table[slice[char,k,axis,bit],{k,5}],1]

(* letters are those whose HOLES should be sculped out of the full cube *)
sculpturePoints[letters_(*{char_,axis_,bit_}*)]:=Complement[cube,Union[Join@@(charBlocks/@letters(*{char,axis,bit}*))]];

collapse[letters_(*{char_,axis_,bit_}*),axis_]:=Union[Reverse/@(Delete[#,axis]&/@sculpturePoints[letters(*{char,axis,bit}*)])](*/.{x_,y_}\[RuleDelayed] {6-x,y}*)

vQ[l_]:=collapse[l,3]==collapse[{l[[1]]},3]\[And]collapse[l,2]==collapse[{l[[2]]},2]\[And]collapse[l,1]==collapse[{l[[3]]},1]

validQ@l_:= vQ[{{l[[1]],3,0},{l[[2]],2,0},{l[[3]],1,0}}]


perspective[letts_,view_:1]:=
Graphics3D[{AbsolutePointSize[10],Cuboid/@sculpturePoints[letts]},
ImageSize-> 120,
ViewPoint-> Switch[view,1,{0,0,\[Infinity]},2,{0,-\[Infinity],0},3,{\[Infinity],0,0},4,Top,5,Front,6,Right,True,{0,0,\[Infinity]}],
PlotLabel-> Switch[view,1,"top orthogonal view",2,"front orthogonal view",3,"right orthogonal view",4,"top close-up view",5,"front close-up view",6,"right close-up view"],
ImagePadding->10]

Örnek

Küp {"B", "G", "E"}geçerli mi? (örneğin, üç harf duvarlara doğru bir şekilde yansıyacak mı?)

validQ[{"B", "G", "E"}]

Yanlış

Çizimleri

Aşağıdaki şekiller BGE’nin nasıl oluşturulduğunu göstermektedir. Üstteki rakam sırası izleyiciyi küpten sonsuz mesafelere yerleştirilmiş gibi dik perspektif alır. Alttaki satır, blokların yakından nasıl görüneceğini gösterir. Bireysel küplerin nerede durduğunu tam olarak kontrol etmek için 3B rakamlar manuel olarak döndürülebilir.

"G" harfiyle bir sorun ortaya çıkıyor. Serif'i mektubun geri kalanına bağlayan hiçbir şey yok.

pts = {{"B", 3, 0}, {"G", 2, 0}, {"E", 1, 0}}
GraphicsGrid@Partition[Table[perspective[pts, view], {view, 1, 6}], 3]

Ancak, BEG iyi çalışmalıdır.

 validQ[{"B", "E", "G"}]

Doğru

pts2 = {{"B", 3, 0}, {"E", 2, 0}, {"G", 1, 0}}
GraphicsGrid@Partition[Table[perspective[pts2, view], {view, 1, 6}], 3]

Engelleme Nasıl Çalışır?

Bu açık görünüyorsa lütfen affedersiniz, ancak belki de bazı insanlar harflerin birbirleriyle nasıl etkileşime girdiğini ve 3D piksellerini nasıl iptal ettiğini görselleştirmek isteyecektir.

BGE küp işlemede G harfine ne olduğunu takip edelim.

Aşağıdaki voksele (3D piksel veya birim küp) özellikle dikkat edeceğiz . BGE küpünde kaybolan piksel budur. Bit dizisindeki ve karşılık gelen dizi grafiğindeki Satır 4, Sütun 5'e karşılık gelen pikseldir.

Xy düzleminde piksel, noktadaki (5,2) gri diske karşılık gelir. Ancak 3D olarak çalışacağımız için, şafttaki 5 pozisyonu (5,1,2) ila (5,5,2) arasında saymamız gerekir. Bu piksellerden herhangi biri B ve E harfleriyle şekillendirmeye devam ederse, ilgilenilen pikselleri duvardaki 3D projeksiyonda görebiliriz.

Pikseller katı bloktan kaldırıldığında harfler karışıyor. Solda, siyah ok sağ altta bulunan bit'e karşılık gelen piksellerin oyulmasını temsil eder; B harfi için 0 değerine sahiptir. Oyma işlemi (5,1,2) 'deki pikseli, doğrudan üstündeki ve altındakilerle kaldırır. Dört piksel hesaba katılmaya devam ediyor.

Ancak sağ bölmede gösterildiği gibi, E harfi kalan ilgi piksellerini (5,2,2) (5,3,2), (5,4,2) ve (5,5,2) çıkarır. (Bunun nedeni, E harfinin dördüncü satırda 0'a, sütun 2'den sütun 5'e kadar bitlere sahip olmasıdır.) Sonuç olarak, noktada gölge sağlamak için gerekli olanlar arasında tek bir piksel kalmaz (5). , 2) uzaktaki duvarda (G harfi için). Bunun yerine, G harfindeki bir deliğe karşılık gelen parlak bir nokta olacaktır! Küp BGE iyi değil çünkü yanlış G yapar.

Golf 423 karakter

İşlev , Ungolfed kodundakiyle haynı rolü üstlendi validQ. Oluşturma işlevi, perspectivedahil edilmemiştir çünkü bu zorluğa katkıda bulunmaz ve gerektirmez.

x=Reverse;q=Flatten;
g@c_:=(ToCharacterCode[c]-64)[[1]];
r[{c_,a_,b_}]:=q[Table[Insert[(x@#),k,a]&/@Position[x@(IntegerDigits[#,10,5]&/@
Transpose[ImportString[s,"Table"]])[[g[c]]],b],{k,5}],1]
p@l_:=Complement[q[Table[{i,j,k},{i,5},{j,5},{k,5}],2],Union[Join@@(r/@l)]];
w[l_,a_]:=Union[x/@(Delete[#,a]&/@p[l])]
v@l_:=w[l,3]==w[{l[[1]]},3]\[And]w[l,2]==w[{l[[2]]},2]\[And]w[l,1]==w[{l[[3]]},1]

h@l_:= v[{{l[[1]],3,0},{l[[2]],2,0},{l[[3]],1,0}}]

Prolog, 440 , 414

:- encoding(utf8).
i(I) :- between(0,4,I).
h(T,L,R,X,Y,Z) :- i(X),i(Y),i(Z),I is 4-X,c(T,Z,I),c(L,Z,Y),c(R,X,Y).
f(T,L,R) :- forall((i(U),i(V),I is 4-V),((\+c(T,U,V);h(T,L,R,I,Y,U)),(\+c(L,U,V);h(T,L,R,X,V,U)),(\+c(R,U,V);h(T,L,R,U,V,Z)))).
c(C,X,Y) :- char_code(C,N),i(X),i(Y),Z is X+5*Y+25*(N-65),I is floor(Z/15),O is (Z mod 15),string_code(I,"䙎㹟䘑߯硁䙏縑ԁࠟя摟䠑䠑ᐑ粤Ⴟ䔅┉ё籁垑䙑曓䗱㩑䙏㡏晑䘞䕟㡞縐Ⴄ䙄㩑⩑䒪噑⩊䕤ᅱ粤ࢨ?",V),1 is (V-32)>>O/\1.

Program şöyle denir:

?- f('B','E','G').
true.
?- f('B','G','E').
false.

Prologiyi bir seçim gibi görünüyordu, çünkü problemi birinci dereceden mantıkta göstermek kolaydı. Ayrıca Prologbu tür bir sorunu çözmek için güçlü işlevsellik sağlar.

Ancak, kod golf oynadığı için biraz açıklama eklemeliyim.

Hafif golf versiyonu

:- encoding(utf8).
i(I) :- between(0,4,I).
t(C,X,Z) :- I is 4-X,c(C,Z,I).
l(C,Y,Z) :- c(C,Z,Y).
r(C,X,Y) :- c(C,X,Y).
h(T,L,R,X,Y,Z) :- i(X),i(Y),i(Z),t(T,X,Z),l(L,Y,Z),r(R,X,Y).
u(T,L,R) :- forall((i(U),i(V),I is 4-V,c(T,U,V)),h(T,L,R,I,Y,U)).
v(T,L,R) :- forall((i(U),i(V),c(L,U,V)),h(T,L,R,X,V,U)).
w(T,L,R) :- forall((i(U),i(V),c(R,U,V)),h(T,L,R,U,V,Z)).
f(T,L,R) :- u(T,L,R),v(T,L,R),w(T,L,R).
c(C,X,Y) :- char_code(C,N),i(X),i(Y),Z is X+5*Y+25*(N-65),I is floor(Z/15),O is (Z mod 15),string_code(I,"䙎㹟䘑߯硁䙏縑ԁࠟя摟䠑䠑ᐑ粤Ⴟ䔅┉ё籁垑䙑曓䗱㩑䙏㡏晑䘞䕟㡞縐Ⴄ䙄㩑⩑䒪噑⩊䕤ᅱ粤ࢨ?",V),1 is (V-32)>>O/\1.

Zarların her iki tarafındaki piksellere karşılık gelen koordinatlar kolayca bir 3D koordinat sistemine dönüştürülebilir. Kullanmak T, Lve Rüst (1) için, (2) ve sağ (3) sol taraf. uve vgörüntülerde koordinatlar için kullanılır:

• T :(u,v) -> (4-v, ?, u)
• L :(u,v) -> (?, v, u)
• R :(u,v) -> (u, v, ?)

Her aktif (yani siyah) piksel için sonuçlar, nesnenin görünümünü bu taraftan değiştirmeden etkinleştirilebilen bir "3D piksel" grubuna birleştirilir. Her bir taraf için kümelerin kesişimi, tüm görüntüleri engelleyen pikselleri eklemeden etkinleştirilebilen tüm 3D piksellerdir (yani, en az bir taraftan bakıldığında orada olmaması gereken bir piksel olacaktır).

Geriye kalan tek şey, kesişme noktasında görünümü engelleyen bir piksel olup olmadığını, her bir taraf için kontrol etmektir.

Bu programdaki tahminlere yol açar:

• f : son kontrolü yapar; harfleri üstte, solda ve sağda alır
• u , v ve w : kontrolleri yapın, eğer taraftaki aktif her piksel için kavşakta 3B piksel varsa, görünümü engeller.
• h : kavşakta bir pikselin olup olmadığını kontrol eder
• t , l , r : 3D pikselin üst, sol ve sağ taraftan engellenip engellenemeyeceğini kontrol eder.

• c : Bir harfin görüntüsündeki pikseli kontrol eder. Buradaki dize biraz tuhaf görünebilir, ancak resim verilerini depolamak için sadece küçük bir yoldur. Bu sadece şu değerlere sahip bir karakter dizisidir (onaltılık gösterim):

  [464e,3e5f,4611,7ef,7841,464f,7e11,501,81f,44f,645f,4811,4811,1411,7ca4,10bf,4505,2509,451,7c41,5791,4651,66d3,45f1,3a51,464f,384f,6651,461e,455f,385e,7e10,10a4,4644,3a51,2a51,44aa,5651,2a4a,4564,1171,7ca4,8a8,3f]
  

  Bu karakterlerin her biri 3 piksel satır verilerini harf görüntülerinde saklar (= 15 piksel). Pikseller de yeniden düzenlenir, böylece veriler bir konumda depolanır ve OP verileri gibi birden fazla satıra bölünmez.

Matematiksel formülasyon

Giriş verileri

Bir pikseldeki pikselden, bu pikselin görüntüsünü engelleyen 3B piksel kümesine dönüştürme

Güvenli bir şekilde eklenebilen pikseller (yanlış yerde görüşü engellemeden)

Her iki taraf için de kontrol edilmesi gereken, engellenmesi gereken piksellerin güvenli bir şekilde engellenebileceğini

Her iki taraf için çeklerin kombinasyonu

J - 223 197 191 karakter

Argüman olarak üç karakterli listeyi alan bir fonksiyon.

(_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:

Bu golf, J'nin rütbeli güçlü bir özelliğine dayanıyor ve bu da bize neredeyse bedava olan "sculpt out" ve "watch side" işlemlerini veriyor. Biraz basitleştirmek için rütbe, bir ismin veya fiilin doğal argümanlarının boyutsallığına işaret eder.

J, çok boyutlu dizilere sahiptir ve bir 3D dizisinin tek bir 3D dizisi veya bir matris listesi veya bir 2D vektör dizisi veya bir 3D skalar dizisi olarak yorumlanabileceği açıktır. Böylece J'deki her işlem, argümana nasıl yayılacağını kontrol ederek uygulamalarını kontrol ettirebilir. Rütbe 0, skalerlere uygulanır, rütbe 1, vektörlere uygulanır vb.

   1 + 2 + 3 + 4  NB. add these things together
10
   +/ 1 2 3 4     NB. sum the list by adding its items together
10
   i. 3 4         NB. 2D array, with shape 3-by-4
0 1  2  3
4 5  6  7
8 9 10 11
   +/"2 i. 3 4    NB. add the items of the matrix together
12 15 18 21
   0 1 2 3 + 4 5 6 7 + 8 9 10 11    NB. equivalent
12 15 18 21
   +/"1 i. 3 4    NB. now sum each vector!
6 22 38
   +/"0 i. 3 4    NB. now sum each scalar!
0 1  2  3
4 5  6  7
8 9 10 11

İkili (iki değişkenli) işlevler tanıttığınız zaman bu çok güçlü bir hal alır, çünkü iki bağımsız değişkenin şekilleri (rütbe için hesaba kattıktan sonra) uygunsa, J bazı kapalı döngüleri yapacaktır:

   10 + 1             NB. scalar addition
11
   10 20 30 + 4 5 6   NB. vector addition, pointwise
14 25 36
   10 + 4 5 6         NB. looping! 
14 15 16
   10 20 + 4 5 6      NB. shapes do not agree...
|length error
|   10 20    +4 5 6

Tüm şekilleriniz kabul edilebilir olduğunda ve rütbeyi kendiniz belirleyebildiğinizde, argümanları birleştirmenin birçok yolu vardır. Burada 2B matris ve 3B diziyi çarpma yöntemlerinden bazılarını gösteriyoruz.

   n =: i. 5 5
   n
 0  1  2  3  4
 5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24
   <"2 n *"2 (5 5 5 $ 1)  NB. multiply by 2-cells
+--------------+--------------+--------------+--------------+--------------+
| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|
| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9|
|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|
|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|
|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|
+--------------+--------------+--------------+--------------+--------------+
   <"2 n *"1 (5 5 5 $ 1)  NB. multiply by vectors
+---------+---------+--------------+--------------+--------------+
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
+---------+---------+--------------+--------------+--------------+
   <"2 n *"0 (5 5 5 $ 1)  NB. multiply by scalars
+---------+---------+--------------+--------------+--------------+
|0 0 0 0 0|5 5 5 5 5|10 10 10 10 10|15 15 15 15 15|20 20 20 20 20|
|1 1 1 1 1|6 6 6 6 6|11 11 11 11 11|16 16 16 16 16|21 21 21 21 21|
|2 2 2 2 2|7 7 7 7 7|12 12 12 12 12|17 17 17 17 17|22 22 22 22 22|
|3 3 3 3 3|8 8 8 8 8|13 13 13 13 13|18 18 18 18 18|23 23 23 23 23|
|4 4 4 4 4|9 9 9 9 9|14 14 14 14 14|19 19 19 19 19|24 24 24 24 24|
+---------+---------+--------------+--------------+--------------+

Bunun aslında sorunun istediği yöndeki harflerle oyulmadığını fark edeceksiniz, sadece onları yazıyor ancak sıra mantığı için uygun. Harfleri uygulamadan önce tersine çevirme veya döndürmediğimiz sürece doğru çalışmaz. Ama böyle düzelterek şeyler, değerli karakterler kadar alacağını bunun yerine biz J doğal bunları açmaktadır zaman, öyle ki harfleri kodlamak edeceğiz bazı yüzlerin üçlü doğru yönelimleri ve göreli konumlarında olacaktır. En kısa çözüm, tüm harf biçimlerinin saat yönünün tersine çeyrek tur döndürülmesidir. J'nin önden arkaya ekseni temsil etmek için üçüncü boyutunu göz önüne alarak, aşağıdaki ham diyagram bu şemanın neden işe yaradığını göstermektedir.

_{Şekil A: J'nin oyduğu küpün üç tarafı. Şekil B: Soru gibi yönlendirilmiş harfleri olan üç tarafı soruyor.}

Kodlamadaki bu seçenek, önceki yönteme göre 12 karakter kaydeder ve her şeyi daha düzenli hale getirir. Gerçek golf küpün dışına çıkarır."1 ve "2bağlı alakasız bir optimizasyon için bazı funky mantığı ile oyar.

O zaman yüzleri kontrol etmeliyiz. Biz 1 ve 0'ların olarak blok kodlamak için, biz sadece istediğimiz şekilde her eksen boyunca toplamı (bunlar olabilir +/"1, +/"2ve+/ bit), Boolean (uyum 0<°), ve daha sonra orijinal 90 tüm doğrudan karşılaştırma - açık-harfler.

Sıkıştırma şeması, her harfin her 5px satırını bir ikili sayının temel 32 temsili olarak kodlar. Birkaç sözdizimsel şekerden ve operatör aşırı yüklemesinden yararlanarak, ".'1b',"#:karakter listesini baz 36 sayıya dönüştürmenin en kısa yoludur. Peki, teknik olarak, üs 32, ama J bunun tekdüze olduğunu düşünüyor, yani kim sayıyor?

Kullanım aşağıda. Dizelerin J'deki karakter dizileri olduğuna dikkat edin, bu nedenle kısa bir şekilde üç öğe listesi 'A','B','C'yazılabilir 'ABC'. Ayrıca, boolean'ler 1/0.

   NB. can be used inline...
   (_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:'BEG'
1
   NB. or assigned to a name
   geb=:(_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:
   geb 'BGE'
0

Python, 687 682 671

import itertools as t,bz2
s=range(5)
c=dict([(i,1)for i in t.product(*3*[s])])
z=dict([(chr(i+65),[map(int,bz2.decompress('QlpoOTFBWSZTWXndUmsAATjYAGAQQABgADABGkAlPJU0GACEkjwP0TQlK9lxsG7aomrsbpyyosGdpR6HFVZM8bntihQctsSiOLrWKHHuO7ueAyiR6zRgxbMOLU2IQyhAEAdIJYB0ITlZwUqUlAzEylBsw41g9JyLx6RdFFDQEVJMBTQUcoH0DEPQ8hBhXBIYkXDmCF6E/F3JFOFCQed1Saw='.decode('base64')).split('\n')[j].split()[i])for j in s])for i in range(26)])
def m(a,g):
 for e in c:c[e]&=g[e[a]][e[a-2]]
def f(a):
 g=map(list,[[0]*5]*5)
 for e in c:g[e[a]][e[a-2]]|=c[e]
 return g
r=lambda g:map(list,zip(*g)[::-1])
def v(T,L,R):T,L,R=r(r(z[T])),r(z[L]),z[R];m(1,T);m(2,L);m(0,R);return(T,L,R)==(f(1),f(2),f(0))

İle ara v:

v('B','E','G') => True
v('B','G','E') => False

Aşağıdaki her şey, yararlı çizim işlevlerini içeren eski sürümümden. Bir atlama noktası olarak kullanmaktan çekinmeyin.

import string as s
import itertools as t

az = """01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111""".split('\n')

dim = range(len(az))
az = dict([(c, [map(int, az[j].split()[i]) for j in dim]) for i, c in enumerate(s.uppercase)])
cube = dict([(i, 1) for i in t.product(*3*[dim])])

def mask(axis, grid):
    for c in cube:
        if not grid[c[axis]][c[axis - 2]]:
            cube[c] = 0

def face(axis):
    grid = [[0 for j in dim] for i in dim]
    for c in cube:
        if cube[c]:
            grid[c[axis]][c[axis - 2]] = 1
    return grid

def rot(grid):
    return map(list, zip(*grid)[::-1])

def draw(grid, filled='X', empty=' '):
    s = ''
    for y in dim:
        for x in dim:
            s += filled if grid[y][x] else empty
        s += '\n'
    print s

def drawAll():
    print 'TOP:\n'
    draw(rot(rot(face(1))))
    print 'LEFT:\n'
    draw(rot(rot(rot(face(2)))))
    print 'RIGHT:\n'
    draw(face(0))

def valid(top, left, right):
    top, left, right = rot(rot(az[top])), rot(az[left]), az[right]
    mask(1, top)
    mask(2, left)
    mask(0, right)
    return top == face(1)and left == face(2) and right == face(0)

letters = 'BEG'

if valid(*letters):
    print letters, 'is valid.\n'
else:
    print letters, 'is not valid!\n'

drawAll()

Aramak validÇalıştırmak için :

valid('B', 'E', 'G') #returns True
valid('B', 'G', 'E') #returns False

Şu anda kod geçerliliğini test etmek için ayarlandı B E G ve ortaya çıkan yüzleri yazdırmak :

BEG is valid.

TOP:

XXXX 
X   X
XXXX 
X   X
XXXX 

LEFT:

XXXXX
X    
XXX  
X    
XXXXX

RIGHT:

XXXXX
X    
X  XX
X   X
XXXXX

Çalıştırırken B G EG'nin yanlış olduğunu görebiliriz:

BGE is not valid!

TOP:

XXXX 
X   X
XXXX 
X   X
XXXX 

LEFT:

XXXXX
X    
X  XX
X    
XXXXX

RIGHT:

XXXXX
X    
XXX  
X    
XXXXX

Python 3 + numpy, 327C

from numpy import*
B=hstack([ord(x)>>i&1for x in'옮弟ჹ羂옱쏷）ជ࿂︹缘龌ℿ쓥剴ℌᾄ起츱ꎚㆋឺ௣옮忬⧼ﯠႄ挒⺌ꕆ豈ꪱ袨冊䈑∾Ϣ'for i in range(16)])[:-6].reshape(26,5,5)
T=transpose
def f(*X):
 A=ones((5,5,5));F=list(zip([A,T(A,(1,0,2)),T(fliplr(A),(2,0,1))],[B[ord(x)-65]for x in X]))
 for r,f in F:r[array([f]*5)==0]=0
 return all([all(r.sum(0)>=f)for r,f in F])

Bu golf çözümünün oldukça popüler olan harici bir kütüphaneye ihtiyacı var, bu yüzden onu kullanmanın iyi olduğunu düşünüyorum.

Unicode string 41 karakterde, @ fabian'ın prolog cevabında aynı şey 44.

Buradaki en ilginç olan, numpy dizisinin endekslenmesidir. In a[ix]ile ixaynı şekilde bir boolean dizisi olabilir a. Söylemekle aynı şeya[i, j, k] where ix[i, j, k] == True .

Ungolfed Sürümü

import numpy as np
table = '옮弟ჹ羂옱쏷）ជ࿂︹缘龌ℿ쓥剴ℌᾄ起츱ꎚㆋឺ௣옮忬⧼ﯠႄ挒⺌ꕆ豈ꪱ袨冊䈑∾Ϣ'

def expand_bits(x):
    return [ord(x) >> i & 1 for i in range(16)]

# B.shape = (26, 5, 5), B[i] is the letter image matrix of the i(th) char
B = np.hstack([expand_bits(x) for x in table])[:-6].reshape(26, 5, 5)

def f(*chars):
    """
    cube:    ----------   axis:           
            /         /|      --------->2  
           /   1     / |     /|            
          /         /  |    / |            
         /         /   |   /  |            
        |---------|  3 |  v   |           
        |         |    /  1   |           
        |    2    |   /       v          
        |         |  /        0         
        |         | /                  
        -----------
    """
    cube = np.ones((5, 5, 5))
    cube_views = [
        cube,
        cube.transpose((1, 0, 2)),  # rotate to make face 2 as face 1
        np.fliplr(cube).transpose(2, 0, 1),  # rotate to make face 3 as face 1
    ]
    faces = [B[ord(char) - ord('A')] for char in chars]
    # mark all white pixels as 0 in cube
    for cube_view, face in zip(cube_views, faces):
        # extrude face to create extractor
        extractor = np.array([face] * 5)
        cube_view[extractor == 0] = 0

    return np.all([
        # cube_view.sum(0): sum along the first axis
        np.all(cube_view.sum(0) >= face)
        for cube_view, face in zip(cube_views, faces)
    ])

Tabloyu sıkıştırmak için komut dosyası

import numpy as np

def make_chars():
    s = """
01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111
""".strip().split('\n')
    bits = np.zeros((26, 5, 5), dtype=np.bool)
    for c_id in range(26):
        for i in range(5):
            for j in range(5):
                bits[c_id, i, j] = s[i][j + c_id * 7] == '1'
    bits = np.hstack([bits.flat, [0] * 7])
    bytes_ = bytearray()
    for i in range(0, len(bits) - 8, 8):
        x = 0
        for j in range(8):
            x |= bits[i + j] << j
        bytes_.append(x)
    chars = bytes_.decode('utf16')
    return chars