चुनौती का वर्णन

आइए एक दो-द्विसंयोजक, आयताकार सरणी कहते हैं (जिसका अर्थ है कि इसकी प्रत्येक उपप्रकार की लंबाई समान है), एक ग्रिड । एक ग्रिड की हर इकाई या तो एक खाली जगह या एक सीमा होती है । पात्रों की एक ग्रिड में, खाली स्थान को एक व्हाट्सएप द्वारा दर्शाया गया है; किसी भी अन्य चरित्र को एक सीमा के रूप में माना जाता है। नमूना ग्रिड ( पठनीयता के लिए +'s, |' s और -'जोड़े गए - वे ग्रिड का हिस्सा नहीं हैं )'

+----+
|    |
|    |
|    |
|    |
|    |
+----+  an empty 4x5 grid

+------+
|      |
|  #   |
|  #   |
+------+  a 6x3 grid with 2 borders

+----------+
|          |
|          |
|  #####   |
|  #   #   |
| ##   # <------ enclosed area
| #    #   |
| ######   |
|          |
+----------+  a 10x8 grid with an enclosed area

एक 2 डी ग्रिड और निर्देशांक की एक जोड़ी को देखते हुए, निर्देशांक द्वारा दर्शाए गए बिंदु के आसपास के संलग्न क्षेत्र को भरें।

नमूना इनपुट / आउटपुट

1)

0 0
+----------+      +----------+
|          |      |XXXXXXXXXX|
|          |  ->  |XXXXXXXXXX|
|          |      |XXXXXXXXXX|
+----------+      +----------+

2)

6 5
+-----------------+      +-----------------+
|                 |      |                 |
|                 |      |                 |
|    ########     |      |    ########     |
|    #       #    |      |    #XXXXXXX#    |
|    #    ####    |      |    #XXXX####    |
|    #    #       |      |    #XXXX#       |
|    #    #       |  ->  |    #XXXX#       |
|    #    #       |      |    #XXXX#       |
|     ####        |      |     ####        |
|                 |      |                 |
|                 |      |                 |
+-----------------+      +-----------------+

3)

4 6
+-----------------+      +-----------------+
|                 |      |XXXXXXXXXXXXXXXXX|
|    ####         |      |XXXX####XXXXXXXXX|
|   #    #        |  ->  |XXX#    #XXXXXXXX|
|    ####         |      |XXXX####XXXXXXXXX|
|                 |      |XXXXXXXXXXXXXXXXX|
+-----------------+      +-----------------+

4)

4 5
+-----------------+      +-----------------+      +-----------------+ 
|                 |      |                 |      |                 |
|                 |      |                 |      |                 |
|    ####         |      |    ####         |      |     XXXX        |
|    ####         |  ->  |    ####         |  or  |     XXXX        |
|    ####         |      |    ####         |      |     XXXX        |
|                 |      |                 |      |                 |
+-----------------+      +-----------------+      +-----------------+

5)

2 6
+----------------+      +----------------+
|                |      |XXXXXXXXXXXXXXXX|
|                |      |XXXXXXXXXXXXXXXX|
|                |      |XXXXXXXXXXXXXXXX|
|                |  ->  |XXXXXXXXXXXXXXXX|
|                |      |XXXXXXXXXXXXXXXX|
|BBBBBBBBBBBBBBBB|      |BBBBBBBBBBBBBBBB|
|                |      |                |
|                |      |                |
+----------------+      +----------------+

एक खाली ग्रिड को संलग्न माना जाता है, अर्थात सीमाएँ ग्रिड के किनारों के साथ-साथ स्थित हैं (उदाहरण 1 और 5 देखें),
एक संलग्न क्षेत्र के एक कोने को एल-आकार का होने की आवश्यकता नहीं है। इसलिए निम्न दो क्षेत्र समतुल्य हैं:

####         ##
#  #        #  #
#  #   ==   #  #
#  #        #  #
####         ##

यदि निर्देशांकों के तहत एक इकाई सीमा होती है तो आप ग्रिड को अपरिवर्तित छोड़ सकते हैं (उदाहरण के लिए 4.) या इसे खाली स्थान के रूप में मानें,
जब तक आप इस जानकारी को सबमिशन में शामिल करते हैं, तब तक आप फिलर / खाली जगह के लिए कोई भी पात्र चुन सकते हैं।
यदि charआपके उद्देश्यों के अलावा किसी अन्य प्रकार का उपयोग करना बेहतर है, तो आप ints( 0खाली स्थान के लिए, 1सीमा के लिए) या booleans( trueऔर falseक्रमशः) या किसी अन्य प्रकार का उपयोग कर सकते हैं - बस इस जानकारी को अपने सबमिशन में शामिल करना सुनिश्चित करें,
उपरोक्त उदाहरणों में प्रयुक्त निर्देशांक 0-अनुक्रमित (row, column)निर्देशांक हैं, क्योंकि यह द्वि-आयामी सरणी के लिए अधिक सुविधाजनक है। यदि आप (column, row)(कार्टेशियन) प्रणाली और / या गैर-0-अनुक्रमित निर्देशांक का उपयोग करना चाहते हैं , तो इसे अपने सबमिशन में निर्दिष्ट करें।
यदि आप नहीं जानते हैं कि कहां से शुरू करें, तो बाढ़ के बारे में विकिपीडिया लेख देखें
याद रखें कि यह एक है कोड गोल्फ चुनौती है, इसलिए अपने कोड को यथासंभव छोटा करें!

code-golf array-manipulation grid

— shooqie
स्रोत

संबंधित: 1 , 2 , 3 , 4 , संभवतः अधिक।

— पीटर टेलर

निर्देशांक की स्थिति में एक एकल सीमा इकाई के साथ एक परीक्षण मामला होने के लायक हो सकता है, यह दिखाने के लिए कि दो वैध आउटपुट हैं: या तो ग्रिड सभी भरे हुए हैं या ग्रिड अपरिवर्तित है। (अगर मैंने आपके 3 नोट को सही तरीके से समझा है।)

— २२:३

एक्स देखें। 4) अपडेट

— जूकी

1

मुझे नहीं पता कि आपको अपना वैकल्पिक उदाहरण कैसे मिलता है 4. जो निर्दिष्ट इनपुट वर्ग के अलावा सीमा कोशिकाओं को नष्ट करता प्रतीत होता है।

— जोफेन

4

MATLAB, 30 7 बाइट्स

जैसा कि हम स्ट्रिंग्स के बजाय तार्किक इनपुट का उपयोग कर सकते हैं, हम नंगे फ़ंक्शन का उपयोग कर सकते हैं, जैसा कि यह है:

@imfill

यह एक अनाम फ़ंक्शन है। उपयोग के लिए, हमें एक नाम मान लेना होगा, जैसे f=@imfill। तब हम इसका मूल्यांकन कर सकते हैं , जैसे कि एक तार्किक मैट्रिक्स f(input,point)कहां inputहै, उदाहरण के लिए [0,0;0,1], और point1-आधारित निर्देशांक के साथ 2d-वेक्टर है, उदा [1,2]।

पुराने वर्जन स्ट्रिंग्स पर काम कर रहे हैं:

@(a,p)[imfill(a>32,p)*3+32,'']

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

धन्यवाद @LuisMendo के लिए - 1 बाइट।

— flawr
स्रोत

स्ट्रिंग संस्करण के लिए, आप की जगह ले सकता ~=32द्वारा>32

— लुइस Mendo

3

सी, 162 बाइट्स

w,l;char*d;f(z){z<0||z>l||d[z]^32||++d[z]&&f(z+1)+f(z-1)+f(z+w)+f(z-w);}main(c,v)char**v;{l=strlen(d=v[3]),w=strchr(d,10)-d+1,f(atoi(v[2])*w+atoi(v[1]));puts(d);}

तर्कों से इनपुट लेता है ( ./floodfill X Y grid)। ग्रिड में प्रत्येक पंक्ति के बीच \nया समाहित होना चाहिए \r\n, अंतिम न्यूलाइन वैकल्पिक है। शेल से आह्वान करने का सबसे सरल तरीका:

./floodfill 1 0 "$(printf "   \n###\n   \n")"
# or
./floodfill 1 0 "$(cat gridfile)"

!भरण- पोषण के लिए आउटपुट, भरण चरित्र के लिए उपयोग करना। यदि प्रारंभ स्थिति a से मेल खाती है #, तो कोई परिवर्तन नहीं करता है।

टूट - फूट:

                                    // GCC is happy enough without any imports
w,l;                                // Globals (line width, total length)
char*d;                             // Global grid pointer
f(z){                               // "Fill" function - z=current cell
    z<0||z>l||                      // Check if out-of-bounds...
    d[z]^32||                       // ...or not empty
        ++d[z]&&                    // Fill cell...
        f(z+1)+f(z-1)+f(z+w)+f(z-w);// ...and continue in "+" pattern
}
main(c,v)char**v;{                  // K&R style function to save 2 bytes
    l=strlen(d=v[3]),               // Store grid & length
    w=strchr(d,10)-d+1,             // Store width of grid (including newlines)
    f(atoi(v[2])*w+atoi(v[1]));     // Parse X & Y arguments and invoke fill

    puts(d);}                       // Print the result

ध्यान दें कि यह इनपुट तर्क स्ट्रिंग को संशोधित करने पर निर्भर करता है, जो निषिद्ध है, इसलिए यह सभी प्लेटफार्मों पर काम नहीं कर सकता है (अंतर्निहित घोषणाएं भी इसे गैर-मानक बनाती हैं)।

— डेव
स्रोत

आप int w, l;बस को बदलकर 4 बाइट्स बचा सकते हैं w, l;- इसे intटाइप करने के लिए चूक करना

— Jacajack

@ जजैक गुड पॉइंट! धन्यवाद

— डेव

1

सी - 263 247 240 238 बाइट्स

यह ~~पहला~~ ~~दूसरा~~ तीसरा संस्करण है, मेरा मानना है कि कोड को छोटा भी किया जा सकता है।

m[99][99],x,y,a,b,c,n;f(v,w){if(m[v][w]==32){m[v][w]=88;f(v,w+1);f(v+1,w);f(v,w-1);f(v-1,w);}}main(){scanf("%d %d\n",&a,&b);for(;~(c=getchar());m[x++][y]=c,n=x>n?x:n)c==10&&++y&&(x=0);f(b+2,a+1);for(a=-1;++a<y*n+n;)putchar(m[a%n][a/n]);}

और पठनीय संस्करण:

m[99][99], x, y, a, b, c, n;

/*
    a, b - flood fill start coordinates
    v, w - recursive function start coordinates
    x, y - iterators
    c - character read
    m - map
    n - maximum map width found

*/


//Recursive flood function
f( v, w )
{
    if ( m[v][w] == 32 ) //If field is empty (is ' '?)
    {
        m[v][w] = 88; //Put 'X' there
        f(v,w+1);f(v+1,w); //Call itself on neighbour fields
        f(v,w-1);f(v-1,w);
    }
}

main( )
{
    //Read coordinates
    scanf( "%d %d\n", &a, &b );

    //Read map (put character in map, track maximum width)
    for ( ; ~( c = getchar( ) ); m[x++][y] = c, n = x > n ? x : n )
        c == 10 && ++y && ( x = 0 );

    //Flood map
    f( b + 2, a + 1 );

    //Draw
    for ( a = -1; ++a < y * n + n; )
            putchar( m[a % n][a / n] );     

}

संकलित करें और चलाएं:
gcc -o flood floodgolf.c && cat 1.txt | ./flood

संसाधन:

नोट: मैं intमूल्यों पर काम कर रहा हूं । प्रत्येक (32) को खाली स्थान माना जाता है। किसी अन्य मूल्य को सीमा के रूप में माना जाता है। निर्देशांक प्रारूप में हैं(row, column)

— Jacajack
स्रोत

1

मत भूलो कि आप for( scanfयहां) के अंदर बयान डालकर अर्धविरामों को बचा सकते हैं , और एक सस्ते इंट घोषणा के रूप में मुख्य के पहले पैरामीटर का उपयोग करना अधिकांश संकलक में काम करेगा। इसके अलावा आप अपने सरणी को समतल करके थोड़ा बचा सकते हैं (निश्चित रूप से प्रिंट लूप की मदद करना चाहिए)

— डेव

@ क्या यह सही है। जब से मैंने यह कोड लिखा है मैंने थोड़ा सीखा है। मुझे लगता है कि 1 डी सरणी में डेटा स्टोर करने से मुझे बहुत बचत करने में मदद मिलेगी, लेकिन जाहिर है कि मैं आपके विचार की नकल नहीं करना चाहता। मैं देखूंगा कि बाद में मैं क्या कर सकता हूं। धन्यवाद!

— जैकजैक

0

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

इसे ऑनलाइन आज़माएं । सरल पुनरावर्ती समाधान

a,X,Y=input()
M=len(a)
N=len(a[0])
def R(x,y):
 if~0<x<M and~0<y<N and a[x][y]:a[x][y]=0;R(x-1,y);R(x+1,y);R(x,y-1);R(x,y+1)
R(X,Y)
print'\n'.join(map(str,a))

0-पंक्ति-स्तंभ क्रम में अनुक्रमित

1 - खाली स्थान, 0 - भरा हुआ स्थान

1 और 0 के सरणियों के सरणी के रूप में इनपुट लेता है, और दो नंबर

— मृत पोसुम
स्रोत

0

पर्ल 5 , 129 + 1 (-ए) = 130 बाइट्स

sub f{my($r,$c)=@_;$a[$r][$c]eq$"&&($a[$r][$c]=X)&&map{f($r+$_,$c);f($r,$c+$_)}-1,1}@a=map[/./g],<>;f$F[0]+1,$F[1]+1;say@$_ for@a

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

कैसे?

sub f{   # recursive subroutine
  my($r,$c)=@_; # taking row and column as inputs
  $a[$r][$c]eq$"&&  # using Boolean short circuit as an 'if' statement to 
                    # check if the current position in the global array is blank
  ($a[$r][$c]=X)&&  # then setting it to 'X'
  map{f($r+$_,$c);f($r,$c+$_)}-1,1 # and checking the four surrounding spaces
}
# -a command line option implicitly splits the first line into the @F array
@a=map[/./g],<>;    # put the input in a 2-D array
f$F[0]+1,$F[1]+1;   # start the fill at the given position, correcting for
                    # Perl's 0 based arrays
say@$_ for@a        # output the resulting pattern

— Xcali
स्रोत

एक 2 डी ग्रिड को भरें