Voici mon emoji pour animaux de compagnie, Billy:

-_-

Les émojis n'aiment pas être sous la pluie, alors Billy est triste ... Tirons-lui un parapluie pour qu'il se sente mieux!

  /\
 /  \
/    \

  -_-

C'est bien, il est entièrement couvert par son parapluie! Voici un exemple où seule une partie de lui est couverte:

  /\
 /  \
/    \

     -_-

Dans ce cas, les sections 2 et 3 de son corps sont exposées à la pluie.

Les parapluies se présentent sous de nombreuses formes et tailles, mais ils sont toujours constitués d'une série de barres obliques ascendantes /suivies d'une série de barres obliques inverses descendantes \. Par exemple, ce sont tous des parapluies valides:

  /\
 /  \
/    \

/\

    /\
   /  \
  /    \
 /      \
/        \

Et ce ne sont pas:

/   \

\/

  \
 / \
/   \

 0\
/  \

//\\
/  \

Vous devez déterminer quelles parties de mes emoji sont exposées à la pluie.

Clarifications

• Votre programme (ou fonction) prendra en entrée une chaîne 2D. Cela peut être dans le format le plus pratique ou le plus naturel pour votre langue. Un tableau de chaînes, un tableau de tableaux de caractères, une chaîne avec des retours à la ligne, etc.

• Vous devez afficher les sections des emoji exposées à la pluie. Cela peut être indexé zéro ou un indexé, à condition que cela soit clair. La sortie peut être dans n'importe quel format raisonnable. Si l'ensemble des emoji est protégé de la pluie, ne rien produire (ou un tableau vide).

• Vous pouvez supposer que toutes les entrées auront un parapluie valide, et même emoji: -_-. L'emoji sera toujours sur la dernière ligne de l'entrée, mais il peut y avoir plusieurs lignes vides entre le parapluie et l'emoji.

• Tout ce qui ne fait pas partie du parapluie ou de l'emoji sera un caractère d' espace ou une nouvelle ligne.

• L'entrée sera complétée par des espaces afin que la longueur de chaque ligne soit la même.

Les failles standard s'appliquent et la réponse la plus courte en octets l'emporte!

Test IO:

Tous les exemples de cas utiliseront une seule indexation.

  /\
 /  \
/    \

  -_-

Outputs: []

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

   /\
  /  \

     -_-

Outputs: [2, 3]

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

    /\
   -_-

Outputs: [1]

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

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




               -_-

Outputs: [1, 2, 3]

05AB1E , 18 17 15 octets

Code:

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

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! (assurez-vous de remplir toutes les lignes avec des espaces à la même longueur ..

JavaScript (ES6), 95 octets

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'entrée doit être un tableau de chaînes, chaque ligne étant remplie d'espaces pour former un carré. La sortie est un tableau de nombres indexés sur 1.

Explication

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 octets

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

Accepte un tableau de lignes irrégulières et renvoie un résultat indexé sur 1. Explication:

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 (ou 161) caractères

Parce que tu sais, Java a également besoin d'émoticônes sèches.

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

Il retourne un ArrayList un HashSet une Stack contenant les parties des emoji qui sont exposées à la pluie (l'indexation commence à 0). Le tout déballé:

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

Mises à jour

J'ai fait du golf de base. Cela comprend la mise en place des déclarations, la comparaison avec les valeurs ascii pour enregistrer certains caractères et raccourcir les boucles.

Merci à @ user902383 d'avoir signalé mon erreur de vidage en utilisant ArrayLists au lieu de simplement Lists. J'ai remplacé les ArrayLists / Lists par HashSets / Sets, ce qui enregistre encore plus de caractères. Merci aussi pour son conseil d'utiliser une boucle foreach dans la boucle intérieure! Grâce à ce changement, je suis en mesure de créer une variable pour l'index de la dernière ligne de la grille, ce qui la raccourcit un peu plus. Au total, 17 caractères ont été enregistrés!

@KevinCruijssen a suggéré de supprimer les génériques lors de l'initialisation, je suis allé plus loin: supprimez tous les génériques. Cela permet d'économiser 10 autres caractères.

Je suis revenu de la boucle foreach à la boucle for. Cela permet de sauter la comparaison de la dernière ligne ce qui à mon tour me permet de raccourcir la comparaison des valeurs ascii. Dans ce contexte, seuls '/', '\' et '_' ont une valeur ascii supérieure à 46. Si nous ne vérifions pas la dernière ligne, nous pouvons utiliser un> 46 check place pour vérifier la valeur réelle.

Merci encore à @ user902383 de m'avoir montré que j'utilise un lambda et que je peux utiliser List + Stack au lieu de Set + HashSet pour raser un autre personnage.

Version renvoyant une chaîne

@ user902383 a souligné que je peux à la place simplement créer une chaîne avec les chiffres. Cela semble très tricheur, mais d'autres semblent le résoudre de cette façon, voici donc une version plus courte utilisant un retour de chaîne:

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

Non 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 octets (non concurrent)

G^R123?/
f\GddHÍó

Version alternative concurrente (21 octets):

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

Essayez-le en ligne!(Remarque, tryitonline.net utilise une version légèrement plus ancienne de V. Pour compenser cela, il utilise cette version légèrement plus longue)

Explication:

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

Cela seul produit le résultat correct en 17 octets. Cependant, cela crée également des espaces supplémentaires. Cela ne me dérange pas, mais je ne veux pas me donner un avantage injuste, alors j'ajoute deux octets:

Íó          "Remove all whitespace

JavaScript (ES6), 117 112 octets

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)

Accepte un tableau irrégulier de tableaux de chaînes de caractères et renvoie des résultats indexés sur 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

Démo

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>

Rétine , 56 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Il s'agit d'une étape de substitution unique, où l'expression régulière correspond à l'un des caractères emoji, à condition qu'il y ait un caractère non spatial (c'est-à-dire un /ou \) quelque part au-dessus dans la même position horizontale, puis nous capturons le nombre de caractères emoji jusqu'à ce point. Cette correspondance est remplacée par la longueur de cette dernière capture, ce qui nous donne l'index de ce caractère emoji non abrité. Le regex contient également un |\Dpour correspondre à tout le reste qui est remplacé par rien du tout, nous supprimons donc tous les autres caractères.

Pyth, 27 23 octets

0 indexé.

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

Essayez-le en ligne!

Explication

-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

Histoire

27 octets: sM:#"^ *\d"0.T:R"-_-"s`M3.z( Essayez-le en ligne! )

Matlab, 43 octets

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

Ce code recherche les positions de colonne des caractères non-espace dans la dernière ligne de l'entrée, additionne le nombre de caractères non-espace dans ces colonnes et trouve où il n'y a qu'un seul de ces caractères (le caractère de l'emoji, non protégé par un parapluie!) . Ce code ne renvoie que des résultats corrects pour les parapluies bien formés (il suppose que tout caractère au-dessus de nos emoji fait partie d'un parapluie bien formé).

Voici un peu de code utilitaire pour écrire des cas de test et vérifier mon travail:

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

Courir x = thrht(7)donne

x =

   /\    
  /  \   
 /    \  

      -_-

Ou x = twht(0) donne

x =

   /\   
  /  \  

 -_-     

APL, 31 octets

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

Cela prend une matrice de caractères en entrée.

Tests:

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

Explication:

• '-_-'⍷⍵: dans une matrice de zéros la taille de l'entrée, marquez la position du début de '-_-'l'entrée avec un 1.
• +\+\: Somme cumulée sur les lignes. Le premier fait 0 0 0 1 0 0 ...dans 0 0 0 1 1 1 ..., le second fait alors dans 0 0 0 1 2 3 ....
• ⍵∊'/\': marque toutes les occurrences de '/' et '\' dans l'entrée avec 1s.
• ∨⌿: orsur des colonnes. Cela marque avec un 1 toutes les positions sur la dernière rangée qui sont couvertes par le parapluie.
• ~: not , parce que nous avons besoin du contraire
• (... )/...: sélectionnez toutes les colonnes non couvertes dans la matrice de somme en cours d'exécution précédente
• ,: Obtenir une liste de toutes les valeurs dans la matrice résultante.
• (⍳3)∩: Intersection entre cela et 1 2 3(cela supprime tous les 0 sélectionnés ou les valeurs supérieures, qui seraient des espaces).

Python 2, 114 111 octets

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)

Utilise une indexation basée sur 0.

Essayez-le ici .