Bu soru, bir tablodaki En Büyük Meydan'a benzer .

Meydan okuma

Dize veya dizi biçiminde 1ve 0dize biçiminde bir matris verildiğinde, tümünü içeren en büyük kare alt matrisinin alanını belirleyen bir işlev oluşturacaksınız ."xxxx,xxxxx,xxxx,xx.."["xxxx","xxxx","xxxx",...]1

Kare bir alt matris eşit genişlik ve yüksekliğe sahiptir ve işleviniz yalnızca en büyük alt matrisin alanını döndürmelidir 1.

Örneğin:

Verilen "10100,10111,11111,10010", bu aşağıdaki matrise benziyor:

1 0 1 0 0

1 0 1 1 1

1 1 1 1 1

1 0 0 1 0

Kalın 1harflerin 2x2 boyutunda en büyük kare alt matrisini oluşturduğunu görebilirsiniz , böylece programınız 4 olan alanı döndürmelidir.

kurallar

• Alt matris eşit genişlik ve yükseklikte olmalıdır
• Alt matris yalnızca değerler içermelidir 1
• İşleviniz en büyük alt matrisin alanını döndürmelidir
• Hiçbir alt matris bulunamazsa, 1
• Alt matristeki alanını, alt matristeki sayısını sayarak 1hesaplayabilirsiniz

Test senaryoları

Giriş: "10100,10111,11111,10010" Çıkış: 4

Giriş: "0111,1111,1111,1111" Çıkış: 9

Giriş "0111,1101,0111" Çıkışı: 1

Bu kod golf, yani bayttaki en kısa cevap kazanır.

Jöle , 18 bayt

_{Hepsi bir arada olmayan alt liste mevcut çıktısını işlemek için +2}

ẆZṡ¥"L€$ẎȦÐfL€Ṁ²»1

Çevrimiçi deneyin! Veya test takımına bakın

Nasıl?

ẆZṡ¥"L€$ẎȦÐfL€Ṁ²»1 - Link: list of lists of 1s and 0s
Ẇ                  - all slices (lists of "rows") call these S = [s1,s2,...]
       $           - last two links as a monad:
     L€            -   length of each (number of rows in each slice) call these X = [x1, x2, ...]
    "              -   zip with (i.e. [f(s1,x1),f(s2,x2),...]):
   ¥               -     last two links as a dyad:
 Z                 -       transpose (get the columns of the current slice)
  ṡ                -       all slices of length xi (i.e. squares of he slice)
        Ẏ          - tighten (to get a list of the square sub-matrices)
          Ðf       - filter keep if:
         Ȧ         -   any & all (all non-zero when flattened?)
            L€     - length of €ach (the side length)
              Ṁ    - maximum
               ²   - square (the maximal area)
                »1 - maximum of that and 1 (to coerce a 0 found area to 1)

Haskell , 113 121 118 117 bayt

x!s=[0..length x-s]
t#d=take t.drop d
f x=last$1:[s*s|s<-min(x!0)$x!!0!0,i<-x!!0!s,j<-x!s,all(>'0')$s#i=<<(s#j)x,s>0]

Çevrimiçi deneyin!

_{Laikoni sayesinde -3 bayt !}

_{Lynn'e -1 bayt teşekkürler !}

_{Tüm 1'ler alt matrisi için 1 döndürme saçma gereksinimi için +8 bayt ..}

Açıklama / Ungolfed

Aşağıdaki yardımcı işlevi, yalnızca xbunları azaltmak için ofsetler oluşturur s:

x!s=[0..length x-s]

x#ydüşecek ybir listeden elemanları daha sonra almak x:

t#d=take t.drop d

İşlev f, sırayla alt-matrisler için tüm olası boyutlar üzerinde döngüler yapar, karşılık gelen büyüklükteki her bir alt-matrisi oluşturur, yalnızca '1's içerip içermediğini test eder ve boyutu saklar. Böylece çözüm listedeki son giriş olacaktır:

--          v prepend a 1 for no all-1s submatrices
f x= last $ 1 : [ s*s
                -- all possible sizes are given by the minimum side-length
                | s <- min(x!0)$x!!0!0
                -- the horizontal offsets are [0..length(x!!0) - s]
                , i <- x!!0!s
                -- the vertical offsets are [0..length x - s]
                , j <- x!s
                -- test whether all are '1's
                , all(>'0') $
                -- from each row: drop first i elements and take s (concatenates them to a single string)
                              s#i =<<
                -- drop the first j rows and take s from the remaining
                                      (s#j) x
                -- exclude size 0...........................................
                , s>0
                ]

Haskell , 99 97 bayt

b s@((_:_):_)=maximum$sum[length s^2|s==('1'<$s<$s)]:map b[init s,tail s,init<$>s,tail<$>s]
b _=1

Girdinin s==('1'<$s<$s)yanıtın uzunluğu ^ 2, başka bir değer olan kare biçimli bir matris olup olmadığını denetler. Daha sonra ilk / son sütun / satırı yinelemeli olarak keser ve her yerde bulduğu maksimum değeri alır.

Çevrimiçi deneyin!

K (ngn / k) , 33 28 bayt

{*/2#+/|/',/'{0&':'0&':x}\x}

Çevrimiçi deneyin!

J , 33 27 bayt

FrownyFrog sayesinde -6 bayt!

[:>./@,,~@#\(#**/)@,;._3"$]

Çevrimiçi deneyin!

Açıklama:

Açıklamamda ilk test senaryosunu kullanacağım:

    ] a =. 3 5$1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 0
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1

1'den girişin satır sayısına kadar tüm olası kare alt matrislerini oluşturuyorum.

,~@#\girdinin ,.birbirini izleyen öneklerinin uzunluğunu değiştirmek için dikiş yaparak alt matrislerin boyutları için bir çift listesi oluşturur #\:

   ,~@#\ a
1 1
2 2
3 3

Sonra x u ;. _3 ygirdiyi alt matrislere kesmek için kullanıyorum. Zaten var x(boyut listesi); ydoğru argüman ](girdi).

 ((,~@#\)<;._3"$]) a
┌─────┬─────┬─────┬───┬─┐
│1    │0    │1    │0  │0│
│     │     │     │   │ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│1    │0    │1    │1  │1│
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│1    │1    │1    │1  │1│
└─────┴─────┴─────┴───┴─┘

┌─────┬─────┬─────┬───┬─┐
│1 0  │0 1  │1 0  │0 0│ │
│1 0  │0 1  │1 1  │1 1│ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│1 0  │0 1  │1 1  │1 1│ │
│1 1  │1 1  │1 1  │1 1│ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
└─────┴─────┴─────┴───┴─┘

┌─────┬─────┬─────┬───┬─┐
│1 0 1│0 1 0│1 0 0│   │ │
│1 0 1│0 1 1│1 1 1│   │ │
│1 1 1│1 1 1│1 1 1│   │ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
└─────┴─────┴─────┴───┴─┘

Her alt (#**/)@,matris için tamamen 1s olup olmadığını kontrol ediyorum: - matrisi düzeltin ve ürünlerine göre öğe sayısını kesin. Tüm öğeler 1s ise, sonuç toplamları olur, aksi takdirde - 0:

   (#**/)@, 3 3$1 0 0 1 1 1 1 1 1
0
   (#**/)@, 2 2$1 1 1 1
4 

   ((,~@#\)(+/**/)@,;._3"$]) a
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1

0 0 0 0 0
0 0 4 4 0
0 0 0 0 0

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

Sonunda, her bir alt matris için sonuç listesini düzleştiriyorum ve maksimumu buluyorum:

>./@,

   ([:>./@,,~@#\(+/**/)@,;._3"$]) a
4

APL (Dyalog Unicode) , 35 34 32 bayt

{⌈/{×⍨⍵×1∊{∧/∊⍵}⌺⍵ ⍵⊢X}¨⍳⌊/⍴X←⍵}

Çevrimiçi deneyin!

Adám'ın SBCS kodundaki tüm karakterlere sahip

Açıklama sonunda geliyor!

Retina , 143 bayt

%`$
,;#
+%(`(\d\d.+;#)#*
$1¶$&¶$&#
\G\d(\d+,)|\G((;#+¶|,)\d)\d+
$1$2
)r`((11)|\d\d)(\d*,;?#*)\G
$#2$3
1,
#
Lv$`(#+).*;\1
$.($.1*$1
N`
-1G`
^$
1

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Girdiyi virgülle ayrılmış dizeler olarak alır. Açıklama:

%`$
,;#

,Son dizeyi sonlandırmak için a ;, dizeleri #s'den ayırmak için a #ve bir sayaç olarak ekleyin .

+%(`
)

Daha fazla alt yerleşim gerçekleşmeyene kadar bloğu tekrarlayın (çünkü her dize artık yalnızca bir basamak uzunluğundadır).

(\d\d.+;#)#*
$1¶$&¶$&#

Satırı üçe katlayın, sayacı ilk satırda 1'e ayarlayın ve son satırda artırın.

\G\d(\d+,)|\G((;#+¶|,)\d)\d+
$1$2

İlk satırda her dizenin ilk basamağını, ikinci satırda ise ilk basamağı hariç tüm basamakları silin.

r`((11)|\d\d)(\d*,;?#*)\G
$#2$3

Üçüncü satırda, bitsel ve ilk iki basamak birlikte.

1,
#

Bu noktada, her çizgi iki değerden oluşur: a) yatay genişlik sayacı ve b) bitsel ve her dizeden alınan birçok bit. Kalan s'leri 1s ile #sayaç arasında karşılaştırılabilsin.

Lv$`(#+).*;\1
$.($.1*$1

1Orijinal girişteki s karelerine karşılık gelen (yatay olarak) bitle eşleşen tüm bitleri (dikey olarak) bulun ve uzunluğu karelayın.

N`

Sayısal olarak sırala.

-1G`

En büyüğünü al.

^$
1

Özel durum sıfır matrisi.

JavaScript, 92 bayt

a=>(g=w=>a.match(Array(w).fill(`1{${w}}`).join(`..{${W-w}}`))?w*w:g(w-1))(W=a.indexOf`,`)||1

f=
a=>(g=w=>a.match(Array(w).fill(`1{${w}}`).join(`..{${W-w}}`))?w*w:g(w-1))(W=a.indexOf`,`)||1
console.log(f('0111,1111,1111,1111'));
console.log(f('10100,10111,11111,10010'));
console.log(f('0111,1101,0111'));

APL (Dyalog Klasik) , 21 20 bayt

×⍨{1∊⍵:1+∇2×/2×⌿⍵⋄0}

Çevrimiçi deneyin!

Python 2 , 117 109 bayt

Bana ek bir bayta mal olan bir verimsizliğe işaret ettiği için @etene'ye teşekkür ederiz.

lambda s:max(i*i for i in range(len(s))if re.search(("."*(s.find(',')-i+1)).join(["1"*i]*i),s))or 1
import re

Çevrimiçi deneyin!

Girdiyi virgülle ayrılmış bir dize olarak alır. Bu, giriş dizesini 111.....111.....111, karenin tüm olası boyutları için form kalıplarıyla eşleştirmeye çalışan normal ifade tabanlı bir yaklaşımdır .

Hesaplamalarımda, bunu anonim bir lambda ile yapmak, tanımlanan işlevden veya tam bir programdan biraz daha kısa. Sondaki or 1kısım 1, girişte hiç kimse yoksa çıktı almamız gereken garip kenar kasasını işlemek için gereklidir .

Python 2 , 116 115 117 109 bayt

@Kirill'e daha da golf oynamam için ve akıllı ve erken çözümü için krediler

Düzenleme : Bir lambda kullanarak 1 bayt Golf, bir değişkene atama bayt sayısı doğru saymadım bilmiyordum.

Edit 2 : Kirill, girişimin yalnızca 1s içerdiği durumlarda işe yaramadığını , düzeltmek zorunda kaldım ve iki değerli bayt kaybettiğimi belirtti ...

Edit 3 : Kirill sayesinde daha fazla golf

Virgülle ayrılmış bir dize alır, bir tamsayı döndürür.

lambda g:max(i*i for i in range(len(g))if re.search(("."*(g.find(",")+1-i)).join(["1"*i]*i),g))or 1
import re

Çevrimiçi deneyin!

Bağımsız olarak Kiril'in cevabına yakın bir cevap buldum, yani regex tabanlı, re.search ve adef .

Her döngü sırasında artan şekilde daha büyük bir kareyi eşleştirmek için oluşturulmuş bir normal ifade kullanır ve en büyük kareyi veya 1 değerini döndürür.

Ruby -n , 63 bayt

p (1..l=$_=~/,|$/).map{|i|/#{[?1*i]*i*(?.*(l-i+1))}/?i*i:1}.max

Çevrimiçi deneyin!

Python cevabımın yakut versiyonu . Golfçü tam bir program olarak. Alternatif olarak, anonim bir lambda:

Yakut , 70 68 bayt

->s{(1..l=s=~/,|$/).map{|i|s=~/#{[?1*i]*i*(?.*(l-i+1))}/?i*i:1}.max}

Çevrimiçi deneyin!

Perl 6 , 61 60 58 bayt

{(^$_ X.. ^$_).max({[~&](.[|$^r||*])~~/$(1 x$r)/&&+$r})²}

Çevrimiçi deneyin!

Python 2 , 138128 bayt

def f(m):j=''.join;L=j(m);k=map(j,zip(*m));return len(L)and max(len(L)*(len(m)**2*'1'==L),f(k[1:]),f(k[:-1]),f(m[1:]),f(m[:-1]))

Çevrimiçi deneyin!

Kayıtlı

• Ovs sayesinde -10 bayt

Clojure, 193 bayt

#(apply max(for [f[(fn[a b](take-while seq(iterate a b)))]R(f next %)R(f butlast R)n[(count R)]c(for[i(range(-(count(first R))n -1)):when(apply = 1(for[r R c(subvec r i(+ i n))]c))](* n n))]c))

Vay canına, işler tırmanıyor: o

Daha az golf:

(def f #(for [rows (->> %    (iterate next)    (take-while seq)) ; row-postfixes
              rows (->> rows (iterate butlast) (take-while seq)) ; row-suffixes
              n    [(count rows)]
              c    (for[i(range(-(count(first rows))n -1)):when(every? pos?(for [row rows col(subvec row i(+ i n))]col))](* n n))] ; rectangular subsections
          c))