Schreiben Sie eine Funktion, die zwei Parameter akzeptiert: eine positive Ganzzahl n und eine Liste von Wörtern.

Weisen Sie bei einem Würfel von n- mal- n- mal- n- Einheiten jeder Oberflächeneinheit einen zufälligen Buchstaben (AZ) zu. (Für einen 3x3x3-Würfel gibt es 9 Oberflächeneinheiten auf jeder Seite.)

Bestimmen Sie dann, ob eine Ameise, die über die Oberfläche läuft (mit der Fähigkeit, Gesichter zu kreuzen), jedes der angegebenen Wörter buchstabieren kann. Angenommen, um ein Wort zu buchstabieren, müssen die Buchstaben oben / unten oder links / rechts nebeneinander sein, aber nicht unbedingt auf derselben Seite. [ Zur Verdeutlichung bearbeiten: Die Ameise kann ihren Pfad umkehren und Buchstaben mehrmals verwenden. Jede Oberflächeneinheit zählt als ein Zeichen. Um ein Wort mit wiederholten Buchstaben (z. B. "sehen") zu buchstabieren, müsste die Ameise drei benachbarte Einheiten besuchen.]

Die Funktion sollte zwei Dinge ausgeben:

1) Jeder der Buchstaben auf jeder Seite, so dass die Topologie abgeleitet werden kann. Für einen 2x2x2-Würfel würde beispielsweise eine akzeptable Ausgabe folgendermaßen aussehen:

   QW
   ER
TY OP UI
DF JK XC
   AS
   GH
   LZ
   VB

2) Jedes der Wörter zusammen mit einem Booleschen Wert, der angibt, ob die Ameise das Wort buchstabieren kann, indem sie über die Oberfläche des Würfels läuft. Zum Beispiel:

1 ask
0 practical
1 pure
0 full

Bonus-Herausforderung (wird nicht nur zum Spaß in die Punktzahl einbezogen): Anstatt n nur die Größe des Würfels darzustellen , soll n auch die Dimensionalität der Form darstellen. Ein n von 2 würde also ein 2x2-Quadrat ergeben; ein n von 3 würde einen 3x3x3-Würfel ergeben; und ein n von 4 würde einen 4x4x4x4-Tesserakt ergeben.

Ruby, 272 Bytes

Zu beiden Seiten der verschachtelten Funktion werden dem Code zwei unnötige Zeilenumbrüche hinzugefügt g, um die Lesbarkeit zu verbessern. Diese sind von der Partitur ausgeschlossen. Die Zeichen f=, die einer Variablen die anonyme Funktion zuweisen, werden ebenfalls ausgeschlossen.

Das Ausgabeformat ist 0oder 1gemäß der Frage anstelle von Rubys nativem trueund false. Eine neue Zeile (anstelle eines Leerzeichens) wird verwendet, um den Booleschen Wert und das Wort zu trennen. Mein Verständnis ist, dass dies eine akzeptable Interpretation der Ausgabeanforderungen ist, aber wenn nicht, wäre die Auswirkung auf die Byteanzahl gering.

f=->n,l{c=''
x=[p=6*n,1,-p,-1]
(m=3*p*n).times{|i|c<<(5+i/n%6-i/n/p&6==6?65+rand(26):i%p==p-1?10:46)}
q=m+3*n
puts c

g=->w,i,d{w==''?$r=1:c[i]<?A?g[w,(i+x[d])%q,d^1]:w[0]==c[i]&&4.times{|j|g[w[1..-1],(i+x[j])%q,j^1]}}

l.each{|w|$r=0
m.times{|i|c[i]>?@&&g[w,i,0]}
puts $r,w}}

Ausgabe

Nach ungefähr 50 Anrufen wie folgt:

f[4,['PPCG','CODE','GOLF','ANT','CAN','CUBE','WORD','WALK','SPELL']]

Ich habe endlich die folgende Ausgabe mit 2 Treffern bekommen. ANTist unten rechts und geht nach oben, und das ANwird geteilt CAN, wobei die CUmhüllung oben links ist.

....KCAAXRHT...........
....ALRZXRKL...........
....NDDLCMCT...........
....ETQZHXQF...........
........FYYUSRZX.......
........CFNPAUVX.......
........ZTJVHZVQ.......
........AUWKGVMC.......
............XWKSDWVZ...
............DPLUVTZF...
............DMFJINRJ...
............ZRXJIAFT...
0
PPCG
0
CODE
0
GOLF
1
ANT
1
CAN
0
CUBE
0
WORD
0
WALK
0
SPELL

Erläuterung

Die besondere Entfaltung des ausgewählten Würfels wurde teilweise aufgrund seiner einfachen Zeichnung, hauptsächlich aber aufgrund seiner einfachen Suche ausgewählt.

Die Nicht-Alphabet-Zeichen (die Punkte plus die neue Zeile am Ende jeder Zeile) sind ein wichtiger Teil des Feldes, in dem sich die Ameise beim Gehen befindet.

Die Suche wird von der rekursiven Funktion durchgeführt g, die in der Funktion verschachtelt ist f. Wenn das übergebene Wort eine leere Zeichenfolge ist, ist die Suche abgeschlossen und $rauf 1 gesetzt. Befindet sich die Ameise auf einem Buchstabenquadrat, das dem ersten Buchstaben des Wortes entspricht, wird die Suche in alle vier Richtungen fortgesetzt: Die Funktion wird erneut aufgerufen mit dem Wort verkürzt durch Entfernen des ersten Buchstabens. In diesem Fall wird der Richtungsparameter ignoriert. Das Verschieben erfolgt durch rekursives Aufrufen mit dem durch die Werte in geänderten Zellenindex. x.Das Ergebnis der Addition wird modulo der Größe des Gitters plus einer zusätzlichen halben Linie genommen. Dies bedeutet, dass die untere Linie mit dem richtigen horizontalen Versatz nach oben und umgekehrt gewickelt wird.

Befindet sich die Ameise auf einem Nicht-Buchstaben-Quadrat, muss sie sich im Zickzack in einer Treppenbewegung bewegen, bis sie ein Buchstaben-Quadrat findet. Sie wird in südöstlicher oder nordwestlicher Richtung zizagieren. Dies wird durch rekursive Aufrufe simuliert, wobei der dParameter jedes Mal mit 1 XOR-verknüpft wird, um ihre Bewegung zu verfolgen. Bis sie das nächste Buchstabenquadrat erreicht, wird das eingegebene Wort nicht verkürzt. Praktischerweise kann dies durch dieselbe Rekursion erfolgen, die verwendet wird, wenn wir in dem Bereich mit Buchstaben suchen. Der Unterschied besteht darin, dass die Rekursion nur einen Zweig hat, wenn sich die Ameise im Leerzeichenbereich befindet, im Gegensatz zu 4 im Buchstabenbereich.

Kommentierter Code

->n,l{                                   #n=square size, l=list of words to search
  c=''                                   #empty grid
  x=[p=6*n,1,-p,-1]                      #offsets for south, east, north, west. p is also number of characters per line
  (m=3*p*n).times{|i|                    #m=total cells in grid. for each cell
    c<<(5+i/n%6-i/n/p&6==6?              #apppend to c (according to the formula)
      65+rand(26):                       #either a random letter
      i%p==p-1?10:46)                    #or a "whitespace character" (newline, ASCII 10 or period, ASCII 46)
  }
  q=m+3*n                                #offset for vertical wraparound = grid size plus half a row.                           
  puts c                                 #print grid

  g=->w,i,d{                             #search function. w=word to search for, i=start index in grid, d=direction
    w==''?                               #if length zero, already found,
      $r=1:                              #so set flag to 1. Else
      c[i]<?A?                           #if grid cell is not a letter
        g[w,(i+x[d])%q,d^1]:             #recursively call from the cell in front, with the direction reflected in NW-SE axis
        w[0]==c[i]&&                     #else if the letter on the grid cell matches the start of the word
          4.times{|j|                    #for each direction (iterate 4 times, each time a different direction is "in front")
            g[w[1..-1],(i+x[j])%q,j^1]}  #recursively call from the cell in front. Chop first letter off word. 
   }                                       #Direction parameter is XORed (reflected in NW-SE axis) in case ant hits whitespace and has to zigzag.

   l.each{|w|                            #for each word in the list
     $r=0                                #set global variable $r to zero to act as a flag
     m.times{|i|c[i]>?@&&g[w,i,0]}       #call g from all cells in the grid that contain a letter 
     puts $r,w}                          #output flag value and word
}