Su tarea es construir un programa que identifique la forma de la entrada. Las formas a identificar pueden ser cualquiera de las siguientes:

Cuadrado

Para identificarse como un cuadrado, la fuente debe tener líneas de igual longitud y el mismo número de líneas que los caracteres por línea (se excluyen los caracteres de nueva línea). Una nueva línea final opcional es aceptable.

$_='
$_="
$_"'
;say

Rectángulo

Para identificarse como un rectángulo, la fuente debe tener líneas de igual longitud, pero el número de líneas no coincide con el número de caracteres por línea (se excluyen los caracteres de nueva línea). Una nueva línea final opcional es aceptable. Esto puede ser horizontal o vertical.

$_=
"no
t a
squ
are
";#

$_="but it
is still a
consistent
shape!";##

Triángulo

Para identificarse como un triángulo, la fuente debe comenzar con un carácter, y cada línea posterior debe tener un carácter adicional (incluido el último), o después de la primera línea, cada línea posterior debe tener un carácter menos hasta el último, que tiene solo uno.

$
_=
"So
this
"."".
shape;

$_="or
even,
this
way
!!
"

Lío

Cualquier cosa que no siga un formato consistente según lo anterior, debe identificarse como un desastre.

Reglas

• Puede devolver cuatro valores imprimibles consistentes para identificar cada forma.
• Su código fuente también debe cumplir con una de las formas anteriores (no, no es un desastre).
• Una nueva línea final en su fuente es aceptable.
• Puede suponer que la entrada no contiene ninguna línea en blanco (incluidas las nuevas líneas finales), no está vacía y no consta solo de nuevas líneas.
• Todas las formas deben tener una altura y un ancho de> = 2; de lo contrario, esto se define como un desastre.
• Las lagunas estándar están prohibidas.
• La solución más corta en bytes, en cada idioma, gana.

Jalea , 35 bytes

L€ṀR,Ṛ$ċƲȧ3
L€,;¥LE€S+Ç
ỴµZL«L>1ȧÇ 

Pruébalo en línea!

0= Desorden
1= Rectángulo
2= Cuadrado
3= Triángulo

Brachylog , 45 bytes

lᵐ{≥₁|≤₁}o{l>1&t>1&}↰₃
lg,?=∧1w|=∧2w|t⟦₁≡?∧3w

Pruébalo en línea!

El código es un rectángulo (a pesar de la forma en que se muestra en mi pantalla). Salidas: 1 para cuadrado, 2 para rectángulo, 3 para triángulo y nada para desorden

Explicación:

lᵐ{≥₁|≤₁}o{l>1&t>1&}↰₃
lg,?=∧1w|=∧2w|t⟦₁≡?∧3w

lᵐ                        Get the length of each string
  {     }                 Verify 
   ≥₁                     The list is non-increasing
     |                    or...
      ≤₁                  The list is non-decreasing
         o                Sort it to be non-decreasing
          {        }      Verify
           l>1            The number of lines is greater than 1
              &           and...
               t>1&       The longest line is longer than 1 character
                    ↰₃    Call the following

lg,?                      Join the number of lines with the line lengths
    =∧1w                  If they are all equal, print 1 (Square)
         |=∧2w            Or if just the line lengths are equal, print 2 (Rectangle)
              |t⟦₁         Or if the range [1, 2, ... <longest line length>]
                  ≡?       Is the list of lengths
                    ∧3w    Print 3 (triangle)
                           Otherwise print nothing (mess)

Java 10, 231 221 219 217 213 211 207 bytes

s->{var a=s.split("\n");int r=a.length,l=a[0].length(),R=0,i=1,L,D;if(r>1){for(L=a[1].length(),D=L-l;++
i<r;R=L-a[i-1].length()!=D?1:R)L=a[i].length();R=R<1?D==0?r==l?1:2:D>-2&D<2&(l<2|L<2)?3:0:0;}return R;}

La función es un rectángulo en sí.
1= Cuadrados; 2= Rectángulos; 3= Triángulos;0= Mess.

-14 bytes gracias a @ OlivierGrégoire .

Explicación:

Pruébalo en línea.

s->{                        // Method with String parameter and integer return-type
  var a=s.split("\n");      //  Input split by new-lines
  int r=a.length,           //  Amount of lines
      l=a[0].length(),      //  Length of the first line
      R=0,                  //  Result-integer, initially 0
      i=1,                  //  Index integer, starting at 1
      L,D;                  //  Temp integers
  if(r>1){                  //  If there are at least two lines:
    for(L=a[1].length(),    //   Set `L` to the length of the second line
        D=L-l;              //   And set `D` to the difference between the first two lines
        ++i<r;              //   Loop over the array
        ;                   //     After every iteration:
         R=L-a[i-1].length()//     If the difference between this and the previous line
          !=D?              //     is not equal to the difference of the first two lines:
           1                //      Set `R` to 1
          :                 //     Else:
           R)               //      Leave `R` the same
      L=a[i].length();      //    Set `L` to the length of the current line
  R=R<1?                    //   If `R` is still 0:
     D==0?                  //    And if `D` is also 0:
      r==l?                 //     And the amount of lines and length of each line is equal
       1                    //      It's a square, so set `R` to 1
      :                     //     Else:
       2                    //      It's a rectangle, so set `R` to 2
     :D>-2&D<2&             //    Else-if `D` is either 1 or -1,
      (l<2|L<2)?            //    and either `l` or `L` is 1:
       3                    //     It's a triangle, so set `R` to 3
    :0:0;}                  //   In all other cases it's a mess, so set `R` to 0
  return R;}                //  Return the result `R`

Python 2 , 129 114 109 107 113 bytes

l=map(len,input().split('\n'));m=len(
l);r=range(1,m+1);print[[1],0,r,r[::-
1],[m]*m,0,[max(l)]*m,l].index(l)%7/2

Pruébalo en línea!

Huellas dactilares

• 0 = Mess
• 1 = Triangle
• 2 = Square
• 3 = Rectangle

Jalea , 32 27 bytes

,U⁼€JẸ,E;SƲ$
ZL«L’aL€Ç$æAƝ

Pruébalo en línea!

Ahora tomando entrada en una lista de líneas y cambiando >1×con ’ay usando SƲafter en L€ lugar de FLƲƊ. Esto me permitió condensarme en dos líneas y ahorré 5 bytes en total. Los siguientes valores son los mismos que antes.

[0.0, 0.0]= Desorden
[0.0, 1.5707963267948966]= Rectángulo
[0.0, 0.7853981633974483]= Cuadrado
[1.5707963267948966, 0.0]= Triángulo

ZL«Lobtiene el mínimo de altura y ancho y ’resta 1 de él. Çllama al segundo enlace y al final si la entrada es una sola línea, el resultado deÇ obtiene un AND lógico con el número anterior si solo hay una sola línea, la salida será [0.0, 0.0].

En el segundo enlace: ,Uproduce una lista de longitudes de línea emparejadas con su reverso. Jes range(number of lines)y ⁼€comprueba si cada uno de ellos es igual al resultado de J. Ẹ(Cualquiera) produce 1 si la entrada es un triángulo.

E comprueba si todas las longitudes de línea son iguales (rectángulo / cuadrado).

SƲ con un $ grupo para agruparlos en una sola mónada, verifica si el número total de caracteres es un número cuadrado.

Entonces, al final del segundo enlace tenemos [[a,b],c]dónde está cada número 0o 1indicando si la entrada es un triángulo, rectangular y tiene un número cuadrado de caracteres respectivamente.

Sin embargo, un número cuadrado de elementos no implica que la entrada sea un cuadrado ya que una entrada desordenada como

a3.
4

tiene un número cuadrado de elementos pero no es un cuadrado.

Aquí es donde æAentra (arctan2). 0æA0== 0æA1== 0. En otras palabras, si la entrada tiene un número cuadrado de elementos pero no es un rectángulo, entonces no es un cuadrado. Ciertamente hay formas más claras de hacer esto, pero qué importa eso cuando tenemos que pensar en bytes y se nos permite una salida arbitraria consistente.

Tenga en cuenta que anteriormente estaba usando en æA/lugar de æAƝ(y a en ,lugar de a ;en el segundo enlace) pero el método anterior distingue entre triángulos que tienen un número cuadrado de elementos y aquellos que no, pero obviamente deben contarse como la misma cosa.

Java 10, 274 323 298 229 bytes

Primera presentación del triángulo.

s
->
{  
var 
a=s. 
split 
("\n");
int i,l=
a.length,
c,f=a[0]. 
length(),r=
l<2||f<2&a[1
].length()<2?
0:f==l?7:5;var
b=f==1;for(i=1;
i<l;){c=a[i++]. 
length();r&=c!=f?
4:7;r&=(b&c!=f+1)|
(!b&c!=f-1)?3:7;f=c
;}return r;}        

0 Lío

1 Rectángulo

3 Cuadrado

4 Triángulo

Pruébelo en línea aquí .

Editado varias veces para jugar al golf un poco más.

Por supuesto, podría ahorrar muchos bytes convirtiéndolo también en un rectángulo ( 281 267 259 200 bytes, ver aquí ).

El resultado de la identificación se manipula utilizando Y bit a bit, produciendo una máscara de bits de la siguiente manera:

1        1      1
triangle square rectangle

Versión sin golf:

s -> {
    var lines = s.split("\n"); // split input into individual lines
    int i, // counter for the for loop
    numLines = lines.length, // number of lines
    current, // length of the current line
    previous = lines[0].length(), // length of the previous line
    result = numLines < 2 // result of the identification process; if there are less than two lines
    || previous < 2 & lines[1].length() < 2 // or the first two lines are both shorter than 2
    ? 0 : previous == numLines ? 7 : 5; // it's a mess, otherwise it might be a square if the length of the first line matches the number of lines
    var ascending = previous == 1; // determines whether a triangle is in ascending or descending order
    for(i = 1; i < numLines; ) { // iterate over all lines
         current = lines[i++].length(); // store the current line's length
        result &= current != previous ? 4 : 7; // check if it's not a rectangle or a square
        result &= (ascending & current != previous+1)|(!ascending & current != previous-1) ? 3 : 7; // if the current line is not one longer (ascending) or shorter (descending) than the previous line, it's not a triangle
        previous = current; // move to the next line
    }
    return result; // return the result
}

Javascript 125 bytes

_=>(g=(l=_.split('\n').map(a=>a.length)).
length)<3?0:(r=l.reduce((a,b)=>a==b?a:0))
?r==g?2:1:l.reduce((a,b)=>++a==b?a:0)?3:0

0 = Mess
1 = Rectangle
2 = Square
3 = Triangle

fa=_=>(g=(l=_.split('\n').map(a=>a.length)).length)<3?0:(r=l.reduce((a,b)=>a==b?a:0))?r==g?2:1:l.reduce((a,b)=>++a==b?a:0)?3:0

var square = `asd
asd
asd`

var rectangle = `asd
asd
asd
asd
asd
asd`

var triangle = `asd
asdf
asdfg
asdfgh`

var mess = `asd
dasdasd
sd
dasasd`

console.log(fa(square), fa(rectangle), fa(triangle), fa(mess))

Perl 5 -p , 83 bytes

• Desorden: nada
• Cuadrado: 0
• Triángulo: 1
• Rectángulo: 2

($z)=grep++$$_{"@+"-$_*~-$.}==$.,0,/$/,-1
}{$.<2or$_=$$z{$z>0||$.}?$z%2:@F>1&&2x!$z

Pruébalo en línea!

PHP 195 205 bytes

<?$a=$argv[1];$r=substr($a,-2,1)=="\n"?strrev($a):$a;foreach(explode("\n",$r)as$l){$s=strlen($l);$x[$s
]=++$i;$m=$i==$s?T:M;}$z=count($x);echo$i*$z>2?$z==1&&key($x)==$i?S:($z==1&&$i>2?R:($i==$z?$m:M)):M;?>

¡El triángulo invertido agrega 56 costosos bytes a esto!

Las salidas son S, R, T, M

Guardado algunos bytes gracias a Dom Hastings.

Pruébalo en línea!

Se corrigieron algunos problemas ahora ... Las ejecuciones de prueba producen esto.

$_="
$_="
$_""
;say

RESULT:S
=============
$_=
"no
t a
squ
are
";#

RESULT:R
=============
$
_=
"So
this
"."".
shape;

RESULT:T
=============
$_="or
even,
this
way
!!
"

RESULT:T
=============
as
smiley
asd
A

RESULT:M
=============
X

RESULT:M
=============
XX

RESULT:M
=============
cccc
a
aa
cccc

RESULT:M
=============

Perl 6 , 81 bytes

{.lines>>.chars.&{($_==.[0],3)[2*(2>.max
)+($_ Z- .skip).&{.[0].abs+.Set*2+^2}]}}

Pruébalo en línea!

Devuelve Truepara cuadrado, Falsepara rectángulo, 3para triángulo, Nilpara desorden.

Stax , 39 bytes

L{%m~;:-c:u{hJchC; 
|mb1=-C;%a\sI^^P}M0

¡Ejecute y depure en línea!

La respuesta más corta de ASCII hasta ahora.

0 - Desorden
1 - Rectángulo
2 - Cuadrado
3 - Triángulo

Explicación

La solución utiliza el siguiente hecho: si algo se imprime explícitamente en la ejecución del programa, no se genera ningún resultado implícito. De lo contrario, la parte superior de la pila al final de la ejecución se genera implícitamente.

L{%m~;:-c:u{hJchC;|mb1=-C;%a\sI^^P}M0
L                                        Collect all lines in an array
 {%m                                     Convert each line to its length
    ~;                                   Make a copy of the length array, put it on the input stack for later use
      :-                                 Difference between consecutive elements.
                                         If the original array has only one line, this will be an empty array
        c:u                              Are all elements in the array the same?
                                         Empty array returns false
           {                      }M0    If last test result is true, execute block
                                         If the block is not executed, or is cancelled in the middle, implicitly output 0
            hJ                           The first element of the difference array squared (*)
              chC                        Cancel if it is not 0 or 1
                 ;|m1=                   Shortest line length (**) is 1
                      -                  Test whether this is the same as (*)
                                         Includes two cases:
                                             a. (*) is 1, and (**) is 1, in which case it is a triangle
                                             b. (*) is 0, and (**) is not 1, in which case it is a square or a rectangle
                        C                Cancel if last test fails
                         ;%              Number of lines
                           a\            [Nr. of lines, (*)]
                             I           Get the 0-based index of (**) in the array
                                         0-> Square, 1->Triangle -1(not found) -> Rectangle
                              ^^P        Add 2 and print

Haskell , 113 107 103 101 bytes

((#)=<<k).map k.lines;k=length;1#x=0;l#x|x==[1..l]
  ||x==[l,l-1..1]=3;l#x=k[1|z<-[l,x!!0],all(==z)x]

Pruébalo en línea!

Devuelve 0, 1, 2 y 3 para desorden, rectángulo, cuadrado y triángulo, respectivamente.

Editar: -2 bytes gracias a Lynn !

05AB1E , 35 29 27 bytes

Guardado 8 bytes gracias a Magic Octopus Urn

DgV€g©ZU¥ÄP®Y
QP®ËJCXY‚1›P*

Pruébalo en línea!

0= Desorden
4= Triángulo
1= Rectángulo
3= Cuadrado

R , 101 bytes

"if"(var(z<-nchar(y<-scan(,"",,,"
","")))==0,"if"(length(y)==z,1,2
),"if"(all(abs(diff(z))==1),3,4))

1 = Cuadrado
2 = Rectángulo
3 = Triángulo
4 = Aleatorio

El código no puede tratar con 'RECONOCIMIENTO NEGATIVO' (U + 0015) o el cuadrado en el código anterior. Este byte se puede cambiar a algo diferente si la entrada requiere que contenga este byte.

Pruébalo en línea!

Caracoles, 29 bytes

ada7A
.2,lr
?!(t.
rw~)z
.+~o~

Clave de salida:

• 0 0 - Mess
• 3 - Triángulo
• 6 6 - Rectángulo
• 7 7 - Cuadrado

Sería 23 bytes sin diseño de origen:

zA
.2,dun!(t.rf~)z.+~o~

Wolfram Language (Mathematica) , 119 bytes

(x=StringLength/@#~StringSplit~"\n")/.{{1}->3,s~(t=Table)~{
s=Tr[1^x]}:>0,x[[1]]~t~s:>1,(r=Range@s)|Reverse@r:>2,_->3}&

Utilizando Replace /. y coincidencia de patrones en el recuento de caracteres por línea. Replaceeliminará el primer RHS de una regla que coincida, por lo que el orden es probar la entrada de 1 carácter, luego cuadrados, rectángulos, triángulos y un error para desorden.

cuadrado = 0, rectángulo = 1, triángulo = 2, desorden = 3

Pruébalo en línea!

Rojo , 209 bytes

func[s][c: copy[]foreach a split s"^/"[append c length? a]d: unique c
r: 0 if 1 < l: length? c[if 1 = length? d[r: 2 if(do d)= l[r: 1]]n: 0
v: copy[]loop l[append v n: n + 1]if(v = c)or(v = reverse c)[r: 3]]r]

Pruébalo en línea!

0 Lío

1 Cuadrado

2 Rectángulo

3 Triángulo

AWK , 119 bytes

{p=l;l=L[NR]=length($0)
D=d}{d=p-l;x=x?x:NR>2?\
d!=D:0}END{print x==1?\
3:d*d==1?(L[NR]+L[1]==\
NR+1)?2:3:p!=NR}#######

Pruébalo en línea!

Salida:

0= Cuadrado
1= Rectángulo
2= Triángulo
3= Desorden

Ruby , 115 111 bytes

->s{m=s.split(?\n).map &:size;r=*1..s=m.size;s<2?4:(m|[
]).size<2?m[0]<2?4:s==m[0]?1:2:r==m.reverse||r==m ?3:4}

Pruébalo en línea!

Lambda anónima. Salidas:

1. Cuadrado
2. Rectángulo
3. Triángulo
4. Lío

C (gcc) , 125 123 bytes

Gracias a ceilingcat por -2 bytes.

f(L,n)int**L;{int i,l,c,F=strlen(*L),s=-F;for(l=i=0;i<n;l=c)c
=strlen(L[i++]),s+=c-l;s=n>1?s||F<2?~abs(s)+n?0:3:n^F?2:1:0;}

Pruébalo en línea!