Este é o meu emoji de estimação, Billy:

-_-

Os emojis não gostam de estar na chuva, então Billy está triste ... Vamos desenhar um guarda-chuva para ele se sentir melhor!

  /\
 /  \
/    \

  -_-

Isso é bom, ele está totalmente coberto por seu guarda-chuva! Aqui está um exemplo em que apenas parte dele é abordada:

  /\
 /  \
/    \

     -_-

Nesse caso, as seções 2 e 3 de seu corpo são expostas à chuva.

Os guarda-chuvas têm várias formas e tamanhos, mas são sempre compostos por uma série de barras ascendentes, /seguidas por uma série de barras invertidas descendentes \. Por exemplo, todos esses são guarda-chuvas válidos:

  /\
 /  \
/    \

/\

    /\
   /  \
  /    \
 /      \
/        \

E estes não são:

/   \

\/

  \
 / \
/   \

 0\
/  \

//\\
/  \

Você precisa determinar quais partes do meu emoji estão expostas à chuva.

Esclarecimentos

• Seu programa (ou função) terá uma string 2d como entrada. Isso pode estar no formato que for mais conveniente ou natural para o seu idioma. Uma matriz de seqüências de caracteres, uma matriz de matrizes de caracteres, uma sequência com novas linhas etc.

• Você deve mostrar quais seções do emoji estão expostas à chuva. Isso pode ser indexado a zero ou a um, desde que você deixe isso claro. A saída pode estar em qualquer formato razoável. Se o emoji inteiro estiver protegido da chuva, não produza nada (ou uma matriz vazia).

• Você pode assumir que todas as entradas terão um guarda-chuva válido, eo mesmo emoji: -_-. O emoji sempre estará na última linha da entrada, no entanto, pode haver várias linhas vazias entre o guarda-chuva e o emoji.

• Tudo o que não faz parte do guarda-chuva ou do emoji será um caractere espacial ou uma nova linha.

• A entrada será preenchida com espaços para que o comprimento de cada linha seja o mesmo.

As brechas padrão se aplicam e a resposta mais curta em bytes vence!

Teste de E / S:

Todos os casos de amostra usarão uma indexação.

  /\
 /  \
/    \

  -_-

Outputs: []

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

   /\
  /  \

     -_-

Outputs: [2, 3]

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

    /\
   -_-

Outputs: [1]

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

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




               -_-

Outputs: [1, 2, 3]

05AB1E , 18 17 15 bytes

Código:

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

Explicação:

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

Usa a codificação CP-1252 . Experimente online! (certifique-se de preencher todas as linhas com espaços do mesmo comprimento.

JavaScript (ES6), 95 bytes

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

A entrada deve ser uma matriz de seqüências de caracteres, com cada linha preenchida com espaços para formar um quadrado. A saída é uma matriz de números indexados em 1.

Explicação

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 bytes

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

Aceita uma matriz irregular de linhas e retorna um resultado indexado em 1. Explicação:

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

Caracteres Java 8 lambda, 241 218 201 191 185 184 (ou 161)

Porque você sabe, o Java também precisa de emojis secos.

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

Ele retorna um ArrayList um HashSet uma pilha contendo as partes do emoji expostas à chuva (a indexação começa em 0). A coisa toda desembrulhou:

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

Atualizações

Eu pratiquei golfe básico. Isso inclui reunir as declarações, comparar com os valores ascii para salvar alguns caracteres e diminuir os loops.

Obrigado a @ user902383 por apontar meu erro de despejo usando ArrayLists em vez de apenas Lists. Substituí ArrayLists / Lists por HashSets / Sets, que salva mais alguns caracteres. Também obrigado por sua dica de usar um loop foreach no loop interno! Com essa alteração, sou capaz de criar uma variável para o índice da última linha da grade, que a reduz um pouco mais. No total, 17 caracteres foram salvos!

@KevinCruijssen sugeriu remover os genéricos na inicialização, fui um passo adiante: remova todos os genéricos. Isso salva outros 10 caracteres.

Voltei do loop foreach para o loop for. Isso torna possível pular a comparação da última linha, o que, por sua vez, me permite reduzir a comparação dos valores ascii. Nesse contexto, apenas '/', '\' e '_' têm um valor ASCII acima de 46. Se não verificarmos a última linha, podemos usar a > 46 checkpara verificar o valor real.

Mais uma vez obrigado a @ user902383 por me mostrar que eu uso um lambda e posso usar List + Stack em vez de Set + HashSet para cortar outro caractere.

Versão de retorno de string

@ user902383 apontou que eu posso apenas criar uma String com os dígitos. Isso parece muito barato, mas outros parecem resolvê-lo dessa maneira, então aqui está uma versão mais curta usando um retorno de String:

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 19 bytes (não concorrente)

G^R123?/
f\GddHÍó

Versão alternativa alternativa (21 bytes):

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

Experimente online! (Observe, tryitonline.net usa uma versão um pouco antiga de V. Para compensar isso, ela usa uma versão um pouco mais longa)

Explicação:

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

Isso por si só produz o resultado correto em 17 bytes. No entanto, também cria algum espaço em branco extra. Não me importo, mas não quero me dar uma vantagem injusta, por isso estou adicionando dois bytes:

Íó          "Remove all whitespace

JavaScript (ES6), 117 112 bytes

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)

Aceita uma matriz irregular de strings, matrizes de caracteres e retorna resultados indexados em 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

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>

Retina , 56 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

Esse é um estágio de substituição único, em que o regex corresponde a um dos caracteres emoji, desde que exista um caractere não espacial (ou seja, um /ou \) em algum lugar acima na mesma posição horizontal, e capturamos o número de caracteres emoji até aquele ponto. Essa correspondência é substituída pela duração da última captura, o que nos fornece o índice desse caractere emoji não abrigado. O regex também contém um |\Dpara corresponder a todo o resto que é substituído por nada, portanto, removemos todos os outros caracteres.

Pitão, 27 23 bytes

Indexado a 0.

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

Experimente online!

Explicação

-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

História

27 bytes: sM:#"^ *\d"0.T:R"-_-"s`M3.z( Experimente online! )

Matlab, 43 bytes

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

Esse código localiza as posições da coluna de caracteres não espaciais na linha final da entrada, soma o número de caracteres não espaciais nessas colunas e localiza onde há apenas um desses caracteres (o caractere do emoji, sem proteção pelo guarda-chuva!) . Esse código só retorna resultados adequados para guarda-chuvas bem formados (assume que qualquer caractere acima do nosso emoji faz parte de um guarda-chuva bem formado).

Aqui está um pouco do código do utilitário para escrever casos de teste e verificar meu trabalho:

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

Correr x = thrht(7)dá

x =

   /\    
  /  \   
 /    \  

      -_-

Ou x = twht(0) dá

x =

   /\   
  /  \  

 -_-     

APL, 31 bytes

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

Isso leva uma matriz de caracteres como entrada.

Testes:

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

Explicação:

• '-_-'⍷⍵: em uma matriz de zeros do tamanho da entrada, marque a posição do início de '-_-'na entrada com 1.
• +\+\: Executando soma sobre linhas. O primeiro torna uma 0 0 0 1 0 0 ...em 0 0 0 1 1 1 ..., a segunda uma, em seguida, faz com que seja em 0 0 0 1 2 3 ....
• ⍵∊'/\': marque todas as ocorrências de '/' e '\' na entrada com 1s.
• ∨⌿: orsobre colunas. Isso marca com 1 todas as posições na última linha que são cobertas pelo guarda-chuva.
• ~: not, porque precisamos do oposto
• (...)/ ...: selecione todas as colunas descobertas da matriz de soma em execução da anterior
• ,: Obtenha uma lista de todos os valores na matriz resultante.
• (⍳3)∩: Interseção entre isso e 1 2 3(isso elimina os 0s ou valores mais altos selecionados, que seriam espaços).

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)

Usa indexação baseada em 0.

Experimente aqui .