एक बूलियन सरणी पलटना

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 यदि गलत है, तो 0)। C("पूरक", 1 ) z ) भी काम करता है।

— लिन
स्रोत
12
मुझे लगता है कि @ डेनिस आपको कठिन समय देने जा रहा है।
— दोष
15
@flawr यह कुछ समय पहले की बात है जब डेनिस 0 बाइट या उससे कम में ऐसा करता है।
— को आउटगॉल्फ
2
@EriktheGolfer "0 बाइट्स या उससे कम " hmm
— zdimension
1
@zdimension यह डेनिस है, वह आपको जितना छोटा लगता है उससे कम कर सकता है (मेम पढ़ें)।
— आउटगॉल्फ
13

जावास्क्रिप्ट ईएस 6, 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
Haha, ठीक है, मुझे आश्चर्य है कि आप Matlab में बहुत धाराप्रवाह हैं!
— दोष
योग्य, यह Borat की तरह लगता है "यह आत्म व्याख्यात्मक होना चाहिए .... नहीं"
— user2023861
निश्चित रूप ~से एक उपयुक्त उत्तर है क्योंकि यह एक ऑपरेटर है जो एक तर्क प्राप्त करता है। मुझे लगता ~[1,0,0,1,0]है कि पूरी तरह से उचित है।
— तस्सो पाप्पिल्लियानौ सेप
1
@TasosPapastylianou संचालक प्रस्तुतियाँ निश्चित रूप से मान्य हैं (कुछ भाषाओं में जैसे जूलिया और गणितज्ञ यह अपने स्वयं के ऑपरेटरों को परिभाषित करने के लिए भी आम बात है क्योंकि यह आपके स्वयं के कार्य को परिभाषित करने की तुलना में छोटा है), लेकिन मुझे यकीन है कि दोष केवल मेरी टिप्पणी को अमान्य नहीं करना चाहता है। ;)
— मार्टिन एंडर
10

हास्केल, 7 बाइट्स

map not

उदाहरण:

Prelude> (map not) [False, True, True]
[True,False,False]
— लिन
स्रोत
आपको उदाहरण में कोष्ठक की आवश्यकता नहीं है, है ना?
— दोष
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

हम एक आयामी सरणियों तक ही सीमित नहीं हैं। चलो एक मैट्रिक्स बनाते हैं, और बेतरतीब ढंग से इसे 0s और 1s के साथ आबाद करते हैं:

> 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
समान उत्तरों को प्रस्तुत करने से बचाने के लिए, यह जूलिया में भी काम करता है (सिवाय इसके कि यह सांख्यिक इनपुट पर काम नहीं करता है)
— Sp3000
8

पर्ल 6 , 4 बाइट्स

"फ्रेंच" / यूनिकोड संस्करण:

!«*

"टेक्सास" / ASCII संस्करण:

!<<*

इनपुट एक एकल मान है जिसे एक सूची के रूप में माना जा सकता है।

यह आ रहा है जो कुछ भी लैम्ब्डा ( *) के साथ तार्किक नहीं उपसर्ग ऑपरेटर ( !) का उपयोग करते हुए संयुक्त उपसर्ग अति ऑपरेटर ( «) ।

प्रभावी रूप से यह समान है:

-> $_ { $_.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)
— ब्रैड गिल्बर्ट b2gills
स्रोत
मैं बस एक ही बात बाहर पहेली करने की कोशिश कर रहा था। मैं केवल {!«@_}:)
— हॉब्स
!**भी काम करना चाहिए
— जो किंग
7

भूलभुलैया , 9 बाइट्स

,$:)%#$.,

इसे ऑनलाइन आज़माएं!एक अनुगामी newline के साथ newline- अलग इनपुट मानता है। गोल्फ के साथ मदद के लिए @MartinEnder को धन्यवाद।

यह कार्यक्रम एक भूलभुलैया कार्यक्रम के लिए थोड़ा अजीब है - यह भाषा की 2 डी प्रकृति का उपयोग नहीं करता है, और यह वास्तव में आगे और पीछे उछलता है। पहली आगे की यात्रा पर, हमारे पास:

[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

$तब X की अगली घटना स्टैक पर मौजूदा 0 के साथ होती है c, जैसा कि पहले रन में स्टैक के निचले हिस्से में एक निहित 0 के विपरीत है। दोनों ही स्थिति ढेर के रूप में छोड़ देती है[c] , और उसके बाद कार्यक्रम दोहराया जाता है।

वैकल्पिक 9-बाइट्स:

,:):/$.:,
,::)/)$.,
,:):%)$.,
— Sp3000
स्रोत
2
यह आगे-पीछे प्रभाव वास्तव में अच्छा है।
— DLosc
मुझे यह उत्तर पसंद है। यह खुश है। :)
— निधि मोनिका का मुकदमा
6

गणितज्ञ, 7 बाइट्स

Not/@#&

या पत्रों के बिना:

!#&/@#&

सिंटैक्टिक शुगर के लिए: &एक अनाम फ़ंक्शन के दाहिने छोर को चिह्नित करता है और इसकी बहुत कम पूर्वता है। #निकटतम और संलग्नक के पहले तर्क को संदर्भित करता है &। !के लिए ऑपरेटर है Not। तो !#&बस एक अनाम फ़ंक्शन है जो इसके तर्क को नकारता है, दूसरे शब्दों में इसके बिल्ट-इन के समान है Not। /@के लिए ऑपरेटर है Map। तो कोड भी कुछ अधिक पठनीय के बराबर होगा Map[Not, #]&।

— मार्टिन एंडर
स्रोत
11
मैं कैसे !#&/@#&पढ़ सकता हूँ? :)
— लिन
1
@ लियन मदद करता है? :)
— मार्टिन एंडर
4
मुझे आश्चर्य है कि Notकोई सूची नहीं है
— A Simmons
@ASimmons हाँ तो मैं था।
— मार्टिन
6

पायथन, 27 25 24 बाइट्स

दो बाइट्स से गोल्फ के लिए लिन का धन्यवाद, और दूसरे से गोल्फिंग के लिए xnor और Mego।

lambda a:[b^1for b in a]
— स्टीवन एच।
स्रोत
1
के एरे 0/ 1अनुमति दी जाती है, और 1-bकी तुलना में कम है not b। मैंने ओपी से पूछा कि क्या 0/ के सरणियों की -1अनुमति दी जाती है, इस मामले ~bमें भी कम है।
— लिन
2
b ^ 1 भी काम करता है।
— xnor
@xnor और वह वास्तव में बेहतर होगा, क्योंकि तब अंतरिक्ष forको गिराया जा सकता था।
— मेगो
मुझे एहसास नहीं था कि 1forदो अलग-अलग टोकन के रूप में पार्स किया जाएगा। हुह, टीआईएल।
— स्टीवन एच।
6

सी #, 19 बाइट्स

एक वार्षिक समारोह के रूप में, एक बूल लेता है [] और एक IEnumerable देता है

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

या के साथ 36 बाइट्स में

dynamic f(bool[]b)=>b.Select(x=>!x);
— hstde
स्रोत
5

आईबीएम / लोटस नोट्स फॉर्मूला, 2 बाइट्स

!a

उपयोग:

A और b नामक दो फ़ील्ड के साथ एक नोट्स फ़ॉर्म बनाएँ।

a (इनपुट) = संपादन योग्य, संख्या, बहु-मूल्य, अल्पविराम अलग

b (आउटपुट) = संगणित, संख्या, बहु-मूल्य, अल्पविराम अलग

उपरोक्त सूत्र को b में पेस्ट करें और 0 का एक डिफ़ॉल्ट मान दें।

फ़ॉर्म के साथ एक नया दस्तावेज़ बनाएं, एक बाइनरी सूची दर्ज करें और आउटपुट को अपडेट करने के लिए F9 दबाएं।

उदाहरण:

यहाँ छवि विवरण दर्ज करें

यहाँ छवि विवरण दर्ज करें

यहाँ छवि विवरण दर्ज करें

काम करता है क्योंकि इनपुट के रूप में एक सूची दी गई है, नोट्स सूत्र सूची में प्रत्येक तत्व के लिए जो भी निर्दिष्ट कार्रवाई लागू करेगा।

— ElPedro
स्रोत
2
हे भगवान ... मेरी कंपनी अभी कमल के नोट से दूर चली गई; मैंने उम्मीद की थी कि इसे फिर कभी नहीं देखूंगा। उस थ्रोबैक के लिए +1।
— मैजिक ऑक्टोपस उर्फ़
मुझे लगता है कि कई कंपनियाँ @carusocomputing हैं और शायद ठीक ही हैं। मैं इसके साथ 20 वर्षों से काम कर रहा हूं और यह अभी भी मुझे हैरान करता है कि कभी-कभी सूची पुनरावृत्तियों के साथ सूत्र भाषा क्या कर सकती है। कभी-कभार डिजाइनर को खोलने में मज़ा आता है और देखो मैं अभी भी कितना याद रख सकता हूं :-)
— एलपेड्रो
5

स्विफ्ट 3 (7 बाइट्स)

.map(!)

जैसे

[true, false].map(!)

व्याख्या

बहुत स्पष्ट लगता है। mapसरणी पर कॉल करता है [true, false]। एक "गोचा" यह है कि, स्विफ्ट में, ऑपरेटर केवल कार्य हैं और तर्कों के रूप में इसे पारित किया जा सकता है। इसका मतलब map(!)है "नहीं" फ़ंक्शन !में गुजर रहा है map।

— mklbtz
स्रोत
एक भाषा के लिए प्रभावशाली संक्षिप्त उत्तर जो गोल्फिंग के लिए भयानक है। :)
— DJMcMayhem
मुझे ऐसा लगता है कि मैंने एक नियम या कुछ और तोड़ दिया। मुझे यकीन नहीं है कि ये कैसे आंका जाता है। : D
— mklbtz
यह कमाल का है।
— JAL
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]

यह मोटे तौर पर निम्नलिखित C pseudocode में अनुवाद करता है:

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

JAISBaL , 1 बाइट

!

अन्य सभी 1-बाइट उत्तरों की तरह, यह निगेटिव ऑपरेटर है, जो जरूरत पड़ने पर एक सरणी पर काम कर सकता है। यह आउटपुट को स्टैक पर छोड़ देता है, जिसे प्रोग्राम के अंत में प्रिंट किया जाता है।

दो बाइट्स के लिए, सरणी को स्पष्ट रूप से मुद्रित किया जा सकता है:

!§

इनपुट JAISBaL के अविश्वसनीय रूप से विषम सरणी प्रारूप में है (जो मैंने आविष्कार किया था, लेकिन मुझे यह पसंद नहीं है ...)।

परीक्षण मामले (जावा दुभाषिया से आउटपुट, 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 और बदले में प्रत्येक आइटम को नकारता है। परिणामी सरणी को पाइपलाइन पर छोड़ दिया गया है।

हालाँकि, साफ-सुथरी बात यह है कि पॉवरशेल अपनी कास्टिंग आवश्यकताओं के कारण बहुत ढीली है, आप पूरी तरह से मिश्रित इनपुट कर सकते हैं और एक उपयुक्त बूलियन आउटपुट प्राप्त कर सकते हैं। उदाहरण के लिए, यहाँ शाब्दिक बूलियन मान हैं $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
स्रोत
गोल्फ के लिए तरीके: (4 बाइट्स बचाता है) arrको बदलें a, (1 बाइट बचाता है) के int[]aबजाय लिखें int a[],
— ओलिवियर ग्रेजायर
उफ़! मैं इसे कैसे भूल सकता हूँ? मैं कितना पागल हूँ। और धन्यवाद @ ओलिवियरग्रेगायर
— 14
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

अविभाजित 1s या 0s (11001) का इनपुट लेता है।

— gtwebb
स्रोत
3

लॉजिकोड , ९ by बाइट्स

out!binp

सरल, वास्तव में।

एक बाइनरी स्ट्रिंग के रूप में इनपुट लेता है, क्योंकि लॉजिकोड के पास सूचियों का समर्थन नहीं है (ऐसा [true, false]होगा 10)।

outलाइन के परिणाम आउटपुट।

!कमांड स्ट्रिंग में हर बिट की नहीं की गणना करता है, तो कुछ इस तरह !111होगा 000।

binpबाइनरी इनपुट है।

1 बाइट @daHugLenny की बदौलत बच गई

— क्लिस्सिम
स्रोत
मुझे लगता है कि आप outऔर के बीच की जगह निकाल सकते हैं !binp।
— acrolith
@daHugLenny हुह, मुझे नहीं पता था कि आप ऐसा कर सकते हैं। धन्यवाद!
— 6
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
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.