Votre tâche consiste à créer un programme qui identifie la forme de l'entrée. Les formes à identifier peuvent être l'une des suivantes:

Carré

Pour être identifiée comme un carré, la source doit avoir des lignes de même longueur et le même nombre de lignes que de caractères par ligne (caractères de nouvelle ligne exclus). Une nouvelle ligne de fin facultative est acceptable.

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

Rectangle

Pour être identifiée comme un rectangle, la source doit avoir des lignes de longueur égale, mais le nombre de lignes ne correspond pas au nombre de caractères par ligne (caractères de nouvelle ligne exclus). Une nouvelle ligne de fin facultative est acceptable. Cela peut être horizontal ou vertical.

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

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

Triangle

Pour être identifiée comme un triangle, la source doit commencer par un caractère, et chaque ligne suivante doit avoir un caractère supplémentaire (y compris le dernier), ou après la première ligne, chaque ligne suivante doit avoir un caractère de moins jusqu'au dernier, ce qui n'en a qu'un.

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

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

Désordre

Tout ce qui ne suit pas un format cohérent selon ce qui précède, doit être identifié comme un gâchis.

Règles

• Vous pouvez renvoyer quatre valeurs imprimables cohérentes pour identifier chaque forme.
• Votre code source doit également adhérer à l'une des formes ci-dessus (non, pas un gâchis).
• Une seule nouvelle ligne de fin dans votre source est acceptable.
• Vous pouvez supposer que l'entrée ne contient pas de lignes vides (y compris les retours à la ligne de fin), n'est pas vide et ne se compose pas uniquement de retours à la ligne.
• Toutes les formes doivent avoir une hauteur et une largeur> = 2, sinon cela est défini comme un gâchis.
• Les failles standard sont interdites.
• La solution la plus courte en octets, dans chaque langue, gagne.

Gelée , 35 octets

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

Essayez-le en ligne!

0= Désordre
1= Rectangle
2= Carré
3= Triangle

Brachylog , 45 octets

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

Essayez-le en ligne!

Le code est un rectangle (malgré la façon dont il s'affiche sur mon écran). Sorties: 1 pour le carré, 2 pour le rectangle, 3 pour le triangle et rien pour le désordre

Explication:

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 octets

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 fonction est un rectangle lui-même.
1= Carrés;2= Rectangles; 3= Triangles;0= Mess.

-14 octets grâce à @ OlivierGrégoire .

Explication:

Essayez-le en ligne.

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 octets

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

Essayez-le en ligne!

Impressions

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

Gelée , 32 27 octets

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

Essayez-le en ligne!

Prenant maintenant une entrée dans une liste de lignes et commutée >1×avec ’aet en utilisant SƲaprès L€ au lieu de FLƲƊ. Cela m'a permis de condenser en deux lignes et j'ai économisé 5 octets au total. Les valeurs suivantes sont les mêmes qu'avant.

[0.0, 0.0]= Désordre
[0.0, 1.5707963267948966]= Rectangle
[0.0, 0.7853981633974483]= Carré
[1.5707963267948966, 0.0]= Triangle

ZL«Lobtient le minimum de hauteur et de largeur et en ’soustrait 1. Çappelle le deuxième lien et à la fin si l'entrée est une seule ligne, le résultat de Çobtient logique ET avec le numéro précédent s'il n'y a qu'une seule ligne, la sortie sera [0.0, 0.0].

Dans le deuxième lien: ,U donne une liste des longueurs de ligne associées à son inverse. Jest range(number of lines)et ⁼€vérifie si chacun d'eux est égal au résultat de J. Ẹ(Tout) renvoie 1 si l'entrée est un triangle.

E vérifie si toutes les longueurs de ligne sont égales (rectangle / carré).

SƲavec a $pour les regrouper en une seule monade vérifie si le nombre total de caractères est un nombre carré.

Donc, à la fin du deuxième lien, nous avons [[a,b],c]où chaque numéro est 0ou1 indiquant si l'entrée est un triangle, rectangulaire et a un nombre carré de caractères respectivement.

Cependant, un nombre carré d'éléments n'implique pas que l'entrée est un carré car une entrée en désordre comme

a3.
4

a un nombre carré d'éléments mais n'est pas un carré.

C'est là æAqu'intervient (arctan2). 0æA0==0æA1 ==0 . En d'autres termes, si l'entrée a un nombre carré d'éléments mais n'est pas un rectangle, ce n'est pas un carré. Il existe certainement des moyens plus clairs de le faire, mais qu'importe si nous avons des octets à penser et que nous sommes autorisés à générer des sorties arbitraires cohérentes.

Notez que j'utilisais précédemment æA/au lieu de æAƝ(et un ,au lieu d'un ;dans le deuxième lien), mais l'ancienne méthode fait la distinction entre les triangles qui ont un nombre carré d'éléments et ceux qui n'en ont pas, mais ils doivent évidemment être comptés comme la même chose.

Java 10, 274 323 298 229 octets

Première soumission triangulaire.

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 Désordre

1 Rectangle

3 Carré

4 Triangle

Essayez-le en ligne ici .

Édité plusieurs fois pour le jouer un peu plus.

Bien sûr, je pourrais économiser beaucoup d'octets en le transformant également en rectangle ( 281 267 259 200 octets, voir ici ).

Le résultat de l'identification est manipulé à l'aide de ET au niveau du bit, ce qui donne un masque de bits comme suit:

1        1      1
triangle square rectangle

Version non golfée:

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 octets

_=>(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 octets

• Désordre: rien
• Carré: 0
• Triangle: 1
• Rectangle: 2

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

Essayez-le en ligne!

PHP, 195 205 octets

<?$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;?>

Le triangle à l'envers ajoute 56 octets coûteux à cela!

Les sorties sont S, R, T, M

Enregistré quelques octets grâce à Dom Hastings.

Essayez-le en ligne!

Correction de quelques problèmes maintenant ... Les exécutions de test produisent cela.

$_="
$_="
$_""
;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 octets

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

Essayez-le en ligne!

Renvoie Truecarré, Falserectangle, 3triangle, Nildésordre.

Stax , 39 octets

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

Exécutez et déboguez en ligne!

Réponse la plus courte en ASCII jusqu'à présent.

0 - Désordre
1 - Rectangle
2 - Carré
3 - Triangle

Explication

La solution utilise le fait suivant: Si quelque chose est explicitement imprimé dans l'exécution du programme, aucune sortie implicite n'est générée. Sinon, le haut de la pile à la fin de l'exécution est implicitement affiché.

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

((#)=<<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]

Essayez-le en ligne!

Renvoie respectivement 0, 1, 2 et 3 pour mess, rectangle, square et triangle.

Edit: -2 octets grâce à Lynn !

05AB1E , 35 29 27 octets

8 octets enregistrés grâce à l' urne Magic Octopus

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

Essayez-le en ligne!

0= Désordre
4= Triangle
1= Rectangle
3= Carré

R , 101 octets

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

1 = carré
2 = rectangle
3 = triangle
4 = aléatoire

Le code ne peut pas traiter avec 'ACCEPTATION NÉGATIVE' (U + 0015) ou le carré dans le code ci-dessus. Cet octet peut être changé pour quelque chose de différent si l'entrée requiert contient cet octet.

Essayez-le en ligne!

Escargots, 29 octets

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

Touche de sortie:

• 0 - Mess
• 3 - Triangle
• 6 - Rectangle
• 7 - Carré

Ce serait 23 octets sans mise en page source:

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

Wolfram Language (Mathematica) , 119 octets

(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}&

Utilisation Replace /.et correspondance de motifs sur le nombre de caractères par ligne. Replaceva expulser le premier RHS d'une règle qui est mise en correspondance, donc l'ordre est de tester l'entrée à 1 caractère, puis les carrés, les rectangles, les triangles et un passage pour les dégâts.

carré = 0, rectangle = 1, triangle = 2, désordre = 3

Essayez-le en ligne!

Rouge , 209 octets

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]

Essayez-le en ligne!

0 Désordre

1 Carré

2 Rectangle

3 Triangle

AWK , 119 octets

{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}#######

Essayez-le en ligne!

Sortie:

0= Carré
1= Rectangle
2= Triangle
3= Désordre

Rubis , 115 111 octets

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

Essayez-le en ligne!

Lambda anonyme. Les sorties:

1. Carré
2. Rectangle
3. Triangle
4. Désordre

C (gcc) , 125 123 bytes

Merci à plafondcat pour -2 octets.

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

Essayez-le en ligne!