Nach Ihrer katastrophalen Kanufahrt sind Sie am Ende der Stromschnellen von einem Wasserfall gefallen. Ihr Kanu explodierte, aber Sie haben es geschafft, die Explosion zu überleben. Ihre Flussreise ist jedoch völlig von der Landkarte verschwunden - Sie haben sich jetzt inmitten eines Waldes verloren. Glücklicherweise haben Sie immer noch Ihre Programmierkenntnisse und beschließen, ein Programm in die Seite eines Baumes zu schnitzen, um sich im Wald zurechtzufinden. Der Baum hat jedoch nicht viel Oberfläche, daher müssen Sie Ihr Programm so kurz wie möglich halten.

Die Gesamtstruktur kann als nby n( n > 5) -Zeichen von Zeichen beschrieben werden, das nur aus Kleinbuchstaben besteht a-z. Ein Beispielwald:

anehcienwlndm
baneiryeivown
bnabncmxlriru
anhahirrnrauc
riwuafuvocvnc
riwnbaueibnxz
hyirorairener
ruwiiwuauawoe
qnnvcizdaiehr
iefyioeorauvi
quoeuroenraib
cuivoaisdfuae
efoiebnxmcsua

Möglicherweise haben Sie bemerkt, dass in diesem Wald eine diagonale Linie von aZeichen von der oberen linken Ecke zur unteren rechten Ecke verläuft. Dies ist ein "Weg" durch den Wald, der Sie irgendwohin führt, wenn Sie ihm folgen. Ihre Aufgabe ist es, ein Programm zu schreiben, das den singulären Pfad findet. Ich werde jetzt genauer beschreiben, was einen "Weg" in dieser Herausforderung bedeutet.

Ein "Pfad" in dieser Herausforderung wird als eine Linie definiert, die einer ähnelt, die möglicherweise mit einem Bresenham-Algorithmus generiert wurde , jedoch mit den zusätzlichen Anforderungen, dass:

• Die Zeile muss mindestens 6 Zeichen lang sein
• Jede kollineare (vollständig benachbarte) Gruppe von Zeichen in der Zeile muss dieselbe Länge haben .
• Es beginnt an einem Waldrand und endet am gegenüberliegenden Waldrand (siehe meinen Kommentar hier für die Ausarbeitung).

Betrachten Sie die folgende Zeile, um die zweite Anforderung klarer zu erläutern:

aaa
   aaa
      aaa
         aaa
            aaa

Diese Zeile besteht aus kollinearen "Segmenten" von Zeichen, von denen jedes genau drei Zeichen lang ist. Es qualifiziert sich als Pfad. Betrachten Sie nun diese Zeile:

a
 aa
   a
    aa
      a
       aa

Diese Zeile besteht aus kollinearen "Segmenten", die nicht alle genau die gleiche Länge von Zeichen haben (einige von ihnen sind 1 Zeichen lang und einige von ihnen sind 2). Somit qualifiziert sich dieser nicht als Pfad.

Ihr Programm identifiziert anhand einer Karte der Gesamtstruktur die im Pfad verwendeten Zeichen. Die Eingabe erfolgt nach Belieben (z. B. Befehlszeilenargument, STDIN prompt()usw.). Es kann nicht in eine Variable vorinitialisiert werden. Der erste Teil der Eingabe ist eine einzelne Ganzzahl, ndie die Größe des Waldes darstellt (der Wald ist immer ein Quadrat). Danach ist ein Leerzeichen und dann die gesamte Gesamtstruktur als einzelne Zeichenfolge. Zum Beispiel würde der Beispielwald als Eingabe wie folgt dargestellt:

13  anehcienwlndmbaneiryeivownbnabncmxlriruanhahirrnraucriwuafuvocvncriwnbaueibnxzhyirorairenerruwiiwuauawoeqnnvcizdaiehriefyioeorauviquoeuroenraibcuivoaisdfuaeefoiebnxmcsua

Die Ausgabe hierfür wäre:

a

weil der Pfad mit dem Buchstaben gebildet wird a. Es wird nur einen Weg im Wald geben. Dies ist Code Golf, also gewinnt die niedrigste Anzahl von Charakteren. Wenn Sie Fragen haben, fragen Sie in den Kommentaren.

APL (Dyalog 14) (70)

⎕ML←3⋄Z/⍨1=≢¨Z←∪¨(↓⍉F),(↓F),{(⍳≢⍵)⌷¨↓⍵}¨(⊂F),⊂⌽F←⊃{⍵⍴⍨2/⍎⍺}/I⊂⍨' '≠I←⍞

Erläuterung:

• ⎕ML←3: set MLto 3, Bedeutung ⊂hat ihre APL2-Bedeutung.
• I←⍞: Lesen Sie eine Zeile von der Tastatur und speichern Sie sie in I
• I⊂⍨' '≠I: Iauf die Felder teilen
• {... }/: Wenden Sie diese Funktion auf die beiden resultierenden Zeichenfolgen an:
  • 2/⍎⍺: Bewerten Sie das linke Argument und replizieren Sie es zweimal, wobei Sie die Matrixgröße angeben
  • ⍵⍴⍨: Formatieren Sie das richtige Argument mit dieser Größe
• F←⊃: entpacke es und speichere es in F.
• {(⍳≢⍵)⌷¨↓⍵}¨(⊂F),⊂⌽F: Erhalte die Diagonalen: Erhalte aus jeder Zeile in beiden Fund ⌽F(vertikal gespiegelt F) den Wert in Spalte X, wobei X die Zeilennummer ist
• (↓⍉F),(↓F),: Holen Sie sich die Zeilen und Spalten von F
• Z←∪¨: Finden Sie die eindeutigen Werte für jede Zeile, Spalte und Diagonale und speichern Sie sie in Z.

Da der 'Wald' rechteckig ist, bedeutet ein gültiger Pfad, dass einer dieser Pfade nur aus einem Zeichen besteht, nämlich dem Pfadzeichen.

• Z/⍨1=≢¨Z: Nehmen Sie diese Subarrays Z, die nur ein Element haben.

Dies zeigt die Zeichen für alle gültigen Pfade an, aber da es nur einen geben sollte, spielt das keine Rolle.

Lua - 506 380 - Bytes

Ich fühlte mich irgendwie schlecht, dass Sie keine Einsendung für Ihre gut durchdachte Herausforderung erhalten hatten, also habe ich das zusammengeschmissen. Es hat Spaß gemacht, aus den von Ihnen angegebenen Informationen zu schließen, welche unterscheidbaren Eigenschaften der Pfad mindestens haben muss. Ich hoffe ich habe es richtig gemacht ... UND richtig umgesetzt.

a=io.read"*l"n=a:match("%d+")+0 m=a:match"[a-z]+"o=""for i=1,n do for k=1,n^2,n do o=o..m:sub(i+k-1,i+k-1)end end q={m,o}for g=1,n^2 do for u=1,2 do l=q[u]:sub(g,g)for r=1,n do i=1 t=0 e=0 while i do s,e=q[u]:find(l:rep(r),e+1)if s then x=s-(e-s)-i-1 print(s,i,r,n,r)if x==n or x==n-2 or t==0 then t=t+1 i=s end else i=nil end end if t*r==n then print(l)os.exit()end end end end

Es kann getestet werden mit:

lua divisorPath.lua "input"

Wenn ein wilder Herausforderer auftaucht, werde ich versuchen, meinen Code für das zu spielen, was er wert ist.

Update : Golf zu Ehren derer, die sich über uns erheben werden. Während ich dabei war, musste ich meinen Code auf den erkannten Pfad von rechts nach links korrigieren. Hoppla.

MATLAB - 270 Zeichen

Im Folgenden wird eine Funktion definiert x, die eine Gesamtstrukturzeichenfolge als Argument akzeptiert und das Zeichen zurückgibt, das den gültigen "Pfad" durch die Gesamtstruktur gemäß den angegebenen Regeln darstellt.

function F=x(s),A=sscanf(s,'%d%s');n=A(1);A=reshape(A(2:end),n,n);for c=A(:)',B=A==c;for i=1:n,if~mod(n,i),C=[kron(eye(i),ones(n/i,1)),zeros(n,n-i)];for j=0:n-i,f=@(B)sum(sum(B&circshift(C,[0,j]))==n;D=fliplr(B);if f(B)|f(B')|f(D)|f(D'),F=char(c);end;end;end;end;end;end

Die nicht minimierte Version ist

function F = x(s)
    A = sscanf( s, '%d %s' );
    n = A(1);
    A = reshape( A(2:end), n,n );
    for c = A(:)'
        B = A==c;
        for i = 1:n
            if ~mod( n, i )
                C = [kron( eye(i), ones( n/i,1 ) ), zeros( n,n-i )];
                for j = 0:n-i
                    f = @(B) sum(sum( B & circshift( C, [0 j] ))) == n;
                    D = fliplr(B);
                    if f(B) | f(B') | f(D) | f(D')
                        F = char(c);
                    end
                end
            end
        end
    end
end

Die Grundvoraussetzung besteht darin, für jeden möglichen gültigen Pfad eine boolesche Maske zu erstellen und jedes Zeichen zurückzugeben, dessen Indexfunktion in der Matrix eine beliebige Maske abdeckt. Um dies zu erreichen, werden nur vertikale oder von hinten nach unten gerichtete, schlitzförmige Masken erstellt, aber die Waldmatrix wird in allen vier Ausrichtungen verglichen: Identität, gespiegelt, um 90 ° gedreht, umgedreht um 90 ° gedreht.

Die Funktion läuft für jede n. Ein Beispiel dafür, wie es in der Befehlszeile aufgerufen wird, ist

x('13 anehcienwlndmbaneiryeivownbnabncmxlriruanhahirrnraucriwuafuvocvncriwnbaueibnxzhyirorairenerruwiiwuauawoeqnnvcizdaiehriefyioeorauviquoeuroenraibcuivoaisdfuaeefoiebnxmcsua')

ans =

    a

Python - 384 325 275

Dieser Algorithmus überprüft im Wesentlichen die erste und letzte Zeile der Matrix auf übereinstimmende Zeichen und berechnet dann die Länge jedes Liniensegments

012345
------
aaVaaa|0
aaVaaa|1
aaaVaa|2
aaaVaa|3
aaaaVa|4
aaaaVa|5

Im obigen Beispiel:
Das V in der ersten Zeile befindet sich am Index 2, das V in der letzten Zeile am Index 4.
Die Länge jedes Liniensegments wäre also n / (4-2) +1 = 2 mit n = 6 .

Anschließend wird geprüft, ob die Zeile gültig ist.

Um einen Pfad von links nach rechts zu finden, werden Zeilen mit Spalten ausgetauscht und das Gleiche erneut ausgeführt.

Edit: Kann nicht ganz auf 270 kommen (Verdammt du Python und deine verdammte Einkerbung !!)

n,m=raw_input().split()
n,r=int(n),range
t=r(n)
a=[m[i:i+n]for i in r(0,n*n,n)]
for v in a,["".join([a[i][j]for i in t])for j in t]:
 for i in t:
  for j in t:
   p=1-2*(j-i<0);d,c=p*(j-i)+1,v[0][i]
   if 6<=sum([v[z][i+(z/(n/d))*p*(n%d==0)]==c for z in t])==n:print c;exit()