Diese Frage basiert auf dem Zahlenrätsel Towers (auch Wolkenkratzer genannt), das Sie online spielen können . Ihr Ziel ist es, eine Lösung für das Rätsel zu finden und die Hinweise zu ermitteln - die Anzahl der Türme, die in jeder Zeile und Spalte sichtbar sind. Dies ist Codegolf, so dass nur wenige Bytes gewinnen.

Wie funktioniert Towers?

Die Lösung für ein Türme-Puzzle ist ein lateinisches Quadrat - ein n*nRaster, in dem jede Zeile und Spalte eine Permutation der 1durchgehenden Zahlen enthält n. Ein Beispiel für n=5ist:

4 3 5 2 1 
5 4 1 3 2 
1 5 2 4 3 
2 1 3 5 4 
3 2 4 1 5 

Jede Zeile und Spalte ist an jedem Ende mit einem Hinweis versehen:

       2 3 1 4 5    
       v v v v v

 2 >   4 3 5 2 1   < 3
 1 >   5 4 1 3 2   < 4
 2 >   1 5 2 4 3   < 3
 3 >   2 1 3 5 4   < 2
 3 >   3 2 4 1 5   < 1 

       ^ ^ ^ ^ ^
       2 2 2 2 1

Jeder Hinweis ist eine Zahl von 1bis n, die angibt, wie viele Türme Sie entlang der Reihe / Spalte aus dieser Richtung "sehen", wenn die Zahlen als Türme mit dieser Höhe behandelt werden. Jeder Turm blockiert kürzere Türme dahinter. Mit anderen Worten, die Türme, die Sie sehen können, sind höher als jeder Turm vor ihnen.

Schauen wir uns zum Beispiel die erste Reihe an.

 2 >   4 3 5 2 1   < 3

Es hat einen Hinweis von 2links, weil Sie das 4und das sehen können 5. Das 4blockiert die 3Sicht und das 5blockiert alles andere. Von der rechten Seite können Sie sehen , 3Türme: 1, 2, und 5.

Programmanforderungen

Schreiben Sie ein Programm oder eine Funktion, die das Zahlenraster aufnimmt und die Hinweise ausgibt oder druckt, und zwar im Uhrzeigersinn von oben links.

Eingang

Ein n*nlateinisches Quadrat mit 2<=n<=9.

Das Format ist flexibel. Sie können eine beliebige Datenstruktur verwenden, die ein Raster oder eine Liste mit Zahlen oder Ziffern darstellt. Möglicherweise benötigen Sie ein Trennzeichen zwischen den Zeilen oder gar kein Trennzeichen. Einige Möglichkeiten sind eine Liste, eine Liste von Listen, eine Matrix, eine durch Token getrennte Zeichenfolge wie

43521 54132 15243 21354 32415,

oder eine Zeichenfolge ohne Leerzeichen.

Sie werden nicht nals Teil der Eingabe angegeben.

Ausgabe

Geben Sie die Hinweise von links oben im Uhrzeigersinn zurück oder drucken Sie sie aus. Also, zuerst lesen die oberen Hinweise nach rechts, dann lesen die rechten Hinweise nach unten, dann lesen die unteren Hinweise nach links, die linken Hinweise nach oben.

Dies wäre 23145 34321 12222 33212für das vorherige Beispiel

       2 3 1 4 5    
       v v v v v

 2 >   4 3 5 2 1   < 3
 1 >   5 4 1 3 2   < 4
 2 >   1 5 2 4 3   < 3
 3 >   2 1 3 5 4   < 2
 3 >   3 2 4 1 5   < 1 

       ^ ^ ^ ^ ^
       2 2 2 2 1

Ebenso wie für die Eingabe können Sie eine Liste, eine Zeichenfolge oder eine beliebige geordnete Struktur verwenden. Die vier "Gruppen" können in einer verschachtelten oder flachen Struktur getrennt sein oder nicht. Das Format muss jedoch für jede Gruppe gleich sein.

Beispiel Testfälle:

(Ihr Eingabe- / Ausgabeformat muss nicht mit diesen identisch sein.)

>> [[1 2] [2 1]]

[2 1]
[1 2]
[2 1]
[1 2]

>> [[3 1 2] [2 3 1] [1 2 3]]

[1 2 2]
[2 2 1]
[1 2 3]
[3 2 1]

>> [[4 3 5 2 1] [5 4 1 3 2] [1 5 2 4 3] [2 1 3 5 4] [3 2 4 1 5]]

[2 3 1 4 5]
[3 4 3 2 1]
[1 2 2 2 2]
[3 3 2 1 2]

>> [[2 6 4 1 3 7 5 8 9] [7 2 9 6 8 3 1 4 5] [5 9 7 4 6 1 8 2 3] [6 1 8 5 7 2 9 3 4] [1 5 3 9 2 6 4 7 8] [3 7 5 2 4 8 6 9 1] [8 3 1 7 9 4 2 5 6] [9 4 2 8 1 5 3 6 7] [4 8 6 3 5 9 7 1 2]]

[4 2 2 3 3 3 3 2 1]
[1 3 3 2 2 2 2 3 3]
[4 3 2 1 2 3 3 2 2]
[3 1 2 4 3 3 2 2 5]

Der Einfachheit halber finden Sie hier dieselben Testfälle im Flat-String-Format.

>> 1221

21
12
21
12

>> 312231123

122
221
123
321

>> 4352154132152432135432415

23145
34321
12222
33212

>> 264137589729683145597461823618572934153926478375248691831794256942815367486359712

422333321
133222233
432123322
312433225

APL 19

≢¨∪/⌈\(⍉⍪⌽⍪⊖∘⌽∘⍉⍪⊖)

(Golfen ein bisschen mehr nach Ngns Vorschlag, danke)

Erläuterung:

(⍉⍪⌽⍪⊖∘⌽∘⍉⍪⊖)  rotates matrix 4 times appending results
⌈\ gets maximums for each row up to current column (example: 4 2 3 5 1 gives 4 4 4 5 5)
≢¨∪/ counts unique elements for each row

Probieren Sie es auf tryapl.org

Python 2, 115 Bytes

def T(m):o=[];exec'm=zip(*m)[::-1]\nfor r in m[::-1]:\n n=k=0\n for x in r:k+=x>n;n=max(x,n)\n o+=[k]\n'*4;return o

Da ist eine Menge Liste drin.

Nimmt die Eingabe als verschachtelte Liste (z T([[4,3,5,2,1],[5,4,1,3,2],[1,5,2,4,3],[2,1,3,5,4],[3,2,4,1,5]]). B. Anruf mit ). Die Ausgabe ist eine einzelne flache Liste.

Ungolfed:

def T(m):
 o=[]
 for _ in [0]*4:
  m=zip(*m)[::-1]
  for r in m[::-1]:
   n=k=0
   for x in r:k+=x>n;n=max(x,n)
   o+=[k]
 return o

Alternative 115:

def T(m):o=[];exec'm=zip(*m)[::-1];o+=[len(set([max(r[:i+1])for i in range(len(r))]))for r in m[::-1]];'*4;return o

Ich habe keine Ahnung, warum dies mit einem Listenverständnis funktioniert, aber wirft ein NameErrormit einem Mengenverständnis ...

Ein bisschen zu lang, aber wenn es jemanden interessiert - ja, es ist möglich, dies auf ein Lambda zu bringen!

T=lambda m:[len({max(r[:i+1])for i in range(len(r))})for k in[1,2,3,4]for r in eval("zip(*"*k+"m"+")[::-1]"*k)[::-1]]

Pyth , 25 Bytes

V4=Q_CQ~Yml{meS<dhkUd_Q)Y

Obligatorischer Pyth-Port.

Geben Sie die Liste über STDIN ein, z [[4, 3, 5, 2, 1], [5, 4, 1, 3, 2], [1, 5, 2, 4, 3], [2, 1, 3, 5, 4], [3, 2, 4, 1, 5]].

Online ausprobieren ... würde ich sagen, aber aus Sicherheitsgründen erlaubt der Online-Interpreter die Verwendung von eval in geschachtelten Klammern nicht. Probieren Sie JcQ5V4=J_CJ~Yml{meS<dhkUd_J)Ystattdessen den Umgehungscode aus und geben Sie ihn als abgeflachte Liste wie folgt ein [4, 3, 5, 2, 1, 5, 4, 1, 3, 2, 1, 5, 2, 4, 3, 2, 1, 3, 5, 4, 3, 2, 4, 1, 5].

(Danke an @isaacg, der ein paar Bytes beim Golfen geholfen hat)

CJam, 29 27 Bytes

q~{z_{[{1$e>}*]_&,}%pW%}4*;

Eingabe wie

[[4 3 5 2 1] [5 4 1 3 2] [1 5 2 4 3] [2 1 3 5 4] [3 2 4 1 5]]

Ausgabe wie

[2 3 1 4 5]
[3 4 3 2 1]
[1 2 2 2 2]
[3 3 2 1 2]

Wie es funktioniert

Die Grundidee ist, dass der Code entlang der Zeilen arbeitet und das Raster viermal gegen den Uhrzeigersinn dreht. Um die Türme zu zählen, hebe ich jeden Turm so weit an, dass es keinen "visuellen Unterschied" macht (dh ändere ihn nicht, wenn er sichtbar ist, oder ziehe ihn auf die gleiche Höhe des Turms vor es), und dann zähle ich verschiedene Höhen.

q~                          "Read and evaluate the input.";
  {                    }4*  "Four times...";
   z                        "Transpose the grid.";
    _                       "Duplicate.";
     {            }%        "Map this block onto each row.";
      [       ]             "Collect into an array.";
       {    }*              "Fold this block onto the row.";
        1$                  "Copy the second-to-topmost element.":
          e>                "Take the maximum of the top two stack elements.";
                            "This fold replaces each element in the row by the
                             maximum of the numbers up to that element. So e.g.
                             [2 1 3 5 4] becomes [2 2 3 5 5].";
               _&,          "Count unique elements. This is how many towers you see.";
                    p       "Print array of results.";
                     W%     "Reverse the rows for the next run. Together with the transpose at
                             the start this rotates the grid counter-clockwise.";
                          ; "Get rid of the grid so that it isn't printed at the end.";

APL, 44

{{+/~0∊¨↓(∘.>⍨⍵)≥∘.<⍨⍳⍴⍵}¨↓(⌽∘⍉⍪⊢⍪⊖∘⍉⍪⊖∘⌽)⍵}

Hier getestet.

J, 35 Zeichen

(+/@((>./={:)\)"2@(|.@|:^:(<4)@|:))

Beispiel:

   t=.4 3 5 2 1,. 5 4 1 3 2,. 1 5 2 4 3,. 2 1 3 5 4,. 3 2 4 1 5
   (+/@((>./={:)\)"2@(|.@|:^:(<4)@|:)) t
2 3 1 4 5
3 4 3 2 1
1 2 2 2 2
3 3 2 1 2

Probieren Sie es hier aus.

Haskell, 113

import Data.List
f(x:s)=1+f[r|r<-s,r>x]
f _=0
r=reverse
t=transpose
(?)=map
l s=[f?t s,(f.r)?s,r$(f.r)?t s,r$f?s]

Mathematica, 230 , 120 , 116 , 113, 110 Bytes

f=(t=Table;a=#;s=Length@a;t[v=t[c=m=0;t[h=a[[y,x]];If[h>m,c++;m=h],{y,s}];c,{x,s}];a=Thread@Reverse@a;v,{4}])&

Verwendung:

f[{
  {4, 3, 5, 2, 1},
  {5, 4, 1, 3, 2},
  {1, 5, 2, 4, 3},
  {2, 1, 3, 5, 4},
  {3, 2, 4, 1, 5}
}]

{{2, 3, 1, 4, 5}, {3, 4, 3, 2, 1}, {1, 2, 2, 2, 2}, {3, 3, 2, 1, 2}}

JavaScript, 335 264 256 213

T=I=>((n,O)=>(S=i=>i--&&O.push([])+S(i)+(R=(j,a,x)=>j--&&R(j,0,0)+(C=k=>k--&&((!(a>>(b=I[(F=[f=>n-k-1,f=>j,f=>k,f=>n-j-1])[i]()][F[i+1&3]()])))&&++x+(a=1<<b))+C(k))(n)+O[i].push(x))(n,0,0))(4)&&O)(I.length,[],[])

In der JavaScript-Konsole des Browsers auswerten (ich habe Firefox 34.0 verwendet, scheint in Chrome 39 nicht zu funktionieren?) Testen mit:

JSON.stringify(T([[4, 3, 5, 2, 1], [5, 4, 1, 3, 2], [1, 5, 2, 4, 3], [2, 1, 3, 5, 4], [3, 2, 4, 1, 5]]));

Hier ist die aktuelle Inkarnation des ungolfed Codes - es wird schwieriger zu folgen:

function countVisibleTowers(input) {
  return ((n, out) =>
      (sideRecurse = i =>
          i-- &&
          out.push([]) +
          sideRecurse(i) +
          (rowRecurse = (j, a, x) =>
              j-- &&
              rowRecurse(j, 0, 0) +
              (columnRecurse = k =>
                  k-- &&
                  ((!(a >> (b = input[
                                        (offsetFtn = [
                                            f => n - k - 1,   // col negative
                                            f => j,           // row positive
                                            f => k,           // col positive
                                            f => n - j - 1    // row negative
                                        ])[i]()
                                     ]
                                     [
                                        offsetFtn[i + 1 & 3]()
                                     ]))) &&
                  ++x +
                  (a = 1 << b)) +
                  columnRecurse(k)
              )(n) +
              out[i].push(x)
          )(n, 0, 0)
      )(4) && out
  )(input.length, [], [])
}

Ich habe absichtlich keine der anderen Antworten angeschaut, ich wollte sehen, ob ich selbst etwas ausarbeiten kann. Mein Ansatz bestand darin, die Eingabearrays auf ein eindimensionales Array zu reduzieren und die Offsets für die Zeilen aus allen vier Richtungen vorab zu berechnen. Dann habe ich mit der Umschalttaste nach rechts getestet, ob der nächste Turm falsch war, und wenn ja, den Zähler für jede Zeile erhöht.

Ich hoffe, es gibt viele Möglichkeiten, dies zu verbessern, vielleicht die Offsets nicht vorab zu berechnen, sondern eine Art Überlauf / Modulo auf dem 1D-Eingangsarray zu verwenden. Und vielleicht meine Schleifen kombinieren, funktionaler werden, deduplizieren.

Anregungen wäre dankbar!

Update Nr. 1 : Fortschritt, wir haben die Technologie! Ich war in der Lage, die vorberechneten Offsets loszuwerden und sie in Übereinstimmung mit aneinander gereihten ternären Operatoren auszuführen. War auch in der Lage, meine if-Anweisung loszuwerden und die for-Schleifen in whiles umzuwandeln.

Update Nr. 2 : Das ist ziemlich frustrierend. Keine Pizza Party für mich. Ich dachte, funktionstüchtig zu werden und Rekursion zu verwenden, würde viele Bytes einsparen, aber meine ersten Versuche endeten damit, dass sie um bis zu 100 Zeichen größer waren! In meiner Verzweiflung habe ich mich voll und ganz darauf konzentriert, ES6-Fettpfeilfunktionen zu verwenden, um es wirklich zu reduzieren. Dann habe ich mich daran gemacht, boolesche Operatoren durch arithmetische zu ersetzen und Parens, Semikolons und Leerzeichen zu entfernen, wo immer ich konnte. Ich habe sogar aufgehört, meine Variablen zu deklarieren, und den globalen Namespace mit meinen lokalen Symbolen verschmutzt. Dreckig, dreckig. Nach all diesen Anstrengungen habe ich meine Punktzahl für Update 1 um satte 8 Zeichen auf 256 geschlagen. Blargh!

Wenn ich die gleichen skrupellosen Optimierungen und ES6-Tricks auf meine Update Nr. 1-Funktion anwenden würde, würde ich diese Punktzahl um eine Meile übertreffen. Ich kann ein Update # 3 durchführen, um zu sehen, wie das aussehen würde.

Update Nr. 3 : Es stellte sich heraus, dass der rekursive Ansatz mit fetten Pfeilen viel mehr Leben in sich birgt. Ich musste nur direkt mit der zweidimensionalen Eingabe arbeiten, anstatt sie zu verflachen, und mich besser mit der Nutzung der Schließbereiche befassen. Ich habe die Berechnung des inneren Array-Offsets zweimal umgeschrieben und dabei die gleiche Punktzahl erhalten, sodass dieser Ansatz möglicherweise kurz vor der Minimierung steht.

Nur Java 352 350 325 Bytes ...

class S{public static void main(String[]a){int n=a.length,i=0,j,k,b,c;int[][]d=new int[n][n];for(;i<n;i++)for(j=0;j<n;)d[i][j]=a[i].charAt(j++);for(i=0;i<4;i++){int[][]e=new int[n][n];for(k=0;k<n;k++)for(j=0;j<n;)e[n-j-1][k]=d[k][j++];d=e;for(j=n;j-->(k=c=b=0);System.out.print(c))for(;k<n;k++)b=d[j][k]>b?d[j][k]+0*c++:b;}}}

Eingabe wie 43521 54132 15243 21354 32415

Ausgabe wie: 23145343211222233212

Eingerückt:

class S{
    public static void main(String[]a){
        int n=a.length,i=0,j,k,b,c;
        int[][]d=new int[n][n];
        for(;i<n;i++)
            for(j=0;j<n;)d[i][j]=a[i].charAt(j++);
        for(i=0;i<4;i++){
            int[][]e=new int[n][n];
            for(k=0;k<n;k++)
                for(j=0;j<n;)e[n-j-1][k]=d[k][j++];
            d=e;
            for(j=n;j-->(k=c=b=0);System.out.print(c))
                for(;k<n;k++)b=d[j][k]>b?d[j][k]+0*c++:b;
        }
    }
}

Alle Tipps wäre sehr dankbar!

Python 2 - 204 Bytes

def f(l):n=len(l);k=[l[c]for c in range(n)if l[c]>([0]+list(l))[c]];return f(k)if k!=l else n
r=lambda m:(l[::-1]for l in m)
m=input();z=zip(*m);n=0
for t in z,r(m),r(z),m:print map(f,t)[::1-(n>1)*2];n+=1

Dies ist wahrscheinlich ein sehr schlechtes Golf. Ich fand das Problem interessant und beschloss, es anzugehen, ohne die Lösung eines anderen zu suchen. Während ich diesen Satz schreibe, muss ich mir noch die Antworten auf diese Frage ansehen. Es würde mich nicht wundern, wenn jemand anderes bereits ein kürzeres Python-Programm gemacht hätte;)

E / A-Beispiel

$ ./towers.py <<< '[[4,3,5,2,1],[5,4,1,3,2],[1,5,2,4,3],[2,1,3,5,4],[3,2,4,1,5]]'
[2, 3, 1, 4, 5]
[3, 4, 3, 2, 1]
[1, 2, 2, 2, 2]
[3, 3, 2, 1, 2]

Sie können optional Leerzeichen in die Eingabe einfügen. Ehrlich gesagt so ziemlich überall. Solange du es kannst eval(), wird es funktionieren.

Erläuterung

Der einzig interessante Teil dieses Programms ist die erste Zeile. Es definiert eine Funktion f(l), die angibt, wie viele Türme in einer Reihe zu sehen sind, und der Rest des Programms wendet diese Funktion nur auf jede mögliche Position an.

Beim Aufruf wird die Länge von ermittelt lund in einer Variablen gespeichert n. Dann erstellt es eine neue Variable kmit diesem ziemlich monströsen Listenverständnis:

[l[c]for c in range(n)if l[c]>([0]+list(l))[c]]

Es ist nicht so schlimm, wenn du es kaputt machst. Da n==len(l)steht alles vor dem ifGerechten l. Mit können ifwir jedoch einige Elemente aus der Liste entfernen. Wir konstruieren eine Liste mit ([0]+list(l)), die nur " lmit einem 0am Anfang angefügten" ist (ignorieren Sie den Aufruf von list(), das ist nur dort, weil manchmal lein Generator ist und wir sicherstellen müssen, dass es tatsächlich eine Liste hier ist). l[c]wird nur in die endgültige Liste aufgenommen, wenn sie größer als ist ([0]+list(l))[c]. Das macht zwei Dinge:

• Da es am Anfang der Liste ein neues Element ist der Index von jedem l[c]wird c+1. Wir vergleichen effektiv jedes Element mit dem Element links davon. Wenn es größer ist, ist es sichtbar. Andernfalls wird es ausgeblendet und aus der Liste entfernt.
• Der erste Turm ist immer sichtbar, weil nichts ihn blockieren kann. Da wir am Anfang 0 setzen, ist der erste Turm immer größer. (Wenn wir nicht diese taten [0]+Unsinn und nur im Vergleich l[c]zu l[c-1], würde Python den ersten Turm bis zum letzten vergleichen (können Sie Index in eine Liste von dem Ende mit -1, -2etc.), so dass , wenn der letzte Turm höher war als die Als erstes würden wir das falsche Ergebnis bekommen.

Wenn alles gesagt und getan ist, lenthält es einige Türme und kenthält jeden der Türme , der nicht kürzer ist als sein unmittelbarer Nachbar links. Wenn keiner von ihnen war (zB für f([1,2,3,4,5])), dann l == k. Wir wissen, dass es nichts mehr zu tun und zurückzukehren gibt n(die Länge der Liste). In l != kdiesem Fall wurde diesmal mindestens einer der Türme entfernt, und möglicherweise ist noch mehr zu tun. Also kehren wir zurück f(k). Gott, ich liebe Rekursion. Interessanterweise ftaucht immer eine Ebene tiefer auf, als es unbedingt "notwendig" ist. Wenn die Liste, die zurückgegeben wird, generiert wird, kann die Funktion dies zunächst nicht wissen.

Als ich anfing, diese Erklärung zu schreiben, war dieses Programm 223 Bytes lang. Während ich die Dinge erklärte, wurde mir klar, dass es Möglichkeiten gibt, Zeichen zu speichern. Ich bin froh, dass ich das geschrieben habe! Das größte Beispiel ist, dass f(l)es ursprünglich als Endlosschleife implementiert wurde, die beim Ausführen der Berechnung ausgebrochen wurde, bevor mir klar wurde, dass eine Rekursion funktionieren würde. Es zeigt nur, dass die erste Lösung, an die Sie denken, nicht immer die beste sein wird. :)

Matlab, (123) (119)

function r=m(h);p=[h rot90(h) rot90(h,2) rot90(h,3)];for i=2:size(p) p(i,:)=max(p(i,:),p(i-1,:));end;r=sum(diff(p)>0)+1

wie folgt verwendet:

m([
 4     3     5     2     1;
 5     4     1     3     2;
 1     5     2     4     3;
 2     1     3     5     4;
 3     2     4     1     5])

 [2 3 1 4 5 3 4 3 2 1 1 2 2 2 2 3 3 2 1 2]

C # bis 354 ...

Anderer Ansatz als TheBestOne.

using System;
using System.Linq;

class A
{
    static void Main(string[] h)
    {
        int m = (int)Math.Sqrt(h[0].Length),k=0;
        var x = h[0].Select(c => c - 48);
        var s = Enumerable.Range(0, m);
        for (; k < 4; k++)
        {
            (k%2 == 0 ? s : s.Reverse())
                .Select(j =>
                        (k > 0 && k < 3 ? x.Reverse() : x).Where((c, i) => (k % 2 == 0 ? i % m : i / m) == j)
                                                          .Aggregate(0, (p, c) =>
                                                                        c > p%10
                                                                            ? c + 10 + p/10*10
                                                                            : p, c => c/10))
                .ToList()
                .ForEach(Console.Write);
        }
    }
}