How tall are the monoliths?

Question

Here is an example of an input of monoliths. There are 4 in this example.

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

The first monolith is 4 units high, the second is 2, the third is 3, and the last is 1.

The task

Your program should output the heights of the monoliths in order from left to right. The output format can be in any sort of list or array.

Notes

• The input can be taken as any dimensional string, list of strings, or list of characters.
• This is code-golf, so lowest bytes wins.
• You are to assume that monoliths always have the same width, and are always at least 1 _ away from another.
• They can come in any height, and in any quantity.

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]

Answer 1

Jelly, (8?) 9 bytes

Ỵ=”|Sḟ0m2

A monadic link accepting a list of characters as specified and returning a list of integers.

Note: 8 bytes if a list of strings, one per line, was really intended to be an allowed input format - just remove the Ỵ.

Try it online!

How?

Ỵ=”|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)

Answer 2

Jelly, 11 bytes

ỴṚZi€”_ỊÐḟ’

Try it online!

Answer 3

JavaScript (ES6), 79 78 77 bytes

-1 byte thanks to @Shaggy
-1 byte thanks to @l4m2

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

Takes input as an array of strings.

Test Snippet

f=
a=>a.map((b,i)=>b.replace(/_/g,(_,j)=>o[j]=a.length+~i),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>

Answer 4

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

Try it online!

C++ (GCC), 150 bytes

Thanks to @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<<" ";}}

Try it online!

Answer 5

05AB1E, 11 bytes

|Rζ'_δkJ®0‚K

Try it online!

ζ has been replaced by .Bø on TIO since it hasn't been pulled there yet.

Answer 6

Dyalog APL, 29 bytes

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

Run with ⎕IO←0.

Try it online!

How?

⌽⍵='_' - where ⍵ is '_', top lines first

×- multiply by ...

(⍳≢⍵) - the range of ⍵ (zero indexed)

↑¨ - for each line, pad with zeros by ...

(⌈/⍴¨⍵) - the maximal length

↑+/ - sum the rows zipped and flatten

0~⍨ - removes zeros

Answer 7

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+",");}}

Try it online!

Ungolfed:

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, first post. Any help improving it would be great. I know I can get rid of that indexOf written twice. Knew it! I toyed with the idea of changing the types in the map from Integer to Long but I think that's a dead end.

---

_{I know there is a much, much better Java 8 solution already, but that takes char[][] as input which I think is easier to work with in this case than String.}

Answer 8

Uiua, 11 bytes

⊢⇌⍉⊚⍉⇌⌕"_ "

Try it!

Explanation:

      ⌕"_ " # Mark the locations of the tower tops
    ⍉⇌      # Rotate the array 90° clockwise
   ⊚        # Get the coordinates of the marked (non-zero) elements, going top to bottom
⊢⇌⍉         # Take the second column of the coordinates 

(here's how the array looks before and after ⌕"_ ")

["  _                      "
 " | |        _            "
 " | |  _    | |           "
 " | | | |   | |     _   _ "
 "_| |_| |___| |____| |_| |"]

[[0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Answer 9

Python 2, 75 bytes

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

Try it online!

Answer 10

Japt, 11 bytes

z ·mb'_ fw0

Test it online!

Explanation

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

Answer 11

APL (Dyalog), 14 bytes

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

with ⎕IO←0

Try it online!

---

This function train equivalent to {((⍳≢⍵)+.×('_'=⊖⍵))~0}

Answer 12

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

Looks like it's not very competitive; it does a regex replace to turn the towers into columns of 1, makes an array of 0 the length of the input string, then steps through the lines adding up the 1s.

Tests ready to run:

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


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

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


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

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

Answer 13

Retina, 48 38 bytes

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

Try it online! Link includes first example. Explanation: A line is prefixed which will collect the results. As each column is repeatedly deleted in turn, those that contains a _ above ground level have the the number of remaining lines in the column counted. Finally the now blank lines are deleted. Edit: Saved 10 bytes thanks to inspriation from @FryAmTheEggman.

Answer 14

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+",");}}

Takes the input as a String[] char[][] (← saves 16 bytes).
-2 bytes in exchange for less readable output thanks to @OlivierGrégoire by changing print(l-j+",") to println(l-j).

Explanation:

Try it here.

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

Answer 15

Haskell, 75 74 bytes

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

The input is expected as a list of strings (rowwise).

Answer 16

MATL, 12 bytes

&nxG2\&fx-Xz

Input is a char matrix, with ; as row separator.

Try it online! Or verify all test cases.

Answer 17

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)

Full/Formatted version:

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

Answer 18

MATL, 10 bytes

ooYssqtO>)

Input is a padded character matrix.

Try it online!

Answer 19

Python 2, 58 bytes

lambda l:[s.index('_')+1for s in zip(*l[-2::-1])if'_'in s]

Try it online!

Taking input as list of strings.

Answer 20

Uiua, 11 12 bytes

▽↧\≠±../+=@|

Try it

Annoyingly my original solution didn’t work, but I have a new one which is much cooler for just a byte longer.

Consider this input:

["  _   _                  "
 " | | | |    _            "
 " | | | |   | |         _ "
 " | | | |   | |     _  | |"
 "_| |_| |___| |____| |_| |"]

First, =@| makes a boolean matrix of where pipes are in the input.

[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 1 0 1]
 [0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 1]]

Then sum /+ the columns:

[0 4 0 4 0 4 0 4 0 0 0 3 0 3 0 0 0 0 1 0 1 0 2 0 2]

Jonathan Allan's Jelly solution uses the same idea of summing the mask of pipes, but in Jelly the shortest way to then get just the relevant numbers is to remove zeros and keep the items at even indices. In Uiua, that comes out to 14 bytes.

Instead, my idea was to first take the signs ± of the sums:

[0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 1]

and to scan \ by not equal to ≠:

[0 1 1 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 1 0]

Then, we take the minimums ↧ of this and the original sums:

[0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0]

Using this as a filter ▽ for the sums yields the final result:

[4 4 3]

Answer 21

Mathematica, 48 47 39 bytes

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

Try it online!

Function which expects a rectangular array of characters. Takes Most of the array (all but the last row), Reverses it, then takes the Transpose*, then finds all Positions at which the _ character appears. The relevant heights are the Last elements of each Position.

*  is the 3 byte private use character U+F3C7 which represents \[Transpose] in Mathematica. Note that this doesn't work in Mathics, so the TIO link just uses Transpose.

Answer 22

Ruby, 82 bytes

Takes in a list of lines.

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

Try it online!

Answer 23

SOGL V0.12, 9 bytes

I{ _WH╥?O

Try it Here!
Takes input as an array of arrays of strings (characters).

Explanation:

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

Answer 24

JavaScript (ES6), 108 104 88 bytes

Saved 16 bytes thanks to @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)

Input taken as an array of strings

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

Answer 25

CJam, 15 14 bytes

^{1 byte saved thanks to @BusinessCat}

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

This is a block that takes an array of strings on the stack and outputs an array.

Explanation:

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

Answer 26

Uiua ^SBCS, 13 bytes

+1↘1⍜⍉⊚↘1⇌=@_

Try it!

+1↘1⍜⍉⊚↘1⇌=@_
          =@_  # matrix mask of underscores
         ⇌     # reverse order of rows
       ↘1      # drop the first, removing the "floor"
    ⍜⍉⊚        # coordinates in the mask were it to be transposed
  ↘1           # drop the x coordinates
+1             # increment

Answer 27

Uiua, 12 bytes

+1▽⊃∊⊗@_⍉↘1⇌

See it in action

Answer 28

Perl 5 -p, 44 bytes

s/_/$r[pos]=$./eg}{$_&&$.-$_&&say$.-$_ for@r

Try it online!

Answer 29

JavaScript (Node.js), 70 bytes

a=>[...a.pop()].flatMap((_,i)=>a.flatMap((s,j)=>s[i]>_?a.length-j:[]))

Try it online!

Answer 30

Ruby, 73 bytes

More boring but shorter than my original solution (below). Takes an array of lines.

->s{s.pop
s.map(&:chars).transpose.filter_map{n=_1.index ?_
n&&s.size-n}}

Attempt This Online!

Ruby, 78 bytes

->s,*a{s.scan(/_/){c=$'.count $/
a<<[$`[/.+\Z/].size,c]if c>0}
a.sort.map{_2}}

Attempt This Online!