Dies ist mein Haustier Emoji, Billy:

-_-

Emojis mögen es nicht, im Regen zu sein, also ist Billy traurig ... Lassen Sie uns ihm einen Regenschirm ziehen, damit er sich besser fühlt!

  /\
 /  \
/    \

  -_-

Das ist gut, er ist vollständig von seinem Regenschirm bedeckt! Hier ist ein Beispiel, in dem nur ein Teil von ihm behandelt wird:

  /\
 /  \
/    \

     -_-

In diesem Fall sind die Abschnitte 2 und 3 seines Körpers dem Regen ausgesetzt.

Regenschirme gibt es in vielen Formen und Größen, aber sie bestehen immer aus einer Reihe von aufsteigenden Schrägstrichen, /gefolgt von einer Reihe von absteigenden Schrägstrichen \. Dies sind zum Beispiel alle gültigen Regenschirme:

  /\
 /  \
/    \

/\

    /\
   /  \
  /    \
 /      \
/        \

Und das sind nicht:

/   \

\/

  \
 / \
/   \

 0\
/  \

//\\
/  \

Sie müssen feststellen, welche Teile meines Emoji dem Regen ausgesetzt sind.

Klarstellungen

• Ihr Programm (oder Ihre Funktion) nimmt einen 2D-String als Eingabe. Dies kann in jedem Format geschehen, das für Ihre Sprache am bequemsten oder am natürlichsten ist. Ein Array von Zeichenfolgen, ein Array von Zeichenfolgen, eine Zeichenfolge mit Zeilenumbrüchen usw.

• Sie müssen ausgeben, welche Bereiche des Emoji dem Regen ausgesetzt sind. Dies kann nullindexiert oder einindexiert sein, solange Sie dies klarstellen. Die Ausgabe kann in jedem vernünftigen Format erfolgen. Wenn das gesamte Emoji vor Regen geschützt ist, geben Sie nichts (oder ein leeres Array) aus.

• Sie können davon ausgehen , dass alle Eingänge einen gültigen Schirm haben, und die gleiche emoji: -_-. Das Emoji befindet sich immer in der letzten Zeile der Eingabe, es kann sich jedoch auch um mehrere leere Zeilen zwischen dem Umbrella und dem Emoji handeln.

• Alles, was nicht Teil des Regenschirms oder des Emojis ist, wird ein Leerzeichen oder eine Newline sein.

• Die Eingabe wird mit Leerzeichen aufgefüllt, sodass die Länge jeder Zeile gleich ist.

Es gelten Standardlücken und die kürzeste Antwort in Bytes gewinnt!

Test IO:

In allen Beispielfällen wird eine Indizierung verwendet.

  /\
 /  \
/    \

  -_-

Outputs: []

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

   /\
  /  \

     -_-

Outputs: [2, 3]

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

    /\
   -_-

Outputs: [1]

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

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




               -_-

Outputs: [1, 2, 3]

05AB1E , 18 17 15 Bytes

Code:

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

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! ( Stellen Sie sicher, dass alle Zeilen mit Leerzeichen auf die gleiche Länge aufgefüllt sind.)

JavaScript (ES6), 95 Byte

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

Die Eingabe sollte aus einer Reihe von Zeichenfolgen bestehen, wobei jede Zeile mit Leerzeichen aufgefüllt wird, um ein Quadrat zu bilden. Die Ausgabe ist ein Array von 1-indizierten Zahlen.

Erläuterung

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>

JavaScript (ES6), 92 Byte

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

Akzeptiert ein uneinheitliches Zeilenarray und gibt ein 1-indiziertes Ergebnis zurück. Erläuterung:

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

Java 8 Lambda, 241 218 201 191 185 184 (oder 161) Zeichen

Weil du weißt, braucht auch Java trockene Emojis.

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;}

Es gibt eine ArrayList und einen HashSet a Stack zurück, der die Teile des Emoji enthält, die dem Regen ausgesetzt sind (die Indizierung beginnt bei 0). Das Ganze ausgepackt:

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;
    }
}

Aktualisierung

Ich habe ein bisschen Golf gespielt. Dies beinhaltet das Zusammenstellen der Deklarationen, den Vergleich mit den ASCII-Werten, um einige Zeichen zu speichern und die Schleifen zu verkürzen.

Vielen Dank an @ user902383 für den Hinweis auf meinen Speicherauszugsfehler bei der Verwendung von ArrayLists anstelle von nur Listen. Ich habe die ArrayLists / Lists durch HashSets / Sets ersetzt, wodurch mehr Zeichen eingespart werden. Vielen Dank auch für seinen Tipp, eine foreach-Schleife in der inneren Schleife zu verwenden! Durch diese Änderung kann ich eine Variable für den Index der letzten Rasterzeile erstellen, die ihn etwas kürzer macht. Insgesamt wurden 17 Zeichen gespeichert!

@ KevinCruijssen schlug vor, die Generika in der Initialisierung zu entfernen, ich ging einen Schritt weiter: Entfernen Sie alle Generika. Dadurch werden weitere 10 Zeichen gespeichert.

Ich bin von der foreach-Schleife zur for-Schleife zurückgeschaltet. Dadurch kann der Vergleich der letzten Zeile übersprungen werden, wodurch der Vergleich der ASCII-Werte verkürzt werden kann. In diesem Zusammenhang haben nur '/', '\' und '_' einen ASCII-Wert über 46. Wenn wir die letzte Zeile nicht überprüfen, können wir > 46 checkstattdessen mit a nach dem tatsächlichen Wert suchen.

Nochmals vielen Dank an @ user902383, der mir gezeigt hat, dass ich ein Lambda verwende und List + Stack anstelle von Set + HashSet verwenden kann, um ein anderes Zeichen zu rasieren.

String-Rückgabeversion

@ user902383 wies darauf hin, dass ich stattdessen einfach einen String mit den Ziffern erstellen kann. Das klingt sehr betrügerisch, aber andere scheinen es auf diese Weise zu lösen. Hier ist eine kürzere Version mit einem String-Return:

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;
    }
}

V , 20 bis 19 Bytes (nicht konkurrierend)

G^R123?/
f\GddHÍó

Alternative, konkurrierende Version (21 Bytes):

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

Probieren Sie es online! (Bitte beachten Sie, dass tryitonline.net eine etwas ältere Version von V verwendet. Um dies auszugleichen, wird diese etwas längere Version verwendet.)

Erläuterung:

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

Dies alleine ergibt das korrekte Ergebnis in 17 Bytes. Es werden jedoch auch zusätzliche Leerzeichen erzeugt. Es macht mir nichts aus, aber ich möchte mir keinen unfairen Vorteil verschaffen, also füge ich zwei Bytes hinzu:

Íó          "Remove all whitespace

JavaScript (ES6), 117 112 Byte

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)

Nimmt eine ragged Array von Zeichenketten Arrays von Zeichen und kehrt 0-indizierte Ergebnisse.

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

Demo

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>

Netzhaut , 56 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Dies ist eine einzelne Substitutionsstufe, in der die Regex mit einem der Emoji-Zeichen übereinstimmt, vorausgesetzt, es gibt ein nicht-Leerzeichen (dh ein /oder \) irgendwo darüber in derselben horizontalen Position, und dann erfassen wir die Anzahl der Emoji-Zeichen bis zu dieser Punkt. Dieses Match wird durch die Länge des letzten Captures ersetzt, wodurch wir den Index dieses ungeschützten Emoji-Charakters erhalten. Der reguläre Ausdruck enthält auch ein |\D, um mit allem anderen übereinzustimmen, das durch gar nichts ersetzt wird. Daher entfernen wir alle anderen Zeichen.

Pyth, 27 23 Bytes

0-indiziert.

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

Probieren Sie es online!

Erläuterung

-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

Geschichte

27 Bytes: sM:#"^ *\d"0.T:R"-_-"s`M3.z( Online ausprobieren! )

Matlab, 43 Bytes

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

Dieser Code findet die Spaltenpositionen von Nicht-Leerzeichen in der letzten Zeile der Eingabe, summiert die Anzahl der Nicht-Leerzeichen in diesen Spalten und findet, wo es nur ein solches Zeichen gibt (das Emoji- Zeichen, das nicht durch einen Regenschirm geschützt ist!). . Dieser Code liefert nur korrekte Ergebnisse für wohlgeformte Regenschirme (er setzt voraus, dass jedes Zeichen über unserem Emoji Teil eines wohlgeformten Regenschirms ist).

Hier ist ein wenig Dienstprogrammcode zum Schreiben von Testfällen und Überprüfen meiner Arbeit:

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) '-_-']);

Laufen x = thrht(7) gibt

x =

   /\    
  /  \   
 /    \  

      -_-

Oder x = twht(0) gibt

x =

   /\   
  /  \  

 -_-     

APL, 31 Bytes

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

Dies nimmt eine Zeichenmatrix als Eingabe.

Tests:

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

Erläuterung:

• '-_-'⍷⍵: Markieren Sie in einer Nullmatrix die Position des Anfangs von '-_-' in der Eingabe mit einer 1.
• +\+\: Laufende Summe über Zeilen. Der erste macht 0 0 0 1 0 0 ...in 0 0 0 1 1 1 ..., der zweite macht es dann in0 0 0 1 2 3 ... .
• ⍵∊'/\': Markiere alle Vorkommen von '/' und '\' in der Eingabe mit 1s.
• ∨⌿: or über Spalten. Dies markiert mit einer 1 alle Positionen in der letzten Reihe, die vom Regenschirm abgedeckt werden.
• ~: not, weil wir das Gegenteil brauchen
• (... )/...: Wählen Sie alle nicht abgedeckten Spalten aus der laufenden Summenmatrix aus
• ,: Eine Liste aller Werte in der resultierenden Matrix erhalten.
• (⍳3)∩: Schnittmenge zwischen diesem und 1 2 3(dabei werden alle ausgewählten Nullen oder höheren Werte entfernt, die Leerzeichen wären).

Python 2, 114 111 Bytes

def f(a):c=a.find("\n")+1;r=a.rfind;g=lambda i:([i],[])[r("\\")%c>=r("-")%c-2+i>=r("/")%c];print g(0)+g(1)+g(2)

Verwendet eine 0-basierte Indizierung.

Probieren Sie es hier aus .