ইতিবাচক পূর্ণসংখ্যার বাছাই করে হত্যা করুন

Question

ভূমিকা

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

ইনপুট বিবরণ

এসটিডিআইএন, কমান্ড লাইন আর্গুমেন্ট বা কোনও ব্যবহারকারী ইনপুট ফাংশন (যেমন raw_input) এর মাধ্যমে ইনপুট দেওয়া হয় । আপনার এটি কোনও ফাংশন আর্গুমেন্ট বা প্রাক-পূর্বনির্ধারিত ভেরিয়েবল হিসাবে থাকতে পারে না (যেমন এই প্রোগ্রামটি একটি ভেরিয়েবলের ইনপুট আশা করে expx )।

ইনপুটটির প্রথম লাইনে একটি একক ধনাত্মক পূর্ণসংখ্যা থাকে nযেখানে 8 >= n >= 3। সেগুলি অনুসরণ করে সেট থেকে nবর্ণগুলি সমেত লাইন রয়েছে । এখানে একটি উদাহরণ ইনপুট:n[1,2,3,4,5,6,7,8,9]

5
22332
46351
65455
24463
65652

আউটপুট বিবরণ

ওয়ার্ডেনগুলি সংখ্যাগুলি সরিয়ে দিতে চাই যাতে নিম্নলিখিত শর্তগুলি মেটানো যায়:

• ফলস্বরূপ গ্রিডের প্রতিটি সারি এবং কলামে, কোনও সংখ্যা দু'বার প্রদর্শিত হবে না;
• কোনও দুটি বর্ধিত সংখ্যা অনুভূমিক বা উল্লম্বভাবে সংলগ্ন হতে পারে না;
• বেঁচে থাকা সংখ্যার অবশ্যই একটি orthogonally স্বতঃস্ফূর্ত গ্রুপ গঠন করতে হবে - যে কোনও বেঁচে থাকা সংখ্যার থেকে অন্য কোনও বেঁচে থাকা সংখ্যায় কেবল অনুভূমিকভাবে এবং উল্লম্বভাবে চলতে এবং কোনও বর্ধিত সংখ্যা কখনই অতিক্রম করা সম্ভব হবে।

আউটপুট ইনপুট (প্রথম লাইন বিয়োগ), প্রতিস্থাপন সংখ্যার সাথে প্রতিস্থাপন করুন # ।

একাধিক সমাধান হতে পারে। যদি এটি হয় তবে আপনি কোনও সমাধান আউটপুট করতে পারেন।

এর কোনও সমাধানও হতে পারে না। যদি এটি হয় তবে স্ট্রিং আউটপুট করুনno answer ।

উদাহরণ ইনপুট জন্য এখানে একটি সম্ভাব্য আউটপুট:

#2#3#
46351
6#4#5
24#63
#56#2

উদাহরণ ইনপুট এবং আউটপুট

প্রতিটি ইনপুট জন্য একাধিক আউটপুট আছে, তাই এই আউটপুট কেবল উদাহরণ।

ইনপুট:

5
46551
51565
32654
14423
43244

আউটপুট:

46#51
#156#
326#4
1#423
#324#

ইনপুট:

7
7183625
1681563
5238564
8786268
1545382
3814756
5325345

আউটপুট:

71#362#
#6815#3
5238#64
#7#62#8
154#382
3814756
#325#4#

ইনপুট:

8
21534768
75196287
68392184
96244853
44865912
76516647
89751326
43698979

আউটপুট:

21#34768
#5196287
683#21#4
9#24#853
#4865912
7#51#64#
89751326
436#8#7#

ইনপুট:

4
2222
2331
3112
1322

আউটপুট:

no answer

Comments

(এছাড়াও সিঙ্গলস হিসাবে পরিচিত ))

— ডুরকনব

এই ধাঁধা দুর্দান্ত। ধন্যবাদ. একটি সমাধান নিয়ে কাজ করা

— চার্লস

আমি এই ধাঁধাটি পছন্দ করি তবে ব্রাউজারে জাভাস্ক্রিপ্ট ব্যবহার করে "যেমন আছে" তেমন উত্তর দেওয়া যায় না, কারণ একমাত্র ব্যবহারকারী ইনপুট পদ্ধতিটি promptমাল্টি লাইন ইনপুটটিকে মঞ্জুরি দেয় না।

— edc65

Answer 1

রুবি, 346 344 329 316 বাইট, স্লু

এটি কোড-গল্ফ, কোড-ফাস্ট নয়, তাই ...

N=/!/=~G=$*[1..-1]*?!
M=N*N
g=->i{(!G[i]||G[i]<?*||i<0||A[i])&&break
A[i]=0
[1,N+1,-1,-1-N].map{|a|g[i+a]}}
f=->w,a{A=[];g[/\d/=~G=a];/#.{#{N}}?#/!~G&&/(\d)([^!]*|.{#{N}}.{#{O=N+1}}*)\1/!~G&&A.count(0)+w==M&&N.times.map{|m|puts G[m*(1+N),N]}&&exit
(w...M).map{|j|b=a+'';b[j]=?#
w<M&&f[w+1,b]}}
f[0,G]
$><<"no answer"

এটি ব্যবহার করুন:

mad_gaksha@madlab ~/Applications/Tools $ ruby -W0 c50442.rb 3 323 312 231
#23
312
231

পতাকাটি -W0প্রয়োজনীয় নয়, তবে আমি আপনাকে পরামর্শ দিচ্ছি এটি হয় সতর্কতা অক্ষম করতে বা পুনঃনির্দেশ করার জন্য addstderr ...

N = 6,7,8 এর উদাহরণগুলিতে এটি চালানোর যথেষ্ট ধৈর্য থাকলে আমাকে বলুন

পরিবর্তণের

• each ⇨ map , @NotThatCharles ধন্যবাদ
• সংলগ্ন মুছে ফেলা এবং দুটি দ্বারা একই অঙ্ক পরীক্ষা করুন regexp@ নটট্যাচারেলস প্রস্তাবিত অনুরূপ,
• সামান্য পড়া পড়া ইনপুট
• ছোট এবং ধীর

Comments

আকারে কয়েকটি বর্ধমান উন্নতি: পেনাল্টিমেট লাইনের \dচেয়ে কম [^#]; M.times.to_aএর চেয়ে দীর্ঘ(0..M-1).to_a

— চার্লস

টিপস জন্য ধন্যবাদ! তবে M.times.to_a1 বাইটের চেয়ে কম(0..M-1).to_a ;) (0...M).to_aখুব বেশি কাজ করে এবং এটি একই দৈর্ঘ্যের।

— ব্লুটোরেঞ্জ

... গণনা শক্ত

— চার্লস

এটি আসলে সম্পূর্ণ হয় যখন এন = 8?

— চার্লস

@ নোটহ্যাটচর্লস যদি আপনি যথেষ্ট দীর্ঘক্ষণ অপেক্ষা করেন বা একটি সুপার-ফাস্ট পিসি ব্যবহার করেন, হ্যাঁ, এটি করা উচিত। এটি গতি হিসাবে কোনও বিধিনিষেধ ছাড়াই একটি কোড-গল্ফ, তাই আমি কোড-দৈর্ঘ্যটিকে

— প্রাধান্য দিয়েছি

Answer 2

রুবি - 541 ..., 394

বেসিক অ্যালগরিদম হ'ল সুনির্দিষ্টভাবে নির্বাচনের জন্য ডুপ্লিকেটগুলির পুনরাবৃত্তিমূলক গভীরতা-প্রথম অনুসন্ধান, সারি 1, তারপরে কলাম 1, তারপর সারি 2, ইত্যাদির সন্ধান এবং দুটি প্রতিবেশী নিহত হয়নি এবং গ্রিড সংযুক্ত রয়েছে কিনা তা পরীক্ষা করে দেখছেন (এটিই break ifধারাটিতে রয়েছে সেখানে এবং কিছুটা আগে এটি উপস্থিত হবে)।

K=(0...(N=gets.to_i)*N).to_a
J=gets(p).split*''
H=->m{K&[m+1,m-1,m+N,m-N]}
Q=->k{s=[k[j=0]]
(j=s.size
s.map{|x|(s+=H[x]&k).uniq!})while s[j]
break if(K-k).any?{|m|(H[m]-k)[0]}||k!=k&s
$><<K.map{|m|[k.index(m)?J[m]:?#,m%N>N-2?"
":p]}*''|exit if !g=((0...N*2).map{|x|(k.select{|m|m.divmod(N)[x/N]==x%N}.group_by{|m|J[m]}.find{|l,c|c[1]}||[])[1]}-[p]).min
g.map{|d|Q[k-g<<d]}}
Q[K]
puts"no answer"

কিছু ঝরঝরে কৌশল:

if w[1]এর চেয়ে অনেক ছোট if !w.one?এবং যদি আপনি জানেন যে কমপক্ষে একজন সদস্য আছেন তবে এটি একই ফলাফল।

একইভাবে, যদি কোনও ব্লক না থাকে তার [0]চেয়ে সংক্ষিপ্ত any?এবং s[j]এটি একটি সুন্দর শর্টকাট j<s.size(প্রযুক্তিগতভাবে এটি আরও বেশি পছন্দ করেj.abs<s.size )

এবং এর y%N+(y/N).iচেয়ে অনেক খাটোComplex(y%N,y/N)

এছাড়াও, যখন স্ট্রিং উত্পন্ন করার জন্য দুটি জটিল শর্ত রয়েছে তখন [cond1?str1a:str1b,cond2?str2a:str2b]*''সমস্ত প্যারেন বা #{}এস যুক্ত করার চেয়ে কম করা কম ।

অবহেলা এবং ব্যাখ্যা:

(এটি 1৩১ বাইট সংস্করণ থেকে I've পূর্ণসংখ্যা। সমস্ত স্থানাঙ্ক কেবলমাত্র পূর্ণসংখ্যা))

H প্রতিবেশীদের গণনা করে

def H m 
  # m, like all indices, is a complex number 
  #    where the real part is x and the imaginary is y
  # so neighbors are just +/-i and +/-1

  i='i'.to_c
  neighborhood = [m+1, m-1, m+i, m-i]

  # and let's just make sure to eliminate out-of-bounds cells
  K & neighborhood
end

N গ্রিডের আকার

N = gets.to_i

K মানচিত্রের কী (জটিল সংখ্যা)

# pretty self-explanatory
# a range of, e.g., if N=3, (0..8)
# mapped to (0+0i),(1+0i),(2+0i),(0+1i),(1+1i),(2+1i),...
K = (0..N**2-1).map{|y| (y%N) +(y/N).i }

J ইনপুট মানচিত্র (জেল)

# so J is [[0+0,"2"],[0+1i,"3"],....].to_h
J=K.zip($<.flat_map {|s|
  # take each input line, and...
  # remove the "\n" and then turn it into an array of chars 
  s.chomp.chars
}).to_h

k নিহত না কী

# starts as K

Q প্রধান recursive পদ্ধতি

def Q k
  j=0 # j is the size of mass
  # the connected mass starts arbitrarily wherever k starts
  mass=[k[0]]
  while j < s.size # while s hasn't grown
    j = mass.size   
    mass.each{|cell|
      # add all neighbors that are in k
      (mass+=H[cell] & k).uniq!
    }
  end
  # if mass != k, it's not all orthogonally connected
  is_all_connected = k!=k&mass

  # (K-k) are the killed cells 
  two_neighbors_killed = (K-k).any?{|m|
    # if any neighbors of killed cells aren't in k,
    # it means it was killed, too 
    (H[m]-k)[0]
  }
  # fail fast
  return if two_neighbors_killed || is_all_connected

  def u x
    x.group_by{|m|J[m]}.select{|l,c|c[1]}
  end

  rows_with_dupes = Array.new(N){|r|u[k.select{|m|m.imag==r}]}

  cols_with_dupes = Array.new(N){|r|u[k.select{|m|m.real==r}]}

  # dupes is an array of hashes
  # each hash represents one row or column.  E.g.,
  #   {
  #     "3"=>[(0+0i),(1+0i),(3+0i)],
  #     "2"=>[(2+0i),(4+0i)]
  #   }
  # means that the 0th, 1st and 3rd cells in row 0
  # all are "3", and 2nd and 4th are "2".
  # Any digits without a duplicate are rejected.
  # Any row/col without any dupes is removed here.
  dupes = (rows_with_dupes+cols_with_dupes-[{}])

  # we solve one row at a time
  first_row = dupes[0]

  if !first_row
    # no dupes => success!
    J.map{|m,v|k.member?(m)?v:?#}.each_slice(N){|s|puts s*''}
    exit
  else
    # the digit doesn't really matter
    t=first_row.values

    # cross-multiply all arrays in the row to get a
    # small search space. We choose one cell from each
    # digit grouping and drop the rest.
    t.inject(:product).map{ |*e|
      # Technically, we drop all cells, and add back the
      # chosen cells, but it's all the same.
      new_k = k-t.flatten+e.flatten

      # and then search that space, recursively
      Q[new_k]
    }
  end
end

কোডটি দিয়ে সম্পাদিত হয়:

# run with whole board
Q[K]

# if we get here, we didn't hit an exit, so we fail
puts"no answer"

পরিবর্তণের

394 নীচে @ ব্লুটোরেঞ্জের পরামর্শ যুক্ত করেছেন এবং আরও অনেকগুলি হেরফের কাটাচ্ছেন

408 আরও একবার সংশোধিত আউটপুট। আমি যেভাবে যাই হোক না কেন কেবল একটি সারি নিচ্ছি তার .minপরিবর্তে এটি ব্যবহার করুন .inject(:+)।

417 স্বল্প আউটপুট গণনা

421 জটিল সংখ্যা বাদ দিয়েছে। শুধু পূর্ণসংখ্যা ব্যবহার করুন। একটি বান্ডিল সংরক্ষণ করুন

আরও 450 ইনপুট উন্নতি

456 ইনপুট উন্নতি

462 ইনক্রিমেন্টাল উন্নতি - esp। find, নাselect

475 বাদ পড়েছে uএবং সারি / কর্ন ডুপ বিল্ডারকে স্কোয়াশ করেছে

503 একবারে সারি / কলামে কেবল একটি সদৃশ অঙ্ক সমাধান করুন।

map &:popপরিবর্তে 530 ব্যবহার করুনvalues

531 ল্যাম্বডাকে টেনে আনুন যা দুপাশগুলিকে অ্যারে করে তোলে

552 উফ! একটি প্রয়োজন মিস

দুপস অ্যারের 536 প্রান্তিক উন্নত জনসংখ্যা (আগে যা ছিল d)

541 প্রাথমিক

Comments

ল্যাম্বডাসের ভিতরে, breakপরিবর্তে ব্যবহার করা returnযেতে পারে, আরও একটি বাইট সংরক্ষণ করতে পারে। আমি এটিকে সত্যিই পছন্দ করি, প্রচুর কৌশল এবং আরও দ্রুত।

— ব্লুটোরেঞ্জ

@ ব্লুটোরেঞ্জ ধন্যবাদ! প্রয়োগ করা হয়েছে। 344 টি আঘাত হানতে এখনও উপায় আছে, যদিও।

— চার্লস

কিছুটা দীর্ঘ, হ্যাঁ, তবে অন্যথায় এটি ভালভাবে দেখায়। আমি আরও একটি জিনিস দেখেছি: দ্বিতীয় লাইনে যেমন ভেরিয়েবলটি aএকবার ব্যবহৃত হয়, আপনি এটি তৈরি করতে পারেন J=gets(p).split*''। আপনি কি ক্লাইট যুক্তি দিয়ে চেষ্টা করেছেন, আমার উত্তর দেখুন?

— ব্লুটোরেঞ্জ

Answer 3

এইচটিএমএল + জাভাস্ক্রিপ্ট ( ES6) ) 459

মাল্টলাইন ইনপুট পেতে একটি এইচটিএমএল পাঠ্য ব্যবহার করা।

পরীক্ষা করতে, ফায়ারফক্সে স্নিপেট চালান। যদি আপনি পছন্দ করেন তবে টেক্সারিয়াকে বড় করুন, টেক্সারিয়ার ভিতরে ইনপুটটি আটকে দিন (সাবধান: সঠিক ইনপুট, কোনও লাইনে কোনও অতিরিক্ত স্পেস নেই) এবং ট্যাব দূরে। ফলাফল সংযুক্ত করা হয়।

পদ্ধতি: একটি পুনরাবৃত্তির গভীরতা প্রথম সেরারচ। এটি সেকেন্ডে সমস্ত পরীক্ষার ক্ষেত্রে অ-অনুকূল সমাধানগুলি সন্ধান করে (এটি গল্ফ গল্ফ, তবে সাধারণ পরীক্ষার ক্ষেত্রে একটি কার্যকর উত্তর শেষ হওয়া উচিত )

<textarea onchange="s=this.value,
  z=s[0],o=-~z,k=[],X='no answer',f='#',
  (R=(s,t,h={},r=[],d=0)=>(
    s.map((v,i)=>v>0&&[i%o,~(i/o)].map(p=>h[p+=v]=[...h[p]||[],i])),
    [h[i][1]&&h[i].map(p=>r[d=p]=p)for(i in h)],
    d?r.some(p=>(
      (s[p+o]!=f&s[p-o]!=f&s[p-1]!=f&s[p+1]!=f)&&
      (
        g=[...s],g[p]=f,e=[...g],n=0,
        (F=p=>e[p]>0&&[1,-1,o,-o].map(d=>F(p+d),e[p]=--n))(p<o?p+o:p-o),
        t+n==0&&!k[g]&&(k[g]=1,R(g,t-1))
      )
    )):X=s.join('')
  ))([...s.slice(2)],z*z-1),this.value+=`

`+X"></textarea>

প্রথম চেষ্টা

পদ্ধতি: একটি ব্যবহারকারী স্ট্যাক ব্যবহার করে একটি ডিপথ ফার্স্ট সেরার্চ, পুনরাবৃত্তিমূলক।
ফাংশনটি সহজেই একটি প্রস্থের প্রথম অনুসন্ধানে রূপান্তরিত হতে পারে, তাড়া l.popকরে l.shift, তাই স্ট্যাকের পরিবর্তে একটি সারি ব্যবহার করে, তবে এটি খুব ধীর এবং আমি নিশ্চিত নই যে এটি যেভাবে কোনও অনুকূল সমাধান খুঁজে পেতে পারে can

S=s=>{
  z=s[0],o=-~z,s=[...s.slice(2)];
  k=[];
  l=[[z*z,s]];

  for(d=1;d&&(t=l.pop());)
  {
    [t,s]=t,--t,

    s.map((v,i)=>v>0&&[i%o,~(i/o)].map(p=>h[p+=v]=[...h[p]||[],i]),h={},r=[])

    d=0
    for(i in h)h[i][1]&&h[i].map(p=>r[d=p]=p)

    r.map(p=>
      (s[p+o]!='#'&s[p-o]!='#'&s[p-1]!='#'&s[p+1]!='#')&&
      (
        g=[...s],g[p]='#',
        f=[...g],n=0,
        (F=p=>f[p]>0&&[1,-1,o,-o].map(d=>F(p+d),f[p]=--n))(p<o?p+o:p-o),
        t+n||k[g]||(k[g]=l.push([t,g]))
      )
    )
  }
  return d?'no answer':s.join('')
}

// TEST
cases=[
 ['5\n22332\n46351\n65455\n24463\n65652','#2#3#\n46351\n6#4#5\n24#63\n#56#2']
,['5\n46551\n51565\n32654\n14423\n43244','46#51\n#156#\n326#4\n1#423\n#324#']
,['7\n7183625\n1681563\n5238564\n8786268\n1545382\n3814756\n5325345'
 ,'71#362#\n#6815#3\n5238#64\n#7#62#8\n154#382\n3814756\n#325#4#']
,['8\n21534768\n75196287\n68392184\n96244853\n44865912\n76516647\n89751326\n43698979'
 ,'21#34768\n#5196287\n683#21#4\n9#24#853\n#4865912\n7#51#64#\n89751326\n436#8#7#']  
,['4\n2222\n2331\n3112\n1322','no answer']
]

  var out = ''
  var nt=0
  var exec =_=>{ 
    var t=cases[nt++];
    if (t) {
      var r = S(t[0]).replace(/#/g,'<b>#</b>');
      var k = t[1].replace(/#/g,'<b>#</b>');
      out += '<tr><th>Input<th>Result<th>Expected</tr>'+
      '<tr><td>'+t[0]+'</td><td>'+r+'</td><td>'+k+'</td></tr>';
      T.innerHTML = out + 'test ' + nt + ' done';
      setTimeout(exec, 100);
    }
    else
    {
      T.innerHTML = out;
    }
  }
  T.innerHTML = "...wait ..."
  setTimeout(exec, 100);  

table {
  font-size: 12px;
}
td {
  font-family: monospace;
  white-space: pre;
  vertical-align: bottom;
  margin: 2x 4px;
}

b {
  color: #ccc;  
}

<table id=T>
</table>