Giriş

İçki içip dünya kupasını izlerken geçen bir günün ardından, dost canlısı bir boggle oyunu oynayabilirsiniz. Herkesin vaktini tahtada olmayan saçma kelimelerle boşa harcamakla suçlandığınız için öfke artıyor! İkili görüyorsunuz, ancak elbette, kelimelerinizin tahtada olduğunu doğrulayacak bir program yazmanız için yeterince düz düşünüyorsunuz.

Senin görevin

Bir reklam panosu ve bir kelimeyi girdi olarak alan bir program, komut dosyası veya işlev yazın ve eğer kelime tahtadaysa True, kelimesi değilse False döndürür.

Girdi, \nayrılmış altı çizgi şeklinde olacaktır . İlk beş satır 5x5 boggle board'lardan oluşacak ve her biri beş büyük harf içerecektir. Altıncı satır, söz konusu kelimeyi tüm büyük harflerle de içerecektir.

Örnek giriş:

AJNES
TNFTR
LSAIL
UDNEX
EQGMM
DAFTER

Çıktı, seçtiğiniz programlama dilinizde açıkça veya Yanlış olarak belirten ve sıfır, boş ve boş belirten False standart kurallarına uyan herhangi bir şey olabilir.

Yukarıdaki giriş için örnek çıktı:

1

G / Ç Kuralları

• Giriş, stdin'den okunabilir ve çıktıyı stdout'a cevaplayabilir.

Veya

• Girdi, bir işleve tek bir dize argümanı olabilir ve bu işlevin dönüş değeri cevap olabilir.

Boggle Kuralları

• Bir kelime 'tahtada' dır, eğer kelimeyi tahta üzerinde ardışık, bitişik, tekrar etmeyen döşemeler yoluyla oluşturabilirseniz.
• Onu çevreleyen sekiz döşemeye bitişik bir döşeme olarak kabul edilir (diyagonal yollara izin verilir). Tahtanın kenarındaki fayanslar sadece beş fayansa bitişiktir. Köşedeki fayanslar sadece üçe bitişik.
• Kelimesinde Ardıl harfleri bitişik olmalı, ikelime inci mektup bitişik olmalıdır i-1th ve i+1inci.
• Bir harf bir kelimede bir defadan fazla görünebilir, ancak boggle board üzerindeki aynı kareyi kelime başına bir defadan fazla kullanamazsınız.
• Çevrimiçi boggle sitesi wordsplay.net , daha önce hiç boggle oynamadıysanız, ancak bu kurallar hakkında fikir edinmek istiyorsanız yararlı olabilir.

Düzenli boggle aksine:

• Kelimenin geçerli bir ingilizce kelime olduğu konusunda endişelenmenize gerek yok.
• YOK Qutek kiremit olmayacak .
• Söz konusu kelime herhangi bir uzunlukta olabilir> 0

Örnek

Tahtada

AJNES
TNFTR
LSAIL
UDNEX
EQGMM

Bu kelimeler True döndürmelidir: FATE, DATING, STANDS, LIFTS.

Bu kelimeler False döndürmeli: SADDEN, SULTANS, EXIST, SUEDE, QUEST

Bu bir kod golf mücadelesidir, bu yüzden en kısa kod kazanır!

GolfScript, 74 karakter

:^n%5>)]){{^@==}+29,\,{{+}+1$/}%\;}/{:s$..&=[s{.@-\}*;]1567`{7&.~)}%-!&},,

Giriş STDIN'de verilmelidir. Tahtadaki geçerli yolların sayısını, yani 0hiçbiri ve pozitif bir sayı (doğru) için yazdırır .

Örneği çevrimiçi olarak test edebilirsiniz .

Bazı yorumları içeren kod:

:^              # assign the input to variable ^
n%              # split at newlines
5>              # truncate array such that [WORD] remains
)])             # prepares [[]] and WORD on the stack

# the following loop generates all possible paths (valid and invalid ones)
# by looking up all index combinations which yield the correct word
{               # loop over all characters
  {^@==}+29,\,  # get all indices of current character in the board
  {{+}+1$/}%\;  # append any index to all lists in the result set
}/              # end loop

# filter the results list for valid paths
{               # {...}, -> apply filter
  :s            # save path to variable s
  $..&=         # check if all numbers in path are unique
  [s{.@-\}*;]   # calculate differences along the path
  1567`{7&.~)}% # generate the array [1 -1 5 -5 6 -6 7 -7] of valid
                # differences
  -!            # check if all differences were valid
  &             # are both conditions fulfilled?
},              # end of filter block

,               # count the number of remaining paths

Javascript (E6) 137 160 175 190

2'den az * Golfscript. Ahlaki zafer ...

F=a=>[...a].some((e,p,b)=>(Q=(p,n)=>p>29||b[p]!=b[n]||(b.r|=!b[++n])||(b[p]=b[n+~[1,5,6,7].map(q=>Q(p+q,n)|Q(p-q,n),b[p]=0)]))(p,30)&b.r)

Düzenleme golfed kod reorganizasyon. Tekrar ve tekrar

Ungolfed Son sürüm, takip etmek biraz zor

F = a => 
  [...a] // input string to array, 30 chars of board then the target word
  .some ( // use some to scan the board, return true when found
      (e,p,b)=> // params to callback: element, position, complete array 
      (         // NB array b has no .r property, so use it for return value (it's undefined at start) 
        Q = (p,n) =>         // Scan function, p=position in board, n=nth char of target word
          p > 29 ||          // Chaek if going outside the board to the target word
          b[p] != b[n] ||    // if invalid char at current position, return
          (b.r |= !b[++n]) ||  // if at end of target, set r to 1 and return (also increment n )
          (                  // else... (NB next tree lines are coalesced in golfed code)
            b[p] = 0,        // remove current char (to avoid reusing) 
            [1,5,6,7].map( q => Q(p+q,n)|Q(p-q,n)), // recursive call for + - 1,5,6,7
            b[p] = b[n-1]    // put current char into array again 
          )
      )(p,30) & b.r // initial position 0 in target word is 30 in the array
  ) 

Ungolfed İlk versiyon, daha net olmalı

F = a => (
  b = a.split('\n'),
  w = b.pop(),
  r = 0,
  Q = (p, n) => 
    (r |= !w[n]) || 
    (
      b[p] = 0,
      [1,5,6,7,-1,-5,-6,-7].map( q => b[q+=p]==w[n] && Q(q,n+1)),
      b[p] = w[n-1]
    ),
  b = [...b+''],
  b.map((e, p) => e==w[0] && Q(p,1)),
  r
)

kullanım

F("AJNES\nTNFTR\nLSAIL\nUDNEX\nEQGMM\nLIFTS\nDAFTER")

Ölçek

['DAFTER', 'STANDS', 'LIFTS', 'FATE', 'DATING' ,
 'SADDEN','SULTANS', 'EXIST', 'SUEDE', 'QUEST']
.map(w => [w, F("AJNES\nTNFTR\nLSAIL\nUDNEX\nEQGMM\n" +w)])

Çıktı:

[["DAFTER", true], ["STANDS", true], ["LIFTS", true], ["FATE", true], ["DATING", true], 
["SADDEN", false], ["SULTANS", false], ["EXIST", false], ["SUEDE", false], ["QUEST", false]]

Python, 207 204 203

g=raw_input
r=range
b=''.join(g()for _ in r(5))
w=g()
s=lambda b,w,i:0<=i<25and(not w or(b[i]==w[0])*any(s(b[:i]+'_'+b[i+1:],w[1:],i+j+k*5-6)for j in r(3)for k in r(3)))
print any(s(b,w,i)for i in r(25))

İle değiştirmek , 2 karakter maliyeti ... (b[i]==w[0])*any ...ile ... b[i]==w[0]and any ...çok daha iyi performans verir.

J - 75 karakter

Eugh, bu kötü görünüyor. Ve hatta Golfscript ile bağlama bile! Bu, tek argüman olarak dize alan bir fonksiyondur. Herhangi bir karakter sınırlayıcısını, son satır dahil, her satırın sonunda bulunduğu sürece kullanabilirsiniz.

+/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2)

Bir açıklama izler. Fonksiyonun, her biri birbirinden ayrılmış 5 ayrı üst seviye parçaya bölünebileceğini unutmayın @, bu yüzden bu parçaların her birine sağdan sola ayrı ayrı davranacağız.

• (<;._2)- Bu satırları yeni satırlara / ayırıcı karakterlere böler. Dizenin sonundaki karakteri, bölüneceği karakter olarak kullanır. Her şeyi kutulara ( <) koyarız çünkü J bize sonucu verirken bazı doldurma sorunları yaşamadık.

• (((<@#:i.)5 5)<@#~&,"2{:=/&:>}:) - Kontrol edilecek kelimedeki her harf için, Boggle tahtasında bu mektubu bulabileceğiniz bir indeks listesi oluşturun.

  • {:son parça (kontrol edilecek kelime) ve }:sonuncusundan başka bir şey (Boggle kurulu).

  • &:>}:2D karakter dizisine dönüşmenin yararlı yan ürünleri ile daha önce yaptığımız kutuları açar . =/daha sonra bu Boggle tahtasının bir kopyasını kelimedeki her bir harf için hazırlar ve tahtadaki harfin bu harfle aynı kelimeye uyup uymadığına bağlı olarak pozisyonları boolean'a çevirir.

  • ((<@#:i.)5 5)5x5 indeks dizisini ifade etmenin kısa bir yoludur. temel gösterimin bir dizisine x#:ydönüştürülür . (Neredeyse. Gerçek daha karmaşık, ama bu bizim amaçlarımız için işe yarıyor.)yx

  • <@#~&,"2- Her mektubun sonuçlanan boolean matrisi için, karşılık gelen tüm doğru endeksleri bir araya toplayın. "2her şeyin doğru sonuçlar üzerinde çalışmasını sağlar #~&,, seçim yapar ve <@her sonucu bir sonraki adıma hazırlamak için bir kutuya toplar.

• {- Tek taraflı olarak kullanılan bu fiili Katalog olarak adlandırır ve argüman olarak kutuların bir listesini alır. Her kutunun içini mümkün olan her şekilde birleştirir. Bu nedenle, örneğin "AB" ve "abc" dizilerini içeren bazı kutulardaki bir katalog "Aa", "Ab", "Ac", "Ba", "Bb", "Bc" sonuçlarını verir.

  Bunu, kutulu indeks listemizde yayınlamak, her indeks kombinasyonunu mümkün kılar. Eğer kelime uzunsa ve tekrarlanan birçok harf varsa bu büyük bir set olabilir, fakat tahtada herhangi bir harf yoksa boş. Ayrıca, döşemeleri şu yollardan bazılarında yeniden kullandığımızı da not ediyoruz: bunu daha sonra hesaba katacağız.

• ([:*/"1^:2(2(=*)@-/\>@~.)S:1) - Burada geçerli olup olmadığını görmek için her yolu kontrol ediyoruz.

  • (...)S:1(...)her yola uygular ve sonuçları düz bir liste halinde toplar. Bu çok önemlidir, çünkü sonucu {çok boyutlu bir dizidir ve bu dizinin yapısını, sadece her bir kutudaki içeriğini umursamıyoruz.

  • 2(=*)@-/\>her bir dizinin her koordinatı, onu izleyenden en fazla bir uzaktaysa 1, aksi takdirde 0 verir. 2Ve /\bu çiftler halinde yapıyor sorumludur.

  • */"1^:2mantıksal-AND hepsi sonunda sonunda. [:Bölüm bu konuda endişelenmeyin, J yapısal bir şeydir.

  • Ekleme @~.için >aslında tekrarlanan girişleriyle yolları hariç tutmak için bir akıllı yoldur. ~.Bir listenin benzersiz öğelerini alır, böylece kendiliğinden kesişirse liste kısalır ve kısa listeler, sonuçlar ortaya çıktıkça birleştirildiği gibi, bir araya getirildiğinde 0'larla otomatik olarak doldurulur S:. Bu sonuçta, kendiliğinden kesişen yolları açıkça dışlamaktan daha kısadır.

• +/- Sonunda, sonunda her şeyi bir araya getiriyoruz. Sonuç, tahtadaki kelimeyi yapan geçerli yolların sayısıdır; 0, hiçbir yol anlamına gelir, yani bu kelime tahtada değildir. Bir karakterin maliyeti için yazabiliriz +./(mantıklı-herşeyi birlikte ORing) bunun yerine açıkça bir boole 1 veya 0 verecek.

İşte bazı örnek çalışmalar. J tercümanını jsoftware.com adresinden edinebilir veya çevrimiçi olarak tryj.tk adresinde deneyebilirsiniz .

   NB. the  0 : 0 ... )  thing is how you do multiline strings in J
   +/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2) 0 : 0
AJNES
TNFTR
LSAIL
UDNEX
EQGMM
DAFTER
)
1
   b =: +/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2)
   b 'AJNES TNFTR LSAIL UDNEX EQGMM FATE '    NB. any separator will do
1
   b 'AJNES TNFTR LSAIL UDNEX EQGMM SADDEN '  NB. not on the board
0
   b 'AJNES TNFTR LSAIL UDNEX EQGMM SANDS '   NB. self-intersecting path
0
   b 'AJNES TNFTR LSAIL UDNEX EQGMM MEND '    NB. multiple paths
2

Prolog - 315

r(L):-get_char(C),(C='\n',!,L=[];r(T),L=[C|T]).
b(0,[]):-!.
b(N,[R|T]):-M is N-1,r(R),b(M,T).
d(-1). d(0). d(1).
d([A,B],[C,D]):-d(X),C is A+X,d(Y),D is B+Y.
f([L|W],B,P,U):-P=[X,Y],nth(Y,B,R),nth(X,R,L),\+member(P,U),(W=[];d(P,Q),f(W,B,Q,[P|U])).
m:-b(5,B),r(W),f(W,B,_,[]),write(t);write(f).
:-initialization(m).

Prolog'un yerleşik geri izleme desteğiyle bunun için iyi bir dil olabileceğini düşündüm, ancak sanırım hemen hemen her hesaplanan değer için bir değişkene ihtiyaç duyularak daha fazla engellendi.

GNU Prolog ile test edilmiştir; ISO Prolog ile uyumlu olmalıdır.

Ungolfed:

get_line(Line) :-
    get_char(C),
    (   C='\n', !, Line=[]
    ;   get_line(Tail), Line=[C|Tail]
    ).

% The cut prevents recursion to help_get_board(-1, MoreRows)
% (and golfs one character shorter than putting N>0 in the second rule).
help_get_board(0, []) :- !.
help_get_board(N, [Row|Tail]) :-
    M is N-1, get_line(Row), help_get_board(M, Tail).

% The golfed version doesn't define an equivalent to get_board/1.
% help_get_board(5,Board) is used directly instead.
get_board(Board) :- help_get_board(5,Board).

small(-1). small(0). small(1).
step([X1,Y1],[X2,Y2]) :-
    small(DX), X2 is X1+DX,
    small(DY), Y2 is Y1+DY.

% The golfed version doesn't define an equivalent to letter_at/3.
% See find_word/4.
letter_at([X,Y], Letter, Board) :-
    nth(Y, Board, Row),
    nth(X, Row, Letter).

find_word([Letter|Word], Board, Pos1, Used) :-
%    letter_at(Pos1, Letter, Board),  % "inlined" to next three lines:
    ( Pos1 = [X,Y],
      nth(Y, Board, Row),
      nth(X, Row, Letter) ),
    \+member(Pos1, Used),
    (   Word=[]
    ;
        step(Pos1, Pos2),
        find_word(Word, Board, Pos2, [Pos1|Used])
    ).

main :-
    get_board(Board),
    get_line(Word),
    % Begin at any position. Initially no positions are "Used".
    find_word(Word, Board, _, []).