ব্যাকটিরিয়া সম্প্রসারণ

25

ব্যাকটিরিয়ার উপনিবেশগুলি সমান-ব্যবধানযুক্ত কোষগুলির একটি বিভাগে লাইভের 1মাধ্যমে লেবেলযুক্ত 9, খালি কোষ দ্বারা নির্দেশিত0

0 0 2 0 0 0 1 2 0 0 3 3 0 0

প্রতি সেকেন্ডে, প্রতিটি কলোনি সংলগ্ন খালি কোষে ছড়িয়ে পড়ে। যদি দুটি কলোনিগুলি একই সময়ে একটি খালি ঘরে পৌঁছে যায় তবে বৃহত্তর-লেবেলযুক্ত কলোনী এটি নেয়।

t=0:  0 0 2 0 0 0 1 2 0 0 3 3 0 0
t=1:  0 2 2 2 0 1 1 2 2 3 3 3 3 0
t=2:  2 2 2 2 2 1 1 2 2 3 3 3 3 3

উপনিবেশগুলি সীমানা ছাড়িয়ে ছড়িয়ে যেতে পারে না। একটি উপনিবেশ অন্য কলোনী দ্বারা কখনই বাস্তুচ্যুত হয় না, তাই সমস্ত খালি ঘরগুলি পূরণ হয়ে গেলে, আর কিছুই পরিবর্তন হয় না।

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

সম্পর্কিত: একটি তালিকায় শূন্যগুলি আবরণ করুন । (উপনিবেশগুলি কেবল ডানদিকে ছড়িয়ে পড়ে))

পরীক্ষার কেস: ইনপুট নীচে আউটপুট।

0 0 2 0 0 0 1 2 0 0 3 3 0 0
2 2 2 2 2 1 1 2 2 3 3 3 3 3

7 0 3 0 0 0 0 0 8 0 9 1
7 7 3 3 3 8 8 8 8 9 9 1

5 0 3 0 0 0
5 5 3 3 3 3

7 7 1
7 7 1

1 0 1
1 1 1

কোড স্নিপেট দেখান

code-golf  cellular-automata 
— xnor
সূত্র

উত্তর:

14

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

a=>a.map(_=>a=a.map((c,i)=>c||Math.max(a[i-1]|0,a[i+1]|0)))&&a

ব্যাখ্যা

a=>                 // a = input as array of numbers
  a.map(_=>         // loop for the length of a, this ensures the end is always reached
    a=a.map((c,i)=> // update a after to the result of t, for each cell c of index i
      c||           // keep the cell if it is not 0
        Math.max(   // else set the cell to the max value of:
          a[i-1]|0, //     the previous cell (or 0 if i - 1 less than 0),
          a[i+1]|0  //     or the next cell (or 0 if i + 1 greater than the length of a)
        )
    )
  )
  &&a               // return a

পরীক্ষা

কোড স্নিপেট দেখান

— user81655
সূত্র
10

পাইথ, 18 বাইট

um|@d1eSd.:++0G03Q

পরীক্ষা স্যুট

পূর্ণসংখ্যার একটি তালিকা হিসাবে ইনপুট নেয়।

মূলত, এটি কনভার্জেন্স লুপ, অবধি প্রয়োগ করে u। এটি প্রতিটি কক্ষের সমস্ত তালিকা এবং উভয় পক্ষের দুটি কক্ষের তালিকা তৈরি করে আপডেটটি প্রয়োগ করে তারপরে প্রতিটি জিরোড সেলকে তার প্রতিবেশীদের সর্বাধিকতে আপডেট করে।

um|@d1eSd.:++0G03Q
                      Implicit: Q = eval(input())
u                Q    Apply the following until convergence, starting with G = Q.
           ++0G0      Pad G with zeros on either side.
         .:     3     Form all 3 element substrings.
                      Now, for each element of G, we have a list of the form
                      [previous, current, next]
 m                    Map over this list
  |@d1                The current element, if it's nonzero
      eSd             Else the max of the list.
— isaacg
সূত্র
8

গণিত, 77 বাইট

আলেফালফের //.সমাধানের তুলনায় খুব বেশি প্রতিযোগিতামূলক নয় , তবে আমি সেলুলার-অটোম্যাটা চ্যালেঞ্জের CellularAutomatonউত্তর থাকা উচিত বলে মনে করেছি :

CellularAutomaton[{If[#2<1,Max@##,#2]&@@#&,{},1},{#,0},{{{l=Length@#}},l-1}]&

ফাংশনটি একটি টন প্যারামিটার লাগে ... আসুন তাদের কিছু নাম দিন:

CellularAutomaton[{f,n,r},{i,b},{{{t}},d}]

তারা যা করে তা এখানে:

  • rবিধিটির পরিসীমা হ'ল, এটি আপডেটের জন্য কত প্রতিবেশী বিবেচিত হবে তা নির্ধারণ করে। আমরা প্রতিটি পাশে একটি প্রতিবেশী চাই, তাই আমরা ব্যবহার করি 1।
  • nসাধারণত রঙের সংখ্যা বা তালিকা (বিভিন্ন ঘর ধরণের) হয় তবে আমরা যদি নিয়ম সংখ্যার পরিবর্তে একটি কাস্টম ফাংশন হিসাবে নিয়মটি নির্দিষ্ট করি তবে এটি হওয়া উচিত {}।
  • fআপডেট বিধি নির্ধারণ করা একটি ফাংশন। এটি 3 টি কক্ষে (যদি r = 1) একটি তালিকা নেয় এবং মধ্যকোষের জন্য নতুন রঙ দেয়।
  • iপ্রাথমিক অবস্থা। এটাই ইনপুট।
  • bপটভূমি হয়। যদি এটি দেওয়া না হয়, CellularAutomatonপর্যায়ক্রমিক সীমানা ব্যবহার করে, যা আমরা চাই না। পরিবর্তে ব্যবহার করে 0একটি মৃত সীমানা শর্ত আরোপ করা হয়।
  • tঅনুকরণ করার সংখ্যা। ইনপুট প্রশস্ত হওয়ার চেয়ে আমাদের আরও পদক্ষেপের দরকার নেই, কারণ এর পরে ব্যাকটিরিয়া রূপান্তরিত হবে, তাই t = Length@#। সাধারণত, CellularAutomatonসমস্ত মধ্যবর্তী পদক্ষেপ ফেরত দেয়। আমরা tদুটি তালিকায় মোড়কে এড়াতে পারি ।
  • dআউটপুটটিতে কোন কোষ উপস্থাপন করা হয় তা নির্ধারণ করে। ডিফল্টরূপে, আমরা এমন সমস্ত কক্ষগুলি পেতাম যা সম্ভাব্যভাবে নিয়ম দ্বারা প্রভাবিত হতে পারে (যা t*rইনপুটটির উভয় প্রান্তে অতিরিক্ত ঘরগুলি)। আমরা এটি দিয়েছি l-1, কারণ এটি গাণিতিকের কয়েকটি পরিস্থিতিতে একটি যেখানে শূন্য-ভিত্তিক সূচক ব্যবহৃত হয়।
— মার্টিন ইন্ডার
সূত্র
6

হাস্কেল, 86 83 81 79 73 71 বাইট

(0#r)l=max r l
(o#_)_=o
p!_=zipWith3(#)p(0:p)$tail p++[0] 
id>>=foldl(!)

ব্যবহারের উদাহরণ: id>>=foldl(!) $ [7,0,3,0,0,0,0,0,8,0,9,1]-> [7,7,3,3,3,8,8,8,8,9,9,1]।

বোঝানোর মতো বেশি কিছুই নেই: কোনও ঘর 0 হলে প্রতিবেশী উপাদানগুলির সর্বাধিক গ্রহণ করুন take ইনপুট বারের দৈর্ঘ্য পুনরাবৃত্তি করুন। এর জন্য আমি এর xমাধ্যমে পুনরাবৃত্তি করি foldlকিন্তু দ্বিতীয় যুক্তিটিকে এড়িয়ে চলি p।

সম্পাদনা করুন: @ মরিসগুলি সংরক্ষণ করতে 6 বাইট খুঁজে পেয়েছে এবং আরও দু'একটি এক্সরার করেছে। ধন্যবাদ!

— nimi
সূত্র
আপনি প্রতিস্থাপন করতে পারেন h pসঙ্গে p!_তারপর প্রতিস্থাপন (const.h)সঙ্গে (!)6 সংরক্ষণ বাইট।
— লিন
@ মরিস: চালাক অনেক ধন্যবাদ!
— নিমি
@ নিমিমি আমি মনে করি শেষ লাইনটি বেনামে ফেলেছে id>>=foldl(!)।
— xnor
@ এক্সনর: হ্যাঁ! ভাল বিক্ষোভ!
— নিমি
4

সিজেম, 27 24 বাইট

{_,{0\0++3ew{~@e>e|}%}*}

এটি এখানে পরীক্ষা করুন।

এটি একটি নামহীন ব্লককে ধাক্কা দেয় যা স্ট্যাকের একটি তালিকাকে একটি নতুন তালিকায় রূপান্তর করে।

ব্যাখ্যা

_,       e# Duplicate the input and get its length N.
{        e# Run this block N times (convergence won't take that long)...
  0\0++  e#   Wrap the list in two zeroes.
  3ew    e#   Get all sublists of length 3.
  {      e#   Map this block onto each sublist...
    ~    e#     Dump all three elements on the stack.
    @    e#     Pull up the left neighbour.
    e>   e#     Maximum of both neighbours.
    e|   e#     Logical OR between centre cell and maximum of neighbours.
  }%
}*
— মার্টিন ইন্ডার
সূত্র
সাইডস্টেপিং কনভার্জেন্সটি একটি দুর্দান্ত কৌশল
— লুইস মেন্ডো
1
... যা আমি নির্লজ্জভাবে ধার নিয়েছি :-)
— লুইস মেন্ডো
4

জে, 24 23 বাইট

(+=&0*(0,~}.)>.0,}:)^:_

ব্যবহার:

   ((+=&0*(0,~}.)>.0,}:)^:_) 0 1 5 0 0 0 6
1 1 5 5 6 6 6

পদ্ধতিটি মাউরিসের সমাধানের মতো ।

(                  )^:_ repeat until change
               0,}:     concat 0 and tailless input
      (0,~}.)           concat headless input and 0
             >.         elementwise maximum of the former two lists
  =&0*                  multiply by input_is_0 (zeroing out the list at nonzero input positions)
 +                       add to input

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

জগারবকে 1 বাইট সংরক্ষণ করা হয়েছে।

— randomra
সূত্র
3

গণিত, 77 74 66 62 বাইট

মার্টিন বাটনারকে 12 বাইট সংরক্ষণ করা হয়েছে।

#//.i_:>BlockMap[If[#2<1,Max@##,#2]&@@#&,Join[{0},i,{0}],3,1]&
— alephalpha
সূত্র
3

জে, 33 বাইট

3 :'y+(y=0)*>./(_1,:1)|.!.0 y'^:_

আমি পছন্দ করতাম তার চেয়ে কিছুটা দীর্ঘ।

3 :'                         '^:_   Repeat a "lambda" until a fixed point:
                            y         The input to this lambda.
               (_1,:1)|.!.0           Shift left and right, fill with 0.
            >./                       Maximum of both shifts.
      (y=0)*                          Don't grow into filled cells.
    y+                                Add growth to input.
— লিন
সূত্র
আমার কাছে যা আছে তা থেকে এটি আলাদা, আমার মনে হয় আপনার এটি উত্তর হিসাবে পোস্ট করা উচিত :)
— লিন
3

পাইথন 3.5, 83 বাইট

এই ফাংশনটি পূর্ণসংখ্যার একটি পাইথন তালিকা গ্রহণ করে। গল্ফের অনেক কিছু বাকি আছে তা নিশ্চিত নয় তবে আমি এটি অন্য ভাষার সাথে কমদামে প্রতিযোগিতামূলক করে তুলতে চাই!

def b(s):
 for _ in s:s=[s[n]or max((0,*s)[n:n+3])for n in range(len(s))]
 return s

পাইথন 3.5 থেকে, PEP 448 আমাদের আনপ্যাক করতে দেয় sমধ্যে 0,*s। প্রথম প্রকাশে এক বাইট অতিরিক্ত অতিরিক্ত প্রয়োজন:

def b(s):
 for _ in s:s=[s[n]or max(([0]+s)[n:n+3])for n in range(len(s))]
 return s

ব্যবহারকারী 81655 এর সমাধান এবং আমাকে বুঝতে সাহায্য করার জন্য ব্যাখ্যাটির ক্রেডিট যে তালিকাটি পরিবর্তন বন্ধ হয়েছে কিনা তা পরীক্ষা করার দরকার নেই; সমস্ত জিরো অবশ্যই আবৃত হয়েছে তা নিশ্চিত হওয়ার জন্য আমাকে কেবল পর্যাপ্ত সময় পুনরাবৃত্তি করতে হবে। (প্রয়োজনীয় পুনরাবৃত্তির সংখ্যা সংখ্যা তালিকার দৈর্ঘ্যের চেয়ে কম; এটি এর চেয়ে একটি পুনরাবৃত্তি বেশি করে, কারণ এতে কোড কম লাগে))

— টিম পেডারিক
সূত্র
@ChrisH: এটা পাইথন 3.5 এ কাজ করে না, এবং আমি মনে করি না এটা আগে সংস্করণের উপর কাজ করবে পারেন: যে না সরানো returnথেকে ভিতরেfor _ in s লুপ?
— টিম পেডেরিক
মন্তব্য মুছে ফেলা হয়েছে - আমি কেবল পরীক্ষার কেসগুলি চেষ্টা করেছিলাম যা প্রথমবার সমাধান করে।
— ক্রিস এইচ
3

মতলব, 90 বাইট

কিছু কনভলিউশন সম্পর্কে কীভাবে?

x=input('');for n=x;x=x+max(conv(x,[0 0 1],'same'),conv(x,[1 0 0],'same')).*~x;end;disp(x)

উদাহরণ

>> x=input('');for n=x;x=x+max(conv(x,[0 0 1],'same'),conv(x,[1 0 0],'same')).*~x;end;disp(x)
[7 0 3 0 0 0 0 0 8 0 9 1]
     7     7     3     3     3     8     8     8     8     9     9     1
— লুইস মেন্ডো
সূত্র
3

হাস্কেল, 65 66 65 বাইট

f x=[maximum[[-j*j,a]|(j,a)<-zip[-i..]x,a>0]!!1|(i,_)<-zip[0..]x]

এই ফাংশন বলা সংজ্ঞায়িত f।

ব্যাখ্যা

সেলুলার অটোমেটনের পুনরাবৃত্তির পরিবর্তে আমি চূড়ান্ত মানগুলি সরাসরি গণনা করি। সংজ্ঞাটি একটি একক তালিকা অনুধাবন। মানটি iথেকে শুরু 0করে length x - 1, যেহেতু আমরা xপ্রাকৃতিক সংখ্যার সাথে জিপ করি । প্রতিটি সূচকের জন্য i, আমরা 2-উপাদানগুলির তালিকার তালিকা তৈরি করি

[-(-i)^2, x0], [-(-i+1)^2, x1], [-(-i+2)^2, x2], ..., [-(-i+n)^2, xn]

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

— Zgarb
সূত্র
অনুদান জিতে অভিনন্দন!
— xnor
2

লুয়া, 133 বাইট

দুটি লুপ, নেস্টেড টেরেনারি ... আমি যদি আরও গল্ফ করতে চাই তবে আমাকে এটি করার জন্য অন্য একটি উপায় খুঁজে বের করতে হবে, তবে আমি এটি দেখতে পাচ্ছি না।

function f(a)for i=1,#a do b={}for j=1,#a do c,d=a[j+1]or 0,a[j-1]b[j]=0<a[j]and a[j]or(d or 0)>c and d or c end a=b end return a end

ব্যাখ্যা

function f(a)
  for i=1,#a                       -- this loop allow us to be sure the cycle is complete
  do
    b={}                           -- set a new pointer for b
    for j=1,#a                     -- loop used to iterate over all elements in a
    do
      c,d=a[j+1]or 0,a[j-1]        -- gains some bytes by attributing these expressions 
                                   -- to a variable
      b[j]=0<a[j]and a[j]or        -- explained below
            (d or 0)>c and d or c
    end
    a=b                            -- we are one cycle further, new value for a
  end                              -- which is our reference array
  return a
end

অংশ

b[j]=0<a[j]and a[j]or(d or 0)>c and d or c

প্রসারিত হবে 

b[j]=0<a[j]and a[j]or(a[j-1] or 0)>(a[j+1] or 0) and a[j-1] or(a[j+1]or 0)

যা নেস্টেড ifহিসাবে অনুবাদ করা যেতে পারে

if 0<a[j]
then
    value=a[j]          -- if the cell isn't at 0, it keeps its value
elseif (a[j-1] or 0)<(a[j+1] or 0)
--[[ x or y as the following truth table :
x | y ||x or y
------||-------
0 | 0 || false
0 | 1 ||   y
1 | 0 ||   x
1 | 1 ||   x
    -- It means that when j=1 (1-based) and we try to index a[j-1]
    -- instead of failing, we will fall in the case false or true
    -- and use the value 0
    -- the same trick is used for when we try to use an index > a:len
]]--
then
    value=a[j-1]        -- the left cell propagate to the cell j
else
    value=a[j+1] or 0   -- if j=a:len, we put 0 instead of a[j+1]
                        -- this case can only be reached when we are on the right most cell
                        -- and a[j-1]==0
end
— Katenkyo
সূত্র
1

পাইথ, 17 বাইট

meeSe#.e,_akdbQUQ

স্টিডিন, স্টপআউট আউটপুট থেকে পাইথন-শৈলীর তালিকা তৈরি করে।

ব্যাখ্যা

এটি মূলত আমার হাস্কেল উত্তরের একটি অনুবাদ। আমি সত্যই এর আগে পাইথ ব্যবহার করি নি তাই ইঙ্গিতগুলি স্বাগত।

                   Implicit: Q is input list
m              UQ  Map over input index d:
      .e      Q     Map over input index k and element b:
        ,_akdb       The pair [-abs(k-d), b]
    e#              Remove those where b==0
 eeS                Take the second element of the maximal pair
— Zgarb
সূত্র
1

এপিএল (ডায়ালগ) , 18 বাইট

বেনামে ট্যাসিট প্রিফিক্স ফাংশন।

(⊢+~∘××3⌈/0,,∘0)⍣≡

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

(...)⍣≡  ফলাফলটি আর্গুমেন্টের সাথে একরকম না হওয়া পর্যন্ত নিম্নলিখিত সারণি ফাংশনটি প্রয়োগ করুন:

 ⊢ যুক্তি

 + যোগ

  ~ না
  ∘
  ×  সংকেত

 × বার

 3⌈/ তিনটি দলের প্রতিটি গ্রুপের উপরে ম্যাক্সিমা

 0, শূন্য অনুসরণ করে

  ,
  ∘ একটি
  0 শূন্য  পরে তর্ক

— আদম
সূত্র
1

জাভা 8, 155 142 বাইট

a->{for(int b[],i,l=a.length,p,n,f=l;f>0;)for(b=a.clone(),i=0,f=l;i<l;f-=a[i-1]>0?1:0)if(a[i++]<1)a[i-1]=(p=i>1?b[i-2]:0)>(n=i<l?b[i]:0)?p:n;}

int[]বাইটগুলি সংরক্ষণ করতে কোনও নতুন ফেরতের পরিবর্তে ইনপুটটি পরিবর্তন করে ।

ব্যাখ্যা:

এখানে চেষ্টা করুন।

a->{                   // Method with integer-array parameter and no return-type
  for(int b[],         //  Copy array
          i,           //  Index integer
          l=a.length,  //  Length of the array
          p,n,         //  Temp integers (for previous and next)
          f=1;         //  Flag integer, starting at 1
      f>0;)            //  Loop (1) as long as the flag is not 0 (array contains zeroes)
    for(b=a.clone(),   //   Create a copy of the current state of the array
        i=0,           //   Reset the index to 0
        f=l;           //   Reset the flag to the length of the array `l`
        i<l;           //   Inner loop (2) over the array
        f-=a[i-1]>0?   //     After every iteration, if the current item is not a zero:
            1          //      Decrease flag `f` by 1
           :           //     Else:
            0)         //      Leave flag `f` the same
      if(a[i++]<1)     //    If the current item is a 0:
        a[i-1]=        //     Change the current item to:
         (p            //      If `p` (which is:
           =i>1?       //        If the current index is not 0:
             b[i-2]    //         `p` is the previous item
            :          //        Else:
             0)        //         `p` is 0)
         >(n           //      Is larger than `n` (which is:
            =i<l?      //        If the current index is not `l-1`:
              b[i]     //         `n` is the next item
             :         //        Else:
              0)?      //         `n` is 0):
          p            //       Set the current item to `p`
         :             //      Else:
          n;           //       Set the current item to `n`
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
}                      // End of method
— কেভিন ক্রুইজসেন
সূত্র
0

রুবি, 81 বাইট

->(a){a.map{|o|a=a.map.with_index{|x,i|x!=0 ? x : a[[0,i-1].max..i+1].max}}[-1]}

আমি মনে করি অভ্যন্তরটি mapআরও গল্ফ হতে পারে।

— হর্ষ গুপ্ত
সূত্র
এখনই বুঝতে পেরেছি, আমার উত্তরটি @ ব্যবহারকারী81655 এর উত্তরের মতোই অনুরূপ ।
— হর্ষ গুপ্ত
আমি মনে করি আপনি তিনটি জায়গার ফাঁকা স্থানগুলি, অর্থাৎ আশেপাশে ?এবং সরাতে পারেন :।
— অ্যালেক্স এ
0

পিএইচপি - 301 291 289 288 264 অক্ষর

এটির চেষ্টা করার আগে অন্য উত্তরগুলি শিখতে পারেনি। ভাষাকে দোষ দিবেন না, আমাকে দোষ দিন। খুব কম উপভোগযোগ্য এবং চ্যালেঞ্জিং কম। সমস্ত কোড গল্ফ পরামর্শ ব্যাপকভাবে প্রশংসা।

$a=explode(' ',$s);$f=1;while($s){$o=1;foreach($a as&$b){
if($b==0){$u=current($a);prev($a);$d=prev($a);if(!$o&&current($a)==0){end($a);$d=prev($a);}if(!$f){$f=1;continue;}if($u>$d)$b=$u;if($u<$d){$b=$d;$f=0;}}
$o=0;}if(!in_array(0,$a))break;}$r=join(' ',$a);echo$r;

ব্যাখ্যা

// Input
$s = '0 0 2 0 0 0 1 2 0 0 3 3 0 0';

// Create array
$a = explode(' ', $s);
// Set skip flag
$f = 1;
while ($s)
{
    // Set first flag
    $o = 1;
    // Foreach
    foreach ($a as &$b)
    {
        // Logic only for non zero numbers
        if ($b == 0)
        {
            // Get above and below value
            $u = current($a);
            prev($a);
            $d = prev($a);

            // Fix for last element
            if (! $o && current($a) == 0)
            {
                end($a);
                $d = prev($a);
            }

            // Skip flag to prevent upwards overrun
            if (! $f)
            {
                $f = 1;
                continue;
            }

            // Change zero value logic
            if ($u > $d)
                $b = $u;
            if ($u < $d)
            {
                $b = $d;
                $f = 0;
            }
        }

        // Turn off zero flag
        $o = 0;
    }

    // if array contains 0, start over, else end loop
    if (! in_array(0, $a))
        break;
}
// Return result
$r = join(' ', $a);
echo $r;(' ', $a);
echo $r;
— হংসী
সূত্র
1
সিরিয়াসলি? গল্ফিং কেবল আপনার কোডের সাদা অংশগুলিকে সরিয়ে দিচ্ছে না। অ্যালগরিদম এছাড়া এখানে কিছু টিপস আছে: ব্যবহার 1বদলে true, splitবদলে explode, forবদলে while, joinবদলে implode, বেহুদা কোঁকড়া বন্ধনী অপসারণ, ...
— Blackhole
আমি বিস্ফোরিত রেখেছি কারণ বিভক্তিকে হ্রাস করা হচ্ছে। এছাড়াও, আমি কীভাবে কীভাবে কিছুক্ষণ লুপ লিখতে হয় তা লিখতে জানি না, তাই আমি এটিকে আপাতত রেখে দিয়েছি, যদি না এখানে কেউ তাদের জ্ঞান ভাগ না করে বা একটি লিঙ্ক ভাগ করে না নিতে পারে। সবাইকে ধন্যবাদ.
— গুজ
0

পাইথন, 71 বাইট

g=lambda l:l*all(l)or g([l[1]or max(l)for l in zip([0]+l,l,l[1:]+[0])])

zipসব দৈর্ঘ্য -3 একটি উপাদান এবং তার প্রতিবেশীদের sublists সৃষ্টি, যেমন এন্ড পয়েন্ট অতিক্রম চিকিত্সা 0। কেন্দ্রীয় উপাদান l[1]একটি উপ-তালিকা l, যদি শূন্য হয় তবে maxপ্রতিবেশীদের দ্বারা প্রতিস্থাপিত হবে l[1]or max(l)। l*all(l)আয় তালিকা lযখন এটি কোন হয়েছে 0এর।

— xnor
সূত্র
0

রুবি, 74 বাইট

->a{(r=0...a.size).map{|n|a[r.min_by{|i|[(a[i]<1)?1:0,(i-n).abs,-a[i]]}]}}

নিকটতম অ-শূন্য নম্বর খুঁজে বের করে কাজ করে।

— MegaTom
সূত্র
0

এমএটিএল , 38 বাইট

আমার মতলব উত্তরের সরাসরি অনুবাদ ভাষা / সংকলকের বর্তমান সংস্করণ ব্যবহার করে ।

it:"tttFFTo2X5I$X+wTFFo2X5I$X+vX>w~*+]

উদাহরণ

>> matl it:"tttFFTo2X5I$X+wTFFo2X5I$X+vX>w~*+]
> [7 0 3 0 0 0 0 0 8 0 9 1]
7 7 3 3 3 8 8 8 8 9 9 1

সম্পাদনা: এটি অনলাইন চেষ্টা করুন! সঙ্গে X+দ্বারা প্রতিস্থাপিত Y+এবং vদ্বারা &v, ভাষা মধ্যে সম্পন্ন করা কিছু পরিবর্তনের কারণে।

— লুইস মেন্ডো
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.