Questa è la mia emoji da compagnia, Billy:

-_-

Agli emoji non piace stare sotto la pioggia, quindi Billy è triste ... Disegniamo un ombrello per farlo stare meglio!

  /\
 /  \
/    \

  -_-

Questo va bene, è interamente coperto dal suo ombrello! Ecco un esempio in cui è coperta solo una parte di lui:

  /\
 /  \
/    \

     -_-

In questo caso, le sezioni 2 e 3 del suo corpo sono esposte alla pioggia.

Gli ombrelli sono disponibili in molte forme e dimensioni, ma sono sempre costituiti da una serie di barre ascendenti /seguite da una serie di barre rovesciate discendenti \. Ad esempio, questi sono tutti ombrelli validi:

  /\
 /  \
/    \

/\

    /\
   /  \
  /    \
 /      \
/        \

E questi non sono:

/   \

\/

  \
 / \
/   \

 0\
/  \

//\\
/  \

Devi determinare quali parti della mia emoji sono esposte alla pioggia.

chiarimenti

• Il tuo programma (o funzione) prenderà una stringa 2d come input. Questo può essere in qualsiasi formato più conveniente o naturale per la tua lingua. Una matrice di stringhe, una matrice di matrici di caratteri, una stringa con dentro nuove righe ecc.

• Devi emettere quali sezioni delle emoji sono esposte alla pioggia. Questo può essere indicizzato zero o indicizzato uno, purché sia ​​chiaro. L'output può essere in qualsiasi formato ragionevole. Se l'intera emoji è protetta dalla pioggia, non emettere nulla (o un array vuoto).

• Si può supporre che tutti gli ingressi avranno un ombrello valida, e lo stesso emoji: -_-. Le emoji saranno sempre sull'ultima riga dell'input, tuttavia potrebbero esserci diverse righe vuote tra l'ombrello e l'emoji.

• Tutto ciò che non fa parte dell'ombrello o dell'emoji sarà un personaggio spaziale o newline.

• L'input sarà riempito con spazi in modo che la lunghezza di ogni riga sia la stessa.

Si applicano scappatoie standard e vince la risposta più breve in byte!

Test IO:

Tutti i casi di esempio utilizzeranno l'indicizzazione singola.

  /\
 /  \
/    \

  -_-

Outputs: []

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

   /\
  /  \

     -_-

Outputs: [2, 3]

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

    /\
   -_-

Outputs: [1]

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

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




               -_-

Outputs: [1, 2, 3]

05AB1E , 18 17 15 byte

Codice:

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

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! (assicurati di riempire tutte le linee con spazi della stessa lunghezza ..

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

L'input dovrebbe essere una matrice di stringhe, con ogni riga riempita di spazi per formare un quadrato. L'output è un array di numeri 1 indicizzati.

Spiegazione

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

Accetta una matrice irregolare di righe e restituisce un risultato con 1 indice. Spiegazione:

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

Perché sai, anche Java ha bisogno di emoji asciutti.

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

Restituisce un ArrayList un HashSet uno Stack contenente le parti delle emoji che sono esposte alla pioggia (l'indicizzazione inizia da 0). Il tutto da scartare:

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

aggiornamenti

Ho fatto un po 'di golf di base. Questo include mettere insieme le dichiarazioni, confrontare con i valori ASCII per salvare alcuni caratteri e accorciare i loop.

Grazie a @ user902383 per aver segnalato il mio errore di dump usando ArrayLists invece che solo Liste. Ho sostituito ArrayLists / Lists con HashSets / Sets che salva alcuni caratteri in più. Grazie anche per il suo suggerimento per usare un ciclo foreach nel circuito interno! Attraverso quella modifica sono in grado di creare una variabile per l'indice dell'ultima riga della griglia che la accorcia un po 'di più. Complessivamente sono stati salvati 17 personaggi!

@KevinCruijssen ha suggerito di rimuovere i generici nell'inizializzazione, ho fatto un passo ulteriore: Rimuovi tutti i generici. Ciò consente di salvare altri 10 caratteri.

Sono passato dal ciclo foreach al ciclo for. Ciò consente di saltare il confronto dell'ultima riga, il che a sua volta mi consente di abbreviare il confronto dei valori ASCII. In questo contesto solo '/', '\' e '_' hanno un valore ascii superiore a 46. Se non controlliamo l'ultima riga, possiamo usare a > 46 checkinvece per verificare il valore effettivo.

Grazie ancora a @ user902383 per avermi mostrato che uso un lambda e posso usare List + Stack invece di Set + HashSet per radere un altro personaggio.

Versione di ritorno della stringa

@utente902383 ha sottolineato che posso invece semplicemente creare una stringa con le cifre. Sembra molto economico, ma altri sembrano risolverlo in questo modo, quindi ecco una versione più breve usando un ritorno 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 byte (non concorrenti)

G^R123?/
f\GddHÍó

Alternate, versione in competizione (21 byte):

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

Provalo online!(Nota, tryitonline.net utilizza una versione un po 'vecchio di V. Per compensare questo, utilizza questa versione leggermente più lungo)

Spiegazione:

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

Questo da solo produce il risultato corretto in 17 byte. Tuttavia, si crea anche un po 'di spazio vuoto in più. Non mi dispiace, ma io non voglio darmi un vantaggio sleale, quindi sto aggiungendo due byte:

Íó          "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)

Accetta una matrice irregolare di matrici di stringhe di caratteri e restituisce risultati con indice 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

dimostrazione

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 byte

conteggio di byte assume codifica ISO 8859-1.

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

Provalo online!

Questa è una singola fase di sostituzione, in cui il regex corrisponde a uno dei personaggi emoji, a condizione che ci sia un personaggio non spaziale (cioè a /o \) da qualche parte sopra nella stessa posizione orizzontale, e quindi catturiamo il numero di caratteri emoji fino a quello punto. Questa partita viene sostituita con la lunghezza dell'ultima cattura, che ci fornisce l'indice di questo personaggio emoji non protetto. Il regex contiene anche un |\Dcorrispondente a tutto il resto che viene sostituito con niente, quindi rimuoviamo tutti gli altri caratteri.

Pyth, 27 23 byte

0-indicizzati.

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

Provalo online!

Spiegazione

-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

Storia

27 byte: sM:#"^ *\d"0.T:R"-_-"s`M3.z( Provalo in rete! )

Matlab, 43 byte

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

Questo codice rileva posizioni delle colonne di caratteri non spazio nella riga finale dell'ingresso, somma il numero di caratteri diversi dallo spazio in tali colonne, e reperti dove c'è solo una tale carattere (carattere del emoji, non schermati da ombrello!) . Questo codice restituisce solo i risultati corretti per gli ombrelli ben formate (assume un carattere sopra la nostra emoji è parte di un ombrello ben formato).

Ecco un po 'di codice di utilità per scrivere casi di test e controllare il mio lavoro:

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

esecuzione x = thrht(7)dà

x =

   /\    
  /  \   
 /    \  

      -_-

o x = twht(0) dà

x =

   /\   
  /  \  

 -_-     

APL, 31 byte

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

Questo richiede una matrice di caratteri come input.

test:

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

Spiegazione:

• '-_-'⍷⍵: in una matrice di zero la dimensione dell'ingresso, contrassegnare la posizione dell'inizio di '-_-'nell'ingresso con un 1.
• +\+\: Somma corrente su righe. Il primo fa 0 0 0 1 0 0 ...in 0 0 0 1 1 1 ..., il secondo rende quindi in 0 0 0 1 2 3 ....
• ⍵∊'/\': Contrassegnare tutte le occorrenze di '/' e '\' nell'input con 1s.
• ∨⌿: orSopra le colonne. Il presente marchio con un 1 tutte le corone ultima fila che sono coperti dal ombrello.
• ~: notperché abbiamo bisogno del contrario
• (...)/ ...: selezionare tutte le colonne non coperte dalla matrice somma parziale da prima
• ,: Ottiene un elenco di tutti i valori nella matrice risultante.
• (⍳3)∩: Intersezione tra questo e 1 2 3(questo elimina qualsiasi 0 selezionato o valori più alti, che sarebbero spazi).

Python 2, 114 111 byte

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)

Utilizza l'indicizzazione basata su 0.

Provalo qui .