당신의 임무는 입력의 모양을 식별하는 프로그램을 구축하는 것입니다. 식별 할 모양은 다음 중 하나 일 수 있습니다.

광장

정사각형으로 식별 되려면 소스에 길이가 모두 같은 행과 한 줄에있는 문자와 동일한 수의 행이 있어야합니다 (줄 바꿈 문자 제외). 선택적인 후행 줄 바꿈이 허용됩니다.

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

구형

사각형으로 식별하려면 소스에 길이가 모두 같은 줄이 있어야하지만 줄 수는 줄당 문자 수와 일치하지 않습니다 (줄 바꿈 문자 제외). 선택적인 후행 줄 바꿈이 허용됩니다. 가로 또는 세로 일 수 있습니다.

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

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

삼각형

삼각형으로 식별하려면 소스는 하나의 문자로 시작해야하며 이후의 각 줄에는 하나의 추가 문자 (마지막 포함)가 있어야합니다. 하나만 있습니다.

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

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

음식물

위와 같이 일관된 형식을 따르지 않는 것은 엉망으로 식별해야합니다.

규칙

• 각 모양을 식별하기 위해 4 개의 일관된 인쇄 가능 값을 반환 할 수 있습니다.
• 소스 코드는 위의 형태 중 하나를 준수해야합니다 (엉망이 아님).
• 소스에서 하나의 후행 줄 바꿈이 허용됩니다.
• 입력에 빈 줄이 포함되지 않고 (후행 줄 바꿈 포함) 비어 있지 않고 줄 바꿈만으로 구성되지 않는다고 가정 할 수 있습니다.
• 모든 모양의 높이와 너비는> = 2 여야합니다. 그렇지 않으면 엉망으로 정의됩니다.
• 표준 허점은 금지되어 있습니다.
• 각 언어에서 가장 짧은 바이트 단위의 솔루션이 우선합니다.

젤리 , 35 바이트

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

온라인으로 사용해보십시오!

0= 엉망
1= 사각형
2= 사각형
3= 삼각형

Brachylog , 45 바이트

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

온라인으로 사용해보십시오!

코드는 사각형입니다 (내 화면에서 렌더링되는 방식에도 불구하고). 출력 : 사각형의 경우 1, 사각형의 경우 2, 삼각형의 경우 3, 엉망인 경우 없음

설명:

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)

자바 10 231 221 219 217 213 211 207 바이트

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

함수는 사각형 자체입니다.
1= 제곱; 2= 직사각형; 3= 삼각형; 0= 엉망.

@ OlivierGrégoire 덕분에 -14 바이트 .

설명:

온라인으로 사용해보십시오.

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`

파이썬 (2) , 129 (114) 109 107 113 바이트

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

온라인으로 사용해보십시오!

인쇄물

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

젤리 , 32 27 바이트

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

온라인으로 사용해보십시오!

이제 줄 목록에서 입력을 받고 대신에 after 를 사용하여 전환 >1×했습니다 . 이것으로 두 줄로 압축하고 총 5 바이트를 절약했습니다. 다음과 같은 값이 이전과 동일합니다.’aSƲL€FLƲƊ

[0.0, 0.0]= 메시
[0.0, 1.5707963267948966]= 사각형
[0.0, 0.7853981633974483]= 사각
[1.5707963267948966, 0.0]= 삼각형

ZL«L높이와 너비의 최소값을 ’구하고 1을 뺍니다. Ç입력이 단일 라인 인 경우 두 번째 링크를 호출하고 마지막에 단일 라인 Ç만있는 경우 이전 번호와 논리 AND 된 결과 가 출력됩니다 [0.0, 0.0].

두 번째 링크에서 : ,U그와 짝을 이루는 줄 길이 목록을 생성합니다. Jis range(number of lines)및 ⁼€각각이의 결과와 같은지 확인합니다 J. Ẹ입력이 삼각형이면 (임의의 값)은 1입니다.

E 모든 선 길이가 동일한 지 확인합니다 (직사각형 / 정사각형).

SƲ를 사용하여 $단일 모나드로 그룹화하면 총 문자 수가 제곱인지 여부를 확인합니다.

따라서 두 번째 링크의 끝에 [[a,b],c]각 숫자가 0있거나 1입력이 삼각형인지, 사각형인지, 문자 수가 제곱인지를 나타내는 위치 가 있습니다 .

그러나 제곱 수의 요소는 입력이 제곱임을 암시하지 않습니다.

a3.
4

요소의 제곱은 있지만 정사각형은 아닙니다.

이것은 æA(arctan2)가 들어오는 곳입니다. 0æA0== 0æA1== 0. 즉, 입력에 제곱 수의 요소가 있지만 사각형이 아닌 경우 사각형이 아닙니다. 이 작업을 수행하는 더 확실한 방법이 있지만 생각할 바이트가 있고 일관된 임의 출력이 허용되는 경우 문제가됩니다.

참고 이전 æA/에 æAƝ( 두 번째 링크에서 ,대신 대신) 대신 사용 ;했지만 이전 방법은 제곱 수의 요소가있는 삼각형과 그렇지 않은 삼각형을 구별하지만 분명히 같은 것으로 계산해야합니다.

자바 10, 274 323 298 229 바이트

첫 번째 삼각형 제출.

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 음식물

1 구형

3 광장

4 삼각형

여기에서 온라인으로 사용해보십시오 .

좀 더 골프를하기 위해 여러 번 편집했습니다.

물론 이것을 직사각형으로 바꾸면 많은 바이트를 절약 할 수 있습니다 ( 281 267 259 200 바이트, 여기 참조 ).

식별 결과는 비트 AND를 사용하여 조작되어 다음과 같이 비트 마스크를 생성합니다.

1        1      1
triangle square rectangle

언 골프 버전 :

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
}

자바 스크립트 125 바이트

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

펄 5 -p , 83 바이트

• 엉망 : 아무것도
• 광장 : 0
• 삼각형 : 1
• 직사각형 : 2

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

온라인으로 사용해보십시오!

PHP, 195 205 바이트

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

거꾸로 된 삼각형은 이것에 비싼 56 바이트를 더합니다!

출력은 S, R, T, M입니다.

Dom Hastings 덕분에 몇 바이트를 절약했습니다.

온라인으로 사용해보십시오!

몇 가지 문제가 해결되었습니다. 테스트 실행에서이 문제가 발생합니다.

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

펄 6 , 81 바이트

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

온라인으로 사용해보십시오!

혼란 , True정사각형, False사각형, 3삼각형 을 반환 합니다 Nil.

Stax , 39 바이트

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

온라인으로 실행하고 디버그하십시오!

지금까지 가장 짧은 ASCII 전용 답변.

0-엉망
1-사각형
2-사각형
3-삼각형

설명

솔루션은 다음 사실을 사용합니다. 프로그램 실행시 무언가가 명시 적으로 인쇄되면 암시 적 출력이 생성되지 않습니다. 그렇지 않으면 실행이 끝날 때 스택 맨이 암시 적으로 출력됩니다.

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

하스켈 , 113 107 103 101 바이트

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

온라인으로 사용해보십시오!

엉망, 사각형, 사각형 및 삼각형에 대해 각각 0, 1, 2 및 3을 반환합니다.

편집 : Lynn 덕분에 -2 바이트 !

05AB1E , 35 29 27 바이트

Magic Octopus Urn 덕분에 8 바이트 절약

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

온라인으로 사용해보십시오!

0= 엉망
4= 삼각형
1= 사각형
3= 사각형

R , 101 바이트

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

1 = 사각
2 = 사각
3 = 삼각
4 = 무작위

코드는 'NEGATIVE ACKNOWLEDGE'(U + 0015) 또는 위 코드의 사각형을 처리 할 수 ​​없습니다. 입력에이 바이트가 포함되어 있으면이 바이트를 다른 것으로 전환 할 수 있습니다.

온라인으로 사용해보십시오!

달팽이, 29 바이트

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

출력 키 :

• 0- 엉망
• 3- 삼각형
• 6- 직사각형
• 7- 광장

소스 레이아웃이없는 23 바이트입니다.

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

Wolfram Language (Mathematica) , 119 바이트

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

Replace /.문자의 사용 및 패턴 일치는 줄 단위로 계산됩니다. Replace일치하는 규칙의 첫 번째 RHS를 시작하므로 순서는 1 문자 입력을 테스트 한 다음 정사각형, 직사각형, 삼각형 및 혼란에 대한 폴 스루입니다.

square = 0, rectangle = 1, triangle = 2, mess = 3

온라인으로 사용해보십시오!

빨강 , 209 바이트

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]

온라인으로 사용해보십시오!

0 음식물

1 광장

2 구형

3 삼각형

AWK , 119 바이트

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

온라인으로 사용해보십시오!

산출:

0= 사각형
1= 사각형
2= 삼각형
3= 엉망

루비 , 115111 바이트

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

온라인으로 사용해보십시오!

익명의 람다. 출력 :

1. 광장
2. 구형
3. 삼각형
4. 음식물

C (GCC) , 125 (123) 바이트

-2 바이트의 ceilingcat 덕분 입니다.

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

온라인으로 사용해보십시오!