Una cadena se considera cuadrada si se cumplen las siguientes condiciones:

• Cada línea tiene el mismo número de caracteres.
• El número de caracteres en cada línea es igual al número de líneas.

Su tarea es escribir un programa o función que determine si una cadena de entrada dada es o no un cuadrado.

Puede requerir que la entrada esté delimitada por su elección de LF, CR o CRLF.

Los caracteres de nueva línea no se consideran parte de la longitud de la línea.

Puede requerir que haya o no una nueva línea final en la entrada, que no cuenta como una línea adicional.

La entrada es una cadena o matriz de caracteres 1D; No es una lista de cadenas.

Puede suponer que la entrada no está vacía y solo contiene ASCII imprimible, incluidos los espacios.

Debe generar un valor verdadero para cadenas cuadradas y uno falso para otras cadenas.

Casos de prueba de verdad:

foo
bar
baz

.

.s.
.ss
.s.
(s representa espacio)

ss
ss
(s representa espacio)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

Casos de prueba de falsa:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Tenga en cuenta líneas en blanco adicionales en algunos de los casos falsos.

Este es el código de golf : ¡la menor cantidad de bytes gana!

Brachylog (2), 3 bytes

ṇẹṁ

Pruébalo en línea!

Programa completo Salidas true.para la verdad, false.para falsey.

Explicación

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

Estaba un poco escéptico sobre la utilidad de la ṁconstrucción cuando se agregó, pero realmente no puedo negar que es útil aquí ...

Brachylog (2), 7 bytes

ṇẹ.\l~l

Pruébalo en línea!

Solución no incorporada. Aún supera todas las demás entradas, en el momento de la escritura. EDITAR: No del todo, la entrada de Jelly de igual longitud entró mientras escribía esto, y la superó a través del desempate de la marca de tiempo.

Explicación

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

Pruébalo en línea! o Pruebe todos los casos de prueba

JavaScript (ES6), 46 45 bytes

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

• 1 byte guardado gracias a ETHproductions

Explicación

1. Divida la cadena en una matriz en líneas nuevas.
2. Pase sobre la matriz.
3. Reste la longitud de la matriz de la longitud de cada línea.
4. Si se devuelve un valor distinto de cero (es decir, verdadero) para cualquier línea, la cadena no es cuadrada.
5. Niega el resultado del bucle para obtener truecuadrado y falseno.

Intentalo

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

Pruébalo en línea!

-2 gracias a Riley, esta es básicamente su respuesta ._.

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

Jalea , 7 5 bytes

Ỵ¬⁼Z$

Pruébalo en línea!

Gracias a FryAmTheEggman por -2

Haskell, 38 34 bytes

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

Pruébalo en línea!

Versión sin puntos de f s = all ((==length (lines s)).length) (lines s), es decir, dividir la entrada en líneas y verificar si la longitud de cada línea es igual al número de líneas.

Editar: Gracias a @xnor por 4 bytes.

Jalea , 7 bytes

ỴµL;L€E

Pruébalo en línea!

Explicación

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

Japt , 9 bytes

=Ur.Q)¥Uy

¡Pruébelo en línea!

Explicación

 =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 algunas características implementadas poco después de que se publicó este desafío, esto puede ser de 6 bytes:

r.Q
¥y

¡Pruébelo en línea!

Explicación

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

Pruébalo en línea! Explicación: La primera etapa simplemente cambia todos los ASCII imprimibles en el mismo carácter para facilitar la coincidencia. (Se podría hacer sin él, pero esto es código golf, no código desafío). La segunda etapa coincide con al menos un personaje en la primera línea. Sin embargo, para cada carácter adicional en la primera línea, opcionalmente coincide con una nueva línea seguida de una copia de la primera línea. La parte final de la expresión hace que la coincidencia falle si hay más columnas que filas.

Casco , 6 bytes

S≡T'a¶

Toma una cadena e imprime 1o 0. Pruébalo en línea! La primera línea itera sobre los casos de prueba; elimínelo si desea probar con un solo valor.

Explicación

Husk es un nuevo lenguaje de golf funcional creado por mí y Leo . Le faltan muchas características y el desarrollo está en curso. Su característica principal es un sistema de tipo rígido que nos permite sobrecargar funciones de orden superior.

En un nivel alto, el programa funciona así:

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.

La función ≡realmente comprueba si dos matrices tienen la misma forma y la misma distribución de elementos verdaderos. En Husk, todos los caracteres excepto el byte nulo son verdaderos, y eso no ocurrirá en nuestras entradas. Además, Ses el S-Combinator , una función que toma como entradas dos funciones, en este caso ≡y T'a, y devuelve una nueva función que los mapas xa ≡(x)(T'a x). El resultado de Sse compone de ¶, y esa función se aplica a la entrada implícitamente.

¿Cómo sabe Husk que debería aplicarse Sa la siguiente función, pero ¶debería estar compuesta con la función a su izquierda? Simple: solo intenta cada interpretación y elige aquella en la que los tipos tienen sentido. Esto se explica con más detalle en la documentación de Husk .

Pure bash (sin utilidades), 55

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

• mapfile lee la entrada en la matriz a
• entonces el número de elementos de la matriz es XORed con cada longitud de línea y la suma tomada. Para un cuadrado perfecto, cada resultado XOR (y, por lo tanto, la suma) será 0. Para cualquier otra cosa, el resultado será> 0.

El sentido opuesto de esto se devuelve como un código de retorno de shell (examinar con echo $?): el cuadrado perfecto es 1, cualquier otra cosa es 0.

Pruébelo en línea (sinceramente) .

Pruébelo en línea (falso) .

Respuesta anterior con eval-escape-expansion hell, 78:

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

Pruébelo en línea (sinceramente) .

Pruébelo en línea (falso) .

Perl 6 , 27 bytes

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

Comprueba si el número de líneas en la cadena de entrada es igual al número de caracteres en cada línea.

Pyth, 7 bytes

CImL1.z

Pruébalo aquí

No requiere nueva línea final. Reemplaza la entrada con una matriz 2D de 1s donde un 1 representa cualquier carácter en la entrada original. Luego verificamos si esa matriz no ha cambiado después de su transposición (reemplazando columnas con filas). Solo un cuadrado volverá verdadero en tal situación.

Java (OpenJDK 8) ,96 91 91 90 87 bytes

-5 bytes gracias a @KevinCruijssen
-1 byte gracias a @TheLethalCoder
-2 bytes gracias a @ OlivierGrégoire

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

Pruébalo en línea!

05AB1E , 7 bytes

|€gDgQP

Pruébalo en línea!

R , 57 bytes

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

Una función anónima; Se divide en líneas nuevas, calcula la longitud de cada línea y comprueba si todas son iguales al número de líneas.

Pruébalo en línea!

MATL , 14 12 bytes

10H&XXot&n=h

La cadena de entrada se define usando la concatenación de cadenas ( [...]) y con el punto de código 10para representar LF. Por ejemplo, ['aaa' 10 'bb']se interpreta en MATL como una cadena 'aaa'concatenada con el carácter con un punto de código 10concatenado con una cadena 'bb'.

La salida es un vector numérico no vacío, que es verdadero si y solo si todas sus entradas son distintas de cero.

Pruébalo en línea!

Explicación

Considere la 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))

Toma información de stdin. Comprueba que el número de caracteres en cada línea es igual al número total de líneas. Devoluciones TRUEo FALSEsegún corresponda.

JavaScript (ES6), 48 bytes

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

CJam, 11 bytes

qN/:,_,f=:*

Pruébalo en línea!

OCaml , 56 bytes

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

Pruébalo en línea!

Pyth, 12 10 bytes

!fnl.zlT.z

Guardado 2 bytes gracias a @FryAmTheEggman.

Pruébalo en línea

Explicación

!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

Yo, estoy contento con lo corto que un derivado QBasic llegó a este desafío.

Explicación:

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

Pyth, 7 bytes

qCC.z.z

Demostración

Transponga la entrada con truncamiento dos veces, luego verifique si el resultado es el mismo que el original.

Ruby, 50 bytes.

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

Pruébalo en línea!

Explicación

1. Dividir la entrada en una matriz en la nueva línea.
2. Afirme que una matriz que contiene solo el tamaño de esta matriz es igual a una matriz que contiene todos los tamaños uniq (conjunto de unión con matriz vacía) de todos los elementos en esta matriz.

Cheddar , 39 bytes

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

Pruébalo en línea!

Clojure, 58 bytes

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

Requiere una nueva línea final, esperando ver algo más mágico.

APL (Dyalog) , 17 bytes

Requiere ⎕ML←3cuál es el predeterminado en muchos sistemas. Utiliza CR.

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

Pruébalo en línea!

↓∘⎕FMT [es el] split-en-líneas F o m un t ted-en-a-cuadrado argumento

≡ idéntico a

⎕TC[2]∘≠ los caracteres into-groups-of-non-newline *

⊂ dividido

⊢ ¿argumento?

* El segundo elemento de la lista de T ERMINAL C personajes ontrol.

En la versión 16.0, se puede escribir ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢con ⎕ML←1.

PowerShell, 64 bytes

El mismo enfoque (división, longitud de línea, número de líneas) que otras respuestas de idiomas que no son de golf, pero no hay un buen equivalente de map (), por lo que es una matriz de longitudes de línea con la cantidad de líneas etiquetadas en el extremo, luego esa matriz está agrupado Los cuadrados salen como 3,3,3,3 -> 1 group, all line lengths and line count were equaly los no cuadrados salen como 3,2,1 -> 3 groups, algo era desigual en el cuadrado:

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

Requiere terminaciones de estilo Linux de nueva línea, sin línea nueva. p.ej

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

$Ttests | % { & $f $_ }

(Y puedes hacer algo similar para las pruebas falsas, pero no lo pondré aquí ya que hay más de ellas). Se @requieren un par de símbolos para cuando la entrada es la única; de lo '.'contrario, dividirla no forma una matriz de una cadena, solo forma una cadena, y luego la concatenación de matriz no 1,1genera la salida 2.

Esperaba que pudiera ser más corto reemplazar todos los caracteres con 'a', y luego la fuerza bruta de 1 a Longitud de entrada todos los cuadrados 'a' y ver si alguno coincidía con la entrada. Una vez que pasé param () y .Length y -join and -replace, termina mucho más tiempo en 81 bytes:

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

Grime , 11 bytes

e`.|_./+/.+

Imprime 1para cuadrados y 0para no cuadrados. Pruébalo en línea!

Explicación

Se puede encontrar una explicación detallada en la página del tutorial de Grime , que contiene este programa exacto como ejemplo.

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.