क्या मेरी इमोजी सूखी है?

17

यह मेरा पालतू इमोजी है, बिली:

-_-

Emojis बारिश में रहना पसंद नहीं करते हैं, इसलिए बिली दुखी है ... चलो उसे बेहतर महसूस करने के लिए एक छाता खींच लें!

  /\
 /  \
/    \

  -_-

यह अच्छा है, वह पूरी तरह से अपनी छतरी से ढका हुआ है! यहाँ एक उदाहरण दिया गया है जहाँ उसका केवल एक हिस्सा कवर किया गया है:

  /\
 /  \
/    \

     -_-

इस मामले में, उसके शरीर के खंड 2 और 3 बारिश के संपर्क में हैं।

छतरियां कई आकारों और आकारों में आती हैं, लेकिन वे हमेशा बढ़ते हुए स्लैशों की एक श्रृंखला से बनती हैं, /जिसके बाद अवरोही बैकस्लैश की एक श्रृंखला होती है \। उदाहरण के लिए, ये सभी वैध छतरियां हैं:

  /\
 /  \
/    \

/\

    /\
   /  \
  /    \
 /      \
/        \

और ये नहीं हैं:

/   \

\/

  \
 / \
/   \

 0\
/  \

//\\
/  \

आपको यह निर्धारित करने की आवश्यकता है कि मेरे इमोजी के कौन से हिस्से बारिश के संपर्क में हैं।

स्पष्टीकरण

  • आपका प्रोग्राम (या फ़ंक्शन) इनपुट के रूप में 2d स्ट्रिंग लेगा। यह उस प्रारूप में हो सकता है जो आपकी भाषा के लिए सबसे सुविधाजनक या स्वाभाविक है। तार की एक सरणी, वर्णों के सरणियों की एक सरणी, इसमें नई लाइनों के साथ एक स्ट्रिंग आदि।

  • आपको आउटपुट करना होगा कि इमोजी के कौन से सेक्शन बारिश के संपर्क में हैं। जब तक आप इसे स्पष्ट करते हैं, तब तक यह शून्य-अनुक्रमित या एक-अनुक्रमित हो सकता है। आउटपुट किसी भी उचित प्रारूप में हो सकता है। यदि संपूर्ण इमोजी बारिश से सुरक्षित है, तो आउटपुट कुछ भी नहीं (या एक खाली सरणी)।

  • आप मान सकते हैं कि सभी इनपुट में एक वैध छाता होगा, और एक ही इमोजी -_-:। इमोजी हमेशा इनपुट की अंतिम पंक्ति पर होगा, हालांकि उनकी छतरी और इमोजी के बीच कई खाली लाइनें हो सकती हैं।

  • वह सब कुछ जो छाता का हिस्सा नहीं है या इमोजी एक अंतरिक्ष पात्र या न्यूलाइन होगा।

  • इनपुट को रिक्त स्थान के साथ गद्देदार किया जाएगा ताकि प्रत्येक पंक्ति की लंबाई समान हो।

स्टैंडर्ड कमियां लागू होती हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है!

टेस्ट IO:

नमूना मामलों के सभी एक-अनुक्रमण का उपयोग करेंगे।

  /\
 /  \
/    \

  -_-

Outputs: []

----------------

   /\
  /  \

     -_-

Outputs: [2, 3]

----------------

    /\
   -_-

Outputs: [1]

----------------

     /\
    /  \
   /    \
  /      \
 /        \
/          \




               -_-

Outputs: [1, 2, 3]
code-golf  ascii-art  parsing 
— DJMcMayhem
स्रोत
2
क्या हम इमोजी के कुछ हिस्सों का उत्पादन कर सकते हैं जो बारिश में हैं? यानी ["_","-"]।
— Rɪᴋᴇʀ
यदि हमारी भाषा तार का समर्थन करती है, तो क्या हम अभी भी वर्णों के 2 डी सरणी को स्वीकार कर सकते हैं? उदाहरण के लिए, जावास्क्रिप्ट में ऐरे के पास स्ट्रिंग के मुकाबले अलग-अलग कार्य उपलब्ध हैं।
— पैट्रिक रॉबर्ट्स
@PatrickRoberts हाँ, यह स्वीकार्य है।
— DJMcMayhem
@ E @s numbersIʀᴋ नहीं, आपको संख्याओं का उत्पादन करना चाहिए।
— DJMcMayhem
1
मुझे लगता है कि आपको इमोटिकॉन से मतलब है। सूखा इमोजी 🔥 (या o I suppose) होगा
— एनएच।

जवाबों:

8

05AB1E , 18 17 15 बाइट्स

कोड:

|…-_-123:)ø€J€ï

स्पष्टीकरण:

|                  # Take all input as a list of strings.
 …-_-              # 3-char string, which results into "-_-".
     123:)         # Replace "-_-" with 123.
          ø        # Zip, resulting into the columns of the 2D array.
           €J      # Join each of them.
             ە    # For each, convert to integer. If this is not possible, it will ignore
                     the result.
                   # Implicitly output the array.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ( एक ही लंबाई के लिए रिक्त स्थान के साथ सभी लाइनों पैड सुनिश्चित करें ..

— अदनान
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 95 बाइट्स

a=>[...a[n=0]].map((_,i)=>a.map(s=>(c=s[i])>"-"&c<"_"?p=1:n+=!++c,p=0)|p<!c&&o.push(n),o=[])&&o

इनपुट स्ट्रिंग्स का एक सरणी होना चाहिए, प्रत्येक रेखा के साथ एक वर्ग बनाने के लिए रिक्त स्थान के साथ गद्देदार होना चाहिए। आउटपुट 1-अनुक्रमित संख्याओं की एक सरणी है।

व्याख्या

var solution =

a=>
  [...a[n=0]].map((_,i)=>  // n = current index of emoji, for each column i of input
    a.map(s=>              // for each line s
      (c=s[i])             // c = character in column
      >"-"&c<"_"?p=1       // p = 1 if column is protected from rain
      :n+=!++c,            // increment n if emoji character found, c = 1 if last line
                           // contained a space in the current column
      p=0
    )
    |p<!c&&o.push(n),      // if the emoji is not protected in the current column
    o=[]
  )
  &&o
<textarea id="input" rows="6" cols="40">   /\   
  /  \  
        
     -_-</textarea><br />
<button onclick="result.textContent=solution(input.value.split('\n'))">Go</button>
<pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 92 बाइट्स

a=>a.map(s=>s.replace(/\S/g,(c,i)=>c>'-'&c<'_'?u[i]=3:++n&u[i]||r.push(n)),n=0,u=[],r=[])&&r

पंक्तियों की एक रगड़ सरणी को स्वीकार करता है और 1-अनुक्रमित परिणाम देता है। स्पष्टीकरण:

a=>a.map(               Loop through all lines
 s=>s.replace(/\S/g,    Loop through all non-whitepsace
  (c,i)=>c>'-'&c<'_'    If it's part of the umbrella
   ?u[i]=3              Mark that column as dry
   :++n&                Add 1 to the emoji index
     u[i]||             If the column is not dry
      r.push(n)         Add the emoji index to the result
  ),n=0,u=[],r=[]       Initialise variables
 )&&r                   Return result
— नील
स्रोत
3

जावा 8 लैम्ब्डा, 241 218 201 191 185 184 (या 161) वर्ण

क्योंकि फिर पता है, जावा को भी सूखी इमोजीज की जरूरत है।

import java.util.*;f->{int e,i=e=-1,c,l=f.length-1;while(++e<f[l].length&&f[l][e]!=45);List p=new Stack();l:for(;++i<3;){for(char[]r:f)if((c=r[e+i])==47|c==92)continue l;p.add(i);}return p;}

यह एक ArrayList को एक HashSet Stack देता है जिसमें इमोजी के कुछ भाग होते हैं जो बारिश के संपर्क में होते हैं (अनुक्रमण 0 से शुरू होता है)। पूरी बात उजागर:

import java.util.*;

public class Q82668 {
    static List isEmojiDryRevE(char[][] fieldToCheck) {
        int emojiStart, i = emojiStart = -1, j, rows = fieldToCheck.length - 1;

        while (++emojiStart < fieldToCheck[rows].length && fieldToCheck[rows][emojiStart] != 45)
            ;

        List parts = new Stack();
        emojiLoop: for (; ++i < 3;) {
            for (j = -1; ++j < rows;) {
                if (fieldToCheck[j][emojiStart + i] > 46) {
                    // umbrella part found
                    continue emojiLoop;
                }
            }
            // no umbrella part found
            parts.add(i);
        }
        return parts;
    }
}

अपडेट

मैंने कुछ बेसिक गोल्फिंग की। इसमें घोषणाओं को एक साथ रखना शामिल है, कुछ पात्रों को बचाने और छोरों को छोटा करने के लिए एएससीआई मूल्यों के साथ तुलना करें।

सिर्फ सूचियों के बजाय ArrayLists का उपयोग करके मेरी डंप गलती को इंगित करने के लिए @ user902383 पर धन्यवाद। मैंने HashSets / Sets के साथ ArrayLists / Lists को प्रतिस्थापित किया जो कुछ और पात्रों को बचाता है। इसके अलावा आंतरिक लूप में एक फॉर्च लूप का उपयोग करने के लिए उसकी टिप के लिए धन्यवाद! उस परिवर्तन के माध्यम से मैं अंतिम ग्रिड पंक्ति के सूचकांक के लिए एक चर बनाने में सक्षम हूं जो इसे थोड़ा और छोटा करता है। कुल मिलाकर 17 पात्रों को बचाया गया है!

@KevinCruijssen ने आरंभ में जेनरिक को हटाने का सुझाव दिया, मैं एक कदम आगे गया: सभी जेनरिक को हटा दें। यह एक और 10 अक्षर बचाता है।

मैंने फ़ॉरच लूप से लूप के लिए वापस स्विच किया। इससे अंतिम पंक्ति की तुलना करना छोड़ना संभव हो जाता है जो बदले में मुझे एससीआई मूल्यों की तुलना को छोटा करने की अनुमति देता है। इस संदर्भ में केवल '/', '\' और '_' का 46 से अधिक का आस्की मूल्य है। यदि हम अंतिम पंक्ति की जांच नहीं करते हैं, तो हम > 46 checkवास्तविक मूल्य की जांच करने के बजाय इसका उपयोग कर सकते हैं ।

मुझे दिखाने के लिए @ user902383 पर फिर से धन्यवाद कि मैं एक लैम्ब्डा का उपयोग करता हूं और दूसरे वर्ण को शेव करने के लिए सेट + हैशसेट के बजाय सूची + स्टैक का उपयोग कर सकता हूं।

स्ट्रिंग वापसी संस्करण

@ user902383 ने बताया कि मैं केवल अंकों के साथ एक स्ट्रिंग बना सकता हूं। यह बहुत ही चटपटा लगता है, लेकिन अन्य लोग इसे इस तरह से हल करते दिखते हैं कि यहां स्ट्रिंग रिटर्न का उपयोग करके एक छोटा संस्करण है:

f->{int e,i=e=-1,c,r=f.length-1;while(++e<f[r].length&&f[r][e]!=45);String p="";l:for(;++i<3;){for(char[]o:f)if((c=o[e+i])==47|c ==92)continue l;p+=i;}return p;}

Ungolfed:

public class Q82668 {
    public static String isEmojiDryRevD(char[][] fieldToCheck) {
        int emojiStart, i = emojiStart = -1, c, rows = fieldToCheck.length - 1;

        while (++emojiStart < fieldToCheck[rows].length && fieldToCheck[rows][emojiStart] != 45)
            ;

        String parts = "";
        emojiLoop: for (; ++i < 3;) {
            for (char[] row : fieldToCheck) {
                if ((c = row[emojiStart + i]) == 47 | c == 92) {
                    // umbrella part found
                    continue emojiLoop;
                }
            }
            // no umbrella part found
            parts += i;
        }
        return parts;
    }
}
— Frozn
स्रोत
2
आपने नियम 1 को तोड़ दिया always program to an interface, यदि आप Listइसके बजाय उपयोग करते ArrayListहैं तो आप 5 बाइट बचा सकते हैं
— user902383
1
मुझे लगता है कि लूप के लिए आंतरिक को
— फॉरेस्ट
1
पूरी तरह से निश्चित नहीं है, लेकिन =new HashSet<>();सबसे अधिक संभावना हो सकती है =new HashSet();।
— केविन क्रूज़सेन
1
@ फ़िरोज़न को इसकी अनुमति क्यों नहीं दी जाएगी? मुझे पता है कि संकलक एक चेतावनी पैदा करता है, जो कोड-गोल्फिंग के दौरान बहुत कुछ होता है। मुझे यकीन नहीं है कि अगर आपका कोड अभी भी वही काम करता है, तो उसने इसका परीक्षण नहीं किया है। यदि ऐसा होता है, तो <>आपको 2 बाइट्स को हटाने की तुलना में । :)
— केविन क्रूज़सेन
2
@ फ़िरोज़न आप पुराने पुराने जावा में सही होंगे, लेकिन अब हमारे पास लैम्ब्डा है, और लैम्ब्डा नोटेशन में आप टाइप टाइप करते हैं। इसलिए आप Set(3) HashSet(7)के खिलाफ List(4) और Stack(5)।
— user902383
3

V , 20 19 बाइट्स (गैर-प्रतिस्पर्धात्मक)

G^R123?/
f\GddHÍó

वैकल्पिक, प्रतिस्पर्धी संस्करण (21 बाइट्स):

G^R123?/
f\òjòddHÍó

इसे ऑनलाइन आज़माएं! (नोट, tryitonline.net वी के थोड़े पुराने संस्करण का उपयोग करता है। इसकी भरपाई करने के लिए, यह इस थोड़े लंबे संस्करण का उपयोग करता है)

स्पष्टीकरण:

G^          "Move to the first non-whitespace character on the last column
  R123<esc> "Replace the emojii with '123'

?/          "Move backwards to the last '/' character
  <C-v>     "Start a blockwise selection
       f\G  "Move the selection to the next '\', and then to the last line
d           "Delete the block selection
 dH         "Delete the umbrella

यह अकेले 17 बाइट्स में सही परिणाम देता है। हालाँकि, यह कुछ अतिरिक्त व्हाट्सएप भी बनाता है। मुझे इससे कोई आपत्ति नहीं है, लेकिन मैं खुद को अनुचित लाभ नहीं देना चाहता, इसलिए मैं दो बाइट्स जोड़ रहा हूं:

Íó          "Remove all whitespace
— DJMcMayhem
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 117 112 बाइट्स

s=>s.map(r=>r.map((c,i)=>~'-_'[o='indexOf'](c)&&!s.some(a=>~'/\\'[o](a[i]))?i-r[o]('-'):-1)).pop().filter(n=>~n)

वर्णों के स्ट्रिंग सरणियों के एक रैग्ड सरणी को स्वीकार करता है , और 0-अनुक्रमित परिणाम देता है।

s=>s.map(     // for each row
  r=>         // row
    r.map(    // for each character
      (c,i)=> // character, index
        ~'-_'[o='indexOf'](c) // if character is part of emoji
        &&                    // and
        !s.some(              // none of the rows have umbrella in this column
          a=>~'/\\'[o](a[i])
        )
        ? // then return 0-index of emoji
          i-r[o]('-')
        : // else return -1
          -1
  )
)
.pop()         // get last element of string array
.filter(n=>~n) // filter out -1s

डेमो

f=s=>s.map(r=>r.map((c,i)=>~'-_'[x='indexOf'](c)&&!s.some(a=>~'/\\'[x](a[i]))?i-r[x]('-'):-1)).pop().filter(n=>~n)
i.oninput=()=>o.value=f(i.value.split`\n`.map(r=>r.split``))
i.oninput()
<textarea rows=6 cols=20 id=i>
   /\
  /  \

     -_-</textarea>
<br/>
<input readonly id=o>
स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत
मुझे आपकी टिप्पणियाँ पसंद हैं!
— सिंटेक्स
2

रेटिना , 56 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

m`(?<!(?(2)!)^(?<-2>.)*\S(.*¶)+(.)*).(?<=([-_]+))|\D
$.3

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

यह एक एकल प्रतिस्थापन चरण है, जहां रेगेक्स इमोजी पात्रों में से एक से मेल खाता है, बशर्ते कि एक ही क्षैतिज स्थिति में एक गैर-अंतरिक्ष वर्ण (यानी /या \कहीं) ऊपर हो, और फिर हम इमोजी वर्णों की संख्या को उस पर कब्जा कर लेते हैं बिंदु। इस मैच को उस अंतिम कैप्चर की लंबाई से बदल दिया गया है, जो हमें इस अनचाहे इमोजी कैरेक्टर का इंडेक्स देता है। रेगेक्स में एक |\Dऔर सब कुछ मैच करने के लिए होता है, जो कुछ भी नहीं के साथ बदल जाता है, इसलिए हम अन्य सभी पात्रों को हटा देते हैं।

— मार्टिन एंडर
स्रोत
क्या आप अधिक बता सकते हैं कि इमोजी पात्रों के ऊपर यह रेगेक्स कैसा दिखता है?
— सिंटेक्स
1
@ सिंटैक्स यह संतुलन समूहों का उपयोग करता है पर पूर्ववर्ती वर्णों को गिनने के लिए । यह इसकी क्षैतिज स्थिति को मापता है। तब के बाद मैं मिलान कर लेते हैं /या \, मैं फिर से उस समूह से पॉपिंग कर रहा हूँ, जबकि सामान पूर्ववर्ती मिलान कि , और फिर यकीन है कि मैं पूरी तरह से समूह समाप्त हो गए हैं। यह मूल रूप से यह सुनिश्चित करता है कि इमोजी की क्षैतिज स्थिति और छत का चरित्र मेल खाता है।
— मार्टिन एंडर
1

पायथ, 27 23 बाइट्स

0 अनुक्रमित।

-m.xsd;.T:R"-_-"s`M3.zd

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

व्याख्या

-m.xsd;.T:R"-_-"s`M3.zd

                    .z   all lines of input, as a list
         :R"-_-"s`M3     replace "-_-" by "012" 
                         "012" is generated by s`M3
       .T                transpose, return all columns
                         The sample input becomes:
                           0
                           1
                          /2
                         / 
                         \ 
                         \
 m   d                   for each line:
  .xs                        attempt to convert to integer.
      ;                      if errors, replace to space
-                     d  remove all spaces

इतिहास

27 बाइट्स: sM:#"^ *\d"0.T:R"-_-"s`M3.z( इसे ऑनलाइन आज़माएं! )

— लीक नन
स्रोत
1

मतलाब, 43 बाइट्स

@(x)find(sum((x(:,x(end,:)~=' '))~=' ')==1)

यह कोड इनपुट की अंतिम पंक्ति में गैर-अंतरिक्ष वर्णों के स्तंभ पदों को खोजता है, उन स्तंभों में गैर-अंतरिक्ष वर्णों की संख्या को बताता है, और पाता है कि जहां केवल एक ही ऐसा चरित्र है (इमोजी का चरित्र, छाता द्वारा अन-कवच!) । यह कोड केवल अच्छी तरह से गठित छतरियों के लिए उचित परिणाम देता है (यह हमारे इमोजी के ऊपर किसी भी चरित्र को मानता है) एक अच्छी तरह से गठित छतरी का हिस्सा है)।

यहाँ परीक्षण मामलों को लिखने और मेरे काम की जाँच करने के लिए उपयोगिता कोड की एक बिट है:

ws = @(x) repmat(' ',1,x);  %  for making strings of spaces
% for writing three-storey umbrellas over an emoji located left-edge at position x
thrht = @(x) strvcat([ws(3) '/\' ws(3); ws(2) '/  \' ws(2); ws(1) '/' ws(4) '\' ws(1); ws(8)], [ws(x-1) '-_-']);
twht = @(x) strvcat([ws(3) '/\' ws(3); ws(2) '/  \' ws(2); ws(8)], [ws(x-1) '-_-']);

रनिंग x = thrht(7)देता है

x =

   /\    
  /  \   
 /    \  

      -_-

या x = twht(0) देता है

x =

   /\   
  /  \  

 -_-
— sintax
स्रोत
0

एपीएल, 31 बाइट्स

{(⍳3)∩,(~∨⌿⍵∊'/\')/+\+\'-_-'⍷⍵}

यह इनपुट के रूप में एक चरित्र मैट्रिक्स लेता है।

टेस्ट:

      t1 t2 t3 t4
┌──────┬────────┬──────┬─────────────────┐
│  /\  │   /\   │    /\│     /\          │
│ /  \ │  /  \  │   -_-│    /  \         │
│/    \│        │      │   /    \        │
│      │     -_-│      │  /      \       │
│  -_- │        │      │ /        \      │
│      │        │      │/          \     │
│      │        │      │                 │
│      │        │      │                 │
│      │        │      │                 │
│      │        │      │                 │
│      │        │      │              -_-│
└──────┴────────┴──────┴─────────────────┘
      {(⍳3)∩,(~∨⌿⍵∊'/\')/+\+\'-_-'⍷⍵} ¨ t1 t2 t3 t4
┌┬───┬─┬─────┐
││2 3│1│1 2 3│
└┴───┴─┴─────┘

स्पष्टीकरण:

  • '-_-'⍷⍵: इनपुट का आकार शून्य में मैट्रिक्स में, '-_-'1 के साथ इनपुट की शुरुआत की स्थिति को चिह्नित करें ।
  • +\+\: पंक्तियों पर योग चल रहा है। पहला एक में बनाता 0 0 0 1 0 0 ...है 0 0 0 1 1 1 ..., दूसरा फिर में बनाता है 0 0 0 1 2 3 ...।
  • ⍵∊'/\': 1s के साथ इनपुट में '/' और '\' की सभी घटनाओं को चिह्नित करें।
  • ∨⌿: orस्तंभों पर। यह अंतिम पंक्ति पर 1 सभी पदों के साथ है जो छाता द्वारा कवर किया गया है।
  • ~: not , क्योंकि हमें इसके विपरीत की आवश्यकता है
  • (... )/...: पहले से चल रहे योग मैट्रिक्स से सभी खुला स्तंभों का चयन करें
  • ,: परिणामी मैट्रिक्स में सभी मानों की एक सूची प्राप्त करें।
  • (⍳3)∩: इसके बीच अंतर और 1 2 3(यह किसी भी चयनित 0s या उच्च मूल्यों से छुटकारा पाता है, जो रिक्त स्थान होगा)।
— मारीनस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.