Ill just put the code here and if you have any questions please feel free to post in the comments.

defmodule Solution do
    def run(print \\ true) do
        read()
        |> print(print, "read")
        |> build_tree_helper()
        |> print(print, "build_tree_helper")
        |> print_tree()
    end
    
    @doc """
    Reads the input and turns the value into an integer
    """
    def read() do
       IO.read(:stdio, :all)
       |> String.trim()
       |> String.to_integer()
    end
    
    @doc """
    Starts the recursive function to compute the value for any given row, column.
    """
    def build_tree_helper(depth) do
        build_tree(depth, 0, 0, [])
    end
    
    
    @doc """
    Runs through each row column. Checks every depth against each row column up to the depth 
    we are given
    """
    def build_tree(_depth, 63, _col, list), do: list
    def build_tree(depth, row, 100, list),  do: build_tree(depth, row + 1, 0, list)
    def build_tree(depth, row, column, list) do
        character = is_one_at_depths(row, column, depth)   # <- use this instead
        build_tree(depth, row, column + 1, [character | list])
    end
    
    @doc """
    Uses function to return the set of values for height, row_mid, and column_mid(list).
    """
    def build_values(depth) do
        %{
          height: div(32, trunc(:math.pow(2, depth))),
          row_mid: row_mid(depth),
          column_mid: column_mid(depth)
        }
    end
      
    @doc """
    Sets all the mid points of any given Y based off the depth given
    """
    def column_mid(1), do: [49]
    def column_mid(depth) when depth > 1 do
        prev = column_mid(depth - 1)
        offset = div(32, trunc(:math.pow(2, depth - 1)))  # height of previous depth

        Enum.flat_map(prev, fn mid ->
            [mid - offset, mid + offset]
        end)
    end

    @doc """
    Sets the mid point of the Y for a given depth. 
    """
    def row_mid(depth) do
        offsets = [47, 23, 11, 5, 2]
        Enum.at(offsets, depth - 1)     
    end
    
    @doc """
    Given a set of values for the height, row mid-point, and a list of column mid-points, will 
    determine if the row/column given is meant to be a "1" or a "_"
    """
    def is_one(row, column, %{height: height, row_mid: row_mid, column_mid: column_mid}) do
        cond do
            row <= row_mid + height and row > row_mid and Enum.member?(column_mid, column) -> "1"
            row < row_mid and row >= row_mid - height and
                Enum.any?(column_mid, fn col ->
                    offset = row_mid - row
                    column == col - offset or column == col + offset
                end) ->  "1"
            row == row_mid and Enum.member?(column_mid, column) -> "1"
            true -> "_"
        end
    end
    
    @doc """
    Will check every value set for each depth against the row/column given.
    """
    def is_one_at_depths(row, column, max_depth) do
        Enum.any?(1..max_depth, fn depth ->
            values = build_values(depth)
            is_one(row, column, values) == "1"
        end)
        |> set_ones()
    end
      
    @doc """
    Changes the true false values of the Enum.any? to useful characters.
    """
    defp set_ones(true), do: "1"
    defp set_ones(false), do: "_"

    @doc """
    Prints the final version of the diagram
    """
    defp print_tree(list) do
        list
        |> Enum.reverse()
        |> Enum.chunk_every(100)
        |> Enum.each(&IO.puts(Enum.join(&1)))
    end

    @doc """
    Used to debug the code as we build each step.
    """
    defp print(data, false, _label), do: data
    defp print(data, true, label) do
        IO.inspect(data, label: label)
    end
end

Solution.run(false)