क्या अधिक हार्ड ऑब्जेक्ट या सॉफ्ट ऑब्जेक्ट हैं

Question

व्हाट-इफ पुस्तक के उद्घाटन से प्रेरित होकर।

इनपुट एक स्ट्रिंग के रूप में रिक्त स्थान की एक स्ट्रिंग है, स्ट्रिंग की सूची, आदि, #अंदर की वस्तुओं से बना है:

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

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

ऑब्जेक्ट हमेशा गैर-इंटरसेक्टिंग, नॉन-टचिंग, आयताकार होंगे। एक नरम वस्तु को एक ऐसी वस्तु के रूप में परिभाषित किया जाता है जो #बीच में भरी नहीं होती है और केवल एक सीमा होती है, एक कठोर वस्तु वह होती है जिसे भरा जाता है। चौड़ाई या ऊँचाई वाली वस्तु को <=2कठोर माना जाता है। सभी ऑब्जेक्ट या तो हार्ड या सॉफ्ट हैं।

यदि इनपुट, आउटपुट में अधिक हार्ड ऑब्जेक्ट हैं "Hard", यदि अधिक सॉफ्ट, आउटपुट "Soft", यदि वे समान हैं, तो आउटपुट "Equal"।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है !

परीक्षण के मामलों

ये मामले पूर्ण इनपुट नहीं हैं, बल्कि यह है कि प्रत्येक वस्तु को किस रूप में चित्रित किया जाना चाहिए। प्रश्न के शीर्ष पर वास्तविक इनपुट ascii- कला की तरह होगा।

कठिन

#

####

##
##

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

मुलायम

###
# #
###

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

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

वास्तविक परीक्षण मामले

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

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

Hard

###                
###                
###                

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

Equal

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


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

Soft

Comments

क्या आउटपुट सख्त हैं, या किसी भी 3 अस्पष्ट आउटपुट का उपयोग किया जा सकता है (जैसे एच / एस / ई या -1/0/1)?

— ट्राइकोप्लाक्स

@trichoplax वे सख्त हैं

— Maltysen

बोझिल I / O स्वरूपों पर मेटा उत्तर (यह कहने के लिए कि आप जो चुनते हैं वह आप नहीं कर सकते, लेकिन लोगों के लिए एक जगह देने के लिए यदि वे चाहें तो अधिक बढ़िया दाने वाली राय व्यक्त करने के लिए)।

— ट्राइकोप्लाक्स

@ डल सुनिश्चित करें कि यह ठीक है, जोड़ना।

— माल्टसेन

@LuisMendo नहीं, जोड़ना।

— माल्टसेन

Answer 1

MATL , 105 104 58 50 49 बाइट्स

एक सुझाव के लिए @Neil का धन्यवाद जिसने मुझे 46 बाइट निकालने की अनुमति दी!

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

इनपुट एक 2 डी चार सरणी है, जिसमें पंक्तियों को अलग किया गया है ;। चुनौती में उदाहरण है

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

यहाँ एक और उदाहरण है:

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

इससे मेल खाती है

###                
###                
###                

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

और इस प्रकार देना चाहिए 'Equal'।

तीसरे उदाहरण के अनुसार 'Soft',

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

अर्थात्,

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


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

इसे ऑनलाइन आज़माएं!

व्याख्या

यह आकृतियों का पता लगाने के लिए 2 डी कनवल्शन का उपयोग करता है। इनपुट को 1संकेत के साथ #और -1अंतरिक्ष के लिए 2 डी सरणी में परिवर्तित किया गया है; और -1मूल्यों के एक फ्रेम के साथ गद्देदार है । यह आश्वासन देता है कि मूल क्षेत्र के किनारे आकार भी पता लगाया जाता है।

मुखौटा द्वारा एक नरम वस्तु का पता लगाया जाता है

 1   1
 1  -1

जो एक खाली आंतरिक बिंदु के साथ ऑब्जेक्ट के ऊपरी-बाएं कोने से मेल खाती है। ध्यान दें कि दृढ़ संकल्प मास्क को निष्क्रिय करता है, इसलिए इसे [-1 1; 1 1]कोड में परिभाषित किया गया है। पदों की संख्या एस जिसमें कनवल्शन समतुल्य 4है, कुल संख्या में सॉफ्ट ऑब्जेक्ट हैं।

मुखौटा द्वारा किसी वस्तु (नरम या कठोर) का पता लगाया जाता है

-1  -1
-1   1

जो कुछ खाली बाहरी बिंदुओं के साथ मिलकर वस्तु के ऊपरी-बाएँ कोने पर स्थित है। यह मुखौटा पिछले एक का नकारात्मक संस्करण है, इसलिए पिछले दृढ़ संकल्प परिणाम का पुन: उपयोग किया जा सकता है। विशेष रूप से, पदों की संख्या T जिसमें परिणाम बराबर होता -4है वह कुल वस्तुओं की संख्या है।

नंबर एच कठोर वस्तुओं की है टी - एस । आउटपुट स्ट्रिंग 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

Comments

इसलिए, मुझे पता नहीं है कि एक दृढ़ संकल्प क्या है, लेकिन क्या आप सभी वस्तुओं (जैसे शीर्ष बाएं कोने को खोजकर) की गणना नहीं कर सकते हैं और दो बार नरम वस्तुओं की तुलना कर सकते हैं?

— नील

@ नील जो बहुत ही आशाजनक लग रहा है, धन्यवाद! इस तरह मैं 5 से 2 कनवल्शन को कम कर सकता था। (एक दृढ़ संकल्प अनिवार्य रूप से यह देख रहा है कि क्या कोई विशिष्ट पैटर्न किसी स्थिति में मेल खाता है)। मैं इसे बाद में कोशिश करूँगा

— लुइस मेंडो

... या सिर्फ 1 कनवल्शनफुल! आपका बहुत बहुत धन्यवाद! 46 बाइट्स :-) @ नील

— लुइस

यह लगभग जेएस के साथ बराबर था ... @ नील आप किस तरफ हैं ;-)

— edc65

Answer 2

जावास्क्रिप्ट (ईएस 6), 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 लंबाई के बहुत करीब! मूल रूप से, यह #प्रत्येक वस्तु के s की शीर्ष रेखा को खोजता है , और यदि शीर्ष रेखा की लंबाई 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")
)

Comments

लगता है कि सिंगल-लाइन इनपुट में कोई समस्या है; ###लौटता है Equal।

— डेनिस

@ डेनिस आप सही कह रहे हैं। ऐसा लगता है कि सिंगल लाइन इनपुट के लिए मेरा पिछला कोड मेरे द्वारा तय किए गए बग पर निर्भर था। अब तय हो गया।

— user81655

IMHO ~g.search(/$/m)की तुलना में थोड़ा अधिक पठनीय है ~g.search`\n`||-1।

— नील

@ नील सच। एक बग था, इसलिए मैंने ||-1इसे ठीक करने के लिए जल्दबाजी की , लेकिन आपके सुझाव ने मुझे एहसास |$दिलाया कि regex को जोड़ने से 2 बाइट्स बच जाएंगे। धन्यवाद!

— user81655

आप n=l=... n>l?...:n<l?...:...

— edc65

Answer 3

जेली, 50 49 46 43 38 34 33 32 बाइट्स

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

कर रहे हैं 16 अलग 2 × 2 ब्लॉक और रिक्त स्थान के पैटर्न:

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

इनमें से, दो वस्तुएं कभी नहीं छुएंगी,

| #|# |
|# | #|

इनपुट में कभी नहीं होगा, हमें 14 संभव पैटर्न के साथ छोड़कर ।

नियत    की एक मूल्य के 0 और #के एक मूल्य 1 , हम एक सांकेतिक शब्दों में बदलना कर सकते हैं 2 × 2 पैटर्न

|ab|
|cd|

as 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.

Answer 4

जूलिया, 99 95 93 बाइट्स

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

!दो आयामी चार सरणी के रूप में तर्क की अपेक्षा करता है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

यह मेरे जेली उत्तर के लगभग एक ही विचार का उपयोग करता है , एक सुधार के साथ:

4 's और 7 ' s की गिनती के बजाय , हम अन्य सभी संख्याओं को हटाते हैं, फिर 5.5 को मैप (4, 7) से (-1.5, 1.5) घटाते हैं । इस तरह, परिणामी अंतरों के योग का संकेत सही आउटपुट निर्धारित करता है।

Answer 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)

explaination:

स्क्रिप्ट पाठ को पैटर्न के लिए स्कैन कर रही है:

      space
space x

उनमें से प्रत्येक एक बॉक्स की शुरुआत है

उन पदों के लिए, स्क्रिप्ट तब पैटर्न के लिए जाँच कर रही है, पहले x के लिए जाँच करने की आवश्यकता नहीं है:

  x
x space 

जब यह मौजूद होता है तो यह एक नरम वस्तु है, अन्यथा यह एक कठिन वस्तु है।