Este es mi mascota emoji, Billy:

-_-

A los emojis no les gusta estar bajo la lluvia, así que Billy está triste ... ¡Dibujémosle un paraguas para que se sienta mejor!

  /\
 /  \
/    \

  -_-

¡Esto es bueno, está completamente cubierto por su paraguas! Aquí hay un ejemplo donde solo una parte de él está cubierto:

  /\
 /  \
/    \

     -_-

En este caso, las secciones 2 y 3 de su cuerpo están expuestas a la lluvia.

Los paraguas vienen en muchas formas y tamaños, pero siempre están formados por una serie de barras ascendentes /seguidas de una serie de barras descendentes \. Por ejemplo, estos son todos los paraguas válidos:

  /\
 /  \
/    \

/\

    /\
   /  \
  /    \
 /      \
/        \

Y estos no son:

/   \

\/

  \
 / \
/   \

 0\
/  \

//\\
/  \

Debes determinar qué partes de mis emoji están expuestas a la lluvia.

Aclaraciones

• Su programa (o función) tomará una cadena 2d como entrada. Esto puede ser en cualquier formato que sea más conveniente o natural para su idioma. Una matriz de cadenas, una matriz de matrices de caracteres, una cadena con nuevas líneas, etc.

• Debes mostrar qué secciones de los emoji están expuestas a la lluvia. Esto puede ser indexado a cero o indexado a uno, siempre que lo deje claro. La salida puede estar en cualquier formato razonable. Si todo el emoji está protegido de la lluvia, no muestre nada (o una matriz vacía).

• Se puede suponer que todas las entradas tendrán un paraguas válida, y el mismo emoji: -_-. El emoji siempre estará en la última línea de la entrada, sin embargo, puede haber varias líneas vacías entre el paraguas y el emoji.

• Todo lo que no sea parte del paraguas o el emoji será un personaje espacial o una nueva línea.

• La entrada se rellenará con espacios para que la longitud de cada línea sea la misma.

Se aplican las lagunas estándar, ¡y gana la respuesta más corta en bytes!

Prueba IO:

Todos los casos de muestra utilizarán una indexación.

  /\
 /  \
/    \

  -_-

Outputs: []

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

   /\
  /  \

     -_-

Outputs: [2, 3]

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

    /\
   -_-

Outputs: [1]

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

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




               -_-

Outputs: [1, 2, 3]

05AB1E , 18 17 15 bytes

Código:

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

Explicación:

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

Utiliza la codificación CP-1252 .Pruébalo en línea! (asegúrese de rellenar todas las líneas con espacios a la misma longitud ..

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

La entrada debe ser una serie de cadenas, con cada línea rellenada con espacios para formar un cuadrado. La salida es una matriz de números indexados 1.

Explicación

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

Acepta una matriz irregular de líneas y devuelve un resultado indexado 1. Explicación:

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 (o 161) caracteres

Porque ya sabes, también Java necesita 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;}

Devuelve un ArrayList un HashSet a Stack que contiene las partes del emoji que están expuestas a la lluvia (la indexación comienza en 0). Todo sin envolver:

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

Actualizaciones

Hice un poco de golf básico. Esto incluye unir las declaraciones, compararlas con los valores ascii para guardar algunos caracteres y acortar los bucles.

Gracias a @ user902383 por señalar mi error de volcado usando ArrayLists en lugar de solo Lists. Reemplacé las ArrayLists / Lists con HashSets / Sets que guarda algunos caracteres más. ¡También gracias por su consejo de usar un bucle foreach en el bucle interno! A través de ese cambio, puedo crear una variable para el índice de la última fila de la cuadrícula que lo acorta un poco más. ¡En total se han guardado 17 caracteres!

@KevinCruijssen sugirió eliminar los genéricos en la inicialización, fui un paso más allá: eliminar todos los genéricos. Esto ahorra otros 10 caracteres.

Volví del bucle foreach al bucle for. Esto hace posible omitir la comparación de la última línea, lo que a su vez me permite acortar la comparación de los valores ascii. En este contexto, solo '/', '\' y '_' tienen un valor ascii superior a 46. Si no verificamos la última línea, podemos usar a > 46 checken su lugar para verificar el valor real.

Gracias nuevamente a @ user902383 por mostrarme que uso un lambda y puedo usar List + Stack en lugar de Set + HashSet para eliminar otro personaje.

Versión de retorno de cadena

@ user902383 señaló que en su lugar solo puedo crear una Cadena con los dígitos. Esto suena muy engañoso, pero otros parecen resolverlo de esta manera, así que aquí hay una versión más corta que usa un retorno de cadena:

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

Sin golf:

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 (no competitivos)

G^R123?/
f\GddHÍó

Versión alternativa y competitiva (21 bytes):

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

Pruébalo en línea!(Tenga en cuenta que tryitonline.net usa una versión ligeramente anterior de V. Para compensar esto, usa esta versión un poco más larga)

Explicación:

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

Esto solo produce el resultado correcto en 17 bytes. Sin embargo, también crea algunos espacios en blanco adicionales. No me importa, pero no quiero darme una ventaja injusta, así que agrego dos 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)

Acepta una matriz irregular de series de cadenas de caracteres y devuelve resultados indexados a 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

Manifestación

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

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Se trata de una sola etapa de sustitución, donde la expresión coincide con uno de los caracteres emoji, siempre que hay un personaje no-espacio (es decir, una /o \) en algún lugar más arriba en la misma posición horizontal, y luego capturar el número de caracteres emoji hasta que punto. Esta coincidencia se reemplaza con la duración de la última captura, lo que nos da el índice de este personaje emoji sin protección. La expresión regular también contiene una |\Dpara que coincida con todo lo demás que se reemplaza con nada, por lo que eliminamos todos los demás caracteres.

Pyth, 27 23 bytes

0 indexado.

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

Pruébalo en línea!

Explicación

-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

Historia

27 bytes: sM:#"^ *\d"0.T:R"-_-"s`M3.z(¡ Pruébelo en línea! )

Matlab, 43 bytes

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

Este código encuentra las posiciones de columna de caracteres no espaciales en la fila final de la entrada, suma el número de caracteres no espaciales en esas columnas y encuentra dónde solo hay uno de esos caracteres (¡el carácter del emoji, sin protección por paraguas!) . Este código solo devuelve resultados adecuados para paraguas bien formados (asume que cualquier carácter por encima de nuestro emoji es parte de un paraguas bien formado).

Aquí hay un poco de código de utilidad para escribir casos de prueba y verificar mi trabajo:

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

x =

   /\    
  /  \   
 /    \  

      -_-

O x = twht(0) da

x =

   /\   
  /  \  

 -_-     

APL, 31 bytes

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

Esto toma una matriz de caracteres como entrada.

Pruebas:

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

Explicación:

• '-_-'⍷⍵: en una matriz de ceros del tamaño de la entrada, marque la posición del comienzo de '-_-'en la entrada con un 1.
• +\+\: Ejecutar suma sobre filas. El primero se convierte 0 0 0 1 0 0 ...en 0 0 0 1 1 1 ..., el segundo luego se convierte en 0 0 0 1 2 3 ....
• ⍵∊'/\': marca todas las apariciones de '/' y '\' en la entrada con 1s.
• ∨⌿: orsobre columnas. Esto marca con un 1 todas las posiciones en la última fila que están cubiertas por el paraguas.
• ~: notporque necesitamos lo contrario
• (...)/ ...: Seleccione todas las columnas descubiertas de la matriz de suma corriente de antes
• ,: Obtenga una lista de todos los valores en la matriz resultante.
• (⍳3)∩: Intersección entre eso y 1 2 3(esto elimina los 0 seleccionados o valores superiores, que serían espacios).

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)

Utiliza indexación basada en 0.

Pruébalo aquí .