Bu soru, çevrimiçi olarak oynayabileceğiniz sayı yerleştirme bulmaca Kuleleri (Gökdelenler olarak da bilinir) üzerine kuruludur . Amacınız bulmacanın çözümünü bulmak ve ipuçlarını belirlemek - her bir satır ve sütun boyunca görülebilecek kulelerin sayısı. Bu kod golf, yani en az bayt kazanıyor.

Kuleler nasıl çalışır?

A - Bir Towers bulmacanın çözümü Latince bir kare n*nher satır ve sütun numaralarının bir permütasyon içerdiği ızgara 1içinden n. Bunun bir örneği n=5:

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 

Her satır ve sütun aşağıdaki gibi her bir uçta bir ipucu ile etiketlenir:

       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

Her ipucu bir sayıdır 1için nsayıların o yüksekliğe sahip kuleleri olarak kabul edilir eğer, bu yönden satır / sütun boyunca bakarak "görmek" kaç kuleleri olduğunu söyler. Her kule arkasındaki kuleleri daha kısa tutar. Başka bir deyişle, görebileceğiniz kuleler, onlardan önceki kulelerden daha uzun boylu olanlardır.

Örneğin, ilk satıra bakalım.

 2 >   4 3 5 2 1   < 3

Bu bir ipucu vardır 2Gördüğünüz çünkü soldan 4ve 5. 4Bloklar 3gelen görme ve 5else blokları her şeyi. Sağdan görebilirsiniz 3kuleleri: 1, 2, ve 5.

Program gereksinimleri

Rakamların ızgarasına giren ve ipuçlarını çıkaran veya basan, soldan itibaren saat yönünde ilerleyen bir program veya işlev yazın.

Giriş

Bir n*nLatin-kare ile 2<=n<=9.

Format esnek. Bir ızgarayı temsil eden herhangi bir veri yapısını veya sayı veya rakam karakter içeren bir liste kullanabilirsiniz. Satırlar arasında bir ayırıcı gerekebilir veya hiç ayırıcı gerekmeyebilir. Bazı olasılıklar bir liste, bir liste listesi, bir matris, tokenle ayrılmış bir dizedir.

43521 54132 15243 21354 32415,

veya boşluksuz bir dize.

nGirişin bir parçası olarak verilmemişsin .

Çıktı

Sol üstten başlayıp saat yönünde giden ipuçlarını iade edin veya yazdırın. Bu nedenle, ilk önce üstteki oklar sağa, sonra sağdaki oklar aşağıya, daha sonra soldaki oklar aşağı, soldaki oklar yukarı okuyor.

Bu 23145 34321 12222 33212önceki örnek için olurdu

       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

Giriş için olduğu gibi, bir liste, dize veya herhangi bir sipariş edilen yapı kullanabilirsiniz. Dört "grup", iç içe geçmiş veya düz bir yapı içinde ayrılabilir veya ayrılamaz. Ancak, format her grup için aynı olmalıdır.

Örnek test durumları:

(Giriş / çıkış biçiminiz bunlarla aynı olmak zorunda değildir.)

>> [[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]

Size kolaylık sağlamak için, burada aynı sınama örnekleri düz dize biçiminde.

>> 1221

21
12
21
12

>> 312231123

122
221
123
321

>> 4352154132152432135432415

23145
34321
12222
33212

>> 264137589729683145597461823618572934153926478375248691831794256942815367486359712

422333321
133222233
432123322
312433225

APL 19

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

(Ngn'in önerisinden sonra biraz daha golf oynadım, teşekkürler)

Açıklama:

(⍉⍪⌽⍪⊖∘⌽∘⍉⍪⊖)  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

Tryapl.org'da deneyin

Python 2, 115 bayt

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

Orada saygısız bir sürü liste var.

Girdiyi iç içe geçmiş bir liste olarak alır (örneğin, ile ara 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]])). Çıktı, tek bir düz listedir.

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

Alternatif 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

Bunun neden bir liste anlayışıyla çalıştığını bilmiyorum ama NameErrorbir dizi anlama da var.

Biraz uzun, ama eğer ilgilenen varsa - evet, bunu bir lambdaya indirmek mümkün!

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 bayt

V4=Q_CQ~Yml{meS<dhkUd_Q)Y

Zorunlu Pyth limanı.

Listeyi STDIN ile girin, örn [[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]].

Çevrimiçi deneyin ... söyleyeceğim şey ancak maalesef, güvenlik nedeniyle çevrimiçi tercüman değerlendirmenin yuvalanmış parantez üzerindeki kullanımını reddetti. Geçici çözüm kodunu deneyin ve JcQ5V4=J_CJ~Yml{meS<dhkUd_J)Ybunun gibi düzleştirilmiş bir liste olarak girin [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].

(Birkaç baytlık golf atmaya yardımcı olan @ isaacg sayesinde)

CJam, 29 27 bayt

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

Gibi giriş

[[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]]

Çıkış gibi

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

Nasıl çalışır

Temel fikir, kodun satırlar boyunca çalışması ve ızgarayı saat yönünün tersine 4 kez döndürmektir. Kuleleri saymak için, her kuleyi "görsel bir fark" yaratmadığı kadar yükseltiyorum (yani, eğer görülebilirse değiştirmeyin veya kulenin önünde aynı yüksekliğe kadar çekmeyin) o) ve sonra farklı yükseklikleri sayıyorum.

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∊¨↓(∘.>⍨⍵)≥∘.<⍨⍳⍴⍵}¨↓(⌽∘⍉⍪⊢⍪⊖∘⍉⍪⊖∘⌽)⍵}

Burada test edildi.

J, 35 karakter

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

Örnek:

   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

Burada dene.

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 bayt

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}])&

Kullanımı:

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,[],[])

Tarayıcının JavaScript konsolunda değerlendirin (Firefox 34.0 kullandım, Chrome 39'da çalışmıyor gibi görünüyor?) Şununla test edin:

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]]));

İşte asılsız kodun şu andaki enkarnasyonu - takip etmesi zorlaşıyor:

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, [], [])
}

Kasıtlı olarak diğer cevapların hiçbirine bakmadım, kendim bir şeyler yapıp yapamayacağımı görmek istedim. Benim yaklaşımım, giriş dizilerini tek boyutlu bir diziye yassılaştırmak ve satırları dört yönden de önceden hesaplamaktı. Sonra bir sonraki kulenin sahte olup olmadığını test etmek için sağa kaydırma kullandım ve öyleyse, her sıra için sayacı arttırın.

Umarım bu durumu iyileştirmenin birçok yolu vardır, belki ofsetleri önceden hesaplamaz, ancak 1D giriş dizisinde bir çeşit taşma / modülo kullanırsınız? Ve belki de döngülerimi birleştiriyor, daha işlevsel, tekilleşiyor.

Herhangi bir öneriniz memnuniyetle karşılanacaktır!

Güncelleme # 1 : İlerleme, teknolojimiz var! Önceden hesaplanmış ofsetlerden kurtulmayı başardım ve bunları üçlü operatörlerin bir araya getirdiği sıraya soktum. Ayrıca if ifademden kurtulabildim ve for döngülerini while'ye çevirebildim.

Güncelleme # 2 : Bu oldukça sinir bozucu; benim için pizza partisi yok. İşlevselleşmeyi ve özyinelemeyi kullanmanın baytları tıraş edeceğini düşündüm, ancak ilk birkaç denemem 100 karakter kadar daha büyük oldu! Çaresizlik içinde, gerçekten aşağı çekmek için ES6 yağ ok fonksiyonlarını kullanmaya başladım. Daha sonra boolean operatörlerini aritmetik olanlarla değiştirmeye ve nerede olsam parens, yarı-kolon ve boşlukları çıkarmaya başladım. Değişkenlerimi ilan etmeyi bile kestim ve yerel isimleri yerel sembollerle kirlettim. Kirli, kirli. Tüm bu çabalardan sonra, # 1 numaralı güncelleme puanımı 8 karakterle 256'ya düşürdüm. Blargh!

Güncelleme # 1 işlevime aynı acımasız optimizasyonları ve ES6 numaralarını uygularsam, bu puanı bir mil öteye alırdım. Nasıl görüneceğini görmek için Güncelleme # 3'ü yapabilirim.

Güncelleme # 3 : Yağ ok özyinelemeli yaklaşımın içinde çok daha fazla ömrü olduğu ortaya çıktı, düzleştirmek yerine doğrudan 2 boyutlu girdiyle çalışmam gerekiyordu ve kapatma kapsamlarını daha iyi kullanmam gerekiyordu. İç dizi ofset hesaplamalarını iki kez yeniden yazdım ve aynı skoru aldım, bu yüzden bu yaklaşım küçültülmüş olabilir!

Sadece Java 352 350 325 bayt ...

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;}}}

Gibi giriş 43521 54132 15243 21354 32415

Gibi çıkış: 23145343211222233212

Girintili'ye:

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;
        }
    }
}

Herhangi bir ipucu çok takdir edilecektir!

Python 2 - 204 bayt

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

Bu muhtemelen gerçekten zayıf bir golf. Sorunun ilginç olduğunu düşündüm, bu yüzden başkasının çözümüne bakmadan başa çıkmaya karar verdim. Bu cümleyi yazarken, bu soruya verilen cevaplara henüz bakmadım. Başka biri daha kısa bir Python programı hazırlamışsa şaşırmam;)

G / Ç Örneği

$ ./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]

İsteğe bağlı olarak girişe boşluk ekleyebilirsiniz. Dürüst olmak gerekirse hemen hemen her yerde. Yapabildiğin sürece eval()işe yarayacak.

açıklama

Bu programın tek ilginç kısmı ilk satır. f(l)Size arka arkaya kaç kulenin görülebileceğini söyleyen bir işlev tanımlar ve programın geri kalanı bu işlevi her olası konuma uygular.

Çağrıldığında, uzunluğu bulur lve değişkene kaydeder n. Sonra kbu oldukça korkunç liste anlayışı ile yeni bir değişken yaratır :

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

Parçaladığınızda çok kötü değil. Çünkü n==len(l), ifsadece önündeki her şey temsil eder l. Ancak, ifbazı öğeleri listeden kaldırabiliriz. İle bir liste oluştururuz([0]+list(l)) "adildir, lbir ile 0başına eklenir" (çağrısına görmezden list()bazen çünkü sadece orada, lbir jeneratör ve biz burada aslında bir liste olduğundan emin olmak gerekir). l[c]sadece daha büyükse son listeye konur ([0]+list(l))[c]. Bu iki şey yapar:

• Listenin başında yeni bir öğe olduğundan, her birinin dizini l[c]olur c+1. Her bir öğeyi, solundaki öğeyle etkin bir şekilde karşılaştırıyoruz. Eğer daha büyükse, görünür. Aksi takdirde listeden gizlenir ve kaldırılır.
• İlk kule her zaman görünür durumdadır, çünkü onu engelleyebilecek hiçbir şey yoktur. Başına 0 koyduğumuz için ilk kule her zaman daha büyük. (Eğer bunu yapmazsak[0]+ saçma ve sadece karşılaştırıldığında l[c]için l[c-1]birlikte Python ucundan bir liste halinde yapabilirsiniz (sonuncusuna endeksi ilk kule karşılaştırmak istiyorsunuz -1, -2vb), bu yüzden son kule daha uzun boylu olsaydı ilk önce yanlış sonucu alırız.

Her şey söylendiğinde ve yapıldığında, lbirkaç kuleden oluşur ve kher birini sola yakın komşusundan daha kısa olmayanlardan her birini içerir. Eğer hiçbiri olmasaydı (örneğin;f([1,2,3,4,5]) , öyleyse) l == k. Yapacak ve geri dönecek bir şey olmadığını biliyoruz n(listenin uzunluğu). Eğer l != kbu, kulelerden en az birinin bu sefer çıkarıldığı anlamına gelirse , yapılacak daha çok şey olabilir. O halde geri döndük f(k). Tanrım, özyinelemeyi seviyorum. İlginçtir ki, fher zaman kesinlikle "gerekli" olandan daha derin bir seviye alır. Döndürülecek liste oluşturulduğunda, işlevin bunu ilk başta bilmesi mümkün değildir.

Bu açıklamayı yazmaya başladığımda, bu program 223 bayt uzunluğundaydı. Her şeyi açıklarken karakterleri kurtarmanın bir yolu olduğunu anladım, bu yüzden bunu yazdığım için memnunum! En büyük örnek, f(l)özyinelemenin işe yarayacağını fark etmeden önce hesaplamanın yapıldığı zamandan kopan sonsuz bir döngü olarak uygulanmış olmasıdır. Sadece, düşündüğünüz ilk çözümün her zaman en iyi olmayacağını göstermeye gider. :)

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

böyle kullanılır:

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 #, 354'e kadar ...

TheBestOne'dan farklı yaklaşım.

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);
        }
    }
}