この質問は、グリッド内の最大の正方形に似ています。

チャレンジ

行列を考える1と、0文字列形式で"xxxx,xxxxx,xxxx,xx.."または配列形式を["xxxx","xxxx","xxxx",...]、あなたはすべてが含まれている最大の広場部分行列の面積を決定する関数を作成します1。

正方形の部分行列は、幅と高さが等しいものであり、関数はのみを含む最大の部分行列の領域を返す必要があります1。

例えば：

"10100,10111,11111,10010"この場合、これは次のマトリックスのようになります。

1 0 1 0 0

1 0 1 1 1

1 1 1 1 1

1 0 0 1 0

太字で1作成されたサイズ2x2の最大の正方形の部分行列を確認できるため、プログラムは4の領域を返すはずです。

ルール

• 部分行列は、幅と高さが同じでなければなりません
• サブマトリックスには値のみが含まれている必要があります 1
• 関数は最大の部分行列の領域を返す必要があります
• 部分行列が見つからない場合は、 1
• あなたはの数をカウントすることにより、部分行列の面積を計算することができ1部分行列に

テストケース

入力： "10100,10111,11111,10010" 出力： 4

入力： "0111,1111,1111,1111" 出力： 9

入出力 "0111,1101,0111" ： 1

これはcode-golfなので、バイト単位の最短の回答が優先されます。

ゼリー、18 バイト

_{+2すべてなし1のサブリスト存在出力を処理する}

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

オンラインでお試しください！またはテストスイートを見る

どうやって？

Ẇ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 118117バイト

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]

オンラインでお試しください！

_{ライコニのおかげで-3バイト！}

_{リンのおかげで-1バイト！}

_{すべて1のサブマトリックスがない場合に1を返すというばかげた要件のために+8バイト。}

説明/ゴルフ

次のヘルパー関数は、オフセットを作成してx、それらをデクリメントできるようにしますs。

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

x#yyリストから要素を削除し、次を取得しますx：

t#d=take t.drop d

関数はf、サブ行列のすべての可能なサイズを順番にループし、対応するサイズの各サブ行列を生成し、'1's のみが含まれているかどうかをテストし、サイズを格納します。したがって、ソリューションはリストの最後のエントリになります。

--          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バイト

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

入力が1の正方行列かどうかをチェックします。正方行列のs==('1'<$s<$s)場合、答えはlength ^ 2、それ以外は0です。次に、最初/最後の列/行を再帰的にチョップし、どこかで見つかった最大値を取ります。

オンラインでお試しください！

K（ngn / k）、33 28バイト

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

オンラインでお試しください！

J、33 27バイト

FrownyFrogのおかげで-6バイト！

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

オンラインでお試しください！

説明：

説明では最初のテストケースを使用します。

    ] 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から入力の行数までのサイズのすべての可能な正方部分行列を生成します。

,~@#\入力の,.連続するプレフィックスの長さを合わせてステッチすることにより、部分行列のサイズのペアのリストを作成#\します。

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

次にx u ;. _3 y、それらを使用して、入力を部分行列にカットします。私はすでに持っていますx（サイズのリスト）; y正しい引数]（入力）です。

 ((,~@#\)<;._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│   │ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
│     │     │     │   │ │
├─────┼─────┼─────┼───┼─┤
│     │     │     │   │ │
└─────┴─────┴─────┴───┴─┘

各(#**/)@,サブマトリックスについて、それが1で完全に構成されているかどうかを確認 します。すべてのアイテムが1の場合、結果はそれらの合計になります。それ以外の場合、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

最後に、各サブマトリックスの結果のリストをフラット化して、最大値を見つけます。

>./@,

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

APL（Dyalog Unicode）、35 34 32バイト

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

オンラインでお試しください！

アダムのSBCSはコード内のすべての文字を持っています

やがて説明が来る！

Retina、143バイト

%`$
,;#
+%(`(\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

オンラインでお試しください！リンクにはテストケースが含まれます。入力をカンマ区切りの文字列として受け取ります。説明：

%`$
,;#

,最後の文字列を終了するにはa を追加;し、#s から文字列を分離するにはa #を、カウンタとしてa を追加します。

+%(`
)

置換が発生しなくなるまでブロックを繰り返します（各文字列の長さが1桁になるため）。

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

行を3回繰り返し、最初の行でカウンターを1に設定し、最後の行でカウンターを増やします。

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

1行目で各文字列の最初の数字を削除し、2行目で最初の数字以外のすべての数字を削除します。

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

3行目では、ビット単位で、最初の2桁を合わせています。

1,
#

この時点で、各行は2つの値、a）水平方向の幅のカウンターとb）ビット単位、および各文字列から取得されたその数のビットで構成されます。残り1のをに変換します# sにして、カウンターと比較できるようにします。

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

1元の入力のsの2乗に対応し、カウンターと（水平方向に）一致するビットの（垂直方向の）ランを見つけ、長さを二乗します。

N`

数値で並べ替えます。

-1G`

最大のものを取る。

^$
1

ゼロ行列の特別な場合。

JavaScript、92バイト

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 Classic）、21 20バイト

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

オンラインでお試しください！

パイソン2、117の 109バイト

@eteneのおかげで、1バイト余分にかかる非効率性を指摘してくれました。

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

オンラインでお試しください！

入力をカンマ区切りの文字列として受け取ります。これは111.....111.....111、正方形の可能なすべてのサイズについて、フォームのパターンに対して入力文字列を照合する正規表現ベースのアプローチです。

私の計算では、匿名のラムダでこれを行うことは、定義された関数または完全なプログラムよりも少し短いだけです。or 1最後の部分は、奇妙なエッジケースを処理するためにのみ必要1であり、入力に何も存在しない場合は出力する必要があります。

パイソン2、116の 115 117 109バイト

ゴルフをさらに手助けしてくれた彼の巧妙で初期の解決策に対する@Kirillの功績

編集する：ラムダを使用して1バイトをゴルフしましたが、変数に割り当ててもバイトカウントにカウントされないことを知りませんでした。

編集2：Kirillは、入力に1s のみが含まれている場合、私のソリューションが機能しないことを指摘し、修正する必要があり、2つの貴重なバイトを失いました...

編集3：キリルのおかげでより多くのゴ​​ルフ

コンマ区切りの文字列を取り、整数を返します。

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

オンラインでお試しください！

私は独立して、私が使用していることを除いて、キリルの答えに近い答え、つまり正規表現ベースの答えを見つけましre.search たdef。

各ループの間に作成された正規表現を使用して、徐々に大きくなる正方形に一致させ、最大の正方形、つまり1を返します。

Ruby -n、63バイト

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

オンラインでお試しください！

私のPython回答の Rubyバージョン。完全なプログラムとしてのゴルファ。または、匿名のラムダ：

Ruby、70 68バイト

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

オンラインでお試しください！

Perl 6の、61の 60 58バイト

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

オンラインでお試しください！

パイソン2、138の 128バイト

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

オンラインでお試しください！

保存しました

• ovsのおかげで-10バイト

Clojure、193バイト

#(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))

うわー、事態はエスカレートしました：o

より少ないゴルフ：

(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))