줄 바꿈이나 공백이 아닌 하나 이상의 문자를 포함하는 인쇄 가능한 ASCII 텍스트 (줄 바꿈 및 공백 포함) 문자열이 제공되면 문자열이 직사각형이면 참 값을, 그렇지 않으면 거짓 값을 출력합니다. 또한 솔루션의 소스 코드는 직사각형이어야합니다 .

문자열이 다음 조건을 모두 충족하는 경우 직사각형입니다.

1. 첫 번째 줄과 마지막 줄에는 공백이 없습니다.
2. 각 줄의 첫 번째와 마지막 문자는 공백이 아닙니다.
3. 모든 줄의 문자 수는 같습니다.

예를 들어 다음 텍스트는 직사각형입니다.

abcd
e fg
hijk

그러나이 텍스트는 직사각형이 아닙니다 (요구 사항 # 3).

1234
567
8900

테스트 사례

진실한 :

sdghajksfg

asdf
jkl;

qwerty
u i op
zxcvbn

1234
5  6
7890

abcd
e fg
hijk

팔시 :

a b c

123
456
7 9

12
345

qwerty
 uiop
zxcvnm

1234
567
8900

이것은 code-golf 이므로 바이트 단위의 최단 솔루션이 이깁니다.

C (GCC) , 127 (125) 124 118 바이트

• 로 골프 r*=!e&(!t|t==c);를 보내 2 바이트를 절약 했습니다 r>>=e||t&&t-c;. (이 골프는 최근 C 팁 답변 역 플래그 업데이트에 대한 영감이었습니다 .)
• 로 골프 *(_-2)를 보내 바이트를 저장했습니다 _[~1].
• 골프 의해 저장된 여섯 바이트 *_++-10||(...)에 *_++<11?...:0상기 틀 제로 이용하는 ...:0골프 (건설적으로 사용되지 않는다)이 c++증가한다. 이 골프는 루프를 다시 전환 할 수있게 해주었습니다.
• 여러 개의 잘못된 값을 사용할 수 있으면 114 바이트 가 가능합니다.

r,e,c,t;_(char*_){for(r=1,t=c=0;*_;*_++<11?r*=(t||(t=c,!e))&*_>32&_[~1]>32&t==c,c=e=0:c++)*_-32||(e=1);r>>=e||t&&t-c;}

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

더 큰 사각형을 달성하는 소스 레이아웃.

설명

다음은 124 바이트 길이 버전에 대한 설명입니다.

r,e,c,t;_(char*_){     // `r` is the boolean result flag, `e` a boolean flag if the current line contains
                       //  a space, `t` the first line's width, `c` the current line's current width
 for(r=1,t=c=0;*_;c++) // initialize, loop through entire string
  *_-32||              // if the current char is a space,
   (e=1),              //  the current line contains a space
  *_++-10||            // if the current char is a newline (char pointer `_` now incremented)
   (r*=(t||(t=c,!e))   // if t is not yet set, the current line is the first line; set it
                       //  to this line's length, check that no spaces where found
    &*_>32             // the next line's first char should not be a space
    &_[~1]>32          // this line's last char should not have been a space
    &t==c,c=~0,e=0);   // the line lengths should match, reset `c` and `e` to zero
                       //  (`~0 == -1`, countering the loop's increment of `c`)
 r>>=e||t&&t-c;}       // return boolean flag, check that the last line does not contain spaces,
                       //  there was either no newline or line lengths match
                       //  (here) equivalent to `r*=!e&(!t|t==c)`

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

자바 10 214 176 169 152 144 139 바이트

s->{String[]a=s.split("\n")
;int r=1,i=0,R=a.length;for
(;i<R;i++)if(i<1|i>R-2?a[i]
.contains(" "):a[i].trim( )
!=a[i])r=0;return-r<0;}////

@Neil 덕분에 -5 바이트 .

; String[]a대신에 사용 대신에 ; 맨 끝에 주석 을 추가 하여 첫 번째 행과 마지막 행에 공백이 없습니다.var areturn-r<0;return r>0;//

이 사각형은 한 줄짜리 입력보다 짧습니다. 왜냐하면 int r=1,...;으로 대체해야 하기 때문에 int[]v{1,...};정수의 모든 사용이됩니다 v[n](여기서 n 은 배열의 변수의 인덱스입니다 v).

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

설명:

s->{                        // Method with String parameter and boolean return-type
  String[]a=s.split("\n");  //  Input split by new-lines
  int r=1,                  //  Result-integer, starting at 1
      i=0,                  //  Index `i`, starting at 0
      R=a.length;           //  Amount of rows `R`
  for(;i<R;i++)             //  Loop `i` over the rows
    if(i<1                  //   If it's the first row,
       |i>R-2?              //   or the last row:
        a[i].contains(" ")  //   And the current row contains a space
       :a[i].trim()!=a[i])  //   Or either column of the current row contains a space
      r=0;                  //    Set the result `r` to 0
   return-r<0;}             //  Return whether `r` is still 1
////                        // Comment to comply to the rules of the challenge

다음은 공백이있는 동일한 기본 프로그램입니다 ( 128 126 바이트 ).

s->{var a=s.split("\n");int r=1,i=0,R=a.length;for(;i<R;i++)if(i<1|i>R-2?a[i].contains(" "):a[i].trim()!=a[i])r=0;return r>0;}

@Neil 덕분에 -2 바이트 .

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

T-SQL, 237207 바이트

SELECT(SELECT(IIF(max(len(v))=min(len(v)),1,0)*IIF(SUM(len(v+'x')-len
(trim(v))-1)=0,1,0))FROM t)*(SELECT(IIF(SUM(charindex(' ',v))=0,1,0))
FROM[t]WHERE[i]IN(SELECT(min(i))FROM[t]UNION(SELECT(max(i))FROM[t])))

직사각형의 경우 1을, 그렇지 않으면 0을 출력합니다. 공간을 제거하기 위해 많은 양의 여분의 괄호와 괄호를 사용해야했지만 개선의 여지가 크다고 확신합니다.

설명 :

허용 된 I / O 옵션 및 질문 설명의 설명에 따라 입력은 기존 테이블 t 에서 별도의 행으로 간주됩니다 . SQL의 데이터는 본질적으로 정렬되지 않기 때문에 해당 테이블에는 "행 번호"ID 필드 i가 포함됩니다 .

CREATE TABLE t (i INT IDENTITY(1,1), v VARCHAR(999))

기본적으로 내 SQL은 3 개의 하위 쿼리를 수행하며 각 쿼리 는 3 개의 "직사각형"코드 기준 을 반환 0하거나 1기반으로합니다. 이 3 개의 값은 서로 곱하여 13을 모두 만족하는 코드에 대해서만 반환 됩니다.

편집 : 공간을 절약하기 위해 기준 2와 3을 동일한 SELECT로 결합

SELECT(
SELECT(IIF(max(len(v))=min(len(v)),1,0)                  --All rows same length
      *IIF(SUM(len(v+'x')-len(trim(v))-1)=0,1,0))FROM t) --no leading or trailing spaces
*(SELECT(IIF(SUM(charindex(' ',v))=0,1,0))               --No spaces at all in
FROM[t]WHERE[i]IN(SELECT(min(i))FROM[t]                  --   first row or
            UNION(SELECT(max(i))FROM[t])))               --   last row

이 TRIM(v)기능은 SQL 2017 이상에서만 지원됩니다. 이전 버전 LTRIM(RTRIM(v))에서는 행을 재조정해야합니다.

하나의 임의의 메모 : LEN()SQL 의 함수는 후행 공백을 무시하므로 LEN('foo ') = 3. "참"길이를 얻으려면 끝에 문자를 붙인 다음 하나를 빼야합니다.

C ++, 199 183 181 175 바이트

이 템플릿 함수는 행을 문자열 (넓은 문자열 일 수 있음) 모음으로 받아들이고 반복자 쌍으로 전달됩니다.

#include<algorithm>//
template<class I>bool
f(I a,I b){return!~+(
*a+b[-1]).find(' ')&&
std::all_of(a,b,[&a](
auto&s){return' '+-s.
back()&&s[0]-' '&&a->
size()==s.size();});}

감사합니다. Erroneous 는 back()멤버 를 상기시키고 0 std::string을 지적 해 주셔서 감사 npos+1합니다.

Ungolfed 동등

유일한 실제 골프는 첫 줄과 마지막 줄을 연결하여 find그 공간에서 하나 의 공백을 수행하는 것 입니다.

#include <algorithm>
template<class It>
bool f(It a, It b)
{
    return (*a+b[-1]).find(' ') == a->npos
        && std::all_of(a, b,
                       [=](auto s) {
                           return s.back() != ' '
                               && s.front() != ' '
                               && s.size() == a->size(); });
}

테스트 프로그램

#include <iostream>
#include <string>
#include <vector>
int expect(const std::vector<std::string>& v, bool expected)
{
    bool actual = f(v.begin(), v.end());
    if (actual == expected) return 0;
    std::cerr << "FAILED " << (expected ? "truthy" : "falsey") << " test\n";
    for (auto const& e: v)
        std::cerr << "  |" << e << "|\n";
    return 1;
}
int expect_true(const std::vector<std::string>& v) { return expect(v, true); }
int expect_false(const std::vector<std::string>& v) { return expect(v, false); }

int main()
{
    return
        // tests from the question
        + expect_true({"sdghajksfg"})
        + expect_true({"asdf", "jkl;",})
        + expect_true({"qwerty", "u i op", "zxcvbn",})
        + expect_true({"1234", "5  6", "7890",})
        + expect_true({"abcd", "e fg", "hijk",})
        + expect_false({"a b c",})
        + expect_false({"123", "456", "7 9",})
        + expect_false({"12", "345",})
        + expect_false({"qwerty", " uiop", "zxcvnm",})
        + expect_false({"1234", "567", "8900",})
        // extra tests for leading and trailing space
        + expect_false({"123", " 56", "789"})
        + expect_false({"123", "45 ", "789"})
        // the function source
        + expect_true({"#include<algorithm>//",
                       "template<class I>bool",
                       "f(I a,I b){return!~+(",
                       "*a+b[-1]).find(' ')&&",
                       "std::all_of(a,b,[&a](",
                       "auto&s){return' '+-s.",
                       "back()&&s[0]-' '&&a->",
                       "size()==s.size();});}",})
        ;
}

자바 스크립트 (Node.js) , 85 바이트

x=>(x=x.split`\n`).some(s=>s.length-x[0].length|s.trim()!=s)<!/\s/.test(x[0]+x.pop())

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

파이썬 2 , 82 바이트

lambda*s:len(set(map(len,s)))<2<'!'<=min(tuple(s[0]+s[-1])+zip(*s)[0]+zip(*s)[-1])

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

로 호출하십시오 f("abcd", "e fg", "hijk").

하스켈 , 106 102 98 110 109 102 바이트

(\a->all(==[])a||and(e((1<$)<$>a):map(all(>='!').($a))[head,last,map$last,map$head]));e(a:s)=all(==a)s

바이트 당 @nimi와 @Laikoni에게 감사드립니다!

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

하스켈 , 79 바이트

g(x:r)=all((==(0<$x)).(0<$))r&&all(>='!')(x++last(x:r)++(head<$>r)++(last<$>r))

온라인으로 사용해보십시오! 행 목록으로 입력을받습니다.

이 패턴 g(x:r)= ...은 첫 번째 행 x과 나머지 행의 (비어있을 수있는) 목록을에 바인딩합니다 r. 그런 다음에 all((==(0<$x)).(0<$))r있는 모든 줄의 r길이가 x( 이 팁 사용) 과 같은지 확인합니다 .

그렇지 않으면 연결이 &&단락되고을 반환하고 False, 그렇지 않으면 오른쪽이 평가됩니다. 문자열로 구성 빌드가 x첫 번째 줄에, last(x:r)마지막 라인 r(또는 경우에 다시 첫 번째 줄에 r비어있는) (head<$>r)처음과 (last<$>r)각 라인의 마지막 문자는. 이 문자열의 all(>='!')경우 공백이 없는지 확인합니다 ( (>' ')소스 코드 제한으로 인해 사용할 수 없음 ).

MATL , 13 바이트

ctgF6Lt&()32>

입력은 형식의 문자열 배열입니다 {'abc' 'de'}.

출력은 truthy 하나만 포함하거나 적어도 0을 포함하는 배열은 false 입니다.

온라인으로 사용해보십시오! 또는 진실 / 거짓 테스트를 포함한 모든 테스트 사례를 확인하십시오 .

설명

c       % Implicit input. Convert to char. This concatenates the
        % strings of the input cell array as rows of a rectangular
        % char array, right-padding with spaces as needed
tg      % Duplicate, convert to logical. Gives a logical array with
        % the same size containing true in all its entries
F       % Push false
6L      % Push the array [2, j-1], where j is the imaginary unit.
        % When used as an index, this is interpreted as 2:end-1
t       % Duplicate
&(      % Assignment indexing with 4 inputs: original array, new
        % value, two indexing arrays. This writes false at the inner
        % rectangle (2:end-1)×(2:end-1) of the logical array that
        % initially only contained true. This will be used as a
        % logical index (mask) into the rectangular char array
)       % Reference indexing. This selects the border of the char
        % array. The result is a column vector of chars
32>     % Is each entry greater than 32? (ASCII code for space)
        % Implicit display

자바 스크립트 (ES6), 88 바이트

s=>!s.split`\n`.some((s,i,a)=>s[L='length']-a[0][L]|(++i%a[L]>1?/^\s|\s$/:/\s/).test(s))

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

캔버스 , 17 15 바이트

４［↷Ｋ；｝┐）｛ＳＬ］∑４≡

여기 사용해보십시오!

설명 (단일 공간의 경우 ASCII로 처리됨) :

4[↷K;}┐){SL]∑4=  full program; pushes the input to the stack.
4[   }           repeat 4 times
  ↷                rotate ToS clockwise. This also pads the input with spaces
   K;              take off the last line and put it below the item
      ┐          pop the remaining of the input (the center)
       )         and wrap the rest (the sides) in an array
        {  ]     map over those
         S         split on spaces - should result to one item in the array
          L        and get the length
            ∑    sum those lengths together
             4=  check if equal 4

펄 5 , 70 바이트

$f||=$_;$l||=y///c;$,||=/^\s|\s$/||$l-y///c;$e=$_}{$\="$f$e"=~/\s/||$,

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

0진실에 대한 출력 , 거짓에 대한 다른 숫자.

레드 , (216) 191 바이트

func[s][d:(length?(first(s:(split(s)"^/"))))sp:
func[a][none = find a" "]b: on foreach c s[b: b
and(d = length? c )and(c/1 <>" ")and(" "<> last
c)]res:(sp(first(s)))and(sp(last(s)))and(b)res]

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

첫 번째와 마지막 행에는 필요하지 않은 많은 괄호를 넣었습니다.

젤리 , 17 바이트

Ỵµ.ịЀ;ịɗẎ⁶e<L€E$

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

젤리 , 15 바이트

Mnemonic이 개발 한 방법을 사용하여 (현재-대소 문자 오류로 인해) 삭제 된 Pyth 제출에 사용합니다. (이제 수정 되었으면 약간의 신용을 주십시오!)

ỴµL€Eȧt€⁶ZUƊ4¡⁼

1 또는 0을 반환하는 문자 목록을 허용하는 모나드 링크.

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

어떻게?

ỴµL€Eȧt€⁶ZUƊ4¡⁼ - Link: list of characters
Ỵ               - split at newlines (making a list of lists - the rows)
 µ              - start a new monadic chain, call that ROWS
  L€            - length of €ach row in ROWS
    E           - all equal? (an integer: 1 if so, otherwise 0)
            4¡  - repeat four times:
           Ɗ    -   last three links as a monad:
      t€⁶       -     trim spaces (⁶) from €ach row in current ROWS
         Z      -     transpose that result
          U     -     upend (reverse each new row)
     ȧ          - logical AND (0 if L€E was 0 else the result of the repeated transform)
              ⁼ - equal to X? (the integer 0 is not equal to any listy of characters)

apt , 22 바이트

비경쟁 답변 : Japt 에는 2 차원 배열 회전으로 결과가 잘리는 알려진 버그가 있습니다. 이 버그로 인해 아래 코드는 정사각형 입력에서만 작동합니다. 그래도 버그가 없으면 아래 코드가 제대로 작동해야합니다.

e_ʶUÌÊéUeº4o)r_z)mx}U
e_                      // Check if every line in the input array
  ʶUÌÊ                 // has the same length as the last item.
       é               // Also,
               r_z)mx}U // check if rotating and trimming the input array
           º4o)         // four times
         Ue             // is equal to the input array.

입력을 문자열 배열로 취합니다. 공백 대신 괄호를 사용하면 직사각형 코드 요구 사항이 매우 쉽습니다.
여기에서 시도하십시오 .

루비 2.5 이상, 63 바이트

->a{!a.uniq(&:size)[1]&&a.none?(/^\s|\s$/)&&!(a[0]+a[-1])[?\s]}

입력을 문자열 배열로 취합니다. TIO (2.4)의 버전이이 버전에 비해 너무 오래 되었기 때문에 테스트 링크가 없습니다. 대신 테스트를 위해 약간 더 긴 (69 바이트) 버전이 있습니다.

->a{!a.uniq(&:size)[1]&&a.none?{|l|l=~/^\s|\s$/}&&!(a[0]+a[-1])[?\s]}

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

차이점은 2.5 Ruby가 Regex 패턴을 직접 전달하는 것을 지원한다는 것입니다. all?, any?, none? 메소드에 몇 바이트가 절약 입니다. 이 방법 자체는 매우 설명이 필요합니다.

1. 고유 한 라인 크기가 1 개만있는 경우
2. 선 경계에 공백이있는 경우
3. 첫 줄과 마지막 줄에 공백이있는 경우

C (gcc) , 119 바이트

n 개 문자열의 목록으로 입력을받습니다.

f(s,n,m,r,p)char**s,*p;{for(r=m=n;m--;r*=strlen(*s)==strlen(s[m])&(!p||m&&m^n-1&&p!=s[m]&&p[1]))p=strchr(s[m],32);n=r;}

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

C # (.NET 코어) , 145 (167) 바이트

S[0].Length>1&&S[0].IndexOf
(" ") + S[ S.Count() - 1 ].
IndexOf(" ")<-1&Array.Find(
S,x=>x[0]==' '| x [x.Length
-1]  ==  ' '  | S[0].Length
!=x.Length)==null?11>0:0>1;

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

S[0].Length>1&                                    // And if the lenght of the first argument is more than 1 char
Array.Find(                                       // Find a string in an array
    S,                                            // The array which will be searched in
    x=>                                           // For x as the current string from the array
    x.Length!=S[0].Length|                        // If the string lenght match not the first argument lenght
    x[0]==' '|                                    // Or if the string begins with a spacer
    x[x.Length-1]==' '                            // Or if the string ends with a spacer
)==null&                                          // And if there was no string found which matched the conditions
S[0].IndexOf(" ")+S[S.Count()-1].IndexOf(" ")<-1  // And if the first and last string doesn't have a spacer
?                                                 // If all above is true do
1>0                                               // Return True
:                                                 // Else
0>1                                               // Return False