Nhiệm vụ của bạn là xây dựng một chương trình xác định hình dạng của đầu vào. Các hình dạng được xác định có thể là bất kỳ hình nào sau đây:

Quảng trường

Để được xác định là hình vuông, nguồn phải có các dòng có độ dài bằng nhau và cùng số dòng với các ký tự trên mỗi dòng (loại trừ các ký tự dòng mới). Một dòng mới tùy chọn là chấp nhận được.

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

Hình chữ nhật

Để được xác định là một hình chữ nhật, nguồn phải có các dòng có độ dài bằng nhau, nhưng số lượng dòng không khớp với số lượng ký tự trên mỗi dòng (loại trừ các ký tự dòng mới). Một dòng mới tùy chọn là chấp nhận được. Điều này có thể là ngang hoặc dọc.

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

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

Tam giác

Để được xác định là một hình tam giác, nguồn phải bắt đầu bằng một ký tự và mỗi dòng tiếp theo phải có thêm một ký tự (bao gồm cả ký tự cuối cùng) hoặc sau dòng đầu tiên, mỗi dòng tiếp theo sẽ có ít hơn một ký tự cho đến cuối cùng chỉ có một.

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

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

Lộn xộn

Bất cứ điều gì không tuân theo một định dạng nhất quán theo như trên, phải được xác định là một mớ hỗn độn.

Quy tắc

• Bạn có thể trả về bất kỳ bốn giá trị có thể in phù hợp để xác định từng hình dạng.
• Mã nguồn của bạn cũng phải tuân thủ một trong các hình dạng trên (không, không phải là một mớ hỗn độn).
• Một dòng mới duy nhất trong nguồn của bạn được chấp nhận.
• Bạn có thể cho rằng đầu vào không chứa bất kỳ dòng trống nào (bao gồm cả các dòng mới), không trống và không chỉ bao gồm các dòng mới.
• Tất cả các hình dạng phải có chiều cao và chiều rộng> = 2, nếu không, điều này được xác định là một mớ hỗn độn.
• Sơ hở tiêu chuẩn bị cấm.
• Giải pháp ngắn nhất tính bằng byte, trong mỗi ngôn ngữ, sẽ thắng.

Thạch , 35 byte

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

Hãy thử trực tuyến!

0= Mess
1= Hình chữ nhật
2= Hình vuông
3= Tam giác

Brachylog , 45 byte

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

Hãy thử trực tuyến!

Mã là một hình chữ nhật (mặc dù cách nó hiển thị trên màn hình của tôi). Đầu ra: 1 cho hình vuông, 2 cho hình chữ nhật, 3 cho hình tam giác và không có gì cho lộn xộn

Giải trình:

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

Chức năng là một hình chữ nhật chính nó.
1= Hình vuông; 2= Hình chữ nhật; 3= Tam giác; 0= Lộn xộn.

-14 byte nhờ @ OlivierGrégoire .

Giải trình:

Hãy thử trực tuyến.

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

Hãy thử trực tuyến!

Bản in

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

Thạch , 32 27 byte

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

Hãy thử trực tuyến!

Bây giờ lấy đầu vào tại một danh sách các đường dây và chuyển >1×với ’avà sử dụng SƲsau khi L€ thay vì FLƲƊ. Chúng cho phép tôi ngưng tụ thành hai dòng và tôi đã lưu tổng cộng 5 byte. Các giá trị sau giống như trước đây.

[0.0, 0.0]= Mess
[0.0, 1.5707963267948966]= Hình chữ nhật
[0.0, 0.7853981633974483]= Hình vuông
[1.5707963267948966, 0.0]= Tam giác

ZL«Lđược tối thiểu chiều cao và chiều rộng và ’trừ 1 từ nó. Çgọi liên kết thứ hai và ở cuối nếu đầu vào là một dòng duy nhất, kết quả của Çlogic ANDed với số trước đó nếu chỉ có một dòng duy nhất thì đầu ra sẽ là [0.0, 0.0].

Trong liên kết thứ hai: ,Umang lại một danh sách các độ dài dòng được ghép nối với nó ngược lại. Jlà range(number of lines)và ⁼€kiểm tra xem mỗi trong số chúng có bằng kết quả của J. Ẹ(Bất kỳ) mang lại 1 nếu đầu vào là một hình tam giác.

E kiểm tra nếu tất cả các độ dài dòng bằng nhau (hình chữ nhật / hình vuông).

SƲvới một $nhóm để nhóm chúng thành một đơn nguyên kiểm tra xem tổng số ký tự có phải là số vuông hay không.

Vì vậy, ở cuối liên kết thứ hai, chúng ta có vị [[a,b],c]trí của mỗi số 0hoặc 1cho biết đầu vào là một hình tam giác, hình chữ nhật và có số lượng ký tự tương ứng.

Tuy nhiên, một số phần tử không có nghĩa là đầu vào là một hình vuông do đầu vào lộn xộn như

a3.
4

có số phần tử vuông nhưng không phải là hình vuông.

Đây là nơi æA(arctan2) xuất hiện. 0æA0== 0æA1== 0. Nói cách khác, nếu đầu vào có số phần tử vuông nhưng không phải là hình chữ nhật, thì nó không phải là hình vuông. Chắc chắn có nhiều cách rõ ràng hơn để làm điều này nhưng vấn đề là gì khi chúng ta có byte để suy nghĩ và chúng ta được phép đầu ra tùy ý nhất quán.

Lưu ý trước đây tôi đã sử dụng æA/thay vì æAƝ(và ,thay vì ;liên kết thứ hai) nhưng phương thức trước đây phân biệt giữa các hình tam giác có số phần tử vuông và các phần tử không nhưng rõ ràng chúng nên được tính là cùng một thứ.

Java 10, 274 323 298 229 byte

Trình tam giác đầu tiên.

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ộn xộn

1 Hình chữ nhật

3 Quảng trường

4 Tam giác

Hãy thử trực tuyến tại đây .

Chỉnh sửa nhiều lần để chơi golf nhiều hơn một chút.

Tất nhiên tôi cũng có thể tiết kiệm rất nhiều byte bằng cách biến nó thành một hình chữ nhật ( 281 267 259 200 byte, xem tại đây ).

Kết quả của việc xác định được xử lý bằng bitwise AND, thu được bitmask như sau:

1        1      1
triangle square rectangle

Phiên bản bị đánh cắp:

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

• Lộn xộn: không có gì
• Hình vuông: 0
• Tam giác: 1
• Hình chữ nhật: 2

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

Hãy thử trực tuyến!

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

Tam giác lộn ngược thêm 56 byte đắt tiền vào đây!

Đầu ra là S, R, T, M

Đã lưu một vài byte nhờ vào Dom Hastings.

Hãy thử trực tuyến!

Đã sửa một vài vấn đề bây giờ ... Chạy thử sản xuất này.

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

Hãy thử trực tuyến!

Trả về Truecho hình vuông, Falsecho hình chữ nhật, 3cho hình tam giác, Nilcho lộn xộn.

Stax , 39 byte

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

Chạy và gỡ lỗi trực tuyến!

Câu trả lời ngắn nhất chỉ có ASCII cho đến nay.

0 - Lộn xộn
1 - Hình chữ nhật
2 - Hình vuông
3 - Tam giác

Giải trình

Giải pháp sử dụng thực tế sau: Nếu một cái gì đó được in rõ ràng trong quá trình thực thi chương trình, không có đầu ra ẩn nào được tạo ra. Mặt khác, đỉnh ngăn xếp ở cuối thực hiện là đầu ra ngầm.

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]

Hãy thử trực tuyến!

Trả về 0, 1, 2 và 3 tương ứng cho mớ hỗn độn, hình chữ nhật, hình vuông và hình tam giác.

Chỉnh sửa: -2 byte nhờ Lynn !

05AB1E , 35 29 27 byte

Đã lưu 8 byte nhờ Magic Octopus Urn

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

Hãy thử trực tuyến!

0= Mess
4= Tam giác
1= Hình chữ nhật
3= Hình vuông

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 = Hình vuông
2 = Hình chữ nhật
3 = Tam giác
4 = Ngẫu nhiên

Mã không thể xử lý với 'ACKNOWLEDGE' (U + 0015) hoặc hình vuông trong mã ở trên. Byte này có thể được chuyển sang một cái gì đó khác nếu đầu vào yêu cầu chứa byte này.

Hãy thử trực tuyến!

Ốc, 29 byte

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

Phím đầu ra:

• 0 - Lộn xộn
• 3 - Tam giác
• 6 - Hình chữ nhật
• 7 - Quảng trường

Nó sẽ là 23 byte mà không cần bố trí nguồn:

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

Ngôn ngữ Wolfram (Mathicala) , 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}&

Sử dụng Replace /.và khớp mẫu trên số lượng ký tự theo dòng. Replacesẽ khởi động RHS đầu tiên của một quy tắc phù hợp, do đó, thứ tự là kiểm tra đầu vào 1 ký tự, sau đó là hình vuông, hình chữ nhật, hình tam giác và thông qua các mớ hỗn độn.

hình vuông = 0, hình chữ nhật = 1, hình tam giác = 2, mess = 3

Hãy thử trực tuyến!

Màu đỏ , 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]

Hãy thử trực tuyến!

0 Lộn xộn

1 Quảng trường

2 Hình chữ nhật

3 Tam giác

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

Hãy thử trực tuyến!

Đầu ra:

0= Hình vuông
1= Hình chữ nhật
2= Tam giác
3= Lộn xộn

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

Hãy thử trực tuyến!

Lambda ẩn danh. Đầu ra:

1. Quảng trường
2. Hình chữ nhật
3. Tam giác
4. Lộn xộn

C (gcc) , 125 123 byte

Nhờ trần nhà cho -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;}

Hãy thử trực tuyến!