यहां मोनोलिथ के इनपुट का एक उदाहरण दिया गया है । इस उदाहरण में 4 हैं।

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

पहला मोनोलिथ 4 यूनिट ऊंचा है, दूसरा 2 है, तीसरा 3 है और आखिरी 1 है।

काम

आपके कार्यक्रम को मोनोलिथ की ऊँचाई को क्रम से बाएं से दाएं की ओर आउटपुट करना चाहिए। आउटपुट स्वरूप किसी भी प्रकार की सूची या सरणी में हो सकता है।

इनपुट को किसी भी आयामी स्ट्रिंग, स्ट्रिंग की सूची या वर्णों की सूची के रूप में लिया जा सकता है।
यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स जीतती हैं ।
आप मान सकते हैं कि मोनोलिथ हमेशा एक ही चौड़ाई के होते हैं, और हमेशा _दूसरे से कम से कम 1 दूर होते हैं।
वे किसी भी ऊंचाई, और किसी भी मात्रा में आ सकते हैं।

आई / ओ

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

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


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

____________________   >> undefined behavior

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

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

code-golf ascii-art

— Graviton
स्रोत

2

क्या मुझे लगता है कि इनपुट सही स्थानों के साथ गद्देदार है?

— ईसैक

17

क्या आपका [10]मोनोलिथ नहीं है [11]?

— TessellatingHeckler

अपरिभाषित एक खाली सरणी नहीं होगा?

— सोलोमन उको

@isaacg हाँ, कि उचित रहेगा

— Graviton

@SolomonUcko तकनीकी रूप से हाँ, हालाँकि इसे सभी भाषाओं के लिए सरल बनाने के लिए मैंने उन्हें इसके साथ सौदा नहीं करने का फैसला किया।

— ग्रेविटन

15

जेली , (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)

— जोनाथन एलन
स्रोत

मुझे नहीं पता, लेकिन क्या यह ठीक है?

— वी। कोर्टोइस

1

@ V.Courtois मैं नहीं देखता कि क्यों नहीं, क्योंकि हम शायद ऐसा इनपुट कभी नहीं लेंगे।

— आउटगोल्फ

ठीक है, ऐसा इसलिए है क्योंकि मैंने देखा कि कुछ अन्य उत्तर इसे गिनती में लेते हैं

— वी। कोर्टोइस

2

@ V.Courtois आपके द्वारा सुझाए गए इनपुट में विनिर्देश फिट नहीं होता है, इसी तरह आकाश में अंडरस्कोर जोड़ते हैं, मोनोलिथ्स, या भूमिगत अप-वे शायद कई अन्य सबमिशन को तोड़ देंगे।

— जोनाथन एलन

डाउन-वोटर - क्या आप अपने कारणों की व्याख्या करना चाहेंगे?

— जोनाथन एलन

8

जेली , 11 बाइट्स

ỴṚZi€”_ỊÐḟ’

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

वाह, आपने जवाब दिया कि उपवास।

— ग्रेविटन

@ ग्रेविटन हेहे को हमेशा यह पृष्ठ कहीं न कहीं खुला होना चाहिए । ;)

— एरिक आउटगोल्फर

14

स्पष्टीकरण, कृपया!

— झबरा २

6

जावास्क्रिप्ट (ईएस 6), 79 78 बाइट्स

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

स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत

1

78 बाइट्स:a=>a.map((x,y)=>x.replace(/_/g,(_,z)=>c[z]=a.length-y-1),c=[])&&c.filter(n=>n)

— झबरा

@Saggy अच्छा, मैं पूरी तरह से उपयोग करने के बारे में नहीं सोचा था replace। धन्यवाद!

— जस्टिन मेरिनर

6

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

इसे ऑनलाइन आज़माएं!

सी ++ (जीसीसी), 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<<" ";}}

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत

1

अगर जी ++ का उपयोग कर रहे हैं, तो आप गैर-मानक का उपयोग कर सकते हैं f(auto s)और यह निर्दिष्ट कर सकते हैं कि रैंडम-एक्सेस कंटेनरों में से कोई भी यादृच्छिक-एक्सेस कंटेनर लेता है char।

— एशेपलर

5

05AB1E , 11 बाइट्स

|Rζ'_δkJ®0‚K

इसे ऑनलाइन आज़माएं!

ζ.BøTIO द्वारा प्रतिस्थापित किया गया है क्योंकि इसे अभी तक वहां नहीं लाया गया है।

— आउटग्रॉफर को एरिक करें
स्रोत

5

दिल्लोग एपीएल, 29 बाइट्स

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

के साथ भागो ⎕IO←0।

इसे ऑनलाइन आज़माएं!

कैसे?

⌽⍵='_'- पहले शीर्ष रेखाएँ कहाँ ⍵है'_'

×- से गुणा करो ...

(⍳≢⍵)- ⍵(शून्य अनुक्रमित) की सीमा

↑¨ - प्रत्येक पंक्ति के लिए, शून्य से पैड ...

(⌈/⍴¨⍵) - अधिकतम लंबाई

↑+/ - पंक्तियों को जोड़कर और समतल करें

0~⍨ - शून्य हटाता है

— Uriel
स्रोत

5

पायथन 2 , 75 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— GarethPW
स्रोत

5

पॉवरशेल, 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"

— TessellatingHeckler
स्रोत

4

जाप , 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

— ETHproductions
स्रोत

4

रेटिना , 48 38 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में पहला उदाहरण शामिल है। स्पष्टीकरण: एक पंक्ति उपसर्ग है जो परिणाम एकत्र करेगी। जैसा कि प्रत्येक स्तंभ को बारी-बारी से हटा दिया जाता है, जिनमें एक _उपरोक्त जमीनी स्तर होता है, जो गिने हुए कॉलम में शेष लाइनों की संख्या होती है। अंत में अब खाली लाइनें हटा दी जाती हैं। संपादित करें: @FryAmTheEggman से प्रेरणा के लिए 10 बाइट्स का धन्यवाद।

— नील
स्रोत

अच्छा, मेरे पास एक छोटा सा समाधान था , लेकिन यह बड़े इनपुट पर काम नहीं करेगा क्योंकि यह उन्हें सॉर्ट करने की मेरी क्षमता को गड़बड़ कर देगा। स्तंभ से स्तंभ जाना उससे बचने का एक अच्छा तरीका है!

— FryAmTheEggman

@FryAmTheEggman मैंने _एस का उपयोग करके लाइनों को गिनने की अपनी पद्धति पर स्विच किया, जो एस का उपयोग करने की कोशिश करने की तुलना में बहुत अधिक समझ में आता है |, धन्यवाद!

— नील

@FryAmTheEggman समस्या को ठीक नहीं करता है, लेकिन आपके द्वारा छाँटे गए चरण को लुकअप और ड्रॉपिंग द्वारा सरल किया जा सकता है $.%`, और अंतिम चरण हो सकता है !`\d+। और यदि आप पहले चरण को लुकहेड में बदलते हैं, तो आपको लूप करने की आवश्यकता नहीं है।

— मार्टिन एंडर

@FryAmTheEggman और यहाँ अपने दृष्टिकोण के लिए एक तय है, लेकिन यह 46 बाइट्स पर समाप्त होता है।

— मार्टिन एंडर

@MartinEnder 45 शायद? इसे ऑनलाइन आज़माएं!

— नील

4

जावा 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 बाइट बचाता है)। -2 के लिए कम पठनीय उत्पादन धन्यवाद के बदले में बाइट्स @ OlivierGrégoire बदलकर करने के लिए ।~~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

— केविन क्रूज़सेन
स्रोत

मैंने इसे अभी तक आज़माया नहीं है, लेकिन इस चुनौती के लिए मेरा विचार ऊपर से नीचे तक जाना था और यह देखना कि _अगर यह स्टोर है, तो उस पर ऑर्डर करें, तो नीचे की पंक्ति को अनदेखा करें। बाइट्स को बचाने में मदद मिल सकती है ...

— TheLethalCoder

@ TheLethalCoder मेरा शुरुआती विचार भी यही था, लेकिन आप इसे कहां स्टोर करना चाहते हैं / इसे ऑर्डर करें? मैंने मूल रूप से एक मानचित्र सोचा था, लेकिन वे लिंक नहीं किए गए हैं, इसलिए आपको एक लिंकडैप की आवश्यकता होगी। मेरे सिर में यह सब कुछ बहुत अधिक लग रहा था, लेकिन अगर आप इसे जवाब देने के लिए स्वतंत्र महसूस करने की तुलना में इसे कम से कम पूरा करने का एक तरीका खोज सकते हैं और मैं इसे +1 करूंगा। :)

— केविन क्रूज़सेन

मैं केवल इसे Linq का उपयोग करके 150 तक लाने में कामयाब रहा, लेकिन इसमें अभी भी गोल्फ खेलने की गुंजाइश होनी चाहिए।

— TheLethalCoder

C # में हमारे पास बहुआयामी सरणियाँ हैं जैसे: new[,]दांतेदार ऐरे के बजाय जो आप उपयोग कर रहे हैं new[][]। यदि आपके पास जावा में है तो यह आपको कुछ बाइट्स बचा सकता है।

— TheLethalCoder

1

System.out.println(l-j);मेरे लिए 2 बाइट्स को छोड़ने के लिए पर्याप्त रूप से आकर्षक लगता है। इसके अलावा, विवरण में, आप बदलना भूल गया length()में length(के रूप में यह प्रस्तुत करने में सही है बाइट गिनती पर कोई घटना)।

— ओलिवियर ग्राएगोयर

3

हास्केल, 75 74 बाइट्स

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

इनपुट स्ट्रिंग (सूची) की सूची के रूप में अपेक्षित है।

— सिराकुसा
स्रोत

आयात के बाद अर्धविराम का उपयोग क्यों करें, जब एक नई रेखा समान लंबाई और अधिक मुहावरेदार हो?

— जूल्स

@ जूल्स: हाँ, मैं आमतौर पर करता हूँ

— सिराकुसा

3

रूबी , 82 बाइट्स

लाइनों की एक सूची में ले जाता है।

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

इसे ऑनलाइन आज़माएं!

— मूल्य स्याही
स्रोत

3

APL (Dyalog) , 14 बाइट्स

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

साथ में ⎕IO←0

इसे ऑनलाइन आज़माएं!

यह फ़ंक्शन ट्रेन के बराबर है {((⍳≢⍵)+.×('_'=⊖⍵))~0}

— TwiNight
स्रोत

3

MATL , 12 बाइट्स

&nxG2\&fx-Xz

इनपुट एक चार मैट्रिक्स है, ;पंक्ति विभाजक के रूप में।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

— लुइस मेंडो
स्रोत

3

सी #, 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();
    }
}

— TheLethalCoder
स्रोत

3

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

इसे ऑनलाइन आज़माएं!

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

वू, पहली पोस्ट। इसे बेहतर बनाने में कोई मदद मिलेगी। ~~मुझे पता है कि मैं indexOfदो बार उस लिखित से छुटकारा पा सकता हूं ।~~ पता था! मैंने इंटीजर से लॉन्ग तक मैप में टाइप बदलने के विचार के साथ खिलवाड़ किया लेकिन मुझे लगता है कि यह एक मृत अंत है।

_{मुझे पता है कि पहले से ही बहुत बेहतर जावा 8 समाधान है , लेकिन वह char[][]इनपुट के रूप में लेता है जो मुझे लगता है कि स्ट्रिंग के साथ इस मामले में काम करना आसान है।}

— माइकल
स्रोत

1

आपने आयातों को शामिल नहीं किया है (वे जावा उत्तरों के लिए आवश्यक हैं)। Mapलेकिन एक का उपयोग न करें int[](शायद शुरू में new int[99]?) के बाद एक स्थान के लिए कोई ज़रूरत नहीं है String[] l: String[]lएक ही काम करता है और कम है। के println(l.length-i-1)बजाय का उपयोग करें println(l.length-i-1+",")। आरंभ न करें j: बस लिखें ,j;:। यदि आप int[]पहले सुझाए अनुसार उपयोग करते हैं, तो इस तरह की घोषणा करें: int m[]=new int[99],i=0,j;और घोषणा को हटा दें for-loop।

— ओलिवियर ग्राएगोयर

1

OlivierGrégoire वास्तव में Map के लिए आवश्यक आयात के बारे में सही है। मानचित्र के साथ अपने वर्तमान कोड की कुछ गोल्फिंग के लिए, आप इसे इस में बदल सकते हैं

import java.util.*;s->{Map m=new TreeMap();String[]a=s.split("\n");int l=a.length-1,j=-1,i=j;for(;++i<l;)for(s=a[i];(j=s.indexOf("_",j+1))>=0;m.put(j,i));for(Object o:m.values())System.out.println(l-(int)o);}

:। <Integer,Integer>जब आप कास्ट कर सकते हैं तो नक्शे की कोई आवश्यकता नहीं है int; a.length-1दो बार उपयोग किया जाता है, इसलिए आप इसके लिए एक चर का उपयोग कर सकते हैं; अंदर-छोरों के लिए सब कुछ डालकर आप सभी कोष्ठक से छुटकारा पा सकते हैं। ओह, और पीपीसीजी में आपका स्वागत है! :)

— केविन क्रूज़सेन

@ केविनक्रूजसेन धन्यवाद! पाश के लिए एक शरीरहीन के लिए पाश के लिए पहले की सामग्री परिवर्तित प्रेरणादायक था! सुपर चालाक।

— माइकल

@ मिचेल आपका स्वागत है। :) ओह, और अगर आपने इसे अभी तक नहीं देखा है: जावा में गोल्फिंग के लिए टिप्स और <सभी भाषाओं में गोल्फिंग के लिए टिप्स> के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है। जब मैंने पहली बार शुरुआत की (और अभी भी कभी-कभी करता है) तो मेरी बहुत मदद की।

— केविन क्रूज़सेन

3

MATL , 10 बाइट्स

ooYssqtO>)

इनपुट एक गद्देदार चरित्र मैट्रिक्स है।

इसे ऑनलाइन आज़माएं!

— बीकर
स्रोत

2

गणितज्ञ, 48 47 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Functionजो वर्णों के आयताकार सरणी की अपेक्षा करता है। Mostसरणी के ले जाता है (सभी लेकिन अंतिम पंक्ति), Reverseयह है, तो Transpose* लेता है , फिर सभी को खोजता है Positionजिस पर _चरित्र दिखाई देता है। प्रासंगिक ऊंचाइयां प्रत्येक के Lastतत्व हैं Position।

* है 3बाइट निजी इस्तेमाल के चरित्र U+F3C7प्रतिनिधित्व करता है जो \[Transpose]मेथेमेटिका में। ध्यान दें कि यह गणित में काम नहीं करता है , इसलिए TIO लिंक का उपयोग करता है Transpose।

— ngenisis
स्रोत

2

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

— dzaima
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 108 104 88 बाइट्स

16 बाइट्स @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)

इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लिया जाता है

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

स्निपेट का विस्तार करें

— alexanderbird
स्रोत

यहां

— जस्टिन मैरीनर

धन्यवाद @JustinMariner! मैं वैरिएबल इनिशियलाइज़ेशन के बारे में अटका हुआ हूँ क्योंकि अप्रयुक्त मापदंडों को दिया जाता है Array.map, यह एक अच्छा ट्रिक है।

— अलेक्जेंडरबर्ड

क्या आपको वास्तव में RegEx को एक चर में असाइन करने की आवश्यकता है? आप इसे सीधे उपयोग कर सकते हैं execऔर कुछ बाइट्स बचा सकते हैं।

— शैगी

वास्तव में, यह आवश्यक है - जबकि लूप एक पंक्ति पर प्रत्येक मैच पर पुनरावृत्ति करता है, और चर में रेगेक्स की आंतरिक स्थिति के बिना यह पहली बार हर बार पाश और असीम रूप से मेल खाता होगा। प्रत्येक पुनरावृत्ति यह एक नया regex पैदा execकरेगा तो पहले से मेल खाएगा। यदि आप regex को इनलाइन करते हैं तो यह वास्तव में स्टैक एक्सचेंज स्निपेट संपादक को क्रैश कर देता है। जब तक मैं कुछ याद कर रहा हूँ?

— अलेक्जेंडरबर्ड

@shaggy मैं अपनी पिछली टिप्पणी में आपको टैग करना भूल गया

— अलेक्जेंडरबर्ड

2

सीजेएम, 15 14 बाइट्स

^{1 बाईट ने @BusinessCat को धन्यवाद दिया}

{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

— फल तोड़ना
स्रोत

आप ट्रांसपोज़ करने से पहले पूरे एरे को उल्टा करके 1 बाइट बचा सकते हैं।

— बिजनेस कैट

1

पिप , 18 17 बाइट्स

15 बाइट्स कोड, -rpझंडे के लिए +2 ।

_FI_@?'_MRVgZDs

स्टड से इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

                 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)

— DLosc
स्रोत

1

पायथ , 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

— जिम
स्रोत

1

ऑक्टेव, 31 बाइट्स

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

इनपुट के रूप में वर्णों का 2 डी सरणी लेता है।

सभी परीक्षण मामलों की पुष्टि करें!

— rahnema1
स्रोत

1

पर्ल 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एक बाइट बचत एक वास्तविक न्यू लाइन चरित्र है।

— शॉन
स्रोत

0

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

चलो इसे तोड़ दो! यहां हमारा इनपुट 2 डी सरणी वर्ण है।

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

— Xanderhall
स्रोत

-1

एक बहुस्तरीय स्ट्रिंग में ले जाता है। सेटअप (शीर्ष लेख और पाद लेख) का श्रेय @GarethPW को जाता है

पायथन 2 , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह एरे को न्यूलाइन द्वारा विभाजित करेगा और लंबाई -1 लौटाएगा।

— emtree
स्रोत

यह पूरी चुनौती को पूरा नहीं करता है। आपको सभी ऊँचाइयों के साथ एक सरणी या सूची वापस करनी चाहिए , न कि केवल सबसे ऊँची।

— स्कॉट मिलनर

मोनोलिथ कितने लंबे हैं?

काम

टिप्पणियाँ

आई / ओ

जेली , (8?) 9 बाइट्स

कैसे?

जेली , 11 बाइट्स

जावास्क्रिप्ट (ईएस 6), 79 78 बाइट्स

टेस्ट स्निपेट

सी ++, 171 169 बाइट्स

सी ++ (जीसीसी), 150 बाइट्स

05AB1E , 11 बाइट्स

दिल्लोग एपीएल, 29 बाइट्स

पायथन 2 , 75 बाइट्स

पॉवरशेल, 133 बाइट्स

जाप , 11 बाइट्स

व्याख्या

रेटिना , 48 38 बाइट्स

जावा 8, 133 117 116 114 बाइट्स

हास्केल, 75 74 बाइट्स

रूबी , 82 बाइट्स

APL (Dyalog) , 14 बाइट्स

MATL , 12 बाइट्स

सी #, 150 144 137 बाइट्स

जावा 8 - 229 बाइट्स 213 बाइट्स

MATL , 10 बाइट्स

गणितज्ञ, 48 47 39 बाइट्स

SOGL V0.12 , 9 बाइट्स

जावास्क्रिप्ट (ईएस 6), 108 104 88 बाइट्स

सीजेएम, 15 14 बाइट्स

स्पष्टीकरण:

पिप , 18 17 बाइट्स

व्याख्या

पायथ , 19 15 14 बाइट्स

ऑक्टेव, 31 बाइट्स

पर्ल 6 , 65 बाइट्स

PHP, 119 बाइट्स

पायथन 2 , 29 बाइट्स