What-If 책의 개봉에서 영감을 얻었습니다.

입력은 #내부에 객체가있는 문자열, 문자열 목록 등의 공백 사각형입니다 .

########          
#      #          
########          

   ###        ####
   ###        ####
   ###             

개체는 항상 교차하지 않고 비 터치 사각형입니다. 부드러운 객체는 #중간에의으로 채워지지 않고 경계 일 뿐인 객체로 정의되며 , 단단한 객체는 채워진 객체입니다. 폭이나 높이를 가진 물체 <=2는 단단하다고 간주됩니다. 모든 물체는 단단하거나 부드럽습니다.

입력에 더 많은 하드 객체가있는 "Hard"경우 더 부드러운 경우 output "Soft", 동일한 경우 output "Equal".

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

테스트 사례

이러한 경우는 전체 입력이 아니라 각 객체의 특징입니다. 실제 입력은 질문 맨 위에있는 아스키 아트와 같습니다.

단단한

#

####

##
##

##########
##########
##########

부드러운

###
# #
###

###################
#                 #
#                 #
#                 #
###################

####
#  #
#  #
#  #
#  #
#  #
#  #
#  #
####

실제 테스트 사례

########          
#      #          
########          

   ###        ####
   ###        ####
   ###             

Hard

###                
###                
###                

###################
#                 #
#                 #
#                 #
###################

Equal

   ######    
   #    #    
   ######    
          ###
   ##  #  # #
          ###


 ########    
 #      #    
 ########  

Soft

MATL , 105 (104) 58 50 49 바이트

46 바이트를 제거 할 수있는 제안에 대해 @Neil에게 감사드립니다!

2\TTYaEq4:HeqgEqZ+K/Zot0>+ss'Soft Hard Equal'Ybw)

입력은 행으로 구분 된 2D 문자 배열 ;입니다. 도전의 예는

['########          ';'#      #          ';'########          ';'                  ';'   ###        ####';'   ###        ####';'   ###            ']

또 다른 예는 다음과 같습니다.

['###                ';'###                ';'###                ';'                   ';'###################';'#                 #';'#                 #';'#                 #';'###################']

이것은

###                
###                
###                

###################
#                 #
#                 #
#                 #
###################

따라서 줄 것이다 'Equal'.

제 3 예로서, 대응 'Soft',

['   ######    ';'   #    #    ';'   ######    ';'          ###';'   ##  #  # #';'          ###';'             ';'             ';' ########    ';' #      #    ';' ########    ']

그건,

   ######    
   #    #    
   ######    
          ###
   ##  #  # #
          ###


 ########    
 #      #    
 ########  

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

설명

2D 컨벌루션을 사용하여 모양을 감지합니다. 입력을 갖는 2 차원 어레이로 변환되어 1표시 #및 -1공간; -1값 의 프레임으로 채워집니다 . 이렇게하면 원래 필드의 가장자리에있는 모양도 감지됩니다.

소프트 목적은 마스크에 의해 검출

 1   1
 1  -1

하나의 빈 내부 점이있는 객체의 왼쪽 위 모서리에 해당합니다. 컨벌루션은 마스크를 반전 시키므로 [-1 1; 1 1]코드에서와 같이 정의됩니다 . 컨벌루션이 동일한 위치 의 수 S4 는 총 소프트 오브젝트의 수입니다.

오브젝트 (소프트 또는 하드) 마스크에 의해 검출

-1  -1
-1   1

객체의 왼쪽 위 모서리에 비어있는 외부 점과 일치합니다. 이 마스크는 이전 마스크의 부정 버전이므로 이전 컨벌루션 결과를 재사용 할 수 있습니다. 구체적으로, 그 결과가 동일한 위치 의 수 ( T-4 )는 총 물체의 수이다.

딱딱한 물체 의 수 H 는 T - S 입니다. 출력 스트링은 S - H = 2 * S - T 의 부호로 결정됩니다 .

2\                 % Input. Modulo 2: '#' gives 1, ' ' gives 0
TTYa               % Add a frame of zeros
Eq                 % Convert 0 to -1
4:HeqgEq           % Generate mask [-1 1; 1 1], for soft objects
Z+                 % 2D convolution, preserving size
K/Zo               % Divide by 4 and round towards 0. Gives 1 or -1 for 4 or -4
t0>                % Duplicate. 1 for positive entries (soft objects), 0 otherwise
+                  % Add. This corresponds to the factor 2 that multiplies number S
ss                 % Sum of 2D array. Gives 2*S-T
'Soft Hard Equal'  % Push this string
Yb                 % Split by spaces. Gives cell array
w)                 % Swap. Apply (modular) index to select one string

자바 스크립트 (ES6) 123 121 118 바이트

s=>s.replace(/#+/g,(m,i)=>s[i+l]>" "?0:n+=!m[1]|s[i-l+1]==s[i-l]||-1,n=l=~s.search`
|$`)|n>l?"Hard":n<l?"Soft":"Equal"

@ edc65 덕분에 2 바이트를 절약했습니다!

공백으로 채워진 여러 줄 문자열로 입력을 받아 격자를 형성합니다.

설명 / 테스트

MATL 길이에 매우 가깝습니다! 기본적으로 #각 객체 의 s의 맨 위 줄을 검색하고 맨 위 줄의 길이가 2보다 작거나 맨 위 줄의 처음 두 문자가 같으면 단단하고 그렇지 않으면 부드럽습니다.

var solution =

s=>
  s.replace(/#+/g,(m,i)=>        // for each run of consecutive # characters
    s[i+l]>" "?                  // if the position above the match contains a #
      0                          // do nothing (this object has already been counted)
    :n+=                         // add 1 to the counter (hard) if
      !m[1]                      // the match is only 1 # wide
      |s[i-l+1]==s[i-l]          // or the characters below are the same
      ||-1,                      // else decrement the counter (soft)
    n=                           // n = counter, hard objects increase n, soft decrease
    l=~s.search`\n|$`            // l = (negative) line length
  )
  |n>l?"Hard":n<l?"Soft":"Equal" // return the result string

// Test
document.write("<pre>" + [`

########          
#      #          
########          
                  
   ###        ####
   ###        ####
   ###            

`,`

###                
###                
###                
                   
###################
#                 #
#                 #
#                 #
###################

`,`

   ######    
   #    #    
   ######    
          ###
   ##  #  # #
          ###
             
             
 ########    
 #      #    
 ########    

`,`

########          
#      #          
########          
                  
   ###        ####
   # #        ####
   ###            

`,`

########          
#      #          
########          
                  
   ###  ###   ####
   ###  # #   ####
   ###  ###       

`,`

#

`,`

##

`,`

#
#

`,`

###
# #
###

`].map((test) => solution(test.slice(2, -2))).join("\n")
)

젤리, 50 49 46 43 38 34 33 32 바이트

Ḥ+ḊZ
>⁶ÇÇFµċ7_ċ4$Ṡị“¤Ỵf“¢*ɦ“¡⁺ƒ»

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

배경

있다 16 개 다른 2 × 2 블록과 공간의 패턴 :

|  |  |  | #|  | #| #|# | #|# |# |##|# |##|##|##|
|  | #|# |  |##| #|# |  |##| #|# |  |##| #|# |##|

이 중 두 물체는 절대 만지지 않기 때문에

| #|# |
|# | #|

입력에서 발생하지 않으므로 14 가지 가능한 패턴이 남습니다 .

  값 0 과 #값 1을 할당  하면 2 × 2 패턴을 인코딩 할 수 있습니다

|ab|
|cd|

로 2 (2A + C) + (2B + D) = 4A + 2B + 2C + D 는 다음 값 이탈 14 개 패턴.

|  |  |  | #|  | #|# | #|# |##|# |##|##|##|
|  | #|# |  |##| #|  |##|# |  |##| #|# |##|
  0  1  2  2  3  3  4  5  6  6  7  7  8  9

일부의 경우 2 × 1 , 1 × 2 또는 1 × 1 가 공백으로 패딩하는 것처럼, 하부 및 / 또는 오른쪽 경계에 패턴, 우리는 그들을 인코딩 그들을 치료 것이다 4A + 2B , 4A + 2C 및 도 4A를 각각 .

이런 식으로, 각 객체 (소프트 또는 하드)는 정확히 하나의 4 패턴 (오른쪽 아래 모서리)을 갖습니다. 각 소프트 오브젝트에는 정확히 두 개의 7 가지 패턴이 있습니다 (왼쪽 아래 및 오른쪽 위 모서리).

따라서, 입력에서 만나는 7 개의 패턴 의 수에서 4 개의 패턴 의 양을 빼면 (s + h)-2s = h-s : = d가됩니다 . 여기서 h 와 s 는 형성하는 단단하고 부드러운 물체의 양입니다.

우리는 인쇄 하드를 경우 D> 0 , 소프트 경우 D <0 과 동등한 경우 D = 0 .

작동 원리

Ḥ+ḊZ                         Helper link. Input: M (n×m matrix)

Ḥ                            Unhalve; multiply all entries of M by 2.
  Ḋ                          Dequeue; remove the first row of M.
 +                           Perform vectorized addition.
                             This returns 2 * M[i] + M[i + 1] for each row M[i].
                             Since the M[n] is unpaired, + will not affect it,
                             as if M[n + 1] were a zero vector.
   Z                         Zip; transpose rows with columns.


>⁶ÇÇFµċ7_ċ4$Ṡị“¤Ỵf“¢*ɦ“¡⁺ƒ»  Main link. Input: G (character grid)

>⁶                           Compare each character with ' ', yielding 1 for '#'
                             and 0 for ' '.
  Ç                          Call the helper link.
                             This will compute (2a + c) for each pattern, which is
                             equal to (2b + d) for the pattern to its left.
   Ç                         This yields 2(2a + c) + (2b + d) for each pattern.
    F                        Flatten; collect all encoded patterns in a flat list.

     µ                       Begin a new, monadic link. Argument: A (list)
      ċ7                     Count the amount of 7's.
         ċ4$                 Count the amount of 4's.
        _                    Subtract the latter from the former.
            Ṡ                Yield the sign (1, -1 or 0) of the difference.
              “¤Ỵf“¢*ɦ“¡⁺ƒ»  Yield ['Hard', 'Soft', Equal'] by indexing into a
                             built-in dictionary.
             ị               Retrieve the string at the corresponding index.

줄리아, 99 95 93 바이트

~=t->2t'+[t[2:end,:];0t[1,:]]'
!x=("Hard","Equal","Soft")[sign(~~(x.>32)∩(4,7)-5.5|>sum)+2]

!인수로 2 차원 Char 배열을 예상합니다. 온라인으로 사용해보십시오!

작동 원리

이것은 내 젤리 답변 과 거의 동일한 아이디어를 사용 하며 한 가지 개선 사항이 있습니다.

4 와 7 의 양을 계산하는 대신 다른 모든 숫자를 제거한 다음 5.5 를 빼서 (4, 7) 을 (-1.5, 1.5) 에 매핑 합니다. 이런 식으로 결과 차이의 합계 부호가 올바른 출력을 결정합니다.

TSQL, 328 249 바이트

변수 및 테스트 데이터 선언 :

DECLARE @l int = 20
DECLARE @ varchar(max)=''
SELECT @+=LEFT(x + replicate(' ', @l), @l)
FROM (values
(' xxxx'),
(' xxxx'),
(' xxxx'),
('x'),
(''),
('xxx'),
('x x  xxx'),
('xxx  x x'),
('     xxx    ')) x(x)

암호:

SELECT substring('Soft EqualHard',sign(sum(iif(substring(@,N,@l+2)like'xx'+replicate('_', @l-2)+'x ',-1,1)))*5+6,5)FROM(SELECT row_number()OVER(ORDER BY Type)N FROM sys.all_objects)x WHERE n<=len(@)AND' x'=substring(@,N-1,2)AND''=substring(@,N-@l,1)

수축 된 코드 :

SELECT
  substring('Soft EqualHard',
    sign(sum(iif(substring(@,N,@l+2)like'xx'+replicate('_', @l-2)+'x ',-1,1)))*5+6,5)
FROM(SELECT row_number()OVER(ORDER BY Type)N FROM sys.all_objects)x
WHERE n<=len(@)AND' x'=substring(@,N-1,2)AND''=substring(@,N-@l,1)

설명 :

스크립트가 패턴에 대해 텍스트를 스캔하고 있습니다.

      space
space x

그 각각은 상자의 시작입니다

해당 위치의 경우 스크립트는 패턴을 확인하므로 처음 x를 확인할 필요는 없습니다.

  x
x space 

그것이 존재하면 그것은 부드러운 물체이고, 그렇지 않으면 그것은 단단한 물체입니다.