পথ খুঁজে!

Question

আপনার অবশ্যই একটি প্রোগ্রাম বা ফাংশন লিখতে হবে।

ইনপুটটি সংখ্যার একটি 'মানচিত্র'। আপনি মানচিত্রটিকে নতুন লাইন বর্ণগুলি ( \n) বা স্ট্রিংগুলির একটি 2D অ্যারে যুক্ত স্ট্রিং হিসাবে বেছে নিতে পারেন ।

সমস্ত মানচিত্র 5 টি অক্ষর দ্বারা 5 টি অক্ষর, এবং অক্ষর সর্বদা হয় 0 বা স্পেসের চেয়ে বড়।

এখানে একটি মানচিত্রের উদাহরণ:

12 45
11233
  233
    1
2 899

আপনার কাজ হ'ল মানচিত্রে সংযুক্ত উপাদানগুলি সন্ধান করা। একটি বৈধ উপাদান হ'ল অন্তত তিনটি অনুভূমিক এবং / অথবা উল্লম্বভাবে ( তির্যক নয় ) সংযুক্ত অভিন্ন অঙ্কের ( ফাঁকা স্থান নয় ) একটি সিরিজ । তারপরে আপনাকে বৈধ সংযুক্ত উপাদানগুলির অক্ষরগুলি xগুলি এর সাথে প্রতিস্থাপন করতে হবে এবং ফলাফলটি মুদ্রণ বা প্রত্যাবর্তন করতে হবে।

সুতরাং, উপরের উদাহরণের জন্য আউটপুট হবে:

x2 45
xx2xx
  2xx
    1
2 899

এখানে আরও একটি পরীক্ষার কেস দেওয়া হয়েছে (মার্টিন এন্ডারকে ধন্যবাদ):

Input:
2   3
    4
 1  5
111 6
11  7

Output:
2   3
    4
 x  5
xxx 6
xx  7

এই কোড গল্ফ তাই বাইট জিতে সংক্ষিপ্ত কোড!

Comments

সম্পর্কিত। সম্পর্কিত। সম্পর্কিত।

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

বিল্ট-ইনগুলি কি অনুমোদিত?

— আইওননেস

@ জোয়ানস, হ্যাঁ

— ড্যানিয়েল

Answer 1

জাভাস্ক্রিপ্ট (ইএস 6), 171 161 139 137 136 133 132 বাইট

f=(a,i=0)=>(F=i=>" "<c&&a[i]===c&&(a[i]=n,1+F(i-1)+F(i+1)+F(i-6)+F(i+6)),n=1,c=a[i],n=F(i)>2?"x":c,c=1,F(i),i>28?a:f(a,++i+(i%6>4)))

<!-- this HTML included just for testing --><textarea rows=5 cols=6 oninput="document.querySelector`pre`.innerHTML=this.value.length==29?f([...this.value]).join``:'invalid input'">12 45&#10;11233&#10;  233&#10;    1&#10;2 899</textarea><br/><pre></pre>

এটি আমার পাইথন উত্তরের একটি অনুবাদ। চরিত্রের অ্যারে হিসাবে I / O।

খুব খারাপ কিছু করার কোনও কার্যকর উপায় নেই sum...

Answer 2

পাইথন 3, 238 237 200 199 192 181 বাইট

def f(a,i=0):F=lambda i,n,c:29>i>=0!=" "!=a[i]==c!=n and(a.__setitem__(i,n)or-~sum(F(i+j,n,c)for j in[-1,1,-6,6]));j=i+i//5;F(j,[a[j],"x"][2<F(j,1,a[j])],1);i>23or f(a,i+1);return a

একটি ফাংশন সংজ্ঞায়িত করে f(a)যা ইনপুটটিকে অক্ষরের অ্যারে হিসাবে গ্রহণ করে এবং একই অ্যারে সংশোধিত ফিরিয়ে দেয়। ( অক্ষরের অ্যারেগুলি ডিফল্টরূপে স্ট্রিং হিসাবে গ্রহণযোগ্য ))

ব্যাখ্যার সাথে নিরবচ্ছিন্ন

পরিবর্তিত কোডটি পুনরাবৃত্ত, তবে একই কাজ করে।

# The main function; fills all continuous nonempty areas of size >= 3 in array
# with x's. Both modifies and returns array.
def findpaths(array):
    # Fills a continuous area of curr_char in array with new_char, starting
    # from index. Returns the number of cells affected.
    def floodfill(index, new_char, curr_char):
        if (0 <= index < 29                   # Check that the position is in bounds
                and (index + 1) % 6 != 0      # Don't fill newlines
                and array[index] != " "       # Don't fill empty cells
                and array[index] == curr_char # Don't fill over other characters
                and curr_char != new_char):   # Don't fill already filled-in cells
            array[index] = new_char # Fill current position
            return (1 # Add neighboring cells' results, plus 1 for this cell
                    + floodfill(index + 1, new_char, curr_char)  # Next char
                    + floodfill(index - 1, new_char, curr_char)  # Previous char
                    + floodfill(index + 6, new_char, curr_char)  # Next line
                    + floodfill(index - 6, new_char, curr_char)) # Previous line
        return 0 # Nothing was filled. The golfed solution returns False here,
                 # but that's coerced to 0 when adding.

    for i in range(25): # Loop through the 25 cells
        i += i // 5 # Accommodate for newlines in input
        curr_char = array[i] # Get the cell's contents
        # Fill the area from the cell with dummies
        area_size = floodfill(i, 1, curr_char)
        # Convert dummies to "x" if area was large enough, back to original otherwise
        fill_char = "x" if 2 < area_size else curr_char
        floodfill(i, fill_char, 1)
    return array

Comments

ম্যাথমেটিক সমাধানটি হারিয়ে 2 বাইট

— ছাড়ুন

@ ফ্লিপট্যাক হ্যাঁ আমি মনে করি না এটি আজ ঘটছে, তবে আমি এটি জেএস-এ অনুবাদ করছি এবং এটি আশাব্যঞ্জক বলে মনে হচ্ছে।

— পূর্বকোদাডারি

Answer 3

রুবি, 304 বাইট

def b(s,i)
  @v=[]
  b2(s,i,s[i])
end
def b2(s,i,c)
  if(0...s.size)===i&&s[i]==c&&!@v[i]
    @v[i]=s[i]='x'
    [1,-1,6,-6].each{|j|b2(s,i+j,c)}
  end
  s
end
def f(s)
  z = s.dup
  ps = ->(i){b(z.dup,i).scan('x').size}
  (0...s.size).each{|i|b(s, i)if ![' ',"\n"].include?(s[i])&&ps.call(i)>2}
  s
end

উদাহরণস্বরূপ ব্যবহার:

puts f(File.read("map.txt"))

কোডটি 'ব্লট' পদ্ধতিটিকে পুনরায় ব্যবহার করে পাথের দৈর্ঘ্য গণনা করে।

ভেরিয়েবল / পদ্ধতি:

• চ (গুলি): মানচিত্রের স্ট্রিং রূপান্তর করতে ফাংশন, 'এক্স এর সাথে নতুন মানচিত্রটি ফেরত দেয়
• PS (i): মানচিত্রের সূচী থেকে পথের আকার i (যেখানে x = i% 6, y = i / 6)
• গুলি: ইনপুট স্ট্রিং, মানচিত্রের লাইনগুলি "\ n" দ্বারা পৃথক করা হয়েছে
• z: ইনপুট স্ট্রিংয়ের অনুলিপি
• বি (গুলি, আই): 'ব্লট' ফাংশন: মানচিত্র সূচী থেকে 'এক্স' লিখেছেন পথগুলিতে
• @v: 'পরিদর্শন করা' অ্যারে

আরও বিশদ ব্যাখ্যায় চেষ্টা করুন:

ইনপুট স্ট্রিংয়ের একটি অনুলিপি তৈরি করুন, যা আমরা মানচিত্রের যে কোনও নির্দিষ্ট বিন্দু থেকে পথের দৈর্ঘ্য সন্ধান করতে ব্যবহার করি।

z = s.dup

একটি 'পিএস' (পথের দৈর্ঘ্য) বেনামে ফাংশন (ল্যাম্বদা) সংজ্ঞায়িত করুন যা মানচিত্র সূচীটিকে আর্গুমেন্ট হিসাবে গ্রহণ করে। এটি সেই বিন্দু থেকে পথের দৈর্ঘ্য ফেরৎ দেয়। এটি আসল মানচিত্রের অনুলিপিটিতে x সন্নিবেশ করানোর জন্য 'বি' (ব্লট) পদ্ধতিটি কল করে এবং তারপরে ফিরে আসা স্ট্রিংয়ে x এর সংখ্যা গণনা করে এটি করে।

  ps = ->(i){b(z.dup,i).scan('x').size}

নিম্নলিখিত অংশটি মানচিত্রে প্রতিটি অক্ষরের উপরে পুনরাবৃত্তি করে (সূচি i, অক্ষরের s [i])। এটি মানচিত্রের অবস্থানটিতে 'বি' (ব্লট) ফাংশনটিকে কল করে যদি আমি অবস্থান থেকে পথের দৈর্ঘ্য 2 এর চেয়ে বেশি হয় এবং যদি এটি কোনও স্থান বা নিউলাইন অক্ষর না হয়।

  (0...s.size).each { |i|
     b(s, i) if ![' ',"\n"].include?(s[i]) && ps.call(i) > 2
  }

বি (ব্লট) ফাংশনটি মানচিত্রের স্ট্রিং এবং একটি সূচককে যুক্তি হিসাবে গ্রহণ করে। এটি @v (পরিদর্শন করা অ্যারে) আরম্ভ করে এবং বি 2 সহায়ক ফাংশনটি কল করে।

def b(s,i)
  @v=[]
  b2(s,i,s[i])
end

বি 2 ফাংশনটি মানচিত্রের স্ট্রিং, একটি মানচিত্রের অবস্থান (i) এবং বর্তমান পথে (সি) একটি অক্ষর গ্রহণ করে। এটি সংখ্যার সংযুক্ত বিভাগগুলিকে 'x' অক্ষরের সাথে প্রতিস্থাপন করতে পুনরাবৃত্তি বলে। এটি ইনপুট স্ট্রিংটি ফেরত দেয় (এটি তাই পিএস ফাংশন রিটার্ন মূল্যে স্ক্যান কল করতে পারে)।

এটি যদি বিবৃতিটি যাচাই করে থাকে যে প্রদত্ত মানচিত্রের অবস্থান (i) স্ট্রিংয়ের (0 ... s.size) সীমানার মধ্যে রয়েছে এবং s [i] এর অক্ষরটি শুরুর চরিত্রের সমান। এছাড়াও @v [i] অনন্ত পুনরাবৃত্তি এড়াতে চেক করা হয়।

if(0...s.size) === i && s[i] == c && !@v[i]

এটি বিট যা সূচকে অক্ষরের পরিবর্তে (i) 'x' অক্ষর দিয়ে থাকে। এটি পরিদর্শন করা হিসাবে সূচক চিহ্নিত করে।

@v[i] = s[i] = 'x'

এখান থেকে বি 2 নিজেকে পুনরাবৃত্তভাবে পথের সন্ধান করে calls i + 1 ডানদিকে একটি অক্ষর, আই -1 বাম দিকে একটি অক্ষর, i + 6 এক সারি নীচে (5 অঙ্ক + 1 নিউলাইন = 6 অক্ষর), আই -6 এক সারি উপরে।

[1,-1,6,-6].each { |j| b2(s, i+j, c) }

Answer 4

সি (আনসি), 243 233 179 188 বাইট

Golfed:

#define O o[1][l]
x,n,l,L;r(o,l)char**o;{if(!(l>L|l<0|O<47|O!=x))n++,O++,r(o,l-1),r(o,l+6),r(o,l-6),r(o,l+1),n>2?O='x':O--;}main(g,o)char**o;{for(;(L=30)>l;l++)n=0,x=O,r(o,l);puts(o[1]);}

টিকা সহ:

#define O o[1][l]
x,n,l,L;      /*-------------------------- Globals*/
r(o,l)char**o;{ /*------------------------ Recursive Function*/
    if(!(l>L|l<0|O<47|O!=x)) /*----------- if this cell is valid(in
                                              range, is a number, is the 
                                              same as the parent number*/
    n++,     /*--------------------------- Increment count*/
    O++,     /*--------------------------- Increment character to mark*/
    r(o,l-1),  /*------------------------- Recurse left*/
    r(o,l+6),  /*------------------------- Recurse down*/
    r(o,l-6),  /*------------------------- Recurse down*/
    r(o,l+1),  /*------------------------- Recurse right*/
    n>2?O='x':O--;  /*---------------------If greater than 3, replace with x, else decrement character*/ 
}          /*----------------------------- Return*/

main(g,o)char**o;{ /*--------------------- Main*/
    for(;l<(L=30);l++){ /*---------------- For entire string and set L*/
        n=0;
        x=O;        /*-------------------- set counter to 0*/
        r(o,l); /*------------------------ Recurse*/
    } /*---------------------------------- End While*/
    puts(o[1]); /*------------------------ Print*/

}

ইনপুট:

স্ট্রিংয়ের শুরু এবং শেষের দিকে একটি নতুন লাইন আশা করে।

উদাহরণ ইনপুট:

./findPaths "
12 45
11233
  233
    1
2 899
"

উদাহরণ আউটপুট:

x2 45
xx2xx
  2xx
    1
2 899

হালনাগাদ

গ্রিড স্থির করে তোলার ফলে আমার প্রায় 60 বাইট ছাঁটাই করতে দেওয়া হয়েছিল।

Comments

আমার ধারণা আমি এটি 22 টি চরিত্রের মতো সংরক্ষণ করতে পারব যদি আমি এটির পরিবর্তনের মানচিত্রের আকারে পরিবর্তন করি - তবে আমি পরিবর্তন করব যে আমি যদি অন্য কিছু পরিবর্তন করতে চাই তবে আমি পরিবর্তন করব

— dj0wns

Answer 5

ম্যাথমেটিকা, 180 বাইট

(f=Flatten@#;p=Partition)[If[Tr[1^VertexComponent[r~Graph~Cases[##&@@p[#,2,1]&/@Join[g=p[r,5],g],{a_,b_}/;(A=f[[a]])==f[[b]]&&A!=" ":>a<->b],#]]<3,f[[#]],"x"]&/@(r=Range@25),5]&

ব্যাখ্যা:

(f=Flatten@#;p=Partition)[
  If[
    Tr[1^VertexComponent[
        r~Graph~Cases[
          ##&@@p[#,2,1]&/@Join[g=p[r,5],g],
          {a_,b_}/;(A=f[[a]])==f[[b]]&&A!=" ":>a<->b
        ],
        #
      ]]<3,
    f[[#]],
    "x"
  ]&/@(r=Range@25),
  5
]&

খাঁটি ফাংশন যা একটি 5x5অ্যারে গ্রহণ করে । পোস্টফিক্স ট্রান্সপোজ অপারেটরের প্রতিনিধিত্বকারী 3-বাইট প্রাইভেট-ব্যবহারের চরিত্র ।U+F3C7\[Transpose]

(f=Flatten@#;p=Partition): ইনপুট তালিকাটি ফ্ল্যাট করে এবং এতে সঞ্চয় করে f। সেট করে p = Partitionএটি ফেরত দেয়।

g=p[r,5]: অ্যারে {{1,2,3,4,5}, ..., {21,22,23,24,25}}(এটি rসেট হয়ে যায় বলে Range@25)।

Join[g=p[r,5],g]: সারি এবং কলামগুলির তালিকা g।

p[#,2,1]&: খাঁটি ফাংশন যা ওভারল্যাপ সহ #দৈর্ঘ্যের সাবলিস্টগুলিতে তালিকাটি ভাগ করে ; যেমন, সংলগ্ন জোড়গুলির তালিকা ।21#

##&@@p[#,2,1]&: উপরের মত একই হিসাবে এটি প্রদান করে a Sequence।

##&@@p[#,2,1]&/@Join[g=p[r,5],g]: মানচিত্র সারি এবং কলাম-এর পূর্ববর্তী ফাংশন gমধ্যে সংলগ্ন এন্ট্রির সব একটি তালিকা প্রাপ্ত করার g। আমার অন্ত্রে বলছে এটি করার একটি ছোট উপায় আছে।

r~Graph~Cases[...]: গ্রাফ যার শীর্ষস্থানগুলি পূর্ণসংখ্যা 1, ..., 25এবং যার প্রান্তগুলি সংলগ্ন প্রবেশের মধ্যবর্তী প্রান্তগুলি gযেখানে ইনপুট অ্যারেতে একই সংযুক্ত এন্ট্রি রয়েছে (ব্যতীত " ")

{a_,b_}/;(A=f[[a]])==f[[b]]&&A!=" ": প্যাটার্ন যা মিলে যায় {a,b}যেমন যে f[[a]] == f[[b]](ইনপুট অ্যারের মধ্যে একই মান) এবং যা সমান নয় " "। বাইট A = f[[a]]সংরক্ষণ করতে সেট করুন 1।

...:>a<->b: প্রতিটি ম্যাচকে অপরিবর্তিত প্রান্ত থেকে a থেকে b এ প্রতিস্থাপন করুন।

VertexComponent: প্রথম আর্গুমেন্টে (একটি গ্রাফ) দ্বিতীয় আর্গুমেন্টের একটি সংযুক্ত উপাদানটি (একটি গ্রাফ) প্রদান করে।

Tr[1^VertexComponent[...]]: সংযুক্ত উপাদানটির আকার। 1থেকে বাইট সংরক্ষণ করে Length@VertexComponent[...]।

If[Tr[...]<3,f[[#]],"x"]&: বিশুদ্ধ ফাংশন যা একটি এন্ট্রি লাগে #মধ্যে g। যদি এর সাথে সংযুক্ত উপাদানটির আকার কম 3হয় তবে এটি ইনপুটটিতে সংশ্লিষ্ট এন্ট্রি দিয়ে প্রতিস্থাপন করুন। অন্যথায়, এটি দিয়ে প্রতিস্থাপন করুন "x"।

(f=Flatten@#;p=Partition)[...,5]: এবং পরিশেষে ফলাফলটিকে একটি 5x5অ্যারে হিসাবে পুনরায় আকার দিন ।

Answer 6

ক্লোজার, 188 বাইট

এটি যথেষ্ট অপ্রতিরোধ্য: ডি

#(apply str(map-indexed(fn[i v](if((set(flatten(for[m(range 30)](let[n(for[p[-1 -6 1 6]:when(=(get %(+ m p)0)((set"123456789")(% m)))](+ m p))](if(< 1(count n))(conj n m)[])))))i)\x v))%))

এই নামে পরিচিত (এটি অক্ষরের 1D ভেক্টর লাগে):

(def f #(apply str(...))

(print (str "\n" (f (vec (str "12 45\n"
                              "11233\n"
                              "  233\n"
                              "    1\n"
                              "2 899\n")))))

(print (str "\n" (f (vec (str "2   3\n"
                              "    4\n"
                              " 1  5\n"
                              "111 6\n"
                              "11  7\n")))))

এটি অলগল্ফ করতে খুব অলস তবে মূলত for[m(range 30)]প্রতিটি সূচকটি পরিদর্শন করে এবং প্রতিটি সূচকের জন্য অভ্যন্তরীণ let[n(for[p[-1 -6 1 6]...(+ m p))]0 থেকে 4 টি উপাদানের একটি তালিকা তৈরি করে যা স্থানগুলির তালিকা করে যা মাঝের অবস্থান হিসাবে একই মান (1 - 9) ছিল। যদি 1 টিরও বেশি প্রতিবেশী মাঝের টুকরোটির সাথে মেলে তবে এর অর্থ এই সমস্তগুলি একটি ক্লাস্টার তৈরি করে, সুতরাং সেই অবস্থানগুলি ব্যবহৃত সেটটিতে যুক্ত করা হয় (if((set(flatten(...)))i)। যদি সূচকটি iসেট থেকে পাওয়া যায় তবে \xনির্গত হয় এবং অন্যথায় আসল মান। যে :when( ... )বেশ আকর্ষণীয় ...