বুলিয়ান অ্যারেটি উল্টান

19

একটি দুর্দান্ত সরল

ইনপুট

একটি বুলিয়ান অ্যারে দেওয়া (বা একটি গ্রহণযোগ্য বিকল্প), আপনি ধরে নিতে পারেন অ্যারেটি 32 টির বেশি উপাদানের বেশি হবে না।

[false, false, true, false, false]

আউটপুট

অ্যারের প্রতিটি উপাদান উল্টিয়ে এটিকে আউটপুট করুন।

[true, true, false, true, true]

বিধি

  • আপনি একটি সম্পূর্ণ প্রোগ্রাম বা কেবল একটি ফাংশন লিখতে পারেন
  • স্ট্যান্ডার্ড লুফোলস প্রযোজ্য
  • প্রতি ভাষা, বাইটে সংক্ষিপ্ততম কোড!

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

Input:
[true, false]
Output:
[false, true]

Input: //Example of acceptable alternative
[0,1,1]
Output:
[1,0,0]
code-golf  array-manipulation  logic 
— শন ওয়াইল্ড
সূত্র
0(মিথ্যা, সমস্ত 0 বিট) এবং -1(সত্য, সমস্ত 1 বিট) এর অ্যারেগুলি সম্পর্কে কীভাবে ?
— লিন
5
— মার্টিন এন্ডার
সম্পর্কিত। (মূল কাজটির সরলতার দিক দিয়ে, আমি বলব যে ফর্ম্যাটের পার্থক্যগুলি যথেষ্ট তাৎপর্যপূর্ণ যে এগুলি সদৃশ নয়))
— মার্টিন এন্ডার
6
কোড গল্ফের চেয়ে বেশি এটি আমার কাছে দেখতে পছন্দ করে: আপনার পছন্দের ভাষায় অপারেটর কী নয়? অতিরিক্ত পয়েন্টগুলি যদি এটি তালিকায় কাজ করে।
— লিকর্না

উত্তর:

14

জেলি , 1 বাইট

¬

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

¬যৌক্তিক নয় (1 টি মিথ্যা- y, অন্য 0)। C("পরিপূরক", 1 − z ) এছাড়াও কাজ করে।

— লিন
সূত্র
12
আমি মনে করি @ ডেনিস আপনাকে ছাড়িয়ে যাওয়ার জন্য একটি কঠিন সময় কাটাচ্ছে।
— flawr
15
@ ফ্লোয়ার ডেনিস 0 বাইট বা তার চেয়ে কম ক্ষেত্রে এটি করা সময়ের ব্যাপার মাত্র।
— এরিক আউটগল্ফার
2
@ এরিক্থে গল্ফার "0 বাইট বা তার চেয়ে কম "
— এইচএম
1
@ জেডিমেনশন এটি ডেনিস, তিনি আপনার চেয়ে কম এটি করতে পারেন (মেমস পড়ুন)।
— এরিক আউটগল্ফার
13

জাভাস্ক্রিপ্ট ES6, 15 বাইট

a=>a.map(b=>!b)

অনুমান করার মতো খুব বেশি ব্যাখ্যা দরকার নেই

f=
a=>a.map(b=>!b)

a.innerHTML = `[true, false, 1, 0] => ${ f([true, false, 1, 0]) }`
<pre id=a>
স্নিপেট প্রসারিত করুন

— বাসড্রপ কম্বারবুবউবউব
সূত্র
12

মতলব, 4 1 বাইট

এটি স্ব-বর্ণনামূলক হওয়া উচিত।

~

মতলব-এর এক-বাইট নাগেশন অপারেটর রয়েছে ~, আপনি যদি কোনও ফাংশন চান তবে আপনি ব্যবহার করতে পারেন @not।

— flawr
সূত্র
22
পেতে @rgument, negate, output, t, erminate ঠিক আছে?
— মার্টিন এন্ডার
2
হাহা, ঠিক আছে, আমি অবাক হয়েছি তুমি মতলব এ এত সাবলীল!
— flawr
লোল,
— বোরাটের
অবশ্যই ~এটি একটি উপযুক্ত উত্তর যেহেতু এটি একটি অপারেটর যা একটি আর্গুমেন্ট গ্রহণ করে। আমি ~[1,0,0,1,0]পুরোপুরি উপযুক্ত মনে করি ।
— তাসোস পাপাস্টাইলিয়ানু
1
@ টাসোসপ্যাপাস্টাইলিয়ানু অপারেটর জমা দেওয়ার বিষয়টি অবশ্যই কার্যকর (জুলিয়া এবং ম্যাথামেটিকার মতো কিছু ভাষায় এটি আপনার নিজস্ব অপারেটরগুলির সংজ্ঞা দেওয়া এমনকি সাধারণ অনুশীলন কারণ এটি আপনার নিজের ফাংশন সংজ্ঞায়িত করার চেয়ে ছোট) তবে আমি নিশ্চিত যে flawr আমার মন্তব্যটি অকার্যকর করতে চায় না। ;)
— মার্টিন ইন্ডার
10

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

map not

উদাহরণ:

Prelude> (map not) [False, True, True]
[True,False,False]
— লিন
সূত্র
উদাহরণস্বরূপ আপনার প্রথম বন্ধনী প্রয়োজন নেই, তাই না?
— flawr
9
আমি তা করি না, তবে উদাহরণটিতে আমি প্রদর্শন করতে চেয়েছিলাম যে কীভাবে আমার উত্তরটি একটি বৈধ এক্সপ্রেশন এবং একটি স্নিপেট নয়।
— লিন
3
কোডটি তৈরি করতে এখনই একটি প্রস্তাবিত সম্পাদনা ছিল not<$>, তবে এটি কোনও বৈধ এক্সপ্রেশন নয়; আপনি লিখতে পারি না f = not<$>তারপর f [False, True, True]; অপারেটর স্লাইসগুলির চারপাশে প্রথম বন্ধনী প্রয়োজন, যা বাইট গণনার পক্ষে অবদান রাখবে।
— লিন
2
এবং আপনি যেভাবেই হোক সম্পাদনাগুলির মাধ্যমে কোড প্রস্তাব করার কথা নয়
— আন্ডারগ্রাউন্ডোমোরিয়েল
10

সি, 46 বাইট পুনরাবৃত্ত সংস্করণ

f(char*s){*s?putchar(*s&72?*s:*s^1),f(++s):0;}

সি, 47 বাইট পুনরাবৃত্ত সংস্করণ

f(char*s){for(;*s;putchar(*s&72?*s:*s^1),s++);}

এই প্রধান ফাংশনটি ব্যবহার করে চালান

main(c,v)char**v;
{
    f(v[1]);
}

এবং এই মত ইনপুট

a.exe [1,0,1,1,0]
[0,1,0,0,1]
— cleblanc
সূত্র
সি চেয়ে দেখার চেয়ে কম চেয়ে কম!
— ক্রিস জেফারসন
10

আর, 1 বাইট

!

উদাহরণ:

> !c(TRUE, FALSE)
[1] FALSE  TRUE

এটি সংখ্যার ইনপুট সহও কাজ করে:

> !c(1, 0)
[1] FALSE  TRUE

আমরা হয় এক-মাত্রিক অ্যারেগুলিতেই সীমাবদ্ধ নেই। আসুন একটি ম্যাট্রিক্স তৈরি করা যাক এবং এলোমেলোভাবে এটি 0 ও 1 এর সহকারে তৈরি করুন:

> mat = matrix(rbinom(16, 1, .5), ncol=4)
> mat
     [,1] [,2] [,3] [,4]
[1,]    0    1    1    1
[2,]    0    1    0    0
[3,]    0    0    0    0
[4,]    1    1    1    0

আমরা এটি ঠিক সহজেই উল্টাতে পারি:

> !mat
      [,1]  [,2]  [,3]  [,4]
[1,]  TRUE FALSE FALSE FALSE
[2,]  TRUE FALSE  TRUE  TRUE
[3,]  TRUE  TRUE  TRUE  TRUE
[4,] FALSE FALSE FALSE  TRUE

আমরা অবিচ্ছিন্ন মাত্রা জন্য এটি করা চালিয়ে যেতে পারেন। চতুর্মাত্রিক অ্যারেতে এখানে একটি উদাহরণ রয়েছে:

> bigarray = array(rbinom(32, 1, 0.5), dim=c(2,2,2,2))
> bigarray
, , 1, 1

     [,1] [,2]
[1,]    0    0
[2,]    0    0

, , 2, 1

     [,1] [,2]
[1,]    1    0
[2,]    0    0

, , 1, 2

     [,1] [,2]
[1,]    0    1
[2,]    0    1

, , 2, 2

     [,1] [,2]
[1,]    1    0
[2,]    1    1

> !bigarray
, , 1, 1

     [,1] [,2]
[1,] TRUE TRUE
[2,] TRUE TRUE

, , 2, 1

      [,1] [,2]
[1,] FALSE TRUE
[2,]  TRUE TRUE

, , 1, 2

     [,1]  [,2]
[1,] TRUE FALSE
[2,] TRUE FALSE

, , 2, 2

      [,1]  [,2]
[1,] FALSE  TRUE
[2,] FALSE FALSE

চরিত্রগুলির জন্য কাজ করে না, আমি ভয় করি।

> !"Hello world"
Error in !"Hello world" : Invalid argument type.
— rturnbull
সূত্র
1
অভিন্ন উত্তর জমা দেওয়ার উপর সঞ্চয় করতে, এটি জুলিয়াতেও কাজ করে (বাদে এটি সেখানে সংখ্যার
— ইনপুটটিতে
8

পার্ল 6 , 4 বাইট

"ফরাসি" / ইউনিকোড সংস্করণ:

!«*

"টেক্সাস" / এএসসিআইআই সংস্করণ:

!<<*

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

এই আ যাই হোক না কেন ল্যামডা ( *) সঙ্গে যৌক্তিক না প্রিফিক্স অপারেটর ( !) ব্যবহার মিলিত উপসর্গ অধি অপারেটর ( «) ।

কার্যকরভাবে এটি একই হিসাবে:

-> $_ { $_.values.hyper.map: &prefix:<!> }
# ( currently the Rakudo implementation doesn't actually do the ｢.hyper｣ call,
#   but prefix ｢«｣ is specifically designated for doing things in parallel )

ব্যবহার:

# pretend it's a method
say (True,False,True,True).&( !«* );
# (False True False False)

say ( !«* )( (False,False,True,False,False) );
# (True True False True True)


# give it a lexical name
my &list-invert = !«*;

#              v¯¯ a space is necessary here
say list-invert (True,False);
# (False True)

say (False,True).&list-invert;
# (True False)
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
আমি ঠিক একই জিনিস ধাঁধা চেষ্টা ছিল। আমি কেবল যতদূর পেরেছি {!«@_}:)
— hobbs
!**খুব কাজ করা উচিত
— জো কিং
7

ভোল্টেজ , 9 বাইট

,$:)%#$.,

এটি অনলাইন চেষ্টা করুন!ট্রেলিং করা নতুন লাইনের সাথে নিউলাইন-বিভক্ত ইনপুট ধরে নেওয়া হয়। গল্ফিংয়ে সহায়তার জন্য @ মার্টিনএেন্ডারকে ধন্যবাদ

এই প্রোগ্রামটি একটি লাইব্রের্থ প্রোগ্রামের জন্য কিছুটা অদ্ভুত - এটি ভাষার 2D প্রকৃতির ব্যবহার করে না এবং এটি আসলে পিছনে পিছনে বাউন্স করে। প্রথম সামনের ভ্রমণে, আমাদের রয়েছে:

[Moving rightward]
,            Read char c of input
 $           XOR c with implicit 0 at bottom of stack
  :)%        Calculate c % (c+1), erroring out if c == -1 from EOF, otherwise returns c
     #$      XOR with (length of stack == 1)
       .     Output (c^1) as char
        ,    Read newline

[Moving leftward]
       .     Output newline
      $      XOR two implicit 0s, stack [0]
    %#       Mod with (length of stack == 1), giving stack [0]
 $:)         Increment, duplicate then XOR, stack still [0]
,            Read char c of input

এরপরের পরবর্তী ঘটনাটি $XORs এর সাথে বিদ্যমান স্ট্যাকটিতে 0 টি রয়েছেc প্রথম রানের মতো স্ট্যাকের নীচে একটি অন্তর্নিহিত 0 এর বিপরীতে। উভয় পরিস্থিতিতেই স্ট্যাকটি ছেড়ে যায় [c]এবং এর পরে প্রোগ্রামটি পুনরাবৃত্তি হয়।

বিকল্প 9-বাইট:

,:):/$.:,
,::)/)$.,
,:):%)$.,
— Sp3000
সূত্র
2
এই ফরোয়ার্ড-পিছনের প্রভাব সত্যিই দুর্দান্ত।
— DLosc
আমি এই উত্তরটি পছন্দ করি। এটা খুশি. :)
— ফান্ড মনিকার লসুইট
6

গণিত, 7 বাইট

Not/@#&

বা চিঠি ছাড়াই:

!#&/@#&

সিনট্যাকটিক চিনির ক্ষেত্রে: &একটি নামবিহীন ফাংশনের ডান প্রান্তটি চিহ্নিত করে এবং এর খুব কম নজরে রয়েছে। #নিকটতম এবং ঘেরের প্রথম যুক্তি বোঝায় &। !অপারেটর জন্য Not। তাই !#&শুধু একটি নামহীন ফাংশন যে তার যুক্তি বিল্ট-ইন তার অভিন্ন negates, অন্য কথায় হয় Not। /@অপারেটর জন্য Map। সুতরাং কোডটি কিছুটা বেশি পঠনযোগ্যের সমতুল্য হবে Map[Not, #]&।

— মার্টিন ইন্ডার
সূত্র
11
আমার কীভাবে !#&/@#&পড়ার কথা? :)
— লিন
1
@ লিন এটি সাহায্য করে? :)
— মার্টিন এন্ডার
4
আমি অবাক হয়েছি যে Notএটি তালিকাভুক্ত নয়
— একটি সিমন্স
@ASimmons হ্যাঁ আমিও ছিল
— মার্টিন Ender
6

পাইথন, 27 25 24 বাইট

লিনকে দুটি বাইট বন্ধ করে গলফ করার জন্য এবং এক্সনর এবং মেগোকে অন্য একটি গল্ফ দেওয়ার জন্য ধন্যবাদ।

lambda a:[b^1for b in a]
— স্টিভেন এইচ।
সূত্র
1
0/ 1এর অ্যারে অনুমোদিত, এবং এর 1-bচেয়ে কম হয় not b। আমি ওপিকে জিজ্ঞাসা করলাম 0/ -1এর অ্যারেগুলি অনুমোদিত কি না, এই ক্ষেত্রে ~bএমনকি আরও খাটো।
— লিন
2
বি ^ 1 এছাড়াও কাজ করে।
— xnor
@ এক্সনর এবং এটি আসলে আরও ভাল হবে, কারণ তারপরে স্থানটি নামানো forযেতে পারে।
— মেগো
আমি বুঝতে পারি নি যে 1forএটি দুটি পৃথক টোকেন হিসাবে বিভক্ত হবে। হু, তিল
— স্টিভেন এইচ।
6

সি #, 19 বাইট

বেনামে ফাংশন হিসাবে, একটি বুল নেয় [] এবং একটি অনুমানযোগ্য ফেরত দেয়

b=>b.Select(x=>!x);

বা 36 বাইট সহ

dynamic f(bool[]b)=>b.Select(x=>!x);
— hstde
সূত্র
5

আইবিএম / লোটাস নোটস সূত্র, 2 বাইট

!a

ব্যবহার:

A এবং b নামের দুটি ক্ষেত্র সহ একটি নোট ফর্ম তৈরি করুন।

a (ইনপুট) = সম্পাদনাযোগ্য, সংখ্যা, বহু-মান, কমা দ্বারা পৃথক

বি (আউটপুট) = গণিত, সংখ্যা, বহু-মান, কমা দ্বারা পৃথক

উপরের সূত্রটি খ-এ পেস্ট করুন এবং 0 এর আ ডিফল্ট মান দিন।

ফর্মটি সহ একটি নতুন দস্তাবেজ তৈরি করুন, একটিতে বাইনারি তালিকা প্রবেশ করুন এবং আউটপুট আপডেট করতে F9 টিপুন।

উদাহরণ:

এখানে চিত্র বর্ণনা লিখুন

এখানে চিত্র বর্ণনা লিখুন

এখানে চিত্র বর্ণনা লিখুন

কাজ করে কারণ ইনপুট হিসাবে একটি তালিকা দেওয়া হয়েছে, নোট সূত্র তালিকার প্রতিটি উপাদানগুলিতে যে কোনও নির্দিষ্ট কর্ম প্রয়োগ করবে।

— ElPedro
সূত্র
2
ওহে আমার ...শ্বর ... আমার সংস্থা পদ্মের নোট থেকে সরে গেছে; আমি আর কখনও এটি দেখতে না প্রত্যাশা ছিল। + থ্রোব্যাকের জন্য +1।
— ম্যাজিক অক্টোপাস উরন
আমি মনে করি অনেক সংস্থা @ কারাসোকম্পিউটিং এবং সম্ভবত সঠিকভাবে এটি। আমি এটির সাথে 20 বছরেরও বেশি সময় ধরে কাজ করে যাচ্ছি এবং এটি এখনও আমাকে বিস্মিত করে যে সূত্রের ভাষা কখনও কখনও তালিকা পুনরাবৃত্তির সাথে কী করতে পারে। মাঝে মাঝে ডিজাইনার খুলতে এবং আমি এখনও কতটা মনে করতে পারি তা দেখতে
— মজাদার
5

সুইফট 3 (7 বাইট)

.map(!)

যেমন

[true, false].map(!)

ব্যাখ্যা

বেশ সুস্পষ্ট মনে হয়। mapঅ্যারেতে কল করুন [true, false]। একটি "গ্যাচা" হ'ল, সুইফটে অপারেটরগুলি কেবল ফাংশন এবং আর্গুমেন্ট হিসাবে এটি পাস করা যেতে পারে। এর অর্থ map(!)হল "না" ফাংশনটি এর !মধ্যে দিয়ে যাওয়া map।

— mklbtz
সূত্র
গল্ফ করার জন্য ভয়ানক এমন ভাষার জন্য একটি চিত্তাকর্ষক সংক্ষিপ্ত উত্তর :) :)
— ডিজেএমসিমেহেম
আমার মনে হচ্ছে আমি কোনও নিয়ম বা কিছু ভঙ্গ করেছি। এগুলি কীভাবে বিচার করা হয় তা আমি নিশ্চিত নই। : ডি
— এমকেএলবিটিজ
এটা সত্যিই দারুন.
— জাল
5

শেক্সপিয়ার প্রোগ্রামিং ভাষা , 240 বাইট

.
Ajax,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Puck]
Puck:
Open your mind.Is hog as big as you?If so, let us return to scene II.You be sum of difference of zero and you and cat.Open thy heart!Let us return to scene I.
Scene II:.
[Exeunt]

অক্ষরের স্ট্রিং \0এবং \1নিয়ন্ত্রণ হিসাবে ইনপুট নেয় । 0বা এর স্ট্রিং হিসাবে আউটপুট 1। যদি ইনপুটটি অবশ্যই আউটপুটের সমান হয় তবে বাইটকাউন্টে কোনও পরিবর্তন না করে এর Open thy heartসাথে প্রতিস্থাপন করুন Speak thy mind। যদি \0এবং \1ব্যবহার না করা যায় তবে উপরেরটি করুন, তবে এটির Open your mindসাথে প্রতিস্থাপন করুনListen to thy heart একটি 5-বাইট শাস্তি জন্য।

Ungolfed:

The Invertion of Veronan Arrays.

Romeo, who stores the element.
Juliet, who lectures him.

Act I: In which an array is inverted.

Scene I: A silent entrance.

[Enter Romeo and Juliet]

Scene II: In which Juliet pours out her heart to Romeo.

Juliet:
  Open your mind. Is nothing better than thee? If so, let us proceed to scene III. 
  Thou art as good as the sum of the difference between nothing and thee and my 
  cat. Open your heart! Let us return to scene II.

Scene III: Finale.

[Exeunt]

এটি মোটামুটি নিম্নলিখিত সি সিডোকোডে অনুবাদ করে:

int romeo;

Scene1:
romeo = getchar();
if (0 > romeo) goto Scene2;
romeo = 0 - romeo + 1;
printf("%d", romeo);
goto Scene1;

Scene2:;

আমি এই দোভাষী ব্যবহার করছি । নমুনা রান:

$ python splc.py invert.spl > invert.c
$ gcc invert.c -o invert.exe
$ echo -ne "\x00\x01\x00" | ./invert
101
— তামা
সূত্র
4

জাইআইএসবিএল , 1 বাইট

!

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

দুটি বাইটের জন্য, অ্যারেটি স্পষ্টভাবে মুদ্রণ করা যেতে পারে:

!§

ইনপুটটি জএআইএসবিএল এর অবিশ্বাস্যভাবে বিজোড় অ্যারে ফর্ম্যাটে রয়েছে (যা আমি আবিষ্কার করেছি, তবে আমি এটি পছন্দ করি না ...)।

পরীক্ষার কেস (জাভা দোভাষী থেকে আউটপুট, 3.0.5):

Enter a value > [true][false]


--------------------
Stack: [[false, true]]
Locals: {}
----------------------------------------
Enter a value > [false][false][true][false][false]


--------------------
Stack: [[true, true, false, true, true]]
Locals: {}
— সক্রেটিক ফিনিক্স
সূত্র
4

পাওয়ারশেল, 15 বাইট

$args[0]|%{!$_}

আমি মনে করি এটি এমনকি v1 এ কাজ করতে পারে, তাই আমি শিরোনামটির বাইরে সংস্করণ নম্বরটি রেখে দিয়েছি। ইনপুট মাধ্যমে লুপ$args এবং প্রতিটি আইটেমকে ঘৃণা করে। যে ফলাফল অ্যারে পাইপলাইনে বাকি আছে।

ঝরঝরে জিনিসটি তবে পাওয়ারশেল তার castালাইয়ের প্রয়োজনীয়তার উপর এতটা আলগা হয়ে গেছে বলে আপনি সম্পূর্ণ মিশ্র ইনপুটটি করতে পারেন এবং উপযুক্ত বুলিয়ান আউটপুট পেতে পারেন get উদাহরণস্বরূপ, এখানে আক্ষরিক বুলিয়ান মানগুলি $false/ $true, সংখ্যা 0 1এবং 123456789পূর্ণসংখ্যা হিসাবে, একটি খালি স্ট্রিং, একটি খালি খালি স্ট্রিং, একটি খালি অ্যারে এবং একটি খালি নয় অ্যারে রয়েছে -

PS C:\Tools\Scripts\golfing> .\invert-a-boolean-array.ps1 @($false,$true,0,1,123456789,'','foo',@(),@(1,1))
True
False
True
False
False
True
False
True
False
— AdmBorkBork
সূত্র
4

পার্ল, 7 বাইট

জন্য +2 অন্তর্ভুক্ত -lp

প্রতিটি বুলিয়ান মান তার নিজস্ব লাইনে 0 বা 1 হিসাবে দিন

invert.pl
1
1
0
^D

invert.pl:

#!/us/bin/perl -lp
$_^=1
— টন হসপেল
সূত্র
3

চেডার, 10 বাইট

@.map((!))

আমি আশা করি আমি ফোন থেকে লিখছি হিসাবে আমি সঠিক গণনা

— Downgoat
সূত্র
1
আমি মনে করি, সমানভাবে, fn.vec((!))যদি এটি কখনও প্রকাশ করা হয়েছিল: পি
— কনর ওব্রায়ান
3

জাভা, 58 বাইট

void f(boolean[]a){for(boolean i:a)System.out.print(!i);}
— Numberknot
সূত্র
গল্ফের উপায়: পরিবর্তন arrকরুন a(4 বাইট সংরক্ষণ করুন) এর int[]aপরিবর্তে লিখুন int a[](1 বাইট সংরক্ষণ করেন),
— অলিভিয়ের গ্রাগোয়ার
ওহো! আমি কীভাবে তা ভুলে যাব? আমি কতটা উন্মাদ। এবং ধন্যবাদ @ অলিভিয়ারগ্রোগোয়ার
— 14-06
3

ব্রেনফাক (58 বাইট)

-[>+<-----]>--->,[<[->->+<<]>[--<]>[>]<[-<+<+>>]<+.[-]<>,]

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

Ungolfed

-[>+<-----]>---     Number 48 (stands for 0)
>,                  Read in first point
[               
    <[->->+<<]      Subtract 1 from 48 flag, subtract 1 from read data, add 1 for new flag
    >           
    [--<]           If sitting on 1 (true) subtract 2 and move left)
        >[>]<       Move to 48 flag
        [-<+<+>>]   Add 48 to data point
        <+.[-]<     Add 1 move print, zero cell, move to new 48 cell
        >,          Read in next point
]                   Loop if input remaining

অবিভক্ত 1 বা 0 সে (11001) এর একটি ইনপুট নেয়।

— gtwebb
সূত্র
3

লজিকোড , 9 8 বাইট

out!binp

সহজ, সত্যিই।

বাইনারি স্ট্রিং হিসাবে ইনপুট নেয়, কারণ তালিকার জন্য লজিকোডের সমর্থন নেই (যেমন [true, false]হবে 10)।

outলাইন এর ফলাফলের আউটপুট।

!কমান্ড স্ট্রিং প্রত্যেক বিট না হিসাব, তাই ভালো কিছু !111হবে 000।

binpবাইনারি ইনপুট হয়।

1 ডি বাইট সংরক্ষিত হয়েছে @ ডাগ হাগলেনিকে ধন্যবাদ

— clismique
সূত্র
আমি মনে করি আপনি outএবং এর মধ্যে স্থান সরাতে পারেন !binp।
— অ্যাক্রোলিথ
@ দাগ হাগলেনি হু, আপনি জানেন না যে আপনি এটি করতে পারেন। ধন্যবাদ!
— ক্লিমেজিক
2

পাইথন 2, 24 বাইট (প্রতিযোগী নয়)

lambda a:[i-1for i in a]

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

— এরিক দ্য আউটগল্ফার
সূত্র
2

রুবি, 14 বাইট

নামবিহীন ফাংশন:

->a{a.map &:!}

এটা পরীক্ষা করো:

->a{a.map &:!}.call([true, true, false, true, false, true, true])
# => [false, false, true, false, true, false, false]
— daniero
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.