ได้รับแรงบันดาลใจจากการเปิดหนังสือ What-If

อินพุตเป็นสี่เหลี่ยมผืนผ้าของช่องว่างในรูปของสตริงรายการของสตริง ฯลฯ โดยมีวัตถุที่ทำจาก#ภายใน:

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

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

วัตถุจะไม่ตัดกันไม่สัมผัสสี่เหลี่ยม วัตถุนุ่มถูกกำหนดให้เป็นวัตถุที่ไม่ได้#อยู่ตรงกลางและเป็นเพียงเส้นขอบวัตถุแข็งคือวัตถุที่เต็มไป วัตถุที่มีความกว้างหรือความสูง<=2ถือว่ายาก วัตถุทั้งหมดมีความแข็งหรืออ่อน

หากมีวัตถุแข็งมากขึ้นในการป้อนข้อมูลการส่งออก"Hard"ถ้ามากขึ้นนุ่มผลผลิต"Soft"ถ้าพวกเขามีค่าเท่ากัน, "Equal"เอาท์พุท

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

กรณีทดสอบ

กรณีเหล่านี้ไม่ได้ป้อนข้อมูลเต็ม แต่ควรระบุว่าแต่ละวัตถุควรเป็นอย่างไร การป้อนข้อมูลจริงจะเป็นแบบ ascii-art ที่ด้านบนของคำถาม

ยาก

#

####

##
##

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

อ่อนนุ่ม

###
# #
###

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

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

กรณีทดสอบจริง

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

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

Hard

###                
###                
###                

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

Equal

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


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

Soft

MATL , 105 104 58 50 49 ไบต์

ขอบคุณ @Neil สำหรับคำแนะนำที่อนุญาตให้ฉันลบ 46 ไบต์!

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

การป้อนข้อมูลเป็นอาร์เรย์ 2D ;ถ่านกับแถวแยกจากกันโดย ตัวอย่างในการท้าทายคือ

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

นี่เป็นอีกตัวอย่าง:

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

สิ่งนี้สอดคล้องกับ

###                
###                
###                

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

'Equal'จึงควรให้

ในฐานะที่เป็นตัวอย่างที่สามที่สอดคล้องกับ'Soft',

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

นั่นคือ,

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


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

ลองออนไลน์!

คำอธิบาย

วิธีนี้ใช้การบิดแบบ 2 มิติเพื่อตรวจจับรูปร่าง อินพุตถูกแปลงเป็นอาเรย์ 2 มิติพร้อมการ1ระบุ#และ-1สำหรับพื้นที่ และเป็นเบาะกับกรอบของ-1ค่า สิ่งนี้ทำให้มั่นใจได้ว่าจะตรวจจับรูปร่างที่ขอบสนามเดิม

มาสก์ตรวจพบวัตถุที่อ่อนนุ่ม

 1   1
 1  -1

ซึ่งสอดคล้องกับมุมบนซ้ายของวัตถุที่มีจุดภายในว่างหนึ่งจุด โปรดทราบว่าการแปลงรูปแบบกลับด้านหน้ากากดังนั้นมันจึงถูกกำหนดไว้[-1 1; 1 1]ในรหัส จำนวนSของตำแหน่งที่ convolution เท่ากับ4คือจำนวนวัตถุนุ่มทั้งหมด

วัตถุ (อ่อนหรือแข็ง) ถูกตรวจพบโดยหน้ากาก

-1  -1
-1   1

ซึ่ง correponds ไปที่มุมบนซ้ายของวัตถุพร้อมกับจุดภายนอกที่ว่างเปล่า มาสก์นี้เป็นรุ่นที่ถูกทำให้ไร้ผลของรุ่นก่อนหน้าดังนั้นผลลัพธ์ที่ได้จากการแปลงก่อนหน้านี้สามารถนำมาใช้ซ้ำ โดยเฉพาะอย่างยิ่งหมายเลข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

JavaScript (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"

บันทึก 2 ไบต์ต้องขอบคุณ @ edc65!

รับอินพุตเป็นสตริงหลายบรรทัดที่มีช่องว่างเพื่อสร้างกริด

คำอธิบาย / ทดสอบ

ใกล้มากกับความยาวของ MATL! โดยทั่วไปแล้วมันจะค้นหาบรรทัดบนสุด#ของแต่ละวัตถุและหากความยาวของบรรทัดบนสุดน้อยกว่า 2 หรือ 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รูปแบบ (ด้านล่างซ้ายและมุมขวาบน)

ดังนั้นการลบจำนวน4รูปแบบจากจำนวน7รูปแบบที่พบในอินพุตจะให้ผล(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.

Julia, 99 95 93 ไบต์

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

!คาดว่าอาร์เรย์ Char สองมิติเป็นอาร์กิวเมนต์ ลองออนไลน์!

มันทำงานอย่างไร

สิ่งนี้ใช้แนวคิดเดียวกันเกือบทั้งหมดกับคำตอบของ Jelly ของฉันด้วยการปรับปรุงอย่างใดอย่างหนึ่ง:

แทนการนับจำนวน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 

เมื่อสิ่งนั้นมีอยู่มันเป็นวัตถุที่อ่อนนุ่มมิฉะนั้นจะเป็นวัตถุที่แข็ง