Uma cadeia de caracteres é considerada quadrada se as seguintes condições forem atendidas:

• Cada linha tem o mesmo número de caracteres
• O número de caracteres em cada linha é igual ao número de linhas.

Sua tarefa é escrever um programa ou função que determine se uma determinada sequência de entrada é ou não um quadrado.

Você pode exigir que a entrada seja delimitada por sua escolha de LF, CR ou CRLF.

Os caracteres da nova linha não são considerados parte do comprimento da linha.

Você pode exigir que exista ou não uma nova linha à direita na entrada, que não conta como uma linha adicional.

Input é uma string ou um array de caracteres 1D; não é uma lista de strings.

Você pode assumir que a entrada não está vazia e contém apenas ASCII imprimível, incluindo espaços.

Você deve gerar um valor de verdade para cadeias de caracteres quadradas e um valor falso para outras cadeias de caracteres.

Casos de teste de verdade:

foo
Barra
baz

.

.s.
.ss
.s.
(s representa espaço)

ss
ss
(s representa espaço)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

Casos de teste de falsidade:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Observe linhas em branco extras em alguns casos de falsificação.

Isso é código-golfe - o menor número de bytes vence!

Braquilog (2), 3 bytes

ṇẹṁ

Experimente online!

Programa completo. Saídas true.para verdade, false.para falsey.

Explicação

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

Fiquei um pouco cético sobre a utilidade do ṁbuilt-in quando foi adicionado, mas não posso negar que é útil aqui ...

Braquilog (2), 7 bytes

ṇẹ.\l~l

Experimente online!

Solução não embutida. Ainda supera todas as outras entradas, até o momento da redação. EDIT: Não é bem assim, a entrada Jelly de mesmo tamanho entrou enquanto eu escrevia isso e a superava através do tiebreak de timestamp.

Explicação

ṇẹ.\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

Python 2 , 52 bytes

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

Experimente online! ou Experimente todos os casos de teste

JavaScript (ES6), 46 45 bytes

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

• 1 byte economizado graças a ETHproductions

Explicação

1. Divida a string em uma matriz em novas linhas.
2. Loop sobre a matriz.
3. Subtraia o comprimento da matriz do comprimento de cada linha.
4. Se um valor diferente de zero (ou seja, verdade) for retornado para qualquer linha, a sequência não será quadrada.
5. Negue o resultado do loop para obter o truequadrado e o falsenão.

Tente

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>

05AB1E , 10 8 bytes

¶¡€gDgQP

Experimente online!

-2 Graças a Riley, esta é basicamente a resposta dele.

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

Geléia , 7 5 bytes

Ỵ¬⁼Z$

Experimente online!

Agradecimentos a FryAmTheEggman por -2

Haskell, 38 34 bytes

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

Experimente online!

Versão sem pontos f s = all ((==length (lines s)).length) (lines s), ou seja, divida a entrada em linhas e verifique se o comprimento de cada linha é igual ao número de linhas.

Edit: Obrigado a @xnor por 4 bytes.

Geléia , 7 bytes

ỴµL;L€E

Experimente online!

Explicação

Ỵµ       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.

Japonês , 9 bytes

=Ur.Q)¥Uy

Teste online!

Explicação

 =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

Usando alguns recursos implementados logo após o lançamento deste desafio, isso pode ter 6 bytes:

r.Q
¥y

Teste online!

Explicação

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

Retina , 33 31 bytes

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

Experimente online! Explicação: O primeiro estágio simplesmente altera todo o ASCII imprimível no mesmo caractere para facilitar a correspondência. (Isso pode ser feito sem, mas isso é código de golfe, não código de desafio.) O segundo estágio corresponde a pelo menos um caractere na primeira linha. No entanto, para cada caractere adicional na primeira linha, ele corresponde opcionalmente a uma nova linha seguida por uma cópia da primeira linha. A parte final da expressão causa falha na correspondência se houver mais colunas do que linhas.

Casca , 6 bytes

S≡T'a¶

Pega uma corda e imprime um 1ou 0. Experimente online! A primeira linha itera sobre os casos de teste; remova-o se desejar testar um único valor.

Explicação

Husk é uma nova linguagem funcional de golfe criada por mim e por Leo . Faltam muitos recursos e o desenvolvimento está em andamento. Sua principal característica é um sistema de tipo rígido que nos permite sobrecarregar funções de ordem superior.

Em um nível alto, o programa funciona assim:

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.

A função ≡realmente verifica se duas matrizes têm a mesma forma e a mesma distribuição de elementos de verdade. No Husk, todos os caracteres, exceto o byte nulo, são verdadeiros e isso não ocorrerá em nossas entradas. Além disso, Sé o S-combinator , uma função que recebe como entrada duas funções, aqui ≡e T'a, e retorna uma nova função que é mapeada xpara ≡(x)(T'a x). O resultado de Sé composto por ¶e essa função é aplicada à entrada implicitamente.

Como Husk sabe que deve se aplicar Sà próxima função, mas ¶deve ser composto com a função à esquerda? Simples: apenas tenta todas as interpretações e escolhe aquela em que os tipos fazem sentido. Isso é explicado em mais detalhes na documentação da Husk .

Pure bash (sem utilitários), 55

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

• mapfile lê a entrada na matriz a
• então o número de elementos da matriz é XORed com cada comprimento de linha e a soma obtida. Para um quadrado perfeito, cada resultado XOR (e, portanto, a soma) será 0. Para qualquer outra coisa, o resultado será> 0.

O sentido oposto disso é retornado como um código de retorno do shell (examine com echo $?) - o quadrado perfeito é 1, qualquer outra coisa é 0.

Experimente online (na verdade) .

Experimente online (falsy) .

Resposta anterior usando eval-escape-expansion hell, 78:

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

Experimente online (na verdade) .

Experimente online (falsy) .

Perl 6 , 27 bytes

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

Testa se o número de linhas na sequência de entrada é igual ao número de caracteres em cada linha.

Pitão, 7 bytes

CImL1.z

Experimente aqui

Não requer nova linha final. Substitui a entrada por uma matriz 2D de 1s, em que 1 representa qualquer caractere na entrada original. Em seguida, verificamos se esse array permanece inalterado após a transposição (substituindo colunas por linhas). Somente um quadrado retornará verdadeiro em tal situação.

Java (OpenJDK 8) ,96 91 90 87 bytes

-5 bytes graças a @KevinCruijssen
-1 byte graças a @TheLethalCoder
-2 bytes graças a @ OlivierGrégoire

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

Experimente online!

05AB1E , 7 bytes

|€gDgQP

Experimente online!

R , 57 bytes

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

Uma função anônima; Divide em novas linhas, calcula o comprimento de cada linha e verifica se todas são iguais ao número de linhas.

Experimente online!

MATL , 14 12 bytes

10H&XXot&n=h

A cadeia de entrada é definida usando concatenação ( [...]) e com o ponto de código 10para representar LF. Por exemplo, ['aaa' 10 'bb']é interpretado em MATL como sequência 'aaa'concatenada com o caractere com ponto de código 10concatenado com sequência 'bb'.

A saída é um vetor numérico não vazio, que é verdadeiro se e somente se todas as suas entradas forem diferentes de zero.

Experimente online!

Explicação

Considere entrada ['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]

R, 35 bytes

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

Recebe entrada de stdin. Verifica se o número de caracteres em cada linha é igual ao número total de linhas. Retorna TRUEou FALSEconforme apropriado.

JavaScript (ES6), 48 bytes

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

CJam, 11 bytes

qN/:,_,f=:*

Experimente online!

OCaml , 56 bytes

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

Experimente online!

Pitão, 12 10 bytes

!fnl.zlT.z

Economizou 2 bytes graças a @FryAmTheEggman.

Experimente online

Explicação

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

QBIC , 43 bytes

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

Eu estou feliz com o quão curto um derivado QBasic chegou a esse desafio.

Explicação:

{_?       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.

Pitão, 7 bytes

qCC.z.z

Demonstração

Transponha a entrada com truncamento duas vezes e verifique se o resultado é igual ao original.

Ruby, 50 bytes

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

Experimente online!

Explicação

1. Divida a entrada em matriz na nova linha.
2. Afirme que uma matriz que contém apenas o tamanho dessa matriz é igual a uma matriz que contém todos os tamanhos uniq (conjunto de união com matriz vazia) de todos os elementos dessa matriz.

Cheddar , 39 bytes

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

Experimente online!

Clojure, 58 bytes

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

Requer uma nova linha à direita, ansiosa para ver algo mais mágico.

APL (Dyalog) , 17 bytes

Requer ⎕ML←3qual é o padrão em muitos sistemas. Usa CR.

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

Experimente online!

↓∘⎕FMT [é a] dividida em linhas- F ou m uma t ted-em-um-quadrado argumento

≡ idêntico a

⎕TC[2]∘≠ os caracteres em grupos de não-nova linha *

⊂ particionado

⊢ argumento?

* O segundo elemento da lista de t erminal C caracteres ontrolo.

Na versão 16.0, pode-se escrever ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢com ⎕ML←1.

PowerShell, 64 bytes

As mesmas abordagens (divisão, comprimento das linhas, número de linhas) que outras respostas em idiomas que não são de golfe, mas não há um bom mapa () equivalente; portanto, é uma matriz de comprimentos de linha com o número de linhas marcadas no final, então essa matriz está agrupado. Quadrados saem como 3,3,3,3 -> 1 group, all line lengths and line count were equale não quadrados saem como 3,2,1 -> 3 groups, algo era desigual na praça:

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

Requer nova linha no estilo Linux, sem nova linha final. por exemplo

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

$Ttests | % { & $f $_ }

(E você pode fazer o mesmo para os testes falsos, mas não vou colocá-lo aqui, pois há mais deles). O par de @símbolos é necessário para que, quando a entrada for a única '.'dividida, ela não forme uma matriz de uma sequência, apenas crie uma sequência e, em seguida, a concatenação da matriz não 1,1gera a saída 2.

Eu esperava que pudesse ser mais curto substituir todos os caracteres por 'a' e, em seguida, força bruta de 1 ao comprimento da entrada todos os quadrados 'a' e ver se algum deles correspondia à entrada. Depois de passar por param () e .Length e -join e -replace, ele termina muito mais em 81 bytes:

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

Grime , 11 bytes

e`.|_./+/.+

Imprime 1para quadrados e 0para não quadrados. Experimente online!

Explicação

Uma explicação detalhada pode ser encontrada na página de tutorial do Grime , que contém este programa exato como exemplo.

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.