बिटफ्लिप और निगेट

42

पूर्णांक को देखते हुए, एक अभिव्यक्ति बनाएं जो इसे 0एकात्मक निषेध -और बिटवाइज पूरक ~( ~n= -n-1) के उपयोग से उत्पन्न करता है , साथ ही ऑपरेटरों को बाएं से दाएं लागू किया जाता है।

...
-3  = ~-~-~0
-2  = ~-~0
-1  = ~0
 0  = 0
 1  = -~0
 2  = -~-~0
 3  = -~-~-~0
...

आपका अभिव्यक्ति संभव के रूप में कम, जिनमें से कोई अनावश्यक भागों का मतलब है के रूप में होना चाहिए ~~, --, -0, या 00। अभिव्यक्ति या स्ट्रिंग या वर्णों के अनुक्रम के रूप में प्रिंट करें।

कोड स्निपेट दिखाएं

code-golf  string  math  bitwise 
— XNOR
स्रोत
11
— जॉर्डन
1
~ और 0 के बीच व्हाट्सएप की अनुमति है?
— 20
नहीं, स्ट्रिंग्स को बिल्कुल आउटपुट करें।
— 21
2
आज्ञाकारी xkcd.com/153
— जेरेड स्मिथ

जवाबों:

17

पायथन, 32 बाइट्स

lambda x:("-~"*abs(x))[x<0:]+"0"

अनाम लम्बा कार्य। एक पूर्णांक x लिखता है "- ~" एब्स (x) बार और पहले चार को हटा देता है यदि x नकारात्मक है, तो एक शून्य अंत में जोड़ा जाता है।

— KarlKastor
स्रोत
अजी, मुझे मारो।
— mbomb007
मैंने अभी भी वही लिखा है - nके स्थान पर xऔर 'के स्थान पर ":)
— जोनाथन एलन
2
@JonathanAllan तब आप सुरक्षित रूप से इसे एक डुबकी मान सकते हैं।
— आउटगॉल्फ
16

जावास्क्रिप्ट (ईएस 6), 33 31 बाइट्स

f=x=>x<0?"~"+f(~x):x&&"-"+f(-x)

पुनरावर्ती <बिल्ट-इन <छोरों (कम से कम इस मामले में)। मूल रूप से इनपुट unevaluates:

  • यदि यह 0 से कम है, तो इसे फ्लिप करें और ~स्ट्रिंग में जोड़ें ;
  • यदि यह 0 से अधिक है, तो इसे नकारात्मक करें और -स्ट्रिंग में जोड़ें ;
  • यदि यह ठीक 0 है, तो 0 लौटाएं।

इस पैटर्न का लाभ लेता है:

 0         = 0
-1 = ~( 0) = ~0
+1 = -(-1) = -~0
-2 = ~(+1) = ~-~0
+2 = -(-2) = -~-~0
-3 = ~(+2) = ~-~-~0
+3 = -(-3) = -~-~-~0
etc.
— ETHproductions
स्रोत
11

पायथ, 14 13 12 बाइट्स

_<>0Q+0sm"~-

-2 बाइट्स @StevenH की बदौलत।

परीक्षण सूट

पायथ को आज़माने का फैसला किया, इसलिए मैंने अपने अजगर के जवाब का अनुवाद किया। किसी भी मदद का स्वागत करते हैं!

स्पष्टीकरण:

_<>0Q+0sm"~-     
        m"~-     # Map "~-" onto the input (= a list of n times "~-").
       s         # Join the list to a string.
     +0          # Add "0" in front. 
 <>0Q            # Slice off the last char if the input is negative.
_                # Reverse the whole thing.
— KarlKastor
स्रोत
एक बाइट को बचाने के लिए अंत में निहित इनपुट का उपयोग करें: >0इसके बजाय<Q0
— स्टीवन एच।
@StevenH। धन्यवाद! अब हम सबसे छोटे उत्तर के साथ टाई में हैं!
— कार्लकास्टर ०
2
बहुत अलग समाधान (जो, दुर्भाग्य से, किसी भी बाइट को नहीं बचाता है):tW>0Q_+0sm"~-
— स्टीवन एच।
2
@StevenH। आपके समाधान को 12 तक नीचे ले आया: _<>0Q+0sm"~-मुझे आशा है कि मेरे समाधान में इसे जोड़ने के साथ आपका ठीक होगा।
— कार्लकास्टर
8

सी, 46 बाइट्स

m(x){putchar(x?x<0?126:45:48);x&&m(-x-(x<0));}

अधिकांश (सभी?) अन्य उत्तरों के विपरीत, यह एक ऑपरेटर ~और -एक - एक करके आउटपुट देता है ।

— anatolyg
स्रोत
7

रेटिना, 19 17 बाइट्स

अंत में एक शून्य के साथ संख्या को एकात्मक के साथ बदलें। प्रत्येक के 1साथ बदलें -~। एक होने पर डबल नेगेटिव निकालें।

\d+
$*10
1
-~
--

इसे ऑनलाइन आज़माएं

एक बार में सभी परीक्षण मामले (कई परीक्षण मामलों का समर्थन करने के लिए थोड़ा संशोधित कार्यक्रम)

— mbomb007
स्रोत
2
— मार्टिन
7

पर्ल 38 35 33 (23 + 1-पी के लिए) 24

s/\d+/"-~"x$&.0/e;s;--;

-13 दादा को धन्यवाद

— रिले
स्रोत
आप शायद -pइसके बजाय मतलब था -r। इसके अलावा आप उन अंतिम कोष्ठक और अर्धविराम से छुटकारा पा सकते हैं: if$h<0पर्याप्त है।
— दादा
मैंने किया, धन्यवाद। मैं sed में बहुत सारे उत्तर लिख रहा हूँ मुझे लगता है।
— रिले
शायद, हाँ। (अंतिम 2 कोष्ठक से भी छुटकारा पाएं)
— दादा
के $h<0&&s;.;बजाए आप 2 बाइट भी बचा सकते हैं s/.// if $h<0। ( कोड के अंत में -pजोड़ता है ;, इसलिए अंतिम ;के लिए कोई आवश्यकता नहीं है s;.;;। और a if bलगभग बराबर है b && a, लेकिन इस मामले में यह आपको एक बाइट बचाता है क्योंकि आप अंतरिक्ष को हटा सकते हैं)
— दादा
धन्यवाद, मुझे पता नहीं था -p ;भी जोड़ा ।
— रिले
6

दिल्लोग एपीएल , 18 बाइट्स

'0',⍨0∘>↓'-~'⍴⍨2×|

'0',⍨ चरित्र शून्य से जुड़ी

0∘> नकारात्मकता (अर्थात शून्य से ऊपर के लिए 0 के तहत संख्या के लिए 1)

↓ इससे गिरा

'-~'⍴⍨ स्ट्रिंग "~ -" चक्रीय रूप से लंबाई में बदल दिया गया

2× दो बार

| निरपेक्ष मूल्य

+ प्लस

0∘< सकारात्मकता (यानी 0 से अधिक संख्या के लिए 1)

TryAPL ऑनलाइन!

— एडम
स्रोत
6

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

f n=['-'|n>0]++(tail$[1..abs n]>>"-~")++"0"

f n|n<0=tail$f(-n)|x<-[1..n]>>"-~"=x++"0"

3 बाइट्स के लिए निम्मी को धन्यवाद

— BlackCap
स्रोत
tailके लिए विफल रहता है n=0। आप drop 1इसके बजाय उपयोग कर सकते हैं ।
— निकमी
@ निम्मी धन्यवाद; मुझे कोई अंदाजा नहीं है कि मैं कैसे चूक गया ..
— BlackCap 7'16
1
— नौ
1
बचाने के लिए 2 बाइट्स ...|n<0=tail$f(-n)|...:।
— nimi
5

वी , 21 बाइट्स

/ä
é
D@"ña-~ñá0kgJó--

इसे ऑनलाइन आज़माएं!

वी के पास बहुत सीमित संख्या में समर्थन है, और इसमें वास्तव में नकारात्मक संख्या की कोई अवधारणा नहीं है। इसका मतलब है कि नकारात्मक (या यहां तक ​​कि 0) का समर्थन करने के लिए, हमें कुछ हैकरी वर्कआर्स का उपयोग करना होगा।

स्पष्टीकरण:

/ä                  "Move forward to the first digit
é                   "And enter a newline
D                   "Delete this number, into register '"'
 @"                 "That number times:
   ñ   ñ            "Repeat the following:
    a               "  Append the string:
     -~             "  '-~'
        á0          "Append a 0
          k         "Move up a line
           gJ       "And join these two lines together
             ó--    "Remove the text '--', if it exists
— DJMcMayhem
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 39 37 बाइट्स

x=>"-~".repeat(x<0?-x:x).slice(x<0)+0

2 बाइट्स @Neil की बदौलत सहेजे गए

— Huntro
स्रोत
5

जेली , 10 बाइट्स

A⁾-~ẋḊẋ¡N0

यह एक पूर्ण कार्यक्रम है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

A⁾-~ẋḊẋ¡N0  Main link. Argument: n

A           Take the absolute value of n.
 ⁾-~ẋ       Repeat the string "-~" that many times. Result: s
       ¡    Conditional application:
     Ḋ        Dequeue; remove the first element of s...
      ẋ N     if s, repeated -n times, is non-empty.
         0  Print the previous return value. Set the return value to 0.
            (implicit) Print the final return value.
— डेनिस
स्रोत
5

जावा 7, 95 79 बाइट्स

79 बाइट्स:

String s(int x){String t=x<0?"~":"";while((x<0?++x:x--)!=0)t+="-~";return t+0;}

Ungolfed:

String s(int x) {
    String t = x<0 ? "~" : "";
    while((x<0 ? ++x : x--) != 0)
        t += "-~";
    return t+0;
}

पुराना संस्करण (95 बाइट्स):

String s(int x){return new String(new char[x<0?-x:x]).replace("\0","-~").substring(x<0?1:0)+0;}

उपयोग:

class A {
    public static void main(String[]a) {
        System.out.println(s(-3));
        System.out.println(s(-2));
        System.out.println(s(-1));
        System.out.println(s(0));
        System.out.println(s(1));
        System.out.println(s(2));
        System.out.println(s(3));
    }
    static String s(int x){String t=x<0?"~":"";while((x<0?++x:x--)!=0)t+="-~";return t+0;}
}

यहाँ यह कोशिश करो!

आउटपुट:

~-~-~0
~-~0
~0
0
-~0
-~-~0
-~-~-~0
— QBrute
स्रोत
नमस्ते, और PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!
— R
PPCG में आपका स्वागत है! हम्म, यह मेरी तुलना में एक छोटा समाधान है, इसलिए मैं अपना उत्तर हटा दूंगा और इसके बजाय तुम्हारा उत्थान करूंगा। :)
— केविन क्रूज़सेन
3

EXCEL: 55 33 बाइट्स

=REPT("-~",IF(A1>0,A1,ABS(A1)-1))&"0"

इनपुट A1 सेल में एक नंबर डालने के रूप में है। फार्मूला A1 को छोड़कर कहीं भी जा सकता है।

मुझे नहीं लगता कि यह ऋणात्मक संख्याओं के लिए काम करता है ...
— पजाकों
3

टी-एसक्यूएल, 87 बाइट्स

select substring(replicate('-~',abs(x)),case when x<0then 2 else 1 end,x*x+1)+'0'from #

x*x+1सबस्टेशन की स्थिति पर्याप्त है, क्योंकि x^2+1>=2*abs(x)सभी के लिए x।

आमतौर पर एसक्यूएल में, इनपुट एक तालिका में संग्रहीत किया जाता है:

create table # (x int)

insert into # values (0)
insert into # values (1)
insert into # values (-1)
insert into # values (2)
insert into # values (-2)
— pajonk
स्रोत
3

CJam , 18 14 बाइट्स

4 बाइट बचाने के लिए एमिग्ना के जवाब से कुछ प्रेरणा ली ।

li_z"-~"*\0<>0

इसे ऑनलाइन आज़माएं! (एक लाइनफीड-सेपरेटेड टेस्ट सूट के रूप में।)

व्याख्या

li      e# Read input and convert to integer N.
_z      e# Duplicate and get |N|.
"-~"*   e# Repeat this string |N| times.
\0<     e# Use the other copy of N to check if it's negative.
>       e# If so, discard the first '-'.
0       e# Put a 0 at the end.
— मार्टिन एंडर
स्रोत
3

विम - 31 कीस्ट्रोक्स

पहले विम गोल्फ, विपुल सामान की एक टन याद किया।

`i-~<esc>:s/-\~-/\~-/dwp<left>ii<esc><left>d$@"<esc>a0`
— Maltysen
स्रोत
अच्छा है, क्लब में आपका स्वागत है! :) आप कर सकता है :s/^-के बजाय :s/-\~/\~-और Dके बजायd$
— DJMcMayhem
अब जब मैं इसके बारे में सोचता हूं, तो मुझे नहीं लगता कि यह हैंडल 0. आप इसे हटाने से पहले बढ़ा सकते हैं <C-a>और फिर अंत में दो वर्णों को हटा सकते हैं।
— DJMcMayhem
@DJMcMayhem ओह, 0iकाम नहीं करता है?
— माल्टसेन
नहीं दुर्भाग्य से नहीं। 0वर्तमान पंक्ति पर कर्सर को पहले वर्ण पर ले जाता है। यद्यपि आप V में एक गणना के रूप में 0 का उपयोग कर सकते हैं।
— DJMcMayhem
2

मतलाब, 61 बाइट्स

x=input('');A=repmat('-~',1,abs(x));disp([A((x<0)+1:end) 48])
— pajonk
स्रोत
2

जेली, 14 12 बाइट्स

-2 बाइट्स @ @ डेनिस के लिए धन्यवाद ("0" के बजाय वापसी 0, यह केवल एक पूर्ण कार्यक्रम बना रहा है)।

0>‘
A⁾-~ẋṫÇ0

यह TryItOnline पर परीक्षण करें

कैसे?

0>‘      - link 1 takes an argument, the input
0>       - greater than 0? 1 if true 0 if false
  ‘      - increment

A⁾-~ẋṫÇ0 - main link takes an argument, the input
      Ç  - y = result of previous link as a monad
A        - x = absolute value of input
 ⁾-~     - the string "-~"
    ẋ    - repeat the sting x times
     ṫ   - tail repeatedString[y:] (y will be 1 or 2, Jelly lists are 1-based)
       0 - implicit print then return 0
— जोनाथन एलन
स्रोत
2

> <>, 18 + 3 = 22 बाइट्स

:?!n0$-:0):1go-
-~

इसे ऑनलाइन आज़माएं! ​ -vझंडे के लिए +3 बाइट्स इनपुट के साथ स्टैक को इनिशियलाइज़ करने के लिए। यदि यह मानते हुए कि STDIN खाली है, तो ठीक है, तो निम्नलिखित बाइट कम है:

:?!ni*:0):1go-
-~

प्रोग्राम इनपुट nको फ़्लिप करता रहता है जब तक कि आवश्यक नहीं हो जाता है जब तक कि यह 0 तक नहीं पहुंचता है, जिसके बाद यह गलत हो जाता है।

[Loop]
:?!n      If n is 0, output it as a num. If this happens then the stack is now
          empty, and the next subtraction fails
0$-       Subtract n from 0
:0)       Push (n > 0)
:1go      Output the char at (n>0, 1) which is a char from the second line
-         Subtract, overall updating n -> -n-(n>0)
— Sp3000
स्रोत
2

ऑक्टेव, 51 बाइट्स

x=input('');[("-~"'*[1:abs(x)>0])((x<0)+1:end),'0']

पहली बार @pajonk द्वारा Matlab दृष्टिकोण की नकल करते हुए और फिर कुछ विवरणों को संशोधित करते हुए, एक "बाहरी उत्पाद" के रूप में लोगों और वर्णों के बीच "- ~" का पुन: लेखन और फ्लाई-इंडेक्सिंग (या यह क्या हो सकता है) का दुरुपयोग करना कहा जाता है) हमें कुछ बाइट्स बचाने की सुविधा देता है। यह अभी भी मुझे थोड़ा परेशान करता है कि मुझे कम बाइट लेने के लिए इंडेक्स एक्सप्रेशन नहीं मिल सकता है।

ऑक्टेव एक (i1) (i2) या सम (...) (i1) (i2) को अनुक्रमण के लिए अनुमति देता है, जहां Matlab हमें अनुक्रमण के बीच चरों को संग्रहीत करने की अनुमति देगा।

((x<0)+1:end)

"पहले छोड़ें तो" वर्णन करने के लिए बहुत लंबा है। इसके लिए अवश्य ही एक बेहतर तरीका होना चाहिए। '

— mathreadler
स्रोत
2

स्यूडोड , 688 579 521 बाइट्स

utilizar mate.pseudo
utilizar entsal.pseudo
adquirir n
adquirir a
adquirir r
adquirir i
fijar n a llamar LeerPalabra finargs
si son iguales n y CERO
escribir {0}
salir
fin
fijar a a llamar ValorAbsoluto n finargs
fijar i a CERO
si comparar Importar.Ent.Comparar n < CERO
fijar r a {~}
sino
fijar r a {-}
fin
mientras comparar Importar.Ent.Comparar i < a
escribir r finargs
si son iguales r y {~}
fijar r a {-}
Importar.Ent.Sumar i UNO i
sino
fijar r a {~}
fin
finbucle
si son iguales r y {~}
escribir {~}
fin
escribir {0}

के बारे में बताएं:

Read a number from STDIN;
If the number is zero (0); Then:
    Writes 0 to STDOUT and exits;
End If;
If the number is less than zero (0); Then:
    Set the fill character to "~";
Else:
    Set the fill character to "-";
End If;
For i = 0; While i is less than abs(number); do:
    Write the fill character to STDOUT;
    If the fill character is "~":
        Set the fill character to "-"
        Increment i by one
    Else:
        Set the fill character to "~"
    End if;
End for;
If the fill character is "~"; Then:
    Write "~" to STDOUT;
End If;
Write "0" to STDOUT
— alinarezrangel
स्रोत
1
PPCG में आपका स्वागत है! क्या यह उतना ही छोटा है जितना इसे मिलता है? मैं कुछ लंबे पहचानकर्ताओं को देखता हूं जिन्हें आप शायद "रे" ("रेलेनो" से "आर", मेनोस रेलेनो: पी) से छोटा कर सकते हैं। मुझे लगता है कि यदि आप केवल एक फ़ंक्शन या कोड स्निपेट भी हैं, तो आप मानक लिबास के लिए आयात छोड़ सकते हैं। यह आउटपुट पर न्यूलाइन को ट्रेस करने के लिए नहीं कहता है, इसलिए हो सकता है कि आप पिछले EscribirLinea को Escribir में बदल सकें। क्या आप छोटे नामों ( adquirir e``fijar p a Escribir) को कार्य सौंप सकते हैं ?
— फेड एस।
1

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

`?+#~.
.  ; 6
54_"#2
  @!

इसे ऑनलाइन आज़माएं!

व्याख्या

मुझे वास्तव में इस एक में नियंत्रण प्रवाह पसंद है। आईपी ​​एक चित्र 8 में चलता है (या वास्तव में एक I, मुझे लगता है) कोड के माध्यम से इनपुट को कम करने के लिए धीरे-धीरे 0संबंधित वर्णों को प्रिंट करते समय।

कोड ऊपरी बाएँ कोने में दाएँ से शुरू होता है। `अभी कुछ भी नहीं करता है। ?इनपुट पढ़ता है और +इसे नीचे दिए गए निहित शून्य में जोड़ता है। बेशक, जो कुछ भी नहीं करता है, लेकिन जब हम फिर से इस कोड पर चलते हैं, तो ?एक शून्य को धक्का देगा (क्योंकि हम ईओएफ में हैं), और +फिर उस शून्य से छुटकारा पा लेंगे।

इसके बाद #स्टैक की गहराई को धक्का देता है, बस यह सुनिश्चित करने के लिए कि आईपी को दक्षिण की ओर मोड़ने के लिए स्टैक पर एक सकारात्मक मूल्य है, और ;इसे फिर से हटा दें।

"नो-सेशन और कोड की मुख्य शाखा के रूप में कार्य करता है। भेद करने के तीन मामले हैं:

  • यदि वर्तमान मान धनात्मक है, तो IP दायाँ (पश्चिम) मुड़ता है और बाएँ पाश का एक चक्कर पूरा करता है:

    _45.`?+
_45      Push 45.
   .     Print as character '-'.
    `    Negate the current value (thereby applying the unary minus).
     ?+  Does nothing.

  • यदि वर्तमान मान ऋणात्मक है, तो IP बाएँ (पूर्व) और निम्न कोड चला जाता है:

    #26.~
#        Push stack depth, 1.
 26      Turn it into a 126.
   .     Print as character '~'.
    ~    Bitwise NOT of the current value (applying the ~).

    ध्यान दें कि ये दोनों वैकल्पिक होंगे (चूंकि दोनों इनपुट के संकेत को बदलते हैं) जब तक इनपुट मूल्य शून्य नहीं हो जाता। उस बिंदु पर...

  • जब वर्तमान मान शून्य होता है, तो आईपी बस दक्षिण की ओर बढ़ता रहता है, और निष्पादित होता है !और फिर पश्चिम की ओर मुड़ जाता है @। !प्रिंट करता है 0और @कार्यक्रम को समाप्त करता है।
— मार्टिन एंडर
स्रोत
1

GolfScript ,30 24 20 बाइट्स

  • सहेजे गए 6 बाइट्स xnor के लिए धन्यवाद।
  • डेनिस की बदौलत 4 बाइट्स बचाए।

~."-~"\abs*\0<{(;}*0

इनपुट: -5

आउटपुट: -5 = ~-~-~-~-~0

व्याख्या

~.     # Input to integer and duplicate
"-~"   # We shall output a repetition of this string
\abs   # Move the input onto the stack and computes abs
*      # Multiply "-~" for abs(input) times
\      # Copy onto the stack the input
0<     # Is it less than 0?
{(;}*  # Yes: remove first '-' from the output
0      # Push 0

इसे ऑनलाइन आज़माएं!

— FedeWar
स्रोत
1
आप मुद्रित करने के लिए की जरूरत नहीं है 2 = , बस -~-~0।
— xnor
1
आप उपयोग कर सकते हैं {(;}*0के बजाय {(;}{}if 0।
— डेनिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.