Is this string a square?

Question

A string is considered to be square if the following conditions are met:

• Each line has the same number of characters
• The number of characters on each line is equal to the number of lines.

Your task is to write a program or function which determines whether or not a given input string is a square.

You may require input to be delimited by your choice of LF, CR, or CRLF.

The newline character(s) are not considered part of the line's length.

You may require there to be or to not be a trailing newline in input, which doesn't count as an additional line.

Input is a string or 1D char array; it is not a list of strings.

You may assume input is non-empty and only contains printable ASCII, including spaces.

You must output a truthy value for square strings and a falsy one for other strings.

Truthy test cases:

foo
bar
baz

.

.s.
.ss
.s.
(s represents space)

ss
ss
(s represents space)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

Falsy test cases:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Note extra blank lines in some of the falsy cases.

This is code-golf - fewest bytes wins!

Answer 1

Brachylog (2), 3 bytes

ṇẹṁ

Try it online!

Full program. Outputs true. for truthy, false. for falsey.

Explanation

ṇẹṁ
ṇ     Split {standard input} into lines
 ẹ    Split {each line} into basic elements {in this case, characters}
  ṁ   Assert that the result is square

I was a bit sceptical about the usefulness of the ṁ builtin when it was added, but I can't really deny that it's helpful here…

Brachylog (2), 7 bytes

ṇẹ.\l~l

Try it online!

Non-builtin solution. Still beats all the other entries, as of the time of writing. EDIT: Not quite, the equal-length Jelly entry got in while I was writing this, and beats it via the timestamp tiebreak.

Explanation

ṇẹ.\l~l
ṇ         Split {standard input} into lines
 ẹ        Split {each line} into basic elements {in this case, characters}
   \l     Assert that the result is rectangular, and the number of columns
  .  ~l     is equal to the number of rows

Answer 2

Python 2, 52 bytes

x=input().split('\n')
print{len(x)}==set(map(len,x))

Try it online! or Try all test cases

Answer 3

JavaScript (ES6), 46 45 bytes

s=>!(s=s.split`
`).some(x=>x.length-s.length)

• 1 byte saved thank to ETHproductions

---

Explanation

1. Split the string to an array on newlines.
2. Loop over the array.
3. Subtract the length of the array from the length of each line.
4. If a non-zero (i.e., truthy) value is returned for any line, the string is not square.
5. Negate the result of the loop to get true for square and false for not.

---

Try it

f=
s=>!(s=s.split`
`).some(x=>x.length-s.length)
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value=`foo
bar
baz`)

<textarea id=i></textarea><pre id=o>

Answer 4

Japt, 9 bytes

=Ur.Q)¥Uy

Test it online!

Explanation

 =Ur.Q)¥ Uy
U=Ur.Q)==Uy
             // Implicit: U = input string, Q = quotation mark
U=    )      // Set U to
  Ur.Q       //   U with each non-newline (/./g) replaced with a quotation mark.
       ==Uy  // Return U == U transposed. U is padded to a rectangle with spaces before
             // transposing; if U was not a rectangle before, or the sides are not of
             // equal length, the result will not be the same as U.
             // Implicit: output result of last expression

---

Using some features implemented shortly after this challenge was posted, this can be 6 bytes:

r.Q
¥y

Test it online!

Explanation

       // Implicit: U = input string
r.Q    // Replace each non-newline (/./g) in U with a quotation mark.
       // Newline: set U to the result.
¥      // Return U ==
 y     //   U transposed.
       // Implicit: output result of last expression

Answer 5

05AB1E, 10 8 bytes

¶¡€gDgQP

Try it online!

-2 thanks to Riley, this is basically his answer ._.

Code       # Explanation                  | Truthy Example          | Falsy Example
-----------#------------------------------+-------------------------+--------------
¶¡         # Split on newlines            | [['aaa','aaa','aaa']]   | [['aa']]
  €g       # Get length of each           | [[3,3,3]]               | [[2]]
    D      # Dupe                         | [[3,3,3],[3,3,3]]       | [[2],[2]]
     g     # Get length                   | [[3,3,3],3]             | [[2],1]
      Q    # Check equality               | [[1,1,1]]               | [[0]]
       P   # Take product                 | 1                       | 0

Answer 6

Jelly, 7 bytes

ỴµL;L€E

Try it online!

Explanation

Ỵµ       Split the input on newline and use as input in the second link     
  L      Get the number of list items
   ;     And append to that
    L€   A list with the legth of each list item
      E  Check to see if all items are equal.

Answer 7

Haskell, 38 34 bytes

l=length
(all=<<(.l).(==).l).lines

Try it online!

Pointfree version of f s = all ((==length (lines s)).length) (lines s), i.e split the input into lines and check if the length of each line is equal to the number of lines.

Edit: Thanks to @xnor for 4 bytes.

Answer 8

Jelly, 7 5 bytes

Ỵ¬⁼Z$

Try it online!

Thanks to FryAmTheEggman for -2

Answer 9

Retina, 33 31 bytes

.
.
^(.(.)*)(?<-2>¶\1)*$(?(2).)

Try it online! Explanation: The first stage simply changes all printable ASCII into the same character to make it easier to match. (It could be done without, but this is code golf, not code challenge.) The second stage then matches at least one character on the first line. However, for each additional character on the first line, it then optionally matches a newline followed by a copy of the first line. The final part of the expression causes the match to fail if there are more columns than rows.

Answer 10

Husk, 6 bytes

S≡T'a¶

Takes a string and prints either 1 or 0. Try it online! The first line iterates over the test cases; remove it if you want to test on a single value.

Explanation

Husk is a new functional golfing language created by myself and Leo. It's missing a lot of features and development is ongoing. Its main feature is a rigid type system that allows us to overload higher order functions.

On a high level, the program works like this:

S≡T'a¶  Define a function:
     ¶  split on newlines,
  T'a   transpose and pad to rectangle using character 'a',
 ≡      check if this has the same shape as
S       the split input.

The function ≡ actually checks if two arrays have the same shape and the same distribution of truthy elements. In Husk, all characters except the null byte are truthy, and that won't occur in our inputs. Also, S is the S-combinator, a function that takes as inputs two functions, here ≡ and T'a, and returns a new function that maps x to ≡(x)(T'a x). The result of S is composed with ¶, and that function is applied to the input implicitly.

How does Husk know that it should apply S to the next function, but ¶ should be composed with the function on its left? Simple: it just tries every interpretation and picks the one where the types make sense. This is explained in more detail in the Husk documentation.

Answer 11

Perl 6, 27 bytes

{.lines==all .lines».comb}

Tests whether the number of lines in the input string is equal to the number of characters on each line.

Answer 12

Pure bash (no utilities), 55

mapfile -t a
for l in ${a[@]};{
((c+=${#l}^${#a[@]}))
}

• mapfile reads the input into array a
• then the number of elements of the array is XORed with each line length, and the sum taken. For a perfect square, each XOR result (and thus the sum) will be 0. For anything else, the result will be >0.

The opposite sense of this is returned as a shell return code (examine with echo $?) - perfect square is 1, anything else is 0.

Try it online (truthy).

Try it online (falsy).

---

Previous answer using eval-escape-expansion hell, 78:

mapfile -t a
echo $[0$(eval eval echo +\\$\{#a[{0..$[${#a[@]}-1]}]}^${#a[@]})]

Try it online (truthy).

Try it online (falsy).

Answer 13

Pyth, 7 bytes

CImL1.z

Try it here

Requires no trailing newline. Replaces the input with a 2D array of 1s where a 1 represents any character in the original input. Then we check whether that array is unchanged after transposing it (replacing columns with rows). Only a square will return true in such a situation.

Answer 14

Java (OpenJDK 8), 96 91 90 87 bytes

-5 bytes thanks to @KevinCruijssen
-1 byte thanks to @TheLethalCoder
-2 bytes thanks to @OlivierGrégoire

a->java.util.Arrays.stream(a.split("\n")).allMatch(x->x.length()==a.split("\n").length)

Try it online!

Answer 15

MATL, 14 12 bytes

10H&XXot&n=h

The input string is defined using string concatenation ([...]) and with the code point 10 to represent LF. For example, ['aaa' 10 'bb'] is interpreted in MATL as string 'aaa' concatenated with the character with code point 10 concatenated with string 'bb'.

The output is a non-empty numeric vector, which is truthy if and only if all its entries are non-zero.

Try it online!

Explanation

Consider input ['4444' 10 '333' 10 '22'].

10H   % Push 10 (code point of LF). Push 2
      % STACK: 10, 2
&XX   % Regexp with three arguments. First argument is implicit input (string);
      % second is 2, which indicates that we want to split the input; third is
      % 10, which is the character to split on. The result is a cell array of
      % matched strings
      % STACK: {'4444', '333', '22'}
o     % Concatenate into a numeric 2D array of code points, right-padding with
      % zeros if needed
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0]
t&n   % Duplicate. Push number of rows and number of columns
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0], 3, 4
=     % Are they equal?
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0], 0
h     % Concatenate into a row vector (in column-major order). Implicit display
      % STACK: [52 51 50 52 51 50 52 51 0 52 0 0 0]

Answer 16

05AB1E, 7 bytes

|€gDgQP

Try it online!

Answer 17

R, 57 bytes

function(s)all(nchar(n<-strsplit(s,'
')[[1]])==length(n))

An anonymous function; Splits on newlines, computes the length of each line, and checks if all are the same as the number of lines.

Try it online!

Answer 18

R, 35 bytes

all(nchar(x<-scan(,""))==length(x))

Takes input from stdin. Checks that the number of characters in each line is equal to the total number of lines. Returns TRUE or FALSE as appropriate.

Answer 19

JavaScript (ES6), 48 bytes

s=>(a=s.split`
`,a.every(l=>l.length==a.length))

Answer 20

CJam, 11 bytes

qN/:,_,f=:*

Try it online!

Answer 21

Pyth, 12 10 bytes

!fnl.zlT.z

Saved 2 bytes thanks to @FryAmTheEggman.

Try it online

Explanation

!fnl.zlT.z
 f     T.z     Filter lines of the input
  nl.zl        whose length is not the number of lines
!              and return whether there are no such lines.

Answer 22

OCaml, 56 bytes

let f t=List.(for_all(fun l->String.length l=length t)t)

Try it online!

Answer 23

QBIC, 43 bytes

{_?~_lA||h=h+1┘g=g+_lA|~g%_lA||_Xp]\_xg/h=h

Me, I'm happy with how short a QBasic derivative got to go on this challenge.

Explanation:

{_?       DO infinitely: ask the user for input, store as A$
~    |    IF
 _lA|       The length of A$   (implicitly <> 0)
h=h+1     Add 1 to our line counter
┘         (syntactic linebreak)
g=g+_lA|  Add the length of this line to the running total of line lengths
~      |  IF
 g%_lA|     The length of the running total modulo the length of the last string
            yields anything but 0, there is a discrepancy between earlier line
            lengths and this one.
_Xp]      THEN QUIT, printing 0, end IF
\         ELSE (refers to the LEN(A$), user didn't input anything.
_xg/h=h   QUIT (the inf. loop) printing -1 if the root of the chars is the row count
            or 0 if not.

Answer 24

Pyth, 7 bytes

qCC.z.z

Demonstration

Transpose the input with truncation twice, then check if the result is the same as the original.

Answer 25

Ruby, 50 bytes

s=$<.read.split $/,-1;p [s.size]==s.map(&:size)|[]

Try it online!

Explanation

1. Split input into array on newline.
2. Assert that an array containing only the size of this array is equal to an array containing all uniq (set union with empty array) sizes of all elements in this array.

Answer 26

Cheddar, 39 bytes

@.split("
").all((i,j,k)->i.len==k.len)

Try it online!

Answer 27

Clojure, 58 bytes

#(let[s(re-seq #"[^\n]+"%)c count](apply =(c s)(map c s)))

Requires a trailing newline, looking forward to seeing something more magical.

Answer 28

APL (Dyalog), 17 bytes

Requires ⎕ML←3 which is default on many systems. Uses CR.

↓∘⎕FMT≡⎕TC[2]∘≠⊂⊢

Try it online!

↓∘⎕FMT [is the] split-into-lines Formatted-into-a-square argument

≡ identical to

⎕TC[2]∘≠ the into-groups-of-non-newline*-characters

⊂ partitioned

⊢ argument?

* the second element of the list of Terminal Control characters.

---

In version 16.0, one can write ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢ with ⎕ML←1.

Answer 29

PowerShell, 64 bytes

The same (split, line lengths, number of lines) approach as other non-golf language answers, but there's no nice map() equivalent, so it's an array of line lengths with the number of lines tagged onto the end, then that array is grouped. Squares come out like 3,3,3,3 -> 1 group, all line lengths and line count were equal and non-squares come out like 3,2,1 -> 3 groups, something was unequal in the square:

$f={@(@(($L="$args"-split"`n")|% le*)+$L.Count|group).Count-eq1}

Requires newline Linux-style endings, no trailing newline. e.g.

$Ttests = @(@'
foo
bar
baz
'@,
'.',
@'
aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
'@
)
$Ttests = $Ttests | foreach {$_ -replace "`r"}

$Ttests | % { & $f $_ }

(And you can do similar for the false tests, but I won't put it here as there's more of them). The couple of @ symbols are required for when the input is the single '.' otherwise splitting it doesn't make an array of one string it just makes one string, and then the array concatenation doesn't output 1,1 it outputs 2.

I hoped it might be shorter to replace all the characters with 'a', and then brute force from 1 to Input Length all the squares 'a' and see if any matched the input. Once I got past param() and .Length and -join and -replace it ends up much longer at 81 bytes:

$f={param($s)!!(1..$s.Length|?{,('a'*$_)*$_-join"`n"-eq($s-replace"[^`n]",'a')})}

Answer 30

Grime, 11 bytes

e`.|_./+/.+

Prints 1 for squares and 0 for non-squares. Try it online!

Explanation

A detailed explanation can be found on the Grime tutorial page, which happens to contain this exact program as an example.

e`.|_./+/.+
e`            Match entire input against pattern:
  .           A single character
   |          OR
    _         a recursive match of this pattern
     ./+      with one column of characters on its right
        /     and below that
         .+   one row of characters.

Answer 31

C#, 73 bytes

using System.Linq;s=>s.Split('\n').All(l=>l.Length==s.Split('\n').Length)

Explanation:

using System.Linq;    //Import Linq
s=>                   //Take input
s.Split('\n')         //Split the input stirng by line feeds
.All(l=>              //Make sure All lines in the array return true for:
l.Length              //The length of the line
==                    //Equaling
s.Split('\n').Length) //The length of the array split again by line feeds

Answer 32

Dart - 54 chars

q(s)=>!(s=s.split('\n')).any((x)=>x.length!=s.length);

(Expects input separated by newlines and not terminated by one)

Try it online

Answer 33

Perl 5, 31 bytes

29 bytes of code + -p0 flags.

/.*/;$_=/^(.{@{+}}
){@{+}}\z/

Try it online!

Explanations:
/.*/ matches the first line, and thus makes @+ contain the length of the first line. Then the regex checks whether the string contains @+ lines of length @+.

Answer 34

MacOS Bash, 34

rs -EH|awk '{print $1}'|uniq|wc -l

rs is part of the default MacOS image. This will also work on Linux if rs is installed; it is on TIO.

• rs -EH lists the length of each line, along with the number of lines
• awk strips out extraneous info
• uniq outputs one line if the line lengths and number of lines are all the same, but more otherwise
• wc -l outputs 1 if the input is square or a greater number otherwise.

Try it online: Truthy, Falsey.

Answer 35

AWK, 49 bytes

{s=length($0)}L{x+=L!=s}{L=s}END{print x?0:L==NR}

Try it online!

Could also have used a BEGIN block to set FS="" but that would be the same byte-count. For some reason using the -F"" argument never seems to work.

Answer 36

Clojure, 42 chars

#(every?(fn[x](=(count %)x))(map count %))

Answer 37

><>, 76 bytes

This should work, next step is trying to golf it more!

0v      0   <
 >i:0)?!va=?^1+
:0)?v1n;\~l:   >
    >r:@=?!vr1-^
        ;n0<

Try it online! Or more more fun, try some examples using this animated interpreter.

printf "aaa\naas\naaa" | fish _square.fish --tick 0.1 --play

Explanation

The idea is roughly as follows.

1. Fill the stack with the number of characters on each line.
2. Push the length of the stack, corresponding to the number of lines (n).
3. Do n times:
   • Check if bottom two elements are equal.
   • Remove deepest element.

Examples

For

aaa
aaa
aaa

we get [3, 3, 3, 3] after the first two steps and we can see that all three length 2 subsequences are equal. However, for

aaa
aa
a

we get [3, 2, 1, 3] and not all sequences are equal. For the last falsy case

`abc.def.ghi`

we get [11, 1] so there is only subpair we can check, but it is unequal so we return falsy.

Answer 38

Charcoal, 20 bytes

Ａ⁺№θ¶¹αＦ⪪θ¶Ａ×α⁼αＬιαα

Try it online! Prints - repeated by the side length as truthy, nothing as falsy.

Answer 39

Add++, 45 bytes

D,g,@,bU10C€=sVcG1+V10CAtbU€bLB]db=$bM*G=

Try it online!

How it works

Boy this was a long one (not even counting the footer)

D,g,@,		; Declare a monadic function 'g'
		; Example argument:    		 ['foo\nbar\nbaz']
	bU	; Unpack;		 STACK = ['f' 'o' 'o' '\n' 'b' 'a' 'r' '\n' 'b' 'a' 'z']
	10C€=s	; Count newlines;	 STACK = ['f' 'o' 'o' '\n' 'b' 'a' 'r' '\n' 'b' 'a' 'z' 2]
	VcG	; Keep last value;	 STACK = [2]
	1+V	; Increment and save;	 STACK = []			; STORE = 3
	10CAt	; Split arg on newlines; STACK = [['foo' 'bar' 'baz']]
	bU€bLB]	; Length of €ach;	 STACK = [[3 3 3]]
	db=	; Are they all equal?	 STACK = [[3 3 3] 1]
	$bM	; Max value;		 STACK = [1 3]
	*	; Logical AND;		 STACK = [3]
	G=	; Equals STORE?		 STACK = [1]

Try it online!

Answer 40

Stax, 9 bytes

éΘ┌«■/ÉW(

Run and debug online!

Turns out that due to way pairwise difference is calculated, I don't need to worry about the equivalence of k and x-k here. Saving 5 bytes.

Uses the unpacked version to explain.

Lc{%mc%+:u
L             Collect rows in a list
 c{%m         List of length of each row
     c%+      Append number of rows to the list
        :u    All elements in the list are equal

Answer 41

PHP, 65 bytes

while(~$c=$argv[1][$p++])$w+=":"^$c||$w=!$$w+=!!++$h;echo$$h==$h;

expects linux style line endings (\n) and a trailing newline; prints 1 for truthy, nothing for falsy.
Run with php -nr '<code>' '<input>' or try it online.

---

Btw: The naive approach takes 82 bytes:

<?=count($a=explode("
",$argv[1]))==min($m=array_map(strlen,$a))&min($m)==max($m);

expects linebreaks as on compile system and no trailing newline; prints 1 or 0.
Run with php -nR '<code>' '<input>'.

Answer 42

Python 3, 79 bytes

lambda a:len(set([len(list(i))for i in a.split('\n')]+[len(a.split('\n'))]))==1

Answer 43

Swift 3, 134 bytes

import Foundation;func r(s:String)->Bool{let i=s.components(separatedBy:"\n");return i.filter{$0.characters.count != i.count}.isEmpty}

Try it online!

Answer 44

PowerShell, 48 bytes

($a=$args-split'
'|%{$_.Length}).Count-eq($a|gu)

Test script:

$f = {

($a=$args-split'
'|%{$_.Length}).Count-eq($a|gu)

}

@(

,($true,@"
foo
bar
baz
"@)

,($true,@"
.
"@)

,($true,@"
. .
.  
. .
"@)

,($true,@"


"@)

,($true,@"
aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
"@)

,($false,@"
..
.
"@)

,($false,@"
.

"@)

,($false,@"

.
"@)

,($false,@"
....


....
"@)

,($false,@"
4444
333
22
"@)

,($false,@"
333
333
"@)

,($false,@"
abc.def.ghi
"@)

) | % {
    $expected,$s = $_
    $result = &$f $s
    "$($result-eq$expected): $result"
}

Output:

True: True
True: True
True: True
True: True
True: True
True: False
True: False
True: False
True: False
True: False
True: False
True: False

Explanation:

• $args-split"``n"|%{$_.Length} creates an array of length of each line.
• $a.Count counts elements of the array
• $a|gu apply Get-Unique to the array. The result is one integer element if all lines has same length.
• $a.Count-eq($a|gu) compares Count of element with result of the Get-Unique. It's true if all lines has same length and this length equals to Count.

Answer 45

Wren, 76 61 bytes

Fn.new{|a|a.split("\n").all{|x|x.count==a.split("\n").count}}

Try it online!

Old answer

The algorithm is essentially just copied from a 05AB1E answer.

Fn.new{|a|
var b=a.split("\n").map{|i|i.count}
return b.all{|i|i==b.count}
}

Try it online!

Answer 46

Red, 73 bytes

func[s][all collect[foreach b a: split s lf[keep(length? b)= length? a]]]

Try it online!

{abcd efg} represents true multiline string and not a list of strings, hence I need split s lf

Answer 47

SnakeEx, 50 bytes

This is BMac's solution to the problem for the 2D regex language design challenge.

m:{v<R>1}{h<>1}
v:${c<L>A1}+$
h:${c<R>A1}+$
c:$.+$

Try it online

Answer 48

J, 12 bytes

(*./=#)#;._2

Input requires trailing LF or CR.

Explanation:

• ;._2 split into intervals and discard trailing atom
• # count each group
• (*./=#) is a fork which returns 0 (false) or 1 (true) if the LCM of the count of each group is equal to the count-of-counts

Tests

(*./=#)#;._2 'abc', LF, 'def', LF, 'ghi', LF   NB. 1 for well-formed input
(*./=#)#;._2 'abc', LF, 'def', LF, 'ghi'       NB. 0 because no trailing LF