অন্যান্য উপাদানগুলির যোগফলের সমতা

Question

কার্য

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

সংজ্ঞা

• সমতা: একটি সংখ্যা বিজোড় বা সমান।

উদাহরণ

অ্যারের জন্য [1,2,3,1]:

• 1এর সমতা 2+3+1, অর্থাৎ প্রতিস্থাপন করুন even।
• 2এর সমতা 1+3+1, অর্থাৎ প্রতিস্থাপন করুন odd।
• 3এর সমতা 1+2+1, অর্থাৎ প্রতিস্থাপন করুন even।
• 1এর সমতা 1+2+3, অর্থাৎ প্রতিস্থাপন করুন even।

আউটপুট: [even, odd, even, even]

ইনপুট

ধনাত্মক পূর্ণসংখ্যার একটি অ্যারে।

আপনি এটিকে যথাযথ অ্যারে বা ধনাত্মক পূর্ণসংখ্যার লাইনফিড-বিচ্ছিন্ন স্ট্রিং হিসাবে নিতে পারেন।

আপনি ধরে নিতে পারেন যে অ্যারে এবং এর মানগুলি আপনার ভাষার হ্যান্ডলিং সক্ষমতার মধ্যে রয়েছে।

আউটপুট

দুটি সামঞ্জস্যপূর্ণ মানগুলির একটি অ্যারে , একটি উপস্থাপনকারী odd, একটি উপস্থাপনকারী even।

আপনি এটিকে দুটি মানের লাইনফিড-বিচ্ছিন্ন স্ট্রিং হিসাবে আউটপুট দিতে পারেন।

Testcases

ইনপুট:

[1, 2, 3, 1]
[1, 2, 3, 2, 1]
[2, 2]
[100, 1001]

আউটপুট:

[even, odd, even, even]
[even, odd, even, odd, even]
[even, even]
[odd, even]

দ্রষ্টব্য: আপনি oddএবং ব্যতীত অন্যান্য সামঞ্জস্যপূর্ণ মানগুলি চয়ন করতে পারেন even।

স্কোরিং

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

স্ট্যান্ডার্ড লুফোল প্রযোজ্য।

Answer 1

জেলি , 3 বাইট

+SḂ

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

কিভাবে এটা কাজ করে

+SḂ  Main link. Argument: A (array)

 S   Compute the sum of A.
+    Add the sum to each element of A.
     Using _ (subtraction) or ^ (bitwise XOR) would also work.
  Ḃ  Bit; compute the parity of each resulting integer.

Comments

এটি একটি চতুর পদ্ধতির।

— ফুটো নুন

@ ল্যাকিয়ুনুন এটি একই পদ্ধতির সবাই প্রত্যেকেই খাটো করে

— খাচ্ছে

@ ইথ প্রডাকশনগুলি বেশ অনেকটা, হ্যাঁ। প্যারিটিটি গণনা করার জন্য থিয়েটটি কেবলমাত্র অনেকগুলি উপায় ...

— ডেনিস

@ এথ প্রডাকশনগুলি এটি বিয়োগের পরিবর্তে সংযোজন ব্যবহার করে ...

— লিকি নুন

@ ল্যাকিয়ুনুন সত্য, আমার জ্যাপের উত্তরটিও তা করে। _SḂ

— জেলিতে

Answer 2

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

a=>a.map(b=>eval(a.join`+`)-b&1)

0এমনকি এবং 1বিজোড় জন্য ব্যবহার করে ।

পরীক্ষা

f=
a=>a.map(b=>eval(a.join`+`)-b&1)
console.log(f([1, 2, 3, 1]))
console.log(f([1, 2, 3, 2, 1]))
console.log(f([100, 1001]))

Comments

2 বাইট বন্ধ: c-b&1পরিবর্তে(c-b)%2

— লিকি নুন

বাঃ! তুমি আমাকে এটা দ্বারা মেরেছ!

— শেগি

আমি ব্যবহার মনে রাখবেন করতে হবে eval(a.join`+`)ওভার a.reduce((x,y)=>x+y)। এটি চতুর

— সায়োস

Answer 3

হাস্কেল, 20 বাইট

f x=odd.(sum x-)<$>x

Trueবিজোড় মান এবং Falseএমনকি মানগুলির জন্য ব্যবহার করে ।

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

তালিকার যোগফল থেকে প্রতিটি উপাদানকে বিয়োগ করুন এবং যদি তা বিজোড় হয় তবে পরীক্ষা করুন।

fpointfree দিকে ফিরে এছাড়াও 20 বাইট রয়েছে: map=<<(odd.).(-).sum।

Answer 4

এমএটিএল , 5 , 4 বাইট

ts-o

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

এক বাইট ডেনিসকে ধন্যবাদ রক্ষা করেছে!

এটি বিজোড়ের জন্য '1' এবং সমান জন্য '0' দেয়। ব্যাখ্যা:

t       % Duplicate the input
 s      % Get the sum of the input
  -     % Subtract it from the original input
   o    % Get the parity of each element

Answer 5

অ্যালিস , 31 28 বাইট

/O.HQ\d$K@
\i#\ /d2-&+!w?+2%

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

যতক্ষণ পূর্ণসংখ্যা পৃথক করা হয় ততক্ষণ ইনপুট ফর্ম্যাটটি গুরুত্বপূর্ণ নয়। আউটপুট ফর্ম্যাটটি লাইনফিড-পৃথক।

লেআউটটি সম্ভবত এখনও অনুকূল নয় তবে এটিকে আরও ছোট করার কোনও উপায় আমি এখনও পাইনি।

ব্যাখ্যা

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string.
      Reflect off bottom boundary. Move to NE.
.     Duplicate the input string.
      Reflect off top boundary. Move to SE.
\     Reflect to N. Switch to Cardinal.
H     Implicitly convert the top copy of the input to the integers it
      contains and take the absolute value of the top-most one. (Taking
      the absolute value doesn't do anything, but we need the implicit
      conversion to integers.)
      The IP wraps back to the second line.
\     Reflect to SE. Switch to Ordinal.
      Immediately reflect off bottom boundary. Move to NE.
Q     Reverse the stack (this converts the integers back to strings but
      that's irrelevant). After this, we end up with all the individual
      integers on the bottom of the stack in reverse order and the other
      copy of the input string with all integers on top.
      Reflect off top boundary. Move to SE.
/     Reflect to E. Switch to Cardinal.
d     Push the stack depth, which is one more than the number of list
      elements (due to the other input string on the stack).
2-    Subtract 2.
&+    Run + that many times, which implicitly converts the second string
      to the integers it contains and then adds up all the list elements.
!     Store the sum on the tape.
w     Push the current IP position to the return address stack. This
      lets us return here repeatedly to implement a loop.

  ?+    Retrieve the input sum from the tape and add it to the current
        element.
  2%    Compute its parity. Other ways to do this are 1A and 0x. 2F would
        also work but it gives 0/2 instead of 0/1.
        The IP wraps the first column of the grid.
  \     Reflect to NE. Switch to Ordinal. The IP bounces diaginally up
        and down until it hits the next \.
  O     Implicitly convert the current parity to a string and print it
        with a trailing linefeed.
  #     Skip the next command (the H).
  \     Reflect to E. Switch to Cardinal.
  d     Push the stack depth. This is zero when we're done.
  $     Skip the next command if the stack depth is indeed zero, which
        exits the loop.

K     Jump to the return address on top of the return address stack without
      popping it (so that the next K will jump there again).

@     Terminate the program.

Answer 6

পাইথ, 7 6 বাইট

mi2-sQ

-1 বাইট @ কেজ্যাংকে ধন্যবাদ

বিজোড়ের জন্য আউটপুট 1, এমনকি 2 এর জন্য।

চেষ্টা করে দেখুন!

ব্যাখ্যা

m%-sQd2
m      Q    # For each element in the (implicit) input list
   sQ       # Take the sum of all the elements
  -  d      # subtract that element, so that we now have the sum of the other elements
 %    2     # modulo 2; 1=off, 0=even

Comments

%_2মডেলোটিকে একটি জিসিডিতে পরিবর্তন করে i2_, আপনি এমনকি বাইট সংরক্ষণ করে dকোডটিকে অন্তর্নিহিত পরিবর্তন করতে পারেন mi2-sQ। ফলাফলগুলি সমান হিসাবে 2 এবং বিজোড়ের জন্য 1 এ পরিবর্তিত হয়।

— কে ঝাং

Answer 7

05 এ বি 1 ই (উত্তরাধিকার) , 4 3 বাইট

O^È

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

O   # Sum
 ^  # XOR with (implicit) input
  È # Print 1 for even / 0 for odd

Comments

1 বাইট অফ

— লিক নুন

আমি জানি এটি কিছুক্ষণ হয়ে গেছে, তবে আপনি প্রাথমিকটি সরিয়ে ফেলতে পারেন D, যেহেতু ইনপুট সুস্পষ্টভাবে।

— কেভিন ক্রুজসেন

Answer 8

পাইথন 2 , 33 31 বাইট

^{-২ বাইট ধন্যবাদ লিকি নুনকে ধন্যবাদ}

lambda x:[sum(x)-z&1for z in x]

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

Comments

2 বাইট বন্ধ: sum(x)-z&1পরিবর্তে(sum(x)-z)%2

— লিকি নুন

sum(x,z)%2এছাড়াও কাজ করবে

— xnor

Answer 9

আর, 21 বাইট

(sum(n<-scan())-n)%%2

স্টিডিন থেকে তালিকাটি পড়ে এবং 0 এর জন্য সমান, বিজোড়ের জন্য 1 প্রদান করে। ইনপুটটিকে nকলটির sumবাইরে কল করার পরিবর্তে ভেরিয়েবলের সাথে সংযুক্ত করে , যেমন,n=scan();(sum(n)-n)%%2

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

Answer 10

গণিত, 13 বাইট

#+Tr@#&/*OddQ

অথবা

OddQ[#+Tr@#]&

Answer 11

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

#(for[i %](odd?(apply - i %)))

প্রতিটি মান থেকে Substracts সব মান ঘুরে, ইনপুট দিয়ে উদাহরণস্বরূপ [a b c d]2nd হিসাব মান b - a - b - c - d= -(a + c + d)। আউটপুট হয়falsetrue সমান এবং বিজোড় জন্য।

তবে আপনি পাশাপাশি +প্রতিটি শব্দটি দু'বার ব্যবহার ও গণনা করতে পারেন যাতে এটি সাম্যকে প্রভাবিত করে না।

Answer 12

সিজেম , 10 বাইট

{_:+f+1f&}

এটি একটি বেনামে ব্লক (ফাংশন) যা স্ট্যাক থেকে ইনপুট নেয় এবং আউটপুট দ্বারা এটি প্রতিস্থাপন করে।

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

ব্যাখ্যা

ইনপুট বিবেচনা করুন [1 2 3 1]।

{         e# Begin block
          e#   STACK: [1 2 3 1]
  _       e#   Duplicate
          e#   STACK: [1 2 3 1], [1 2 3 1]
  :+      e#   Fold addition over the array: compute its sum
          e#   STACK: [1 2 3 1], 7 
  f+      e#   Map addition over the array with extra parameter
          e#   STACK: [8 10 11 8]
  1       e#   Push 1
          e#   STACK: [8 10 11 8], 1
  f&      e#   Map bit-wise "and" over the array with extra parameter
          e#   STACK: [0 0 1 0]
}         e# End block

Answer 13

জে , 6 বাইট

2|]++/

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

Answer 14

এপিএল (ডায়ালগ ইউনিকোড) , 19 7 বাইট

গল্ফড 12 বাইট @ অ্যাডমকে ধন্যবাদ

2|+/-¨⊢

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

Answer 15

জাপট , 7 বাইট

£x +X&1

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

ব্যাখ্যা

 £   x +X&1
 mX{ x +X&1}  // Ungolfed
UmX{Ux +X&1}  // Variable introduction

UmX{       }  // Replace each item in the input array with
         &1   //   the parity of
    Ux        //   the sum of the input array
       +X     //   plus X.
              // Implicit: output result of last expression

Answer 16

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

sub{map$x+=$_,@_;map$x-$_&1,@_}

1বিজোড় এবং 0এমনকি জন্য আউটপুট ।

Comments

+1, দুর্দান্ত আমার মনে হয় এটি ২৮ বাইট, যদিও perldoc perlsubবলেছেন : "স্বাক্ষরটি একটি সাবরুটিনের দেহের অংশ।

— এমএস 210

@ এমএস 210 ধন্যবাদ! আমি মনে করি না এটি কীভাবে কাজ করে, যদিও- নিশ্চিত যে সাব্রোটিনের দেহটি কেবলমাত্র 28 বাইট, তবে আপনি subএটি না ভেঙে ছাড়তে পারবেন না ।

— ক্রিস

তবে কখনও কখনও একটি সাব্রুটাইন কাজ করে না subযেমন উদাহরণস্বরূপ পরে sortবা grepঅন্য সাব্রোটিনের পক্ষে যুক্তি হিসাবে। কোড গল্ফ মেটা সম্পর্কে এটি জিজ্ঞাসা করার উপযুক্ত হতে পারে ।

— এমএস 210

@ এমএস 210 একটি সাব্রোটাইন subকেবলমাত্র প্রোটোটাইপড ফাংশনে ব্যবহৃত হয় ( sortএবং grepআরও বা কম প্রোটোটাইপড থাকে) ছাড়াই কাজ করে । তবে অন্যথায়, subপ্রয়োজন হয়। নির্বিশেষে, বাদ দিয়ে 3 বাইট গল্ফ করা subসত্যিই আকর্ষণীয় নয়।

— দাদা 12

Answer 17

ক্লোজার (স্ক্রিপ্ট), 36 বাইট

আউটপুট trueঅদ্ভুত এবং falseএমনকি জন্য। আউটপুট এবং ইনপুট উভয়ই সিকোয়েন্স।

(fn[l](map #(odd?(-(apply + l)%))l))

Answer 18

পিএইচপি, 50 বাইট

অনলাইন সংস্করণ

বিজোড় জন্য 1, এমনকি সমান

স্ট্রিং হিসাবে আউটপুট পৃথক _

<?foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

পিএইচপি, 72 বাইট

অ্যারে ব্যবহার হিসাবে আউটপুট array_map

<?print_r(array_map(function($v){return array_sum($_GET)-$v&1;},$_GET));

Comments

আপনি কিছু ফেলে না ?:0তা ফেলে দিতে পারেন । foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

— ক্রিস্টোফ

Answer 19

সি, 68 62 বাইট

i;s;f(c,l)int*l;{while(i<c)s+=l[i++];while(i)l[--i]=s-l[i]&1;}

বিজোড় জন্য 1, এমনকি সমান

বিস্তারিত চেষ্টা অনলাইন

f(int c, int * l)
{
    int i = 0, s = 0;

    while(i < c)
    {
        s = s + l[i];
        i = i + 1;
    }

    // assert(i == c)

    while(i > 0)
    {
        i = i - 1;
        l[i] = s - l[i]&1;
    }
}

Answer 20

রেটিনা , 40 38 বাইট

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

এটি অনলাইন চেষ্টা করুন! বিজোড়ের জন্য আউটপুট 1 এবং সমান জন্য 0। ব্যাখ্যা: প্রথম দুটি লাইন ইনপুট প্রতিটি সংখ্যার জন্য একবার ইনপুট সদৃশ, কিন্তু উপাদান নিজেই ছাড়া। এটি একটি অতিরিক্ত ফাঁকা লাইন তৈরি করে যা মুছে ফেলা হয়। ইনপুটটি দশমিক থেকে আনারিতে রূপান্তরিত হয়, স্পেসগুলি মুছে ফেলা হয় এবং সমতাটি গণনা করা হয়। এমনকি সমতাটি তখন শূন্যে রূপান্তরিত হয় এবং ফলাফলগুলি আবার এক লাইনে যোগ দেয়। সম্পাদনা: @ ফ্রাইআমএইজিজিম্যানকে 2 বাইট সংরক্ষণ করা হয়েছে। আমি কিছু অন্যান্য সংস্করণ চেষ্টা করেছি যা ধারণাগতভাবে আরও আনন্দদায়ক তবে এটি প্রকাশ করতে অনেক বেশি বাইট লাগে:

\d\B

T`2468O`00001
T`d`10`^([^1]*1[^1]*1)*[^1]*1[^1]*$

সমস্ত ইনপুটগুলি তাদের প্যারিটিতে পরিবর্তন করে, তারপরে যদি মোটের মধ্যে বিজোড় সমতা থাকে তবে তাদের সমস্ত অংশকে উল্টিয়ে দেয়।

\d+
$*
^.*
$&¶$&
 (?=.*$)

11

\B
0
T`d`10`.*¶1
¶0

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

Comments

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

— FryAmTheEggman

@ ফ্রাইআম দ্য এজিগম্যান আপনার সঞ্চয়টি আপনার ;স্থানগুলিতে ফিরে রূপান্তর করার একটি কম দৃশ্যমান উপায়ে আসা থেকে আসে । আপনি যদি ;শুরুতে রেখে দেন তবে আপনি এটি 0 তে রূপান্তরিত করার পরিবর্তে তত্ক্ষণাত মুছে ফেলে একটি বাইট সংরক্ষণ করতে পারেন

— নীল

প্রকৃতপক্ষে, আবার তাকান, কেন আপনার শেষ পর্যায়টি কেবল ফাঁকা জায়গায় নতুন লাইনের প্রতিস্থাপন করছে না? এটি কি 2 বাইট সংরক্ষণ করবে না?

— FryAmTheEggman

নিবন্ধন করুন আমি মনে করি পূর্ববর্তী পুনরাবৃত্তির জন্য আমার মূলত একাধিক প্রতিস্থাপন ছিল।

— নিল

Answer 21

ওহম , 4 বাইট

DΣ-é

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

মূলত MATL এবং 05AB1E উত্তরগুলির সরাসরি পোর্ট । trueএমনকি এবং falseবিজোড় জন্য ব্যবহার করে ।

Answer 22

কে, 9 বাইট

{2!x-+/x}

আউটপুটটি একটির 1জন্য oddএবং একটি 0সমান for এটি অনলাইনে চেষ্টা করুন।

সিউডোকোডে রূপান্তরিত, এটি হবে:

for number in x:
    yield (number - sum(x)) % 2

Answer 23

স্কালা , 19 বাইট

x=>x.map(x.sum-_&1)

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

Answer 24

ব্রেন-ফ্লাক , 94 68 66 বাইট

({({}<>)<>})<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

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

এটি কাজের জন্য কিছুটা দীর্ঘ বলে মনে হচ্ছে। এটি করার জন্য আরও সুবিধাজনক উপায় হতে পারে।

ব্যাখ্যা

প্রথমে আমরা স্ট্যাকের যোগফলটি এর সাথে গণনা করি:

({({}<>)<>})

আমরা প্রতিটি স্ট্যাক্টে ফলাফল যুক্ত করে পুরো স্ট্যাকের মধ্য দিয়ে যাই এবং জুড়িটি নির্ধারণ করি

<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

---

এটি এই চ্যালেঞ্জের জন্য সামনে এলাম একটি দুর্দান্ত শীতল 2 মডেল আলগোরিদম ব্যবহার করে।

({}(())){({}[()]<([{}]())>)}{}

1-nআমরা পূর্বে রাখা 1 টির জন্য প্রতিবার ইনপুট শূন্য না হওয়া অবধি এই ইনপুট হ্রাস 1 এর দিকে ধাক্কা দেয় , এটি তারপরে ইনপুটটিকে সরিয়ে দেয়।

Comments

আপনি শেষ 2 মোড করতে পারেন। আপনার যোগফল 2 যোগ করার দরকার নেই।

— ফাঁস নুন

@ লিকিউন ধন্যবাদ! আমি ঠিক তা বুঝতে পেরেছি এবং ঠিক করেছি।

— গম উইজার্ড

Answer 25

বুদ্ধিমান , 54 52 বাইট

::^:??[:!^:?^:!^:?^?]|!::^??[!:?^:><^!:?^:!^:?^?]!&|

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

ব্যাখ্যা

শীর্ষ কোডের দুটি উপাদান অদলবদল করতে এতগুলি বাইট না নিলে এই কোডটি অনেক ছোট হবে। বর্তমান রেকর্ডটি হয়

:?^:!^:?^!

দুর্ভাগ্যক্রমে কোডটির সংখ্যাগরিষ্ঠতা গঠন করে।

---

প্রথমে আমরা স্ট্যাকের XOR যোগ করি sum

::^:??[:!^:?^:!^:?^?]|!

তারপরে আমরা এটি প্রতিটি উপাদান এবং এটির সাথে উপাদানটি শেষ বিট শূন্যের সাথে এক্সওআর করি

::^??[!:?^:><^!:?^:!^:?^?]!&|

Answer 26

জাভা , 81 78 বাইট

কেভিন ক্রুইসেনকে 3 বাইট ধন্যবাদ জানাই

void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

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

স্থানে অ্যারে পরিবর্তন করে।

Comments

আপনি এটির মতো 3 বাইট দ্বারা গল্ফ করতে পারেন:void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

— কেভিন ক্রুইজসেন 3:38

67 টি বাইট যদি আপনি ল্যাম্বডা ব্যবহার করেন: এটি অনলাইনে চেষ্টা করুন!

— ব্রায়ান ম্যাকচ্যাটন

ধন্যবাদ, তবে আমি ল্যাম্বডা ব্যবহার করতে পছন্দ করি না।

— লিকি নুন

Answer 27

এডাব্লুকে , by৪ বাইট

{for(i=0;++i<=NF;print s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}

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

0এমনকি 1নতুন অঙ্কের দ্বারা পৃথককৃত বিজোড় অঙ্কের জন্য আউটপুট দেয় । বাক্সের বাইরে থাকা কিছুটা ভাবনা "বর্ধন" পদক্ষেপের printভিতরে কমান্ডটি forরেখেছিল। আমি মুদ্রণের কয়েকটি "চতুর" উপায় চেষ্টা করেছি, তবে তারা বাইটগুলি সংরক্ষণ করেনি।

কেবল গিগলসের জন্য, আপনি যদি নতুন লাইনগুলি না চান:

{for(i=0;++i<=NF;m=m,s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}1

যার উপরের মতো একই বাইট-কাউন্ট রয়েছে তবে এটি কিছুটা অবসন্ন।

Answer 28

সুইফ্ট - 55 বাইট

^{অবশেষে সি মার! এছাড়াও, সমান জন্য 0, বিজোড় জন্য 1}

func g(a:[Int]){for i in a{print((a.reduce(0,+)-i)%2)}}

ব্যবহার সহ একটি ফাংশন: g(a: [1,2,3,2,1] // => 0 1 0 1 0

এটা দেখ!

Comments

না সুইফট সাথে পরিচিত, কিন্তু অনেক ভাষায় আপনি প্রতিস্থাপন করতে পারেন (x-y)%2সঙ্গেx-y&1

— Cyoce

@ কিয়েস আমার জন্য, পরীক্ষার পরে, এটি কার্যকর হয় না। বিটওয়াইজ অপারেশনগুলি সুইফটের

— জাল

Answer 29

অ্যাক্সিয়াম, 45 বাইট

f(a)==[(reduce(+,a)-a.j)rem 2 for j in 1..#a]

ইনপুট প্রকারের জন্য কোনও চেক নেই, প্রতিটি উপাদানকে "a" যোগফলের পুনরায় গণনা ... পরীক্ষাগুলি

(27) -> [[a,f(a)] for a in [[1,2,3,1], [1,2,3,2,1], [2,2], [100, 1001] ]]
   (27)
   [[[1,2,3,1],[0,1,0,0]], [[1,2,3,2,1],[0,1,0,1,0]], [[2,2],[0,0]],
    [[100,1001],[1,0]]]

Answer 30

জুলিয়া 1.0 , 17 বাইট

x->(sum(x).-x).%2

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