Aquí hay un ejemplo de una entrada de monolitos . Hay 4 en este ejemplo.

  _
 | |        _
 | |  _    | |
 | | | |   | |     _
_| |_| |___| |____| |_

El primer monolito tiene 4 unidades de altura, el segundo es 2, el tercero es 3 y el último es 1.

La tarea

Su programa debería generar las alturas de los monolitos en orden de izquierda a derecha. El formato de salida puede estar en cualquier tipo de lista o matriz.

Notas

• La entrada se puede tomar como cualquier cadena dimensional, lista de cadenas o lista de caracteres.
• Este es el código de golf , por lo que gana los bytes más bajos .
• Debe suponer que los monolitos siempre tienen el mismo ancho y siempre están al menos a 1 _distancia de otro.
• Pueden venir en cualquier altura y en cualquier cantidad.

I / O

  _
 | |        _
 | |  _    | |
 | | | |   | |     _
_| |_| |___| |____| |_   >> [4,2,3,1]

           _
          | |
  _       | |
 | |  _   | |  _
_| |_| |__| |_| |_   >> [2,1,4,1]


 _   _   _ 
| |_| |_| |_____   >> [1,1,1]

____________________   >> undefined behavior

 _
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |   >> [11]

     _       _       _       _       _
 _  | |  _  | |  _  | |  _  | |  _  | |
| |_| |_| |_| |_| |_| |_| |_| |_| |_| |  >> [1,2,1,2,1,2,1,2,1,2]

Jalea , (8?) 9 bytes

Ỵ=”|Sḟ0m2

Un enlace monádico que acepta una lista de caracteres como se especifica y devuelve una lista de enteros.

Nota: 8 bytes si una lista de cadenas, una por línea, realmente tenía la intención de ser un formato de entrada permitido, simplemente elimine el Ỵ.

Pruébalo en línea!

¿Cómo?

Ỵ=”|Sḟ0m2 - Link: list of characters, s
Ỵ         - split at newlines
  ”|      - literal '|'
 =        - equals (vectorises)
    S     - sum (vectorises, hence counts the number of '|' in every column)
     ḟ0   - filter out zeros (only keep the results from the sides of the towers)
       m2 - modulo index with 2 (keep only the left side measurements)

Jalea , 11 bytes

ỴṚZi€”_ỊÐḟ’

Pruébalo en línea!

JavaScript (ES6), 79 78 bytes

-1 byte gracias a @Shaggy

a=>a.map((b,i)=>b.replace(/_/g,(_,j)=>o[j]=a.length-i-1),o=[])&&o.filter(x=>x)

Toma la entrada como una matriz de cadenas.

Fragmento de prueba

f=
a=>a.map((b,i)=>b.replace(/_/g,(_,j)=>o[j]=a.length-i-1),o=[])&&o.filter(x=>x)
I.value="           _\n          | |\n  _       | |\n | |  _   | |  _\n_| |_| |__| |_| |_"

<textarea id=I rows=7 cols=30></textarea><br><button onclick="O.value=`[${f(I.value.split`\n`).join`, `}]`">Run</button> <input id=O disabled>

C ++, 171 169 bytes

#import<vector>
#import<iostream>
int f(std::vector<std::string>s){for(int a,j,i=0,k=s.size()-1;a=s[k][i];++i)if(a==32){for(j=0;(a=s[k-++j][i])-95;);std::cout<<j<<" ";}}

Pruébalo en línea!

C ++ (GCC), 150 bytes

Gracias a @aschepler!

#import<vector>
#import<iostream>
int f(auto s){for(int a,j,i=0,k=s.size()-1;a=s[k][i];++i)if(a==32){for(j=0;(a=s[k-++j][i])-95;);std::cout<<j<<" ";}}

Pruébalo en línea!

05AB1E , 11 bytes

|Rζ'_δkJ®0‚K

Pruébalo en línea!

ζha sido reemplazado por .BøTIO ya que aún no se ha extraído allí.

Dyalog APL, 29 bytes

{0~⍨↑+/(⌈/⍴¨⍵)↑¨(⍳≢⍵)×⌽⍵='_'}

Corre con ⎕IO←0.

Pruébalo en línea!

¿Cómo?

⌽⍵='_'- dónde ⍵está '_', primero las líneas superiores

×- multiplicar por ...

(⍳≢⍵)- el rango de ⍵(indexado a cero)

↑¨ - para cada línea, pad con ceros por ...

(⌈/⍴¨⍵) - la longitud máxima

↑+/ - Sumar las filas con cremallera y aplanar

0~⍨ - elimina ceros

Python 2 , 75 bytes

lambda s:[x.index('_')for x in map(None,*s.split('\n')[::-1])if'_'in x[1:]]

Pruébalo en línea!

PowerShell, 133 bytes

param($s)$r=,0*($l=($s=$s-replace'\| \|',' 1 ')[0].Length);1..$s.Count|%{$z=$_-1;0..($l-1)|%{$r[$_]+=(''+$s[$z][$_]-as[int])}};$r-ne0

Parece que no es muy competitivo; hace un reemplazo de expresiones regulares para convertir las torres en columnas de 1, hace una matriz de 0 de la longitud de la cadena de entrada, luego pasa a través de las líneas sumando los 1s.

Pruebas listas para correr:

$s1 = @'
  _                   
 | |        _         
 | |  _    | |        
 | | | |   | |     _  
_| |_| |___| |____| |_
'@-split"`r?`n"


$s2 = @'
 _
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| | 
'@-split"`r?`n"

$s3 = @'
           _      
          | |       
  _       | |           
 | |  _   | |  _   
_| |_| |__| |_| |_ 
'@-split"`r?`n"


$s4 = @'
 _   _   _      
| |_| |_| |_____ 
'@-split"`r?`n"

$s5 = @'
     _       _       _       _       _ 
 _  | |  _  | |  _  | |  _  | |  _  | |
| |_| |_| |_| |_| |_| |_| |_| |_| |_| | 
'@-split"`r?`n"

Japt , 11 bytes

z ·mb'_ fw0

¡Pruébelo en línea!

Explicación

z ·mb'_ fw0   : Implicit input
z             : Rotate the input clockwise. This puts the "floor" against the left side.
  ·           : Split the 2D string into lines.
   m          : Replace each column (now row) X with
    b'_       :   the index of '_' in X (0-indexed). This gives us the output list, with
              :   0's and -1's mixed in representing the columns that are not monoliths.
        f     : Take only the items X where
         w0   :   max(X, 0) is truthy. Since 0 is falsy, this removes anything <= 0.
              : Implicit: output result of last expression

Retina , 48 38 bytes

^
¶
{`(¶.*)*¶_(.*¶)+
$#2 $&
}`¶.
¶
G`.

Pruébalo en línea! El enlace incluye el primer ejemplo. Explicación: una línea tiene el prefijo que recogerá los resultados. Como cada columna se elimina repetidamente por turno, las que contienen un _nivel sobre el suelo tienen el número de líneas restantes en la columna contada. Finalmente, las líneas ahora en blanco se eliminan. Editar: guardado 10 bytes gracias a la inspiración de @FryAmTheEggman.

Java 8, 133 117 116 114 bytes

a->{for(int l=a.length-1,i=0,j;i<a[0].length;i++)if(a[l][i]<33){for(j=0;a[j][i]<33;j++);System.out.print(l-j+",");}}

Toma la entrada como a (← guarda 16 bytes). -2 bytes a cambio de una salida menos legible gracias a @ OlivierGrégoire al cambiar a .String[] char[][]
print(l-j+",")println(l-j)

Explicación:

Pruébalo aquí.

a->{                         // Method with character 2D-array parameter and no return-type
  for(int l=a.length-1,      //  Length of the 2D char-array - 1
      i=0,j;                 //  Index-integers
    i<a[0].length;i++)       //  Loop (1) over the 2D char-array
    if(a[l][i]<33){          //   If the base of the current column is a space
      for(j=0;a[j][i]<33;    //    Loop (2) over the cells in this column as long as
                             //    we encounter spaces (from top to bottom)
        j++                  //     And increase `j` every time, to go down the column
      );                     //    End of loop (2)
      System.out.println(l-j);
                             //    Print the amount of rows - `j`
    }                        //   End of if-block
                             //  End of loop (1) (implicit / single-line body)
}                            // End of method

Haskell 75 74 bytes

import Data.List;f=filter(>0).map(length.fst.span(<'!').reverse).transpose

La entrada se espera como una lista de cadenas (rowwise).

Ruby , 82 bytes

Toma en una lista de líneas.

->l{l.map! &:chars;(l.pop.zip(*l).map{|s|s.join.count ?|}-[i=0]).select{0<1&i+=1}}

Pruébalo en línea!

APL (Dyalog) , 14 bytes

0~⍨⍳∘≢+.×'_'=⊖

con ⎕IO←0

Pruébalo en línea!

Este tren de funciones equivalente a {((⍳≢⍵)+.×('_'=⊖⍵))~0}

MATL , 12 bytes

&nxG2\&fx-Xz

La entrada es una matriz de caracteres, con un ;separador de filas.

Pruébalo en línea! O verificar todos los casos de prueba .

C #, 150 144 137 bytes

using System.Linq;a=>a.SelectMany((i,h)=>i.Select((c,w)=>new{c,w,d=a.Length-1-h}).Where(o=>o.c==95&o.d>0)).OrderBy(o=>o.w).Select(o=>o.d)

Versión completa / formateada:

using System;
using System.Collections.Generic;
using System.Linq;

class P
{
    static void Main()
    {
        Func<char[][], IEnumerable<int>> f = a =>
            a.SelectMany((i, h) => i.Select((c, w) => new { c, w, d = a.Length - 1 - h })
                                    .Where(o => o.c == 95 & o.d > 0))
             .OrderBy(o => o.w)
             .Select(o => o.d);

        Console.WriteLine(string.Concat(f(new char[][]
        {
            "  _                 ".ToArray(),
            " | |       _        ".ToArray(),
            " | |  _   | |       ".ToArray(),
            " | | | |  | |    _  ".ToArray(),
            "_| |_| |__| |___| |_".ToArray(),
        })));

        Console.ReadLine();
    }
}

Java 8 - 229 bytes 213 bytes

s->{Map<Integer,Integer> m=new TreeMap();String[] l=s.split("\n");for(int i=0,j=-1;i<l.length-1;++i){s=l[i];while((j=s.indexOf("_",j+1))>=0){m.put(j,i);}}for(int i:m.values()){System.out.print(l.length-i-1+",");}}

Pruébalo en línea!

Sin golf:

public static void foo(String input)
{
    Map<Integer, Integer> map = new TreeMap(); // Raw types!!
    String[] lines = input.split("\n");

    for (int i = 0, j = -1; i < lines.length - 1; ++i)
    {
        input = lines[i];

        while ((j = input.indexOf("_", j + 1)) >= 0)
        {
            map.put(j, i);
        }
    }

    for(int i:map.values())
    {
        System.out.print(lines.length - i - 1 + ",");
    }
}

Woo, primer post. Cualquier ayuda para mejorarlo sería genial. Yo sé que puedo deshacerse de ese indexOfescrito dos veces. ¡Lo sabía! Jugué con la idea de cambiar los tipos en el mapa de Integer a Long, pero creo que es un callejón sin salida.

_{Sé que ya existe una solución Java 8 mucho mejor , pero eso toma char[][]como entrada, lo que creo que es más fácil de trabajar en este caso que String.}

MATL , 10 bytes

ooYssqtO>)

La entrada es una matriz de caracteres acolchada.

Pruébalo en línea!

Mathematica, 48 47 39 bytes

Last/@(Reverse@Most@#~Position~"_")&

Pruébalo en línea!

Functionque espera una matriz rectangular de caracteres. Toma Mostla matriz (todos menos la última fila), Reverses, luego toma el Transpose*, luego encuentra todos los Positions en los que _aparece el carácter. Las alturas relevantes son los Lastelementos de cada uno Position.

* es el 3carácter de uso privado de bytes U+F3C7que representa \[Transpose]en Mathematica. Tenga en cuenta que esto no funciona en matemáticas , por lo que solo usa el enlace TIOTranspose .

SOGL V0.12 , 9 bytes

I{ _WH╥?O

Pruébalo aquí!
Toma la entrada como una matriz de matrices de cadenas (caracteres).

Explicación:

I          rotate the array clockwise
 {         for each element
   _       push "_"
    W      get its index in the array (0 if not found, 1 if its the ground, >1 if its what we need)
     H     decrease that
      ╥    palindromize (duplicates the number, if it's <0, then errors and pushes 0, if =0, pushes 0, if >0, then pushes the number palindromized (always truthy))
       ?   if that, then
        T  output in a new line the original decreased index

JavaScript (ES6), 108 104 88 bytes

Guardado 16 bytes gracias a @JustinMariner

i=>i.map((s,h)=>{while(t=r.exec(s))m[t.index]=i.length-h-1},m=[],r=/_/g)&&m.filter(e=>e)

Entrada tomada como una matriz de cadenas

let input = [
'  _',
' | |           _',
' | |  _   _   | |',
' | | | | | |  | |     _',
'_| |_| |_| |__| |____| |_'
]

let anonymousFunction =
i=>i.map((s,h)=>{while(t=r.exec(s))m[t.index]=i.length-h-1},m=[],r=/_/g)&&m.filter(e=>e)

console.log(anonymousFunction(input))

CJam, 15 14 bytes

^{1 byte guardado gracias a @BusinessCat}

{W%z'_f#{0>},}

Este es un bloque que toma una matriz de cadenas en la pila y genera una matriz.

Explicación:

W%    e# Reverse
z     e# Zip
'_f#  e# Get the index of '_' in each element (-1 if not found)
{0>}, e# Filter where positive

Pip , 18 17 bytes

15 bytes de código, +2 para -rpbanderas.

_FI_@?'_MRVgZDs

Toma información de stdin. Pruébalo en línea!

Explicación

                 g is list of lines from stdin (-r flag); s is space
         RVg     Reverse g
            ZDs  Zip (transpose), filling gaps with a default char of space
        M        Map this function:
   _@?'_          Index of _ in each line (or nil if it doesn't appear)
_FI              Filter, keeping only the truthy (nonzero, non-nil) values
                 Autoprint in repr format (-p flag)

Pyth , 19 15 14 bytes

f>T0mx_d\_.tQd

¡Pruébelo en línea! La entrada es una lista de líneas.

Explicaciones

          .tQd     # Transpose, pad with spaces
    mx_d\_         # For each line, reverse it, find the position of "_" (-1 if not found)
f>T0               # Filter on positions greater than zero

Octava, 31 bytes

@(a)(s=sum(a>95))(s>0)(1:2:end)

Toma una matriz 2D de caracteres como entrada.

¡Verifique todos los casos de prueba!

Perl 6 , 65 bytes

{m:ex/^^(\N+)_([\N*\n]+:)/.sort(*[0].chars).map(+*[1].comb("
"))}

Pruébalo en línea!

• m:exhaustive/^^(\N+)_([\N*\n]+:)/busca en la cadena de entrada todos los guiones bajos y devuelve un objeto de coincidencia para cada uno, donde los primeros paréntesis de captura contienen la parte anterior de la línea en la que se encuentra el guión bajo, y los segundos paréntesis de captura contienen el resto de la cadena. El resto de la cadena debe contener al menos una nueva línea, por lo que no contamos los guiones bajos a nivel del suelo. La :exhaustivebandera permite que estas coincidencias se superpongan.
• .sort(*[0].chars)ordena estos objetos de coincidencia por el número de caracteres en la parte de la línea que precede a cada subrayado. Esto los ordena de izquierda a derecha.
• .map(+*[1].comb("\n"))asigna cada objeto de coincidencia al número de caracteres de nueva línea en la parte de la cadena de entrada que sigue a cada subrayado, es decir, la altura. los\n es un carácter de nueva línea real, que guarda un byte.

PHP, 119 bytes

function($s){$r=array_map(null,...$s);foreach($r as$k=>&$v)if($v=array_count_values($v)['|'])echo($v+$r[$k+2]=0)." ";};

¡Analicemos esto! Nuestra entrada aquí es una matriz 2D de caracteres.

$r=array_map(null,...$s) // Neat little snippet to transpose the array

foreach($r as$k=>&$v)    // Loop through the array, grabbing each row of our 2D array 
(which is now each column of the monolith)

if($v=array_count_values($v)['|']) // Count the number of '|' characters in the column 
(which is the height of our monolith), and if it's greater than 0 (truthy in PHP)...

echo($v+$r[$k+2]=0)." "; // Output that number, and simultaneously set the row 2 indices
                            down to null (to remove duplicate values)

Toma una cuerda multilínea. El crédito para la configuración (encabezado y pie de página) va a @GarethPW

Python 2 , 29 bytes

lambda s:len(s.split('\n'))-1

Pruébalo en línea!

Esto simplemente dividirá la matriz por nueva línea y devolverá longitud-1.