Il tuo compito è costruire un programma che identifichi la forma dell'input. Le forme da identificare possono essere le seguenti:

Piazza

Per essere identificato come un quadrato, l'origine deve avere linee di uguale lunghezza e lo stesso numero di righe dei caratteri per riga (esclusi i caratteri di nuova riga). Una nuova riga finale facoltativa è accettabile.

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

Rettangolo

Per essere identificato come un rettangolo, l'origine deve avere linee di uguale lunghezza, ma il numero di righe non corrisponde al numero di caratteri per riga (esclusi i caratteri di nuova riga). Una nuova riga finale facoltativa è accettabile. Questo può essere orizzontale o verticale.

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

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

Triangolo

Per essere identificato come un triangolo, l'origine deve iniziare con un carattere e ogni riga successiva deve avere un carattere aggiuntivo (incluso l'ultimo) oppure, dopo la prima riga, ogni riga successiva deve avere un carattere in meno fino all'ultimo, che ne ha solo uno.

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

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

pasticcio

Tutto ciò che non segue un formato coerente come sopra, deve essere identificato come un disastro.

Regole

• È possibile restituire quattro valori di stampa coerenti per identificare ciascuna forma.
• Il tuo codice sorgente deve anche aderire a una delle forme sopra (no, non un casino).
• È accettabile una nuova riga finale finale nella tua fonte.
• Si può presumere che l'input non contenga righe vuote (comprese le nuove righe finali), non sia vuoto e non sia costituito solo da nuove righe.
• Tutte le forme devono avere un'altezza e una larghezza di> = 2, altrimenti viene definita un disastro.
• Sono vietate le scappatoie standard.
• Vince la soluzione più breve in byte, in ogni lingua.

Gelatina , 35 byte

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

Provalo online!

0= Pasticcio
1= Rettangolo
2= Quadrato
3= Triangolo

Brachylog , 45 byte

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

Provalo online!

Il codice è un rettangolo (nonostante il modo in cui viene visualizzato sul mio schermo). Output: 1 per quadrato, 2 per rettangolo, 3 per triangolo e niente per disordine

Spiegazione:

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 byte

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 funzione è un rettangolo stesso.
1= Quadrati; 2= Rettangoli; 3= Triangoli; 0= Mess.

-14 byte grazie a @ OlivierGrégoire .

Spiegazione:

Provalo online.

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 byte

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

Provalo online!

stampe

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

Gelatina , 32 27 byte

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

Provalo online!

Ora prendendo input in un elenco di righe e commutato >1× con ’ae usando SƲafter L€ anziché FLƲƊ. Questi mi hanno permesso di condensare in due righe e ho salvato 5 byte in totale. I seguenti valori sono gli stessi di prima.

[0.0, 0.0]= Pasticcio
[0.0, 1.5707963267948966]= Rettangolo
[0.0, 0.7853981633974483] = Quadrato
[1.5707963267948966, 0.0]= Triangolo

ZL«Lottiene il minimo di altezza e larghezza e ne ’sottrae 1. Çchiama il secondo collegamento e alla fine se l'ingresso è una linea singola, il risultato di Çdiventa logico ANDed con il numero precedente se esiste solo una linea, l'uscita sarà[0.0, 0.0] .

Nel secondo collegamento: ,Urestituisce un elenco di lunghezze di linea accoppiate al suo contrario. Jè range(number of lines)e⁼€ controlla se ciascuno di essi è uguale al risultato di J. Ẹ(Qualsiasi) restituisce 1 se l'input è un triangolo.

E controlla se tutte le lunghezze delle linee sono uguali (rettangolo / quadrato).

SƲ con un $ per raggrupparli in una singola monade controlla se il numero totale di caratteri è un numero quadrato.

Quindi alla fine del secondo link abbiamo [[a,b],c]dove si trova ogni numero0 o1 indica se l'input è un triangolo, rettangolare e ha un numero quadrato di caratteri rispettivamente.

Tuttavia un numero quadrato di elementi non implica che l'input sia un quadrato poiché un input disordinato come

a3.
4

ha un numero quadrato di elementi ma non è un quadrato.

Qui æAentra in gioco (arctan2). 0æA0== 0æA1==0 . In altre parole, se l'input ha un numero quadrato di elementi ma non è un rettangolo, allora non è un quadrato. Ci sono certamente modi più chiari per farlo, ma cosa importa quando abbiamo byte a cui pensare e ci è permesso un output arbitrario coerente.

Nota in precedenza stavo usando æA/invece di æAƝ(e un ,invece di a ;nel secondo collegamento) ma il metodo precedente distingue tra triangoli che hanno un numero quadrato di elementi e quelli che non lo fanno ma dovrebbero ovviamente essere considerati come la stessa cosa.

Java 10, 274 323 298 229 byte

Presentazione del primo triangolo.

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 pasticcio

1 Rettangolo

3 Piazza

4 Triangolo

Provalo online qui .

Modificato più volte per giocare a golf un po 'di più.

Ovviamente ho potuto salvare molti byte trasformando anche questo in un rettangolo ( 281 267 259 200 byte, vedi qui ).

Il risultato dell'identificazione viene manipolato usando AND bit a bit, producendo una maschera di bit come segue:

1        1      1
triangle square rectangle

Versione non golfata:

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 byte

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

• Pasticcio: niente
• Quadrato: 0
• Triangolo: 1
• Rettangolo: 2

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

Provalo online!

PHP, 195 205 byte

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

Il triangolo rovesciato aggiunge 56 byte costosi a questo!

Le uscite sono S, R, T, M

Risparmio di pochi byte grazie a Dom Hastings.

Provalo online!

Risolti alcuni problemi ora ... Le esecuzioni di test producono questo.

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

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

Provalo online!

Restituisce Trueper quadrato, Falseper rettangolo, 3per triangolo, Nilper disordine.

Stax , 39 byte

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

Esegui ed esegui il debug online!

La risposta solo ASCII più breve finora.

0 - Pasticcio
1 - Rettangolo
2 - Quadrato
3 - Triangolo

Spiegazione

La soluzione utilizza il seguente fatto: se qualcosa viene esplicitamente stampato nell'esecuzione del programma, non viene generato alcun output implicito. Altrimenti, la parte superiore dello stack alla fine dell'esecuzione viene implicitamente emessa.

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 byte

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

Provalo online!

Restituisce 0, 1, 2 e 3 rispettivamente per pasticcio, rettangolo, quadrato e triangolo.

Modifica: -2 byte grazie a Lynn !

05AB1E , 35 29 27 byte

Risparmiato 8 byte grazie a Magic Octopus Urn

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

Provalo online!

0= Pasticcio
4= Triangolo
1= Rettangolo
3= Quadrato

R , 101 byte

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

1 = Quadrato
2 = Rettangolo
3 = Triangolo
4 = Casuale

Il codice non può gestire "RICONOSCIMENTO NEGATIVO" (U + 0015) o il quadrato nel codice sopra. Questo byte può essere commutato su qualcosa di diverso se l'ingresso richiede contiene questo byte.

Provalo online!

Lumache, 29 byte

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

Chiave di uscita:

• 0 - Mess
• 3 - Triangolo
• 6 - Rettangolo
• 7 - Quadrato

Sarebbe 23 byte senza layout di origine:

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

Uso Replace /.e corrispondenza del modello sul conteggio dei caratteri per riga. Replacedarà il via al primo RHS di una regola che viene abbinata, quindi l'ordinamento è di testare l'inserimento di 1 carattere, quindi quadrati, rettangoli, triangoli e un fall-through per i messaggi.

quadrato = 0, = 1 rettangolo, triangolo = 2, disordine = 3

Provalo online!

Rosso , 209 byte

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]

Provalo online!

0 pasticcio

1 Piazza

2 Rettangolo

3 Triangolo

AWK , 119 byte

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

Provalo online!

Produzione:

0= Quadrato
1= Rettangolo
2= Triangolo
3= Mess

Rubino , 115 111 byte

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

Provalo online!

Lambda anonimo. Uscite:

1. Piazza
2. Rettangolo
3. Triangolo
4. pasticcio

C (gcc) , 125 123 byte

Grazie a ceilingcat per -2 byte.

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

Provalo online!