Ihre Aufgabe ist es, ein Programm zu erstellen, das die Form der Eingabe identifiziert. Die zu identifizierenden Formen können folgende sein:

Platz

Um als Quadrat identifiziert zu werden, muss die Quelle Zeilen mit der gleichen Länge und der gleichen Anzahl von Zeilen wie Zeichen pro Zeile enthalten (Zeilenumbruch ausgeschlossen). Ein optionaler abschließender Zeilenumbruch ist zulässig.

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

Rechteck

Um als Rechteck identifiziert zu werden, muss die Quelle Zeilen mit der gleichen Länge haben, aber die Anzahl der Zeilen stimmt nicht mit der Anzahl der Zeichen pro Zeile überein (Zeilenumbruch ausgeschlossen). Ein optionaler abschließender Zeilenumbruch ist zulässig. Dies kann entweder horizontal oder vertikal sein.

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

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

Dreieck

Um als Dreieck identifiziert zu werden, muss die Quelle entweder mit einem Zeichen beginnen und jede nachfolgende Zeile muss ein zusätzliches Zeichen (einschließlich des letzten Zeichens) enthalten, oder nach der ersten Zeile sollte jede nachfolgende Zeile bis zur letzten Zeile ein Zeichen weniger enthalten hat nur einen.

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

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

Chaos

Alles, was nicht einem einheitlichen Format wie oben folgt, muss als Durcheinander identifiziert werden.

Regeln

• Sie können vier konsistente druckbare Werte zurückgeben, um jede Form zu identifizieren.
• Ihr Quellcode muss sich auch an eine der oben genannten Formen halten (nein, kein Durcheinander).
• Eine einzelne nachgestellte Zeile in Ihrer Quelle ist akzeptabel.
• Sie können davon ausgehen, dass die Eingabe keine Leerzeilen (einschließlich nachfolgender Zeilenumbrüche) enthält, nicht leer ist und nicht nur aus Zeilenumbrüchen besteht.
• Alle Formen müssen eine Höhe und Breite von> = 2 haben, andernfalls wird dies als Durcheinander definiert.
• Standardlücken sind verboten.
• Die kürzeste Lösung in Bytes in jeder Sprache gewinnt.

Gelee , 35 Bytes

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

Probieren Sie es online!

0= Durcheinander
1= Rechteck
2= Quadrat
3= Dreieck

Brachylog , 45 Bytes

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

Probieren Sie es online!

Code ist ein Rechteck (trotz der Darstellung auf meinem Bildschirm). Ausgänge: 1 für Quadrat, 2 für Rechteck, 3 für Dreieck und nichts für Chaos

Erläuterung:

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

Funktion ist selbst ein Rechteck.
1= Quadrate; 2= Rechtecke; 3= Dreiecke; 0= Durcheinander.

-14 Bytes dank @ OlivierGrégoire .

Erläuterung:

Probieren Sie es online aus.

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

Probieren Sie es online!

Druckt

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

Jelly , 32 27 Bytes

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

Probieren Sie es online!

Nehmen Sie nun die Eingabe in einer Liste von Zeilen vor und schalten Sie >1×mit ’aund using SƲafter L€ statt FLƲƊ. Dadurch konnte ich mich in zwei Zeilen zusammenfassen und insgesamt 5 Bytes einsparen. Die folgenden Werte sind dieselben wie zuvor.

[0.0, 0.0]= Durcheinander
[0.0, 1.5707963267948966]= Rechteck
[0.0, 0.7853981633974483]= Quadrat
[1.5707963267948966, 0.0]= Dreieck

ZL«Lerhält das Minimum an Höhe und Breite und ’subtrahiert 1 davon. Çruft den zweiten Link auf und am Ende, wenn die Eingabe eine einzelne Zeile ist, wird das Ergebnis von Çmit der vorherigen Nummer logisch UND-verknüpft, wenn es nur eine einzelne Zeile gibt, wird die Ausgabe erfolgen [0.0, 0.0].

Im zweiten Link: ,UGibt eine Liste der Zeilenlängen in Kombination mit der Umkehrung zurück. Jist range(number of lines)und ⁼€prüft, ob jeder von ihnen gleich dem Ergebnis von ist J. Ẹ(Any) ergibt 1, wenn die Eingabe ein Dreieck ist.

E prüft, ob alle Zeilenlängen gleich sind (Rechteck / Quadrat).

SƲMit a $, um sie zu einer einzelnen Monade zu gruppieren, wird überprüft, ob die Gesamtzahl der Zeichen eine quadratische Zahl ist.

Am Ende des zweiten Links steht also, [[a,b],c]wo sich jede Zahl befindet 0oder 1ob die Eingabe ein Dreieck, ein Rechteck oder eine quadratische Anzahl von Zeichen ist.

Eine quadratische Anzahl von Elementen bedeutet jedoch nicht, dass die Eingabe ein Quadrat ist, da eine unordentliche Eingabe wie

a3.
4

hat eine quadratische Anzahl von Elementen, ist aber kein Quadrat.

Hier kommt æA(arctan2) ins Spiel. 0æA0== 0æA1== 0. Mit anderen Worten, wenn die Eingabe eine quadratische Anzahl von Elementen hat, jedoch kein Rechteck ist, ist sie kein Quadrat. Es gibt sicherlich klarere Wege, um dies zu tun, aber was macht das schon, wenn wir über Bytes nachdenken müssen und wir die Möglichkeit haben, willkürlich konsistente Ausgaben zu machen.

Hinweis: Früher habe ich æA/anstelle von æAƝ(und ,anstelle von a ;im zweiten Link) verwendet, aber die erstere Methode unterscheidet zwischen Dreiecken mit einer quadratischen Anzahl von Elementen und solchen, die keine haben, aber sie sollten offensichtlich als dasselbe gezählt werden.

Java 10, 274 323 298 229 Bytes

Erste Dreieckseinreichung.

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 Chaos

1 Rechteck

3 Platz

4 Dreieck

Probieren Sie es hier online aus .

Mehrmals bearbeitet, um ein bisschen mehr Golf zu spielen.

Natürlich könnte ich eine Menge Bytes sparen, indem ich dies ebenfalls in ein Rechteck verwandle ( 281 267 259 200 Bytes, siehe hier ).

Das Ergebnis der Identifikation wird mit bitweisem AND manipuliert und ergibt eine Bitmaske wie folgt:

1        1      1
triangle square rectangle

Ungolfed-Version:

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

• Chaos: nichts
• Quadrat: 0
• Dreieck: 1
• Rechteck: 2

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

Probieren Sie es online!

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

Das umgedrehte Dreieck fügt diesem 56 Bytes hinzu!

Ausgänge sind S, R, T, M

Ein paar Bytes gespart dank Dom Hastings.

Probieren Sie es online!

Einige Probleme wurden behoben ... Testläufe erzeugen dies.

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

Probieren Sie es online!

Gibt Truefür Quadrat, Falsefür Rechteck, 3für Dreieck, Nilfür Chaos zurück.

Stax , 39 Bytes

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

Online ausführen und debuggen!

Kürzeste reine ASCII-Antwort.

0 - Durcheinander
1 - Rechteck
2 - Quadrat
3 - Dreieck

Erläuterung

Die Lösung nutzt die folgende Tatsache: Wenn bei der Ausführung des Programms explizit etwas gedruckt wird, wird keine implizite Ausgabe generiert. Andernfalls wird implizit die Stapelspitze am Ende der Ausführung ausgegeben.

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]

Probieren Sie es online!

Gibt 0, 1, 2 und 3 für Chaos, Rechteck, Quadrat bzw. Dreieck zurück.

Edit: -2 Bytes dank Lynn !

05AB1E , 35 29 27 Bytes

8 Bytes gespart dank Magic Octopus Urn

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

Probieren Sie es online!

0= Durcheinander
4= Dreieck
1= Rechteck
3= Quadrat

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 = Quadrat
2 = Rechteck
3 = Dreieck
4 = Zufall

Der Code kann nicht mit 'NEGATIVER BESTÄTIGUNG' (U + 0015) oder dem Quadrat im obigen Code umgehen. Dieses Byte kann auf etwas anderes umgeschaltet werden, wenn der Eingang dieses Byte enthält.

Probieren Sie es online!

Schnecken, 29 Bytes

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

Ausgabetaste:

• 0 - Mess
• 3 - Dreieck
• 6 - Rechteck
• 7 - Platz

Ohne Quell-Layout wären es 23 Bytes:

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

Wolfram Language (Mathematica) , 119 Byte

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

Verwenden Replace /.und Anpassen von Mustern für die Anzahl der Zeichen pro Zeile. ReplaceGibt die erste RHS einer Regel aus, die übereinstimmt. Die Reihenfolge ist also, nach der Eingabe von 1 Zeichen zu suchen, danach nach Quadraten, Rechtecken, Dreiecken und einem Durchfall für Unordnung.

Quadrat = 0, Rechteck = 1, Dreieck = 2, Durcheinander = 3

Probieren Sie es online!

Rot , 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]

Probieren Sie es online!

0 Chaos

1 Platz

2 Rechteck

3 Dreieck

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

Probieren Sie es online!

Ausgabe:

0= Quadrat
1= Rechteck
2= Dreieck
3= Durcheinander

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}

Probieren Sie es online!

Anonymes Lambda. Ausgänge:

1. Platz
2. Rechteck
3. Dreieck
4. Chaos

C (GCC) , 125 123 Bytes

Danke an ceilingcat für -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;}

Probieren Sie es online!