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

Python 2, 52 bytes

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

Try it online! or Try all test cases

Answer 2

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

Jelly, 7 5 bytes

Ỵ¬⁼Z$

Try it online!

Thanks to FryAmTheEggman for -2

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

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 7

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 8

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 9

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 10

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 11

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 12

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 13

Jelly, 4 bytes

Ỵ¬zƑ

Try it online!

Input via command-line argument. The input must be given with no trailing newline (otherwise the program sees a blank line at the end, which isn't the same length as the others); this I/O format is explicitly allowed by the question.

So far, the shortest answer that doesn't use an "is a square" builtin. (There's an existing 5-byte Jelly answer that works on similar principles, but is wrong, incorrectly considering "aa\na" to be square – this answer is not only shorter, it also fixes that issue.)

Explanation

Ỵ¬zƑ
Ỵ      split {the input} on newlines
 ¬     replace every truthy character (i.e. all of them) with 0
   Ƒ   does that remain unchanged, after
  z      a ragged transpose that pads to a rectangle using {the input}?

There are two main cases:

• The string is not even a rectangle. In this case, the "transpose and pad to rectangle" builtin z will pad the string to a rectangle, but uses copies of the user input as the padding, which are not zeroes (even if the input uses the character '0', this compares unequal to the integer 0). So there's no way the ragged transpose can leave the split-and-zeroed version of the input unchanged.
• The string is a rectangle. In this case, the ragged transpose won't apply any padding, but will produce a rectangle of zeroes with the number of rows and columns swapped from the transpose input. The only way the input and output can match is therefore if the number of rows equals the number of columns, i.e. the input is a square. (If the input is a square, the transpose will leave it unchanged because, as every element is a zero, all the elements will be the same and thus it doesn't matter that the transpose swaps some of them.)

Answer 14

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 15

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

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 19

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 20

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 21

JavaScript (ES6), 48 bytes

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

Answer 22

CJam, 11 bytes

qN/:,_,f=:*

Try it online!

Answer 23

OCaml, 56 bytes

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

Try it online!

Answer 24

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 25

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 26

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 27

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 28

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 29

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 30

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