2 डी भूलभुलैया माइनस 1 डी


27

यह चुनौती 2 डी mazes को 1D mazes में बदलने के बारे में है।

अवलोकन

+-+-+-+-+-+-+   +-+-+-+-+-+-+                    graph {
| |   |     |   |A|   |    B|   A         B        A -- D
+ + + + +-+-+   + + + + +-+-+    \        |        C -- D
|   | |     |   |   | |     |     \       |        D -- E
+-+-+ +-+-+ +   +-+-+ +-+-+ +      \      |        E -- F
|           |   |C   D E   F|   C---D-E---F        E -- G
+-+-+-+ +-+ +   +-+-+-+ +-+ +         |   |        B -- F
|         | |   |      G  | |     .---G   |        F -- J
+ +-+-+-+ + +   + +-+-+-+ + +   .'   /    |        G -- H
| |       | |   |H|I      |J|   H I-'     J        G -- I
+-+-+-+-+-+-+   +-+-+-+-+-+-+     (ascii)        } // (graphviz dot)       
   Figure 1       Figure 2                 Figure 3

इस चुनौती के प्रयोजनों के लिए, एक पारंपरिक 2 डी भूलभुलैया एक आयताकार भूलभुलैया है जिसे जाली बिंदुओं से बनाया गया है जहां निम्नलिखित सभी हैं:

  • यह बंद है (बाहरी रिम दीवारों द्वारा जुड़ा हुआ है)।
  • सभी जाली बिंदु दीवारों से जुड़े हैं
  • यह जुड़ा हुआ है (हर दो स्थानों के लिए X और Y उनके बीच एक रास्ता है)
  • यह एसाइक्लिक है (किसी भी जगह से कोई रास्ता नहीं है एक्स बैक टू एक्स बिना बैकट्रैकिंग के)

चित्रा 1 एक पारंपरिक 2 डी भूलभुलैया दिखाता है। इन मजाज़ों की रुचि के तीन क्षेत्र हैं:

  • मृत समाप्त होता है - ऐसे स्थान जहां से केवल एक ही उपलब्ध मार्ग है
  • गलियारे - वे स्थान जहाँ से दो उपलब्ध रास्ते हैं
  • निर्णय बिंदु - वे स्थान जहाँ से तीन या चार उपलब्ध रास्ते हैं

इस तरह के हर चक्रव्यूह के लिए, एक ऐसा ग्राफ बनाया जा सकता है जहां मृत अंत और निर्णय बिंदु नोड होते हैं, और गलियारे के साथ एक मार्ग से जुड़े प्रत्येक दो नोड्स के बीच एक किनारे होता है। चित्रा 2 ऐसे नोड्स को लेबल के साथ एक ही भूलभुलैया दिखाता है, और चित्रा 3 भूलभुलैया का ग्राफ (एएससीआईआई और ग्राफविज़ डॉट नोटेशन में)।

1 डी mazes

1 डी mazes ताना बिंदुओं को शामिल करते हैं, जो जोड़े में आते हैं, और एक पत्र का उपयोग करके पहचाने जाते हैं (या तो मामले में)। चित्रा 4 एक उदाहरण 1D भूलभुलैया दिखाता है। यह अन्यथा 1 की ऊंचाई के साथ 2 डी भूलभुलैया के समान है, जैसा कि चित्र 5 में दिखाया गया है। चित्रा 5 में विशेष रूप से नोट करें +जो चिह्नित किए गए जाली बिंदु पदों पर हैं , जो कि बाएं से दाएं की ओर है; 1 डी भूलभुलैया में, बाईं दीवार से शुरू होने वाला प्रत्येक अन्य वर्ण भी एक जाली बिंदु है।

                                 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|  D|  D E|G E F|  F  |  G  |    |  D|  D E|G E F|  F  |  G  |
                                 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
            Figure 4                         Figure 5

इस चक्रव्यूह को नेविगेट करने के नियम इस प्रकार हैं। हर कदम को आगे ( >) या पिछड़े ( <) के रूप में दर्शाया जा सकता है । आगे और पीछे डिफ़ॉल्ट रूप से हमारे सहज स्थानिक जागरूकता के रूप में एक ही अर्थ है; आगे की स्थिति तुरंत दाईं ओर जाती है, और पीछे की ओर तुरंत बाईं ओर।

ताना बिंदु उन स्थानों का प्रतिनिधित्व करते हैं जो पड़ोसियों के साथ विषम रूप से जुड़ाव की अदला-बदली करते हैं। यदि आप पड़ोसी से ताना बिंदु पर आ रहे हैं, तो दो ताना बिंदुओं की स्थिति बदली हुई है; यदि आप पड़ोसी से ताना बिंदु से आ रहे हैं, तो उन्हें स्वैप नहीं किया जाता है। उदाहरण के लिए, चित्रा 6 में, 1 से पीछे की ओर जाना आपको 2 तक लाता है (क्योंकि 1 जी का पड़ोसी है, और हम पड़ोसी से बढ़ रहे हैं, अंक 2 और @ स्वैप किए गए हैं)। 2 से आगे बढ़ते हुए (ताना बिंदु जी) आपको 3 पर लाता है (यहां, हम एक ताना बिंदु से शुरू कर रहे हैं, इसलिए कोई स्वैप नहीं है)। इसी तरह, 3 से पीछे की ओर बढ़ने से आप @ तक पहुँचते हैं।

        54 2367    89^   @1
|  D|  D E|G E F|  F  |  G  |
                     Y     X
          Figure 6

चित्रा 6 चालों के अनुक्रम का उपयोग करके एक्स से वाई तक एक उदाहरण नेविगेशन दिखाता है <<>><>>>>>। ये चालें आपको 123456789^उस क्रम में क्रमशः लेबल किए गए बिंदुओं पर लाती हैं । अगले अनुभाग में कोड स्निपेट का उपयोग करके खुद को इसका पता लगाने के लिए स्वतंत्र महसूस करें।

2 डी को 1 डी में परिवर्तित करना

1 डी भूलभुलैया को देखते हुए, एक ग्राफ बना सकता है जहां प्रत्येक नोड या तो एक मृत अंत या एक ताना बिंदु जोड़ी है, और किनारे गलियारे से जुड़े किसी भी दो नोड्स के बीच मौजूद हैं। यह ग्राफ हमें 1D और 2D mazes की तुलना करने की अनुमति देता है।

उदाहरण के लिए, चित्र 4 में 1D भूलभुलैया चित्र 1 में वही भूलभुलैया है। यह देखने के लिए कि, चित्र 7 मृत सिरों पर लेबल क्यों जोड़ता है। ग्राफ़ बनाने के लिए उन लेबलों का उपयोग करना, चित्र 7 का ग्राफ़ बस चित्र 3 फिर से है। चित्र 8 इस ग्राफ के निर्माण का एक ब्रेकआउट दिखाता है।

|  D|  D E|G E F|  F  |  G  |
 A   C           B   J H   I 
          Figure 7

|  D|  D E|G E F|  F  |  G  |
+ + + + + + + + + + + + + + + <- lattice points
|A  |C    |     |B   J|H   I| <- dead ends
|A D|C D E|G E F|B F J|H G I| <- all nodes (dead ends+warp points); i.e.:
                                 "where each end is either a dead end
                                  or a warp point pair"; note that each
                                  pair of warp points is the same node.
|A-D|C-D-E|G-E-F|B-F-J|H-G-I| <- corridors; note each is a connection, since
  1   2 3   4 5   6 7   8 9      "edges exist between any two nodes
                                  connected along a corridor"
   graph {                 graph {                 
     A -- D  // 1 <---->     A -- D                
     C -- D  // 2 <---->     C -- D                
     D -- E  // 3 <---->     D -- E                
     G -- E  // 4 <---->     E -- G                
     E -- F  // 5 <---->     E -- F                
     B -- F  // 6 <---->     B -- F                
     F -- J  // 7 <---->     F -- J                
     H -- G  // 8 <---->     G -- H                
     G -- I  // 9 <---->     G -- I                
   }                ^      }
    Built from      |      From Figure 3
     1D maze         `-> isomorphic mappings
                Figure 8

(ध्यान दें कि प्रत्येक ग्राफ के लेबल और लेआउट चित्रण प्रयोजनों के लिए संरेखित करने के लिए कृत्रिम रूप से चुने गए थे; आम तौर पर बोलते हुए यह एक ग्राफ समरूपता समस्या है )।

निम्नलिखित स्निपेट को 1D भूलभुलैया और 1D भूलभुलैया, समतुल्य ग्राफ और 2 डी भूलभुलैया के बीच संबंध की कल्पना करने में मदद करने के लिए प्रदान किया जाता है।

जैसा कि आप इस स्निपेट में 1D भूलभुलैया नेविगेट करते हैं, आपके द्वारा स्पर्श किए गए अंतिम दो नोड हाइलाइट किए जाते हैं। समतुल्य ग्राफ और 2 डी भूलभुलैया पर समान नोड्स को उसी तरह से हाइलाइट किया गया है।


सामान्य तौर पर, किसी भी पारंपरिक 2D भूलभुलैया के लिए इस प्रकार का 1D भूलभुलैया बनाया जा सकता है। एक और अधिक जटिल उदाहरण चित्र 9 है:

+-+-+-+-+-+-+   +-+-+-+-+-+-+                   graph {
| |   |   | |   |A|   |   |B|   A         B       A -- D
+ + + + + + +   + + + + + + +    \       /        C -- D
|   | | |   |   |   | | |   |     \     /         D -- E
+-+-+ + +-+-+   +-+-+ + +-+-+      \   /          B -- E
|           |   |C   D E    |   C---D-E           E -- F
+-+-+-+ +-+ +   +-+-+-+ +-+ +         |\          E -- I
|         | |   |      F  | |     .---F \         F -- G
+ +-+-+-+ + +   + +-+-+-+ + +   .'   /   \        G -- H
| |       | |   |G|H      |I|   G H-'     I       H -- I
+-+-+-+-+-+-+   +-+-+-+-+-+-+     (ascii)       } // (graphviz dot)
   Figure 9       Figure 10             Figure 11

|  D|  D E  |F E  |  F  |       |  D|  D E  |F E  |  F  |
                                 A   C     I     B G   H
      Figure 12                       Figure 13

इस भूलभुलैया में चार रास्तों के साथ एक नोड है (चित्र 10 में ई)। चित्र 11 इसका ग्राफ दर्शाता है। चित्रा 12 एक बराबर 1D भूलभुलैया है; और चित्रा 13 चित्र 11 के साथ तुलना करने के लिए मृत सिरों के लेबल के साथ एक ही भूलभुलैया दिखाता है।

चुनौती

इनपुट के रूप में 2 डी भूलभुलैया को देखते हुए, एक फ़ंक्शन या प्रोग्राम लिखें जो 2 डी भूलभुलैया को 1 डी भूलभुलैया में ताना बिंदुओं के साथ बदल देता है। ताना अंक प्रत्येक मामले में 52 पत्रों में से किसी का उपयोग कर सकते हैं।

इनपुट गारंटी (यदि इनमें से कोई भी इनपुट आपको पूरा नहीं करना है, तो उससे निपटने के लिए):

  • इनपुट भूलभुलैया जुड़ा हुआ है (अर्थात, आप हमेशा किसी भी स्थान से किसी अन्य पर जा सकते हैं)।
  • इनपुट भूलभुलैया बंद है।
  • इनपुट भूलभुलैया आयताकार है।
  • सभी जाली बिंदु उपयोग करते हैं +
  • एक ही पंक्ति के उपयोग पर जाली बिंदुओं के बीच सभी दीवारें |
  • समान स्तंभ उपयोग में जाली बिंदुओं के बीच की सभी दीवारें -
  • सभी रिक्त स्थान एक पथ का हिस्सा हैं (और भूलभुलैया के अंदर सभी)।
  • पथ सभी रिक्त स्थान हैं (यह हमेशा पारंपरिक, गैर-युद्धशील होगा)
  • रास्ते ठीक एक जगह चौड़े हैं।
  • भूलभुलैया एक जाली पर बिंदुओं को जोड़कर बनाया गया है।
  • भूलभुलैया के ग्राफ में 52 से अधिक कुल नोड्स (यानी, डेड एंड प्लस निर्णय बिंदु) नहीं हैं।

आउटपुट स्वरूप:

  1. आपका आउटपुट 1D भूलभुलैया दिखाने वाली एकल पंक्ति होनी चाहिए ।
  2. आपके आउटपुट में कोई अग्रणी / अनुगामी व्हाट्सएप नहीं होना चाहिए; सिवाय इसके कि एक अनुगामी न्यूलाइन ठीक है।
  3. पहला चरित्र और उसके बाद का प्रत्येक चरित्र जाली बिंदु हैं।
  4. सभी दीवारें जाली बिंदुओं पर होनी चाहिए; और उनके बीच सभी ताना बिंदु।
  5. आपके 1D भूलभुलैया का ग्राफ 2D भूलभुलैया के ग्राफ के बराबर होना चाहिए।
  6. आपके 1D mazes कॉम्पैक्ट होने चाहिए; सभी गैर-जाली बिंदु मृत छोर (यानी, दीवारों से सटे) या ताना बिंदु होने चाहिए।
  7. केवल अक्षर अपने उत्पादन में ताना अंक होना चाहिए। प्रत्येक ताना बिंदु लाइन पर दो बार होता है।

उदाहरण:

|  D|  D E|G E F|  F  |  G  | <- (1,2) The single line output
+ + + + + + + + + + + + + + + <- lattice point spacing... (3) 
                                 (4,6) lattice points are all walls or spaces
                                 (5) See Figure 8
                                 (7) D, E, F, G appear twice; no other labels

यह कोड-गोल्फ है। विजेता कम से कम बाइट्स के साथ सही गैर-लूपोल जमा है।

परिक्षण

इस चुनौती के लिए कोई भी परीक्षण के मामले नहीं हैं, क्योंकि बड़ी संख्या में किसी भी नैटिवियल भूलभुलैया के लिए सही आउटपुट हैं।

हालाँकि, मैंने C ++ में एक चेकर बनाया है (यह चेकर ग्राफ ग्राफ्यूलेशन के माध्यम से दोनों सॉल्यूशंस को ग्राफ करता है )।

इसके अलावा, उचित स्वरूपण को समझने में मदद करने के लिए यहां कुछ उदाहरण दिए गए हैं:

उदाहरण 1

+-+-+-+-+-+-+
| |   |     |
+ + + + +-+-+
|   | |     |
+-+-+ +-+-+ +
|           |
+-+-+-+ +-+ +
|         | |
+ +-+-+-+ + +
| |       | |
+-+-+-+-+-+-+
->
|  D|  D E|G E F|  F  |  G  |

उदाहरण 2

+-+-+-+-+-+-+
| |   |   | |
+ + + + + + +
|   | | |   |
+-+-+ + +-+-+
|           |
+-+-+-+ +-+ +
|         | |
+ +-+-+-+ + +
| |       | |
+-+-+-+-+-+-+
->
|  D|  D E  |F E  |  F  |

और अधिक उदाहरण यहाँ मिल सकते हैं


1
मुझे नहीं लगता कि 1 डी माज़ का स्पष्टीकरण बिल्कुल स्पष्ट है ... शायद एक छोटा / सरल उदाहरण जोड़ने से मदद मिलेगी।
mbomb007

यह बहुत मजेदार है। हाँ जो मदद करता है।
mbomb007

हालांकि आपकी इंटरेक्टिव स्क्रिप्ट ने मदद की, फिर भी यह एक कठिन समस्या है। इसलिए मैं इसे छोड़ देता हूं। इस बारे में मेरी समझ अभी भी सबसे बेहतर है।
mbomb007

1D भूलभुलैया का वर्णन स्केच है। मुझे यह समझने के लिए 7 तक पढ़ना था कि 1 डी भूलभुलैया में ऊर्ध्वाधर बार के अक्षर दीवार हैं जिन्हें आप पास नहीं कर सकते।
edc65

1
उदाहरण 1 1 डी भूलभुलैया के साथ 2 डी भूलभुलैया में ढेर हो गया जहां अक्षरों की प्रत्येक जोड़ी एक सीढ़ी है: gist.github.com/sparr/36d6355cc4c785a27b121576666769082
2

जवाबों:


3

इग्राफ के साथ पायथन 2 , 492 369 बाइट्स

import igraph,string
def f(s):
 C=s.find('\n')/2;N=' ';g=igraph.Graph(0,[(i,i+j)for i in range(len(s)/(4*C+4)*C)for j in(1,C)if s[(i/C*2+1)*(2*C+2)+i%C*2+2*j+j/C*3]==N]);V=g.vs;g.d=g.degree;O='';V(_d=1)[N]=N;V(_d_gt=2)[N]=list(string.ascii_letters)
 while g.es:
    v=V(_d=1)[0];O+='|'+v[N]
    while g.d(v):w=v.neighbors()[0];g-=(v,w);v=w;O+=N+v[N]if v[N]else''
 print O+'|'

(पांचवीं और छठी पंक्तियाँ प्रत्येक एक टैब से शुरू होती हैं, न कि चार रिक्त स्थान जैसे StackExchange शो।)

  • सहेजे गए छह बाइट्स कुछ अंकगणित को पुनर्व्यवस्थित करते हैं
  • ज़िप के बजाय एक स्लाइस का उपयोग करके सात बाइट्स को बचाया
  • के g+=tuple(v.neighbors())बजाय का उपयोग कर तीन बाइट्स बचाता हैg.add_edge(*v.neighbors())
  • के g-=g.es[g.incident(v)]बजाय का उपयोग कर सात बाइट्स बचायाg.delete_edges(g.incident(v))
  • सहेजे गए ग्यारह बाइट्स अलियासिंग g.d=g.degree
  • 52 बाइट्स (!) को नष्ट कर दिया, जो एक लूप को समाप्त कर देता है, जो अपने पड़ोसियों के बीच एक किनारे के साथ डिग्री -2 कोने को बदलकर सभी गलियारों को अनुबंधित करता है। इसके बजाय, आउटपुट लूप इन वर्टिस को अनदेखा करता है।
  • 13 बाइट्स को ध्यान में रखते हुए बताया गया है कि जब नाम निर्दिष्ट करते हैं, तो igraph ध्यान नहीं देता है यदि प्रदान किए गए चलने योग्य बहुत लंबा है
  • Rपंक्तियों की संख्या के लिए एक चर नहीं होने से चार बाइट्स को बचाया , इसकी गणना को केवल उपयोग बिंदु तक ले जाना
  • दो बाइट्स को रिक्त स्थान के बजाय दूसरे स्तर के इंडेंटेशन को टैब में बदल दिया
  • सहेजे गए छह बाइट्स 2*(i%C)को i%C*2, 2*(i/C)को i/C*2, और (C-1)*jकोj*C-j
  • सहेजे गए चार बाइट्स नामकरण N='n'
  • यदि कोई वर्ण केवल मान्य वर्ण प्रकट <'-'होता है ==' ', तो इस धारणा के तहत उपयोग करने के बजाय कि स्पेस का उपयोग करके यह निर्धारित किया जाता है कि सहेजा गया ।
  • तब मुझे एहसास हुआ कि मैं ' 'इसके बजाय वर्टेक्स विशेषता को नाम दे सकता हूं 'n', और Nस्रोत में दो शाब्दिक रिक्त स्थान के लिए पुन: उपयोग कर सकता हूं , और ==Nइसके बजाय <'-', अधिक बाइट्स बचा सकता हूं

कुछ हद तक अनगुल्ड संस्करण इस प्रकार है। मूल विचार सबसे पहले सभी भूलभुलैया अनुलंबों पर एक ग्राफ बनाना है (शून्य-अनुक्रमित होने पर विषम पंक्ति और स्तंभ के साथ धब्बे।) निम्न पंक्ति एक स्थान है तो एक ही पंक्ति में एक शीर्ष से अगले एक तक एक किनारे है , और नहीं |। यदि शीर्ष पंक्ति में संबंधित वर्ण एक स्थान है, और नहीं, तो इसके शीर्ष पर नीचे से एक छोर तक एक किनारे है -

इस ग्राफ के निर्माण के बाद, हम कोई भी पत्ता उठाते हैं, और क्रमिक रूप से आसन्न सिरों का अनुसरण करते हैं, यदि उनके गलियारे नहीं हैं, तो उनका नाम लिखते हैं और उपयोग किए गए किनारों को हटाते हैं, जब तक हम अटक नहीं जाते। फिर हम एक और पत्ती लेते हैं और तब तक जारी रखते हैं जब तक कि सभी किनारे निकल नहीं जाते।

import string
import igraph
def f(s):
  C = s.find('\n')/2 # number of maze vertices in each row
  R = len(s)/(4*C+4) # number of rows
  def strpos(r, c):
    """Index of the vertex at row r, col c in the newline-delimited string s"""
    return (2*r+1)*(2*C+2) + 2*c + 1
  def vertpos(i):
    """Index of the i-th vertex in s"""
    return strpos(i/C, i%C)
  g = igraph.Graph(edges=[(i, i+(C if j else 1))
                          for i in range(R*C)
                          for j in (0, 1)
                          if s[vertpos(i)+(2*C+2 if j else 1)] == ' '])
  V = g.vs # the graph's vertex sequence
  O = ''
  V(_degree=1)['n'] = ' ' # All leaves are named space
  W = V(_degree_gt=2) # All warp points...
  W['n'] = list(string.ascii_letters[:len(W)]) # ...are named successive letters
  while g.es: # while any edges remain...
    v = V(_degree=1)[0] # find a leaf
    O += '|'+v['n'] # start a new 'block'
    while v.degree():
      w = v.neighbors()[0] # pick a neighbor
      g -= (v, w) # delete that edge
      v = w
      if v['n']: # If it's a dead end or warp point...
        O += ' '+v['n'] # ...write out the new neighbor
  print O+'|'

आप पाँच उदाहरण mazes के लिए परिणाम देख सकते हैं । (दुर्भाग्य से, igraphट्राई इट ऑनलाइन पर उपलब्ध नहीं है; ये परिणाम SageMathCloud से निर्यात किए गए थे ।)


4

हास्केल - 481 405 387 बाइट्स

import Data.List
s&t=elemIndices s t
l=last
c!(x:y:z)=l$(y:c)!(x:z):do{[x:p,q]<-mapM([id,reverse]<*>)[[x],[y]];x&[l q];[[]!((q++p):c++z)]}
c![x]=x:[]!c
c!z=z
main=interact(\m->let{g=' '&m;
u=(\\[k|k<-g,length(v>>=(k&))==2])<$>[]!v;
v=[[x,y]|x<-g,y<-g,elem(y-x-1)[0,head$'\n'&m]];
}in '|':(u>>=(++"|").init.(>>=(:" ").toEnum.((+)<*>(+65).(*32).(`div`26)).l.(-1:).(&(nub$u>>=init.tail)))))

यह उन रिक्त स्थान की सूची बनाता है जो भूलभुलैया में हैं, स्ट्रिंग में सूचकांक द्वारा क्रमांकित हैं, और इसका उपयोग आसन्न स्थानों के सभी जोड़े को खोजने के लिए करते हैं। यह तब जोड़े को पहले / अंतिम तत्वों के मिलान के आधार पर बिंदुओं के लंबे अनुक्रम में एक साथ सिलाई करता है और गलियारों को हटा देता है, ताकि प्रत्येक अनुक्रम 1D भूलभुलैया में एक कमरा हो। अनुक्रमों को तब एक स्ट्रिंग में अनुवादित किया जाता है, जो कम से कम एक कमरे (ताना बिंदुओं) के इंटीरियर पर बिंदुओं को संबंधित अक्षरों में और बाकी के रिक्त स्थान पर प्रतिस्थापित करके किया जाता है।

2D भूलभुलैया को STDIN से पढ़ा जाता है और 1D भूलभुलैया को STDOUT में मुद्रित किया जाता है।

संपादित करें: 62 से कम की जगह सामान का एक समूह एक और 14 उलटफेर और एल्गोरिथ्म थोड़ा संशोधित बाइट, और chrसाथ toEnumके रूप में Laikoni ने सुझाव दिया।

संपादित करें 2: (!)सूची पैटर्न मिलान चीनी का उपयोग करके तर्क में सरलीकृत द्वारा 3 और बाइट्स का उपयोग करके 13 अधिक बाइट्स सहेजे गए , और >>=इनका उपयोग करने के लिए 2 का उपयोग करके u


मुझे लगता है कि पैटर्न गार्ड से पहले आपको नई लिंक और रिक्त स्थान की आवश्यकता नहीं है, उदाहरण के o(x:p)q|x==last q=[q++p]|1>0=[]लिए भी काम करना चाहिए।
लिकोनी

इसके toEnumबजाय काम करना चाहिए chr, फिर import Data.Charगिराया जा सकता है।
लैकोनी

और अंत में चुनौती के रूप में एक कार्यक्रम या समारोह के लिए पूछता है, तो आप main=interact(\m->...)बस के साथ बदल सकते हैं f m=...। यह अजगर जवाब को हरा करने के लिए पर्याप्त होना चाहिए, अगर इसका मतलब है कि आपके लिए कुछ भी।
लकोनी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.