চ্যালেঞ্জ

কোনও আকারের একটি গ্রাফিকাল ইনপুট দেওয়া হয়েছে, এটিতে কতগুলি ছিদ্র রয়েছে তা নির্ধারণ করুন।

সদৃশ নয়

এই প্রশ্নটি গণনা দ্বীপপুঞ্জের সম্ভাব্য সদৃশ হিসাবে চিহ্নিত করা হয়েছিল । আমি বিশ্বাস করি এই চ্যালেঞ্জটি কাউন্ট আইল্যান্ড চ্যালেঞ্জ থেকে পৃথক, কারণ এই একটিতে, আপনাকে সীমানা স্পর্শকারী ব্লকগুলি কীভাবে নির্মূল করতে হবে তা নির্ধারণ করতে হবে।

ইনপুট

ইনপুটটিকে 2D আকারের ইনপুট হিসাবে দেওয়া হবে, হয় মাল্টলাইন স্ট্রিং, স্ট্রিংগুলির একটি অ্যারে বা অক্ষরের অ্যারের অ্যারে। এটি আকৃতির প্রতিনিধিত্ব করে। আকৃতিটি কেবলমাত্র এক টুকরোতে থাকবে, প্রান্ত দিয়ে সংযুক্ত by আপনি কীভাবে ইনপুট নিতে চান তা নির্দিষ্ট করুন।

আউটপুট

আউটপুট একটি একক পূর্ণসংখ্যার আকারের মধ্যে কতগুলি ছিদ্র রয়েছে তা উল্লেখ করে। একটি অনুসরণকারী নিউলাইন অনুমোদিত, তবে অন্য কোনও নেতৃস্থানীয় বা পিছনের সাদা জায়গা নেই। অন্য কথায়, আউটপুট অবশ্যই নিয়মিত প্রকাশের সাথে মেলে ^\d+\n?$।

গর্ত কী?

এগুলি একক গর্ত:

####
#  #
#  #
####

####
#  #
# ##
###

#####
# # #
#   #
#####

এগুলি গর্ত নয়:

########
########
#   ####
#   ####
# ######
#       
########

###
#  
###

##########
#         
# ########
# #      #
# # #### #
# #   ## #
# ###### #
#        #
##########

খুব সুন্দর, যদি এটি ফাঁকটি বাইরের প্রান্তে যোগ দেয় তবে এটি কোনও গর্ত নয়।

পরীক্ষার মামলা

#####
# # # -> 2
#####

#####
#    
# ### -> 1
# # #
#####

####
## # -> 1 (things are connected by edges)
# ##
####

###
### -> 0 (You must handle shapes with no holes, but input will always contain at least one filled space)
###

আপনি '#' এর জায়গায় এবং স্পেসগুলির জায়গায় যে কোনও অক্ষর ব্যবহার করতে পারেন।

উদ্দেশ্যমূলক স্কোরিং মানদণ্ড

স্কোরটি আপনার প্রোগ্রামের বাইট সংখ্যা হিসাবে দেওয়া হয়।

জয়লাভ

4 এপ্রিলের মধ্যে বিজয়ীর সর্বনিম্ন স্কোর সহ জমা দেওয়া হবে।

— HyperNeutrino
সূত্র

1

সম্পর্কিত

— ভিজুয়ালমেলন

2

আপনি ###|# #|## একটি পরীক্ষা কেস হিসাবে যুক্ত করতে পারেন ? ঠিক তাই করা উচিত 0?

— মার্টিন ইন্ডার

1

সম্পর্কিত

— ম্যাথু রোহ

1

কোড-গল্ফের

— ম্যাথু রোহ

@ সিগএসইজিভি এটি নির্দেশ করার জন্য আপনাকে ধন্যবাদ; তবে আমি বিশ্বাস করি যে এই চ্যালেঞ্জটির একটি জটিল উপাদান রয়েছে যা এটির নিজের পোস্টকে ওয়ারেন্ট দেওয়ার জন্য অন্যান্য চ্যালেঞ্জের থেকে যথেষ্ট আলাদা করে তোলে (আমি তফাতটি সম্পাদনা করেছি)। আপনি কী মনে করেন দয়া করে আমাকে তা জানান এবং প্রয়োজনে আমরা আড্ডায় একটি আলোচনা শুরু করতে চাই।

— হাইপারনিউট্রিনো

12

ম্যাটল্যাব / অষ্টাভ, 18 বাইট

@(g)1-bweuler(g,4)

এটি অনলাইন চেষ্টা করুন!

লজিক্যাল ম্যাট্রিক্সকে ইনপুট হিসাবে গ্রহণ করা এটি একটি বেনামে ফাংশন। অবজেক্টগুলি trueএন্ট্রি দ্বারা নির্ধারিত হয় (নির্দিষ্ট সংযোগের সাথে), খালি স্থানটি falseএন্ট্রি হয়।

bweuler তারপরে সেই ম্যাট্রিক্স দ্বারা উপস্থাপিত বাইনারি ইমেজের ইউরার সংখ্যা গণনা করে, এটি হোলের সংখ্যার বিয়োগ বস্তুর সংখ্যা the

— flawr
সূত্র

8

গণিত, 59 57 বাইট

1/.ComponentMeasurements[#,"Holes",CornerNeighbors->0>1]&

তার জন্য একটি অন্তর্নির্মিত আছে। 1গুলি (দেয়াল) এবং 0গুলি (গর্ত) এর 2D ম্যাট্রিক্স হিসাবে ইনপুট নেয় । সুবিধার জন্য, এই ইনপুট ফর্ম্যাটে সমস্ত পরীক্ষার কেস এখানে রয়েছে:

{{{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,1,1,1}},
 {{1,1,1,1},{1,0,0,1},{1,0,1,1},{1,1,1,0}},
 {{1,1,1,1,1},{1,0,1,0,1},{1,0,0,0,1},{1,1,1,1,1}},
 {{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1},{1,0,0,0,1,1,1,1},{1,0,0,0,1,1,1,1},{1,0,1,1,1,1,1,1},{1,0,0,0,0,0,0,0},{1,1,1,1,1,1,1,1}},
 {{1,1,1},{1,0,0},{1,1,1}},
 {{1,1,1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0,0,0},{1,0,1,1,1,1,1,1,1,1},{1,0,1,0,0,0,0,0,0,1},{1,0,1,0,1,1,1,1,0,1},{1,0,1,0,0,0,1,1,0,1},{1,0,1,1,1,1,1,1,0,1},{1,0,0,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1}},
 {{1,1,1,1,1},{1,0,1,0,1},{1,1,1,1,1}},
 {{1,1,1,1,1},{1,0,0,0,0},{1,0,1,1,1},{1,0,1,0,1},{1,1,1,1,1}},
 {{1,1,1,1},{1,1,0,1},{1,0,1,1},{1,1,1,1}}}

বিকল্প সমাধান, 59 বাইট

এটি ছিল আমার আসল পন্থা। এটি উপাদান-সম্পর্কিত বিল্ট-ইনগুলির উপর ভিত্তি করেও গর্তগুলি সরাসরি গণনা করে না (পরিবর্তে এটি গর্তগুলিকে উপাদান হিসাবে বিবেচনা করে)।

Max@*MorphologicalComponents@*DeleteBorderComponents@*Image

উপরের মত একই ইনপুট ফর্ম্যাট নেয়, তবে 0গুলি এবং 1গুলি অদলবদলের ভূমিকা নিয়ে ।

আমাকে এটিকে Imageপ্রথমটিতে রূপান্তরিত করার কারণটি হ'ল, অন্যথায়, ম্যাথামেটিকা সমস্ত 1কক্ষকে একটি একক উপাদান হিসাবে বিবেচনা করবে (কারণ এটি ম্যাট্রিক্সকে একটি উপাদান-লেবেল ম্যাট্রিক্স হিসাবে বিবেচনা করে)। সুতরাং, যদি কোনও 1-सेल মার্জিনের সীমানা করে, তবে এটি সমস্ত মুছে ফেলবে। যখন DeleteBorderComponentsপরিবর্তে একটি ছবিতে ব্যবহার করা হয়, তাহলে এটি উপাদান এটি একটি অন্তর্নিহিত সংযোগ পরীক্ষা করতে হবে।

বিকল্পভাবে, আমি MorphologicalComponents প্রথমে কল করতে পারি , যা ইনপুটটিকে একটি উপযুক্ত লেবেল ম্যাট্রিক্সে রূপান্তরিত করবে, তবে আমি যদি DeleteBorderComponentsদ্বিতীয়টি করি তবে এটির গ্যারান্টি নেই যে সর্বাধিক উপাদান লেবেল উপাদানগুলির সংখ্যার সাথে সামঞ্জস্য করে (কারণ আমি কোনও ছোট উপাদান মুছতে পারি)।

— মার্টিন ইন্ডার
সূত্র

5

সত্যিই, ম্যাথমেটিকা কেবলমাত্র সমস্ত কিছুর জন্য অন্তর্নির্মিত হয়েছেন ...

— মিঃ এক্সকোডার

3

@ মিঃ এক্সকোডার আমার একটি ভাল চ্যালেঞ্জ ধারণা রয়েছে: এমন একটি চ্যালেঞ্জ সন্ধান করুন যার জন্য গণিতের কোনও অন্তর্নির্মিতা নেই।

— হাইপারনিউটারিনো

@ হাইপারনিউট্রিনো ভাল ধারণা, তবে আমি মনে করি যে ম্যাথামেটিকার ব্যবহারকারীরা এটিকে ভারীভাবে হ্রাস করবেন, দুর্ভাগ্যক্রমে, এবং এই সম্প্রদায়টি ভাল প্রতিক্রিয়া জানাবে কিনা তা আমি জানি না ... =]

— মিঃ এক্সকোডার

1

@ হাইপার নিউট্রিনো, সম্ভবত এটির জন্য একটি বিল্টিনও রয়েছে :-)

— ব্রায়ান মিন্টন

নিবন্ধন করুন ম্যাথমেটিকায় সম্ভবত একটি বিল্ট-ইন রয়েছে GenerateBuiltin। এটি যে কোনও চ্যালেঞ্জের জন্য অন্তর্নির্মিত অন্তর্নির্মিত জেনারেট তৈরি করে। এছাড়াও, মার্টিন ইন্ডারের ইনবক্সের জন্য আমার খারাপ লাগছে, তাই আপনি চাইলে আসুন এই আলোচনাটি এখানে

— HyperNeutrino

4

পার্ল 5 , 154 বাইট

-p0পতাকা জন্য 152 বাইট কোড + 2 বাইট ।

s/^ | $/A/gm;s/^.*\K | (?=.*$)/A/&&redo;/.*/;$@="@+"-1;for$%(A,X){$~="(.?.?.{$@})?";(s/$%$~ /$%$1$%/s||s/ $~$%/$%$1$%/s)&&redo}s/ /X/&&++$\&&redo}{$\|=0

এটি অনলাইন চেষ্টা করুন!

আমি মনে করি কোডটি বেশ স্ব-ব্যাখ্যামূলক।

আপনার যদি বুঝতে কিছু ব্যাখ্যা প্রয়োজন হয় তবে প্রোগ্রামের দ্বারা একটি সাধারণ ইনপুটটিতে করা রূপান্তরের কয়েকটি পদক্ষেপ এখানে দেওয়া হয়েছে ( এখান থেকে আসছেন) ) হয়ে কিছু রদবদলের , তারপরে কিছু ব্যাখ্যা নীচে নামবে:

######
#     
# #####
# # #
#### #
######

######
# ক
# #####
# # #
#### #
######

######
#AAAAA
#A ####
# এ # #
#### #
######

######
#AAAAA
#A ####
# এ # এক্স #
#### #
######

######
#AAAAA
#A ####
# একজন # এক্সএক্স #
####এক্স#
######

প্রথমত, s/^ | $/A/gm;s/^.*\K | (?=.*$)/A/&&redoসীমান্তের ফাঁকা স্থানগুলি (বাম / ডানদিকে 1 ম রেজেক্স, নীচে / শীর্ষের জন্য 2 য়) এর সাথে প্রতিস্থাপন করবে A(আমি সেই চরিত্রটি বেশ নির্বিচারে বেছে নিই)।
তারপরে, আমরা আকারটি প্রস্থটি দিয়ে পাই /.*/;$@="@+"-1;।
এখন, আমরা ক এর Aসাথে সংযুক্ত প্রতিটি স্থানকে প্রতিস্থাপন করতে চাই A(কারণ যদি স্থানটি একটিতে সংযুক্ত থাকে A, তবে এর অর্থ এটি কোনও গর্তের অংশ হতে পারে না That's এটি সম্পন্ন হয়েছে for$%(A,X){(s/$%(.?.?.{$@})? /$%$1$%/s||s/ (.?.?.{$@})?$%/$%$1$%/s)&&redo}( একবার এস এর জন্য এবং Aএর জন্য একটি X- Xবেলো হ'ল এখানে দুটি রেইজেক্স রয়েছে: s/$%(.?.?.{$@})? /$%$1$%/sক এর ডান বা নীচে থাকা ফাঁকা স্থানগুলির সাথে ডিল করে AAnd এবং এই মুহুর্তে, কেবলমাত্র ফাঁকা স্থানগুলি যা বাকী রয়েছে স্ট্রিং গর্ত অংশ।s/ (.?.?.{$@})?$%/$%$1$%/s উপরে ব্যবধান সহ বা বামA ।

যদিও এখনও শূন্যস্থান রয়েছে, আমরা আবার বলি:
- সেখানে কতগুলি ছিদ্র রয়েছে তা জানতে, আমরা একটি স্থান একটি X( s/ /X/) দিয়ে প্রতিস্থাপন করব এবং গর্তের পাল্টা বৃদ্ধি করব ( $\++), পুরো প্রোগ্রামটি আবার করব (আসলে, আমরা কেবল forলুপটি আবার করতে চাই , তবে পুরো প্রোগ্রামটি আবার করা কম বাইটস)
- তারপরে, forলুপটি ক এর Xসাথে সংযুক্ত প্রতিটি স্থানকে প্রতিস্থাপন করবে X, কারণ তারা একই গর্তের অংশ।
শেষে, $\|=0নিশ্চিত করে যে যদি কোনও গর্ত না থাকে তবে 0খালি স্ট্রিংয়ের পরিবর্তে একটি মুদ্রিত হয়। এবং $\স্পষ্টভাবে -pপতাকা মুদ্রণ ধন্যবাদ ।

— দাদা
সূত্র

4

পাইথন 2, 282 বাইট

তির্যক ছোঁয়া T + টিটি পরিচালনা করতে +100 (আমাদের কি সত্যই প্রয়োজন?)
-১১৯ @ রড গাইডেন্সের জন্য ধন্যবাদ :)

এটি অনলাইনে চেষ্টা করুন । ইনপুট হিসাবে অক্ষরের অ্যারে এবং # সাদা অংশের অ্যারে নেয়।

A=input()
c=0
X=len(A[0])-1
Y=len(A)-1
def C(T):
 x,y=T
 global g
 if A[y][x]<'#':
    if y<1or y==Y or x<1or x==X:g=0
    A[y][x]='#';map(C,zip([x]*3+[min(x+1,X)]*3+[max(x-1,0)]*3,[y,min(y+1,Y),max(y-1,0)]*3))
while' 'in sum(A,[]):i=sum(A,[]).index(' ');g=1;C((i%-~X,i/-~X));c+=g
print c

প্রথম সাদা স্থানের জন্য অনুসন্ধান করুন এবং এটি খালি নয় ('#') হিসাবে চিহ্নিত করুন। সমস্ত খালি ঘরগুলি পূরণ করার সময় এর চারপাশে পুনরাবৃত্তভাবে পরীক্ষা করুন। যদি বর্তমান "গর্ত" এর কোনও খালি ঘরটি বর্ডার কাউন্টারে উপস্থিত থাকে তবে তা পরিবর্তন হবে না, অন্যথায় এটি 1 দ্বারা বৃদ্ধি করা হবে process যতক্ষণ না কোনও শ্বেতস্থান না থাকে ততক্ষণ পুনরাবৃত্তি প্রক্রিয়া।

— ডেড পসুম
সূত্র

1

আপনি ব্যবহার করতে পারেন sum(A,[])চেপ্টা করতে

— ডান্ডা

1

এছাড়াও আপনি এই উত্তরটি যাচাই করতে পারেন , এর একই পুনরাবৃত্ত যুক্তি রয়েছে এবং এর সাথে আরও কিছু কৌশল রয়েছে (যেমন প্রথম লাইনে ফাংশন "নামকরণ")

— রড

@ রড ট্রিক যোগফল খুব ভাল, আপনাকে ধন্যবাদ। আমি এখন এই সমস্ত কদর্যতা ছাড়াই 8 টি দিকনির্দেশ পেয়ে কাজ করছি, আপনার উত্তর সাহায্য করতে পারে। আমি তার পরে আপডেট করব

— মৃত পসসাম

মনে রাখবেন যে আমার উত্তরে আমি তালিকা বোধের ভিতরে পুনরাবৃত্তির ফাংশনটি কেবলমাত্র কম বাইট ব্যবহার করার জন্য কল করেছি, তবে আপনার ক্ষেত্রে আপনি তালিকার দৈর্ঘ্যটি পরীক্ষা করে দেখতে পারেন যে বর্তমান ঘরটি সীমান্তের অন্তর্ভুক্ত কিনা (তালিকার বিষয়বস্তু অনেক বেশি হবে Nones, তবে তা অপ্রাসঙ্গিক)

— রড

1

আপনি তালিকাটি আনপ্যাক করে ব্যবহার করতে পারেন x=T[0];y=T[1]-> এ x,y=T, আপনার (সম্ভবত) g=1তৃতীয় লাইনে ঘোষণা করার দরকার নেই এবং আপনি স্ট্রিংগুলি ব্যবহার করতে <বা >তুলনা করতে পারেন (এটি গ্রহণ করবে)ord() প্রতিটি গৃহস্থালির কাজ এর মান) আপনি প্রতিস্থাপন করতে সক্ষম হবেন A[y][x]!='#'সঙ্গে A[y][x]<'#', যেহেতু ' '<'#'।

— রড

3

পাইথন 2, 233 225 222 বাইট

গণিত_জুনকি : -8 বাইট

ইনপুট হিসাবে বুলিয়ান / পূর্ণসংখ্যার (0/1) 2 ডি অ্যারে নেয়

s=input()
o=[-1,0,1]
m=lambda x,y:0if x in[-1,len(s[0])]or y in[-1,len(s)]else 1if s[y][x]else(s[y].__setitem__(x,1),all([m(x+a,y+b)for a in o for b in o]))[1]
e=enumerate
print sum(m(x,y)-c for y,l in e(s)for x,c in e(l))

এটি অনলাইন চেষ্টা করুন!

ফর্ম্যাট সংস্করণ:

s = input()
o = [-1, 0, 1]
m = lambda x,y:
    0 if x in [-1, len(s[0])] or y in [-1, len(s)]
      else
        1 if s[y][x]
          else
            (s[y].__setitem__(x, 1),
             all([m(x + a, y + b) for a in o for b in o]))[1]
e = enumerate
print sum(m(x, y) - c for y, l in e(s) for x, c in e(l))

— পিউ পিউ
সূত্র

1

আপনি print sum(m(x,y)...পরিবর্তে a=এবংprint a

— ম্যাথ জাঙ্কি

1

এছাড়াও, কিছু ছোটখাটো সাদা স্পেস গল্ফ: টিআইও

— গণিত জাঙ্কি

1

সি # 7, 364 বাইট

এতে খুশি হওয়ার চেয়ে কম ... হতে পারে অন্য কেউ এটিকে বাছাই করতে পারে ... পরে যদি আমার শক্তি থাকে তবে আমি প্রথম লুপটি উল্টে দেব, এবং এটি সীমাবদ্ধতা পরীক্ষা করে ছাঁটাতে সহায়তা করতে পারে কিনা তা দেখুন।

using C=System.Console;class P{static void Main(){string D="",L;int W=0,H=0,z;for(;(L=C.ReadLine())!=null;H+=W=L.Length)D+=L;int[]S=new int[H*9];int Q(int p)=>S[p]<p?Q(S[p]):p;void R(int r)=>S[Q(r+=z)]=S[r]>0?z:0;for(z=H;z-->0;)if(D[z]<33){S[z]=z;R(1);R(W);R(W+1);R(W-1);}for(;++z<H;)S[Q(z)]*=z>H-W-2|z%W<1|z%W>W-2?0:1;for(;W<H;)z+=Q(W)<W++?0:1;C.WriteLine(z-H);}}

এটি অনলাইনে চেষ্টা করুন

সম্পূর্ণ প্রোগ্রাম, স্ট্যান্ডার্ড ইন ইনপুট গ্রহণ করে, আউটপুট থেকে স্ট্যান্ডার্ড আউট। অস্থায়ী ছিদ্রগুলি নির্ধারণ করার জন্য বিচ্ছিন্নতা সেটগুলি ব্যবহার করে এবং যখন কোনও মেরে ফেলা হয় তখন সীমানা স্পর্শ করে (উপরের প্রান্তের জন্য কিছুটা dodgyness সহ)।

ফর্ম্যাট এবং মন্তব্য কোড:

using C=System.Console;

class P
{
    static void Main()
    {
        string D="", // the whole map
            L; // initally each line of the map, later each line of output

        // TODO: some of thse might be charable
        int W=0, // width, later position
            H=0, // length (width * height)
            z; // position, later counter

        // read map and width
        for(;(L=C.ReadLine())!=null; // read a line, while we can
                H+=W=L.Length) // record the width, and increment height
            D+=L; // add the line to the map

        // disjoint sets
        int[]S=new int[H*9]; // generousness (relieve some bounds checking)
        // note that S[x] <= x, because we call R with decending values of z

        // returns whatever p points to
        int Q(int p)=>S[p]<p?Q(S[p]):p;
        // points whatever r points to at z if r is empty
        void R(int r)=>S[Q(r+=z)]=S[r]>0?z:0; // note that is never called when z=0

        // fill out disjoint sets
        for(z=H;z-->0;)
            if(D[z]<33) // if cell is empty
            {
                S[z]=z; // point it at itself

                // point the things next  to z at z
                R(1);
                R(W);
                R(W+1);
                R(W-1);
            }

        // zero sets which are against the left, bottom, or right edges
        for(;++z<H;)
            S[Q(z)]*=z>H-W-2|z%W<1|z%W>W-2?0:1; // TODO?: this suggests inverting the first loop (NOTE: would break S[x]<=x)

        // starting from the second row, count all the sets that point to this cell (ignores any non-zeros pointing to first row)
        for(;W<H;)
            z+=Q(W)<W++?0:1;

        C.WriteLine(z-H);
    }
}

— VisualMelon
সূত্র

Func<List<string>, int>ফ্লাফ এবং কনসোল স্টাফগুলি সরাতে এটিতে রূপান্তর করুন । যাইহোক, আমি আপনার স্থানীয় ফাংশনগুলি দেখেছি যাতে আপনি এগুলি মজাদার অবস্থায় রাখতে সক্ষম নাও হতে পারেন। শুধু একটি পদ্ধতিতে সংকলন করতে পারে int h(string[] s) { }।

— TheLethalCoder

আমি নিশ্চিত যে আরও অনেক কিছুই এখানে সরল করা যায় ...

— TheLethalCoder

@TheLethalCoder আমি এটিকে অন্য রূপে রূপান্তর করব না, ফাংশন হিসাবে উত্তরগুলি পছন্দ করি না (যেমন আপনি বলেছিলেন ল্যাম্বডা লাগবে না)। হ্যাঁ ... পুরো জিনিসটি ফুলে যায় বলে মনে হয় ... তবে এটিকে রূপান্তর করার সময় আমি বেশ ভাল ব্যয় করেছি এবং কোনও তাত্পর্যপূর্ণ অগ্রগতি করতে পারি নি, তাই আমি 'বিটি' গল্ফ করে কয়েক পাস করেছি এবং এটি ঠেলে দিয়েছি। একটি সংক্ষিপ্ত সংস্করণ জমা দিতে নির্দ্বিধায়, আমি এটির সাথে কম সংযুক্ত।

— ভিজ্যুমেলন

আমার অর্থ এটি কেবল একটি পদ্ধতিতে রূপান্তর করা এবং সমস্ত কনসোল স্টাফগুলি অপসারণ করা, যেহেতু আর প্রয়োজন হবে না, 50-100 বাইট ছোঁড়া যাচ্ছে (কেবল একটি অনুমান তবে এটি অনেকটা ছিটকে যাবে)।

— TheLethalCoder

নিবন্ধন করুন আমি শুধু উত্তর হিসাবে ফাংশন জমা দিতে পছন্দ করি না। স্ট্যান্ডার্ড ইনপুটটি বেশ স্ট্যান্ডার্ড এবং একটি 'সম্পূর্ণ প্রোগ্রাম' যে কোনও জায়গায় সংকলন করা এবং চালানো সহজ। আমাকে টাইপ করা ল্যাম্বডাস শুরু করবেন না ... স্পষ্টতই, যদি এখানে প্রতিযোগিতার কোনও জাভা উত্তর থাকে তবে আমাকে আমার মানগুলি কিছুটা কমিয়ে দিতে হবে ...

— কমিয়ে দিতে হবে

1

শামুক , 48 বাইট

!{\ z`+~}\ {t\ z!.!~=((lu|u.+r)!(.,~},!{t\ z!.!~

Ungolfed:

!{
    (\   z)+
    ~
}
\ 
{
    t \ 
    z !.!~
    ={
        (lu|u.+r)
        !(.,~)
    }
},
!{
    t \ 
    z !.!~
}

— feersum
সূত্র

0

জাভাস্ক্রিপ্ট (ES6), 192 বাইট

v=a=>Math.min(...a=a.map(s=>s.length))==Math.max(...a);
f=(s,t=(u=` `.repeat(w=s.search`
`+1))+`
`+s.replace(/^|$/gm,` `)+`
`+u,v=t.replace(RegExp(`( |@)([^]{${w},${w+2}})?(?!\\1)[ @]`),`@$2@`))=>t!=v?f(s,v):/ /.test(t)?f(s,t.replace(` `,`@`))+1:-1

<textarea id=i rows=10 cols=10></textarea><input type=button value=Count onclick=o.textContent=/^[\s#]+$/.test(i.value)*v(i.value.split`\n`)?f(i.value):`Invalid_Entry`><span id=o>

স্নিপেট প্রসারিত করুন

ব্যর্থ ক্যাসলগুলি সনাক্ত করতে আমার উত্তরের ভিত্তিতে । আকারের চারপাশে একটি অঞ্চল তৈরি করার জন্য প্রথমে স্ট্রিংটি ফাঁকা জায়গায় প্যাড করা হয়। RegExp এর পরে দুটি সংলগ্ন স্কোয়ার সন্ধান করা হবে, একটিতে একটি রয়েছে @, একটিতে একটি জায়গা রয়েছে এবং এটি উভয়কে একটি দ্বারা প্রতিস্থাপন করে @। যদি এটি এটি না করতে পারে তবে এটি একটি স্পেসে পূর্ণ হয় @এবং এটিকে একটি নতুন গর্ত হিসাবে গণনা করে। অবশেষে একটিকে আশেপাশের অঞ্চলে অ্যাকাউন্টে বিয়োগ করা হয়।

— নিল
সূত্র

আপনি কি কোনও ধরণের টিআইও লিঙ্ক সরবরাহ করতে পারেন? ধন্যবাদ!

— হাইপারনিউট্রিনো

কত ছিদ্র?

চ্যালেঞ্জ

সদৃশ নয়

ইনপুট

আউটপুট

গর্ত কী?

পরীক্ষার মামলা

উদ্দেশ্যমূলক স্কোরিং মানদণ্ড

জয়লাভ

ম্যাটল্যাব / অষ্টাভ, 18 বাইট

গণিত, 59 57 বাইট

বিকল্প সমাধান, 59 বাইট

পার্ল 5 , 154 বাইট

পাইথন 2, 282 বাইট

পাইথন 2, 233 225 222 বাইট

সি # 7, 364 বাইট

শামুক , 48 বাইট

জাভাস্ক্রিপ্ট (ES6), 192 বাইট