एक हीट मैप को डिकोड करें

Question

हीटमैप

एक आयताकार कमरे पर विचार करें, जिसकी छत पर हमारे पास एक थर्मल कैमरा है जो नीचे की ओर इशारा करता है। कमरे में, तीव्रता के कुछ ऊष्मा स्रोत हैं 1-9, पृष्ठभूमि का तापमान है 0। गर्मी प्रत्येक स्रोत से फैलती है, प्रति इकाई (गैर-विकर्ण) कदम से गिरती है। उदाहरण के लिए, 20x10कमरा

...........1........
....................
...8................
..5...............2.
....................
.1..................
................1...
.................65.
....................
............2.......

इसमें 9 ताप स्रोत शामिल हैं, और थर्मल कैमरा द्वारा दिखाया गया तापमान ढाल है

34565432100100000000
45676543210000000000
56787654321000000110
45676543210000001221
34565432100000012321
23454321000000123432
12343210000001234543
01232100000012345654
00121000000011234543
00010000000121123432

चित्रमय रूप में यह इस तरह दिख सकता है:

ढाल से, हम कुछ गर्मी स्रोतों के पदों और तीव्रता का अनुमान लगा सकते हैं, लेकिन सभी नहीं। उदाहरण के लिए, सभी 9एस हमेशा अनुमान लगाया जा सकता है, क्योंकि उनके पास अधिकतम तापमान है, और 8इस मामले में ऐसा हो सकता है , क्योंकि यह ढाल में एक स्थानीय अधिकतम पैदा करता है। 2पास सही सीमा भी अनुमान लगाया जा सकता है, भले ही यह एक स्थानीय अधिकतम पर नहीं है, क्योंकि यह एक और नहीं है 2एक पड़ोसी के रूप। 5रों, दूसरे हाथ पर, पता नहीं लगाया जाता है, के बाद से उनकी गर्मी के साथ-साथ उनके पास अधिक तीव्र स्रोतों द्वारा उत्पादित किया जा सकता है। 0कोई गर्मी स्रोतों को रोकने के लिए जाना जाता है, लेकिन अन्य सभी टाइल्स सकता है संभवतः एक होते हैं। आइए हाइफ़न द्वारा अनिश्चित टाइल्स को निरूपित करें-, इसी अंक के अनुसार कुछ ऊष्मा स्रोत, और अवधि के अनुसार कुछ खाली स्थान .:

---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------

आपका कार्य तापमान प्रवणता से इस अनुमान पैटर्न का उत्पादन करना होगा।

नियम

आपको इनपुट को एक स्ट्रिंग के रूप में दिया जाता है, जिसे नईलाइन या वर्टिकल पाइप द्वारा सीमांकित किया जाता है |, जो भी अधिक सुविधाजनक हो, और आउटपुट उसी रूप में होगा। इनपुट और / या आउटपुट में एक अनुगामी सीमांकक हो सकता है, लेकिन कोई पूर्ववर्ती नहीं। इनपुट का आकार भिन्न हो सकता है, लेकिन इसकी चौड़ाई और ऊंचाई हमेशा कम से कम होती है 4। दोनों कार्य और पूर्ण कार्यक्रम स्वीकार्य हैं। सबसे कम बाइट गिनती जीतती है, और मानक खामियों को मना किया जाता है।

अतिरिक्त परीक्षण मामले

इनपुट:

898778765432100
787667654321100
677656543211210
678765432112321
567654321123210

जो ग्राफिकल रूप में इस तरह दिखता है:

आउटपुट:

-9---8-------..
-------------..
--------------.
--8---------3--
-----------3--.

इनपुट:

7898
8787
7676
6565

आउटपुट:

--9-
8---
----
----

इनपुट:

00001
00000
00000
10000

आउटपुट:

....1
.....
.....
1....

Comments

अगर आपको लगता है कि आपके मान में 2 हीटमैप ग्राफिक्स जोड़ते हैं तो क्या आपको लगता है कि वे मूल्य जोड़ते हैं? वे सिर्फ 2 मिनट का प्रयोग कर रहे हैं।

— लॉजिक नाइट

@CarpetPython ज़रूर, आगे बढ़ो। वे मुझे बहुत अच्छे लगते हैं। आप अपने आप को श्रेय देने के लिए "शिष्टाचार कालीन" को भी जोड़ सकते हैं। ;)

— ज़गर्ब

किया हुआ। कोई क्रेडिट की आवश्यकता नहीं है, लेकिन मुझे लगा कि इसे संपादित करने से पहले नहीं पूछना असभ्य होगा।

— लॉजिक नाइट

स्ट्रिंग के बजाय इनपुट को 2-आयामी सरणी के रूप में अनुमति क्यों नहीं दी जाती है?

— फ़ेरसम

@ फैर्सम आमतौर पर इनपुट विधियां संगत होती हैं।

— ऑप्टिमाइज़र

Answer 1

CJam, 73 69 62 55 बाइट्स

अद्यतन : नया एल्गोरिथ्म। कम और सुधार की अधिक गुंजाइश

qN/5ff*{{[{_@_@<{I'0t}*\}*]W%}%z}4fI{):X-'-X~X'.??}f%N*

यह काम किस प्रकार करता है

तर्क नीचे दिए गए एल्गोरिदम के समान है, लेकिन यहां मैं एक ही पुनरावृत्ति में सभी 4 पड़ोसियों के लिए जाँच नहीं कर रहा हूं। इसके बजाय, मैं दोनों दिशाओं में सभी पंक्तियों और स्तंभों के माध्यम से पुनरावृति करने के लिए एक छोटे दृष्टिकोण का उपयोग करता हूं। इसमें शामिल कदम हैं:

• प्रत्येक वर्ण को 5 के सेट में परिवर्तित करें। पहले 4 को यह बताने के लिए संशोधित किया जाएगा कि क्या वे पुनरावृत्ति करते समय पंक्ति में आसन्न कोशिका से बड़े हैं। अंतिम एक तुलना उद्देश्यों के लिए है।
• प्रत्येक पंक्ति पर Iterate करें और प्रत्येक पंक्ति पर कम करें। कम करते समय, मेरे पास दो 5 वर्ण स्ट्रिंग हैं। मुझे पता है कि किस तरह की पुनरावृत्ति होती है [0 पंक्तियों के लिए सामान्य, 1 कॉलम उलट, पंक्तियों के लिए 2 उलट और सामान्य कॉलम के लिए 3] मैं पहले 5 वर्ण स्ट्रिंग में i ^वें चरित्र को अपडेट करता हूं और इसे 0 से बनाता हूं यदि यह दूसरे से छोटा है। ।
• सभी 4 पुनरावृत्तियों के बाद, यदि सभी 5 वर्ण समान और गैर-शून्य हैं, तो यह स्थानीय मैक्सिमा है। मैं सभी 5 कैरेक्टर स्ट्रिंग्स के माध्यम से मैप करता हूं और उन्हें सिंगल डिजिट में बदलता हूं, .या -।

यहां एक छोटे इनपुट पर एक उदाहरण चलाया गया है:

7898
8787
7676
6565

पहले चरण के बाद:

["77777" "88888" "99999" "88888"
 "88888" "77777" "88888" "77777"
 "77777" "66666" "77777" "66666"
 "66666" "55555" "66666" "55555"]

दूसरे चरण के बाद:

["00777" "08888" "99999" "88088"
 "88888" "07007" "88808" "77007"
 "77707" "06006" "77707" "66006"
 "66606" "05005" "66606" "55005"]

एकल चरित्र के लिए अंतिम मानचित्रण के बाद, अंतिम आउटपुट:

--9-
8---
----
----

कोड स्पष्टीकरण :

qN/5ff*                         "Split the input on new line and convert each character";
                                "to string of 5 of those characters.";
{{[{             }*]W%}%z}4fI   "This code block runs 4 times. In each iteration, it";
                                "maps over each row/column and then for each of them,";
                                "It reduce over all elements of the row/column";
                                "Using combination of W% and z ensures that both rows and";
                                "columns are covered and in both directions while reducing";
    _@_@                        "Take a copy of last two elements while reducing over";
        <                       "If the last element is bigger than second last:";
         {I'0t}*\               "Convert the Ith character of the 5 char string of"
                                "second last element to 0";
                                "We don't have to compare Ith character of last two 5 char";
                                "string as the smaller one will be having more leading";
                                "0 anyways. This saves 4 bytes while comparing elements";
{):X-'-X~X'.??}f%N*             "This part of code converts the 5 char back to single char";
 ):X                            "Remove the last character and store in X. This last char";
                                "was not touched in the prev. loop, so is the original char";
    -                           "Subtract X from remaining 4 char. If string is not empty";
                                "then it means that it was not all same characters";
                                "In other words, this character was smaller then neighbors";
     '-      ?                  "If non-empty, then replace with - else ...";
       X~X'.?                   "if int(X) is zero, put . else put X";
               f%N*             "The mapping code block was run for each row and then";
                                "The rows are joined by newline.";

इसे यहाँ आज़माएँ

---

पुराना दृष्टिकोण

qN/~_,):L0s*]0s*:Q_,{QI=:A[W1LL~)]If+Qf=$W=<'-A?A~\'.?I\t}fIL/W<Wf<N*

यह काम किस प्रकार करता है

तर्क सरल है, ग्रिड के माध्यम से पुनरावृत्ति करें और देखें कि वर्तमान मूल्य शेष चार पड़ोसियों से अधिक है या बराबर है - ऊपर, नीचे, बाएं और दाएं। फिर उपरोक्त नियम के आधार पर वर्तमान मान को रूपांतरित करें और यदि मान 0 के बराबर है, तो इसे बनाएं "।" ।

कोड स्पष्टीकरण

qN/~_,):L0s*]0s*:Q         "This part of code pads the grid with 0s";
qN/~                       "Read the input, split on new lines and unwrap the arrays";
    _,):L                  "Copy the last row, taken length, increment and store in L";
         0s*               "Get L length 0 string";
            ]0s*           "Wrap everything in an array and join the rows by 0";
                :Q         "Store this final single string in Q";

_,{        ...      }fI    "Copy Q and take length. For I in 0..length, execute block";
   QI=:A                   "Get the I'th element from Q and store in A";
   [WiLL~)]If+             "This creates indexes of all 4 neighboring cells to the Ith cell";
              Qf=          "Get all 4 values on the above 4 indexes";
                 $W=       "Sort and get the maximum value";
<'-A?                      "If the current value is not the largest, convert it to -";
     A~\'.?                "If current value is 0, convert it to .";
           I\t             "Update the current value back in the string";
{ ... }fIL/                "After the loop, split the resulting string into chunks of L";
           W<Wf<           "Remove last row and last column";
                N*         "Join by new line and auto print";

इसे यहाँ ऑनलाइन आज़माएँ

Comments

मुझे कहना होगा, मैं सीजेएम कोड का वर्णन करते समय शायद ही कभी "बहुत लंबा" सुनता हूं।

— एलेक्स ए।

Answer 2

जावास्क्रिप्ट (ईएस 6) 99

F=h=>[...h].map((c,i)=>[o=~h.search('\n'),-o,1,-1].some(d=>h[d+i]>c)&c>0?'-':c=='0'?'.':c).join('')

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

console.log(F('\
34565432100100000000\n\
45676543210000000000\n\
56787654321000000110\n\
45676543210000001221\n\
34565432100000012321\n\
23454321000000123432\n\
12343210000001234543\n\
01232100000012345654\n\
00121000000011234543\n\
00010000000121123432\n'),'\n\n',
F('\
898778765432100\n\
787667654321100\n\
677656543211210\n\
678765432112321\n\
567654321123210\n'), '\n\n',
F('7898\n8787\n7676\n6565\n'))

उत्पादन

---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------


-9---8-------..
-------------..
--------------.
--8---------3--
-----------3--.


--9-
8---
----
----

Answer 3

पायथन 2: 154 बाइट

b=input()
l=b.index('\n')+1
print''.join(('\n.'+('-'+v)[all([v>=b[j]for j in i-l,i-1,i+l,i+1if 0<=j<len(b)])])[('\n0'+v).index(v)]for i,v in enumerate(b))

इनपुट फॉर्म का होना है "00001\n00000\n00000\n10000"।

एक स्ट्रिंग को 2 डी-मैट्रिक्स में परिवर्तित करना पायथन में काफी लंबा है। इसलिए मैं मूल स्ट्रिंग प्रारूप रखता हूं। मैं इनपुट पर गणना करता हूं, iइंडेक्स vहै, चार है (अंत में एक गोल्फ में बाइट्स को बचाने के लिए)।) प्रत्येक जोड़ी के लिए (i,v)मैं आउटपुट के सही चार्ट की गणना करता हूं, और उनसे जुड़ता हूं। मैं सही आउटपुट चार कैसे चुनूं? यदि v == '\n', आउटपुट चार है \n, तो यह v == '0'आउटपुट चार है '.'। अन्यथा मैं 4 पड़ोसियों का परीक्षण करता हूं v, जो b[i-b.index('\n')-1](ऊपर), b[i-1](बाएं, b[i+1](दाएं) और b[i+b.index('\n')+1](नीचे) हैं, यदि वे हैं <= vऔर एक '-'या दूसरे का चयन करते हैंv। यहाँ मैं संख्याओं की तुलना नहीं कर रहा हूँ, लेकिन यह काफी ठीक काम करता है, क्योंकि एससीआई मान सही क्रम में हैं। इसके अलावा, कोई समस्या नहीं है, अगर b[i-1]या b[i+1]बराबर '\n', क्योंकि ord('\n') = 10।

पायथ: 61 58

JhxQbVQK@QN~k@++b\.?\-f&&gT0<TlQ<K@QT[tNhN-NJ+NJ)Kx+b\0K)k

कमोबेश पायथन लिपि का अनुवाद। काफी बदसूरत ;-)

इसे ऑनलाइन आज़माएं: पायथन कंपाइलर / एक्ज़ीक्यूटर समान इनपुट फॉर्मेट पायथन सॉल्यूशन के रूप में।

JhxQb      Q = input()
  xQb      Q.index('\n')
 h         +1
J          store in J

VQK@QN~k.....)k   k is initialized as empty string
VQ           )    for N in [0, 1, 2, ..., len(Q)-1]:
  K@QN                K = Q[n]
      ~k              k += ... (a char, computed in the next paragraph)
             )    end for
              k   print k

@...x+b\0K   ... is a char of len 3 (is constructed below)
     +b\0    the string "\n0"
    x    K   find Q[d] in this string and return index, if not found -1
@...         lookup in string at the computed position (this is done mod 3 automatically!)

++b\.?\-f&&gT0<TlQ<K@QT[tNhN-NJ+NJ)K   not to the string
                       [tNhN-NJ+NJ)    the list [d-1, d+1, d-J, d+j]
        f                              filter the list for indices T which
           gT0                            T >= 0
          &                               and
              <TlQ                        T < len(Q)
         &                                and
                  <K@QT                   Q[d] < Q[T]
     ?\-                           K   use "-" if len(filter) > 0 else Q[d]
                                       this creates the third char
++b\.                                  "\n" + "." + third char

Answer 4

पर्ल, 77, 75, 72 70

मानक 2d regex मिलान चाल।

#!perl -p0
/
/;$x="(.{@-})?";y/0/./while s/$.$x\K$"|$"(?=$x$.)/-/s||($"=$.++)<9

उदाहरण:

$ perl heat.pl <in.txt
---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------

इसे यहाँ आज़माएँ

Answer 5

जावा, 307 , 304 , 303 , 299 298

यह निश्चित रूप से कुछ जावा कोडगॉल्फ के लिए एक "सही" चुनौती है :)

class M{public static void main(String[]a){int c=a[0].indexOf('|'),i=c,d,v;char[]r=a[0].replace("|","").toCharArray(),m=new char[(v=r.length+c)+c];for(;i<v;){m[i]=r[i++-c];}for(i=c;i<v;i++){a[0]=i%c<1?"\n":"";d=m[i];System.out.print(a[0]+(d<49?'.':m[i-c]>d|m[i+c]>d|m[i-1]>d|m[i+1]>d?'-':m[i]));}}}

इनपुट (पाइप '|' विधि):

34565432100100000000|45676543210000000000|56787654321000000110|45676543210000001221|34565432100000012321|23454321000000123432|12343210000001234543|01232100000012345654|00121000000011234543|00010000000121123432

आउटपुट:

---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------

Comments

यदि आप अंतरिक्ष को हटाते हैं तो यह 288 हो सकता है char[]r=a[0].replace("|", <--here"").toCharArray()।

— bcsb1001

उस एक को हाजिर नहीं किया, धन्यवाद! खैर यह 298 बनाता है

— रॉल्फ

Answer 6

एपीएल, 92

('.-',⎕D)[1+(M≠0)+M{(1+⍺)×0≠⍺∧M[J/⍨Z∊⍨J←⍵∘+¨(⌽¨,+)(-,+)⊂0 1]∧.≤⍺}¨Z←⍳⍴M←↑{×⍴⍵:(⊂⍎¨⍵),∇⍞⋄⍬}⍞]

उदाहरण:

       ('.-',⎕D)[1+(M≠0)+M{(1+⍺)×0≠⍺∧M[J/⍨Z∊⍨J←⍵∘+¨(⌽¨,+)(-,+)⊂0 1]∧.≤⍺}¨Z←⍳⍴M←↑{×⍴⍵:(⊂⍎¨⍵),∇⍞⋄⍬}⍞]
34565432100100000000
45676543210000000000
56787654321000000110
45676543210000001221
34565432100000012321
23454321000000123432
12343210000001234543
01232100000012345654
00121000000011234543
00010000000121123432

---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------

Comments

अब तक का सबसे लंबा एपीएल कार्यक्रम मैंने देखा है। आप यह नोट करना चाहते हैं कि यह मानक एपीएल नहीं है क्योंकि यह dfns का उपयोग करता है।

— FUZxxl

Answer 7

रूबी 140

f=->s{
r=s.dup
l=s.index(?\n)+1
(0...s.size).map{|i|
s[i]<?0||r[i]=r[i]<?1??.:[i-1,i+1,i-l,i+l].map{|n|n<0??0:s[n]||?0}.max>r[i]??-:s[i]}
r}

कुछ खास नहीं; बस नक्शे के माध्यम से पुनरावृत्त करें और चार पड़ोसियों के मूल्य के साथ वर्तमान मूल्य की तुलना करें।

इसे परीक्षणों के साथ ऑनलाइन चलाएं: http://ideone.com/AQkOSY

Answer 8

आर, 223

सर्वश्रेष्ठ के बारे में मैं इस समय साथ आ सकता हूं। स्ट्रिंग से निपटना काफी महंगा है। मुझे लगता है कि इसमें सुधार की गुंजाइश है, लेकिन फिलहाल इसे देख नहीं सकते

s=strsplit;a=c(m<-do.call(rbind,s(s(scan(w="c"),'|',T)[[1]],'')));w=(d<-dim(m))[1];n=c(-1,1,-w,w);cat(t(array(sapply(seq(a),function(x)if(a[x]>0)if(any(a[(n+x)[which(n+x>0)]]>a[x]))'-'else a[x]else'.'),d)),fill=d[2],sep='')

परीक्षा परिणाम

> s=strsplit;a=c(m<-do.call(rbind,s(s(scan(w="c"),'|',T)[[1]],'')));w=(d<-dim(m))[1];n=c(-1,1,-w,w);cat(t(array(sapply(seq(a),function(x)if(a[x]>0)if(any(a[(n+x)[which(n+x>0)]]>a[x]))'-'else a[x]else'.'),d)),fill=d[2],sep='')
1: 898778765432100|787667654321100|677656543211210|678765432112321|567654321123210
2: 
Read 1 item
-9---8-------..
-------------..
--------------.
--8---------3--
-----------3--.
> s=strsplit;a=c(m<-do.call(rbind,s(s(scan(w="c"),'|',T)[[1]],'')));w=(d<-dim(m))[1];n=c(-1,1,-w,w);cat(t(array(sapply(seq(a),function(x)if(a[x]>0)if(any(a[(n+x)[which(n+x>0)]]>a[x]))'-'else a[x]else'.'),d)),fill=d[2],sep='')
1: 34565432100100000000|45676543210000000000|56787654321000000110|45676543210000001221|34565432100000012321|23454321000000123432|12343210000001234543|01232100000012345654|00121000000011234543|00010000000121123432
2: 
Read 1 item
---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------
> 

Answer 9

जे - 69 बाइट्स

[:u:45+[:(+2 0 3{~"#1+*)@((]*]=(0,(,-)1 0,:0 1)>./@:|.])-0=])"."0;._2

उदाहरण:

   ([:u:45+[:(+2 0 3{~"#1+*)@((]*]=(0,(,-)1 0,:0 1)>./@:|.])-0=])"."0;._2) (0 : 0)
34565432100100000000
45676543210000000000
56787654321000000110
45676543210000001221
34565432100000012321
23454321000000123432
12343210000001234543
01232100000012345654
00121000000011234543
00010000000121123432
)
---------..1........
----------..........
---8-------......--.
----------......--2-
---------......-----
--------......------
-------......-------
.-----......-----6--
..---.......--------
...-.......-2-------
   ([:u:45+[:(+2 0 3{~"#1+*)@((]*]=(0,(,-)1 0,:0 1)>./@:|.])-0=])"."0;._2) (0 : 0)
898778765432100
787667654321100
677656543211210
678765432112321
567654321123210
)
-9---8-------..
-------------..
--------------.
--8---------3--
-----------3--.

पुनश्च: (0 : 0)तार को निर्दिष्ट करने का मानक J तरीका है। आप |सीमांकित तारों (अनुगामी के साथ |) का उपयोग कर सकते हैं।

Answer 10

एक्सेल VBA - 426

यह एक दुर्लभ अवसर होगा कि VBA किसी भी कोड गोल्फ गेम को जीतता है, लेकिन जैसा कि मैंने सबसे अधिक उपयोग किया है, इसके साथ खेलने के लिए मजेदार है। पहली पंक्ति एक किनारे का मामला है जिसने इसे लंबे समय से बना दिया है ऐसा लगता है कि इसे होना चाहिए।

Sub m(a)
    b = InStr(a, "|")
    For i = 1 To Len(a)
        t = Mid(a, i, 1)
        Select Case t
            Case "|"
                r = r & "|"
            Case 0
                r = r & "."
            Case Else
                On Error Resume Next
                x = Mid(a, i - 1, 1)
                y = Mid(a, i + 1, 1)
                Z = Mid(a, i + b, 1)
                If i < b Then
                    If t < x Or t < y Or t < Z Then
                        r = r & "-"
                    Else
                        r = r & t
                    End If
                Else
                    If t < x Or t < y Or t < Z Or t < Mid(a, i - b, 1) Then
                        r = r & "-"
                    Else
                        r = r & t
                    End If
                End If
        End Select
    Next
    MsgBox r
End Sub

गिनती में प्रारंभिक लाइन व्हाट्सएप शामिल नहीं है।

मैंने एक पत्रक को इनपुट भेजने और वहां से काम करने के विचार के साथ खेला, लेकिन मुझे लगता है कि पारित स्ट्रिंग चरित्र-दर-चरित्र कोड को सहेजता है।

तत्काल विंडो से कॉल करें:

m "34565432100100000000|45676543210000000000|56787654321000000110|45676543210000001221|34565432100000012321|23454321000000123432|12343210000001234543|01232100000012345654|00121000000011234543|00010000000121123432"

आउटपुट (एक विंडो में):

---------..1........|----------..........|---8-------......--.|----------......--2-|---------......-----|--------......------|-------......-------|.-----......-----6--|..---.......--------|...-.......-2-------

Answer 11

पर्ल - 226

sub f{for(split'
',$_[0]){chomp;push@r,r($_);}for(t(@r)){push@y,r($_)=~s/0/./gr}$,=$/;say t(@y);}sub r{$_[0]=~s/(?<=(.))?(.)(?=(.))?/$1<=$2&&$3<=$2?$2:$2eq'0'?0:"-"/ger;}sub t{@q=();for(@_){for(split//){$q[$i++].=$_;}$i=0;}@q}

आप इसे विचारधारा पर आजमा सकते हैं । अगर किसी को स्पष्टीकरण में दिलचस्पी है, तो मुझे बताएं।

Comments

मुझे लगता है कि आपके पास 226 चर हैं, 227 नहीं।

— क्रिस्टियान लुपस्कू

@ w0lf आप सही कह रहे हैं, जब से मैं विंडोज पर हूं, नई लाइन 2 के लिए गिनी गई।

— hmatt1

Answer 12

हास्केल - 193

z='0'
r=repeat z
g s=zipWith3(\u t d->zip3(zip(z:t)u)t$zip(tail t++[z])d)(r:s)s$tail s++[r]
f=unlines.map(map(\((l,u),t,(r,d))->case()of _|t==z->'.'|maximum[u,l,t,r,d]==t->t|0<1->'-')).g.lines

f एक फन है जो एक स्ट्रिंग को रूप में लेता है 0001\n0000\n0000\n1000 और आवश्यक स्ट्रिंग लौटाता है।

g एक ऐसा कार्य है जो वर्णों की सूची की सूची लेता है और ((बाएं, ऊपर), इस, (दाएं, नीचे) की सूचियों की सूची लौटाता है।