다음은 모놀리스 입력의 예입니다 . 이 예에는 4가 있습니다.

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

첫 번째 단일체는 높이가 4 단위이고 두 번째는 2, 세 번째는 3, 마지막은 1입니다.

작업

프로그램은 왼쪽에서 오른쪽으로 모놀리스 높이를 출력해야합니다. 출력 형식은 모든 종류의 목록 또는 배열 일 수 있습니다.

노트

• 입력을 차원 문자열, 문자열 목록 또는 문자 목록으로 사용할 수 있습니다.
• 이것은 code-golf 이므로 가장 낮은 바이트가 이깁니다 .
• 모놀리스는 항상 같은 너비를 가지며 항상 _다른 너비와 1 이상 떨어져 있다고 가정해야합니다 .
• 그들은 어떤 높이와 수량으로도 올 수 있습니다.

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]

젤리 , (8?) 9 바이트

Ỵ=”|Sḟ0m2

지정된 문자 목록을 허용하고 정수 목록을 리턴하는 모나드 링크.

참고 : 한 줄에 하나씩 문자열 목록이 실제로 허용 된 입력 형식으로되어있는 경우 8 바이트Ỵ 입니다.

온라인으로 사용해보십시오!

방법?

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

젤리 , 11 바이트

ỴṚZi€”_ỊÐḟ’

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 79 78 바이트

@Shaggy 덕분에 -1 바이트

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

입력을 문자열 배열로 취합니다.

테스트 스 니펫

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 바이트

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

온라인으로 사용해보십시오!

C ++ (GCC), 150 바이트

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

온라인으로 사용해보십시오!

05AB1E , 11 바이트

|Rζ'_δkJ®0‚K

온라인으로 사용해보십시오!

ζ.BøTIO는 아직 뽑히지 않았기 때문에 TIO 로 대체 되었습니다.

Dyalog APL, 29 바이트

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

로 실행하십시오 ⎕IO←0.

온라인으로 사용해보십시오!

방법?

⌽⍵='_'- 맨 위 줄 ⍵은 어디에 있습니까?'_'

×-곱하기 ...

(⍳≢⍵)- ⍵(0 인덱스) 의 범위

↑¨ -각 라인마다 0으로 채워진 패드 ...

(⌈/⍴¨⍵) -최대 길이

↑+/ -압축 행을 합산

0~⍨ -0을 제거

파이썬 2 , 75 바이트

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

온라인으로 사용해보십시오!

PowerShell, 133 바이트

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

경쟁이 심하지 않은 것 같습니다. 그것은 정규식 대체를 수행하여 타워를 1의 열로 바꾸고 0의 배열을 입력 문자열의 길이로 만든 다음 1을 더하는 라인을 단계별로 수행합니다.

테스트 준비 완료 :

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


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

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


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

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

apt , 11 바이트

z ·mb'_ fw0

온라인으로 테스트하십시오!

설명

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

망막 , 48 38 바이트

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

온라인으로 사용해보십시오! 링크는 첫 번째 예를 포함합니다. 설명 : 결과를 수집 할 행이 앞에 붙습니다. 각 열이 차례로 반복적으로 삭제되면 _지면 수준이 포함 된 열의 열에 남아있는 줄 수가 계산됩니다. 마지막으로 이제 빈 줄이 삭제됩니다. 편집 : @FryAmTheEggman의 inspriation 덕분에 10 바이트를 절약했습니다.

자바 (8) 133 117 116 114 바이트

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

입력을 a로 가져옵니다 (← 16 바이트 저장). 로 변경 하여 @ OlivierGrégoire 덕분에 읽을 수없는 출력을 대체 하는 -2 바이트 .String[] char[][]
print(l-j+",")println(l-j)

설명:

여기에서 시도하십시오.

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

하스켈, 75 74 바이트

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

입력은 문자열 목록 (행 단위)으로 예상됩니다.

루비 , 82 바이트

줄 목록을받습니다.

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

온라인으로 사용해보십시오!

APL (Dyalog) , 14 바이트

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

와 ⎕IO←0

온라인으로 사용해보십시오!

이 기능은 {((⍳≢⍵)+.×('_'=⊖⍵))~0}

MATL , 12 바이트

&nxG2\&fx-Xz

입력은 ;행 분리 자로 문자 행렬 입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

C #을 150 144 137 바이트

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)

풀 / 포맷 버전 :

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

자바 8-229 바이트 213 바이트

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

온라인으로 사용해보십시오!

언 골프 드 :

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

우, 첫번째 포스트. 그것을 개선하는 데 도움이 될 것입니다. 나는 그 글을 두 번 제거 할 수 있다는 것을 안다indexOf . 그럴 줄 알았지! 지도의 유형을 Integer에서 Long으로 변경한다는 아이디어를 가지고 놀았지만 막 다른 골목이라고 생각합니다.

_{나는 이미 훨씬 더 나은 Java 8 솔루션 이 있다는 것을 알고 있지만, char[][]이 경우 String보다 작업하기가 더 쉬운 입력으로 사용됩니다.}

MATL , 10 바이트

ooYssqtO>)

입력은 채워진 문자 행렬입니다.

온라인으로 사용해보십시오!

Mathematica, 48 47 39 바이트

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

온라인으로 사용해보십시오!

Function직사각형 배열의 문자가 필요합니다. 소요 Most배열 (모든하지만 마지막 행)의 Reverse다음, 그것을 s를 필요 Transpose*를, 모든 발견 Position의에서 _문자 나타납니다. 관련 높이는 Last각 요소입니다 Position.

* 는 Mathematica에서 나타내는 3바이트 전용 사용 문자 U+F3C7입니다 \[Transpose]. 이것은 Mathics 에서는 작동하지 않으므로 TIO 링크 는을 사용합니다 Transpose.

SOGL V0.12 , 9 바이트

I{ _WH╥?O

여기 사용해보십시오!
문자열 배열 (문자)의 배열로 입력을받습니다.

설명:

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

자바 스크립트 (ES6), 108 (104) 88 바이트

@JustinMariner 덕분에 16 바이트 절약

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

문자열 배열로 가져온 입력

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 바이트

^{@BusinessCat 덕분에 1 바이트 절약}

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

스택에서 문자열 배열을 가져 와서 배열을 출력하는 블록입니다.

설명:

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

핍 , 18 17 바이트

15 바이트의 코드, -rp플래그의 경우 +2

_FI_@?'_MRVgZDs

stdin에서 입력을받습니다. 온라인으로 사용해보십시오!

설명

                 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 바이트

f>T0mx_d\_.tQd

온라인으로 테스트하십시오! 입력은 라인 목록입니다.

설명

          .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

옥타브, 31 바이트

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

2D 문자 배열을 입력으로받습니다.

모든 테스트 사례를 확인하십시오!

펄 6 , 65 바이트

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

온라인으로 사용해보십시오!

• m:exhaustive/^^(\N+)_([\N*\n]+:)/입력 문자열에서 모든 밑줄을 검색하고 각 밑줄을 찾습니다. 첫 번째 캡처 괄호에는 밑줄이있는 줄의 앞 부분이 포함되고 두 번째 캡처 괄호에는 나머지 문자열 전체가 포함됩니다. 문자열의 나머지 부분에는 적어도 하나의 줄 바꿈이 포함되어야하므로지면 수준에서 밑줄을 계산하지 않습니다. :exhaustive플래그는 중복 이러한 일치 할 수 있습니다.
• .sort(*[0].chars)이러한 일치 객체를 각 밑줄 앞에있는 줄 부분의 문자 수로 정렬합니다. 이렇게하면 왼쪽에서 오른쪽으로 주문됩니다.
• .map(+*[1].comb("\n"))각 일치 객체를 각 밑줄 뒤에 오는 입력 문자열 부분의 높이 (즉, 높이)에 줄 바꿈 문자 수에 매핑합니다. 는 \n한 바이트를 저장, 실제 개행 문자입니다.

PHP, 119 바이트

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

이것을 분해하자! 여기 입력은 2D 문자 배열입니다.

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

여러 줄 문자열을받습니다. 설정에 대한 크레딧 (헤더 및 바닥 글)은 @GarethPW로 이동합니다.

파이썬 2 , 29 바이트

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

온라인으로 사용해보십시오!

이것은 단순히 배열을 개행으로 나누고 length-1을 반환합니다.