मुझे लगता है कि यहां पर बहुत आसान सवाल नहीं हैं जो शुरुआती प्रयास कर सकते हैं!
चुनौती: 1 और 0 के यादृच्छिक इनपुट स्ट्रिंग को देखते हुए जैसे:
10101110101010010100010001010110101001010
सबसे छोटा कोड लिखें जो बिट-वार प्रतिलोम को आउटपुट करता है जैसे:
01010001010101101011101110101001010110101
जवाबों:
मान लें कि इनपुट स्ट्रिंग चर में है b।
b='0'
यह वह नहीं करता है जो ज्यादातर भाषाओं में करता है ...
J तुलना ऑपरेटर सिर्फ
=(=:और=.क्रमशः वैश्विक और स्थानीय असाइनमेंट हैं)। हालांकि,=सामान्य==ऑपरेटर की तरह काम नहीं करता है : यह आइटम-दर-आइटम की तुलना करता है। ध्यान रखें कि इस तरह एक सरणी बनाई जाती है0 2 3 2 3 1 2 3 4:। उदाहरण के लिए2 = 0 2 3 2 3 1 2 3 4देता0 1 0 1 0 0 1 0 0है। यह एक स्ट्रिंग के लिए समान है:'a'='abcadcadda'केवल वापस नहीं0आता है, यह रिटर्न करता है1 0 0 1 0 0 1 0 0 1(इसका मतलब के0साथ एक्सट्रपलेशन किया जा सकता है*/, जो मूल रूप से होता हैall।) इस मामले में, हालांकि, यह व्यवहार उत्कृष्ट है, क्योंकि हम लोगों और शून्य का एक स्ट्रिंग चाहते हैं, या सच्ची और झूठी। चूँकि J के बूल हैं1और0, इसके परिणामस्वरूप सरणी होती है1और0की (वे तार नहीं हैं, और इसके अलावा अन्य हर चरित्र1भी0इस सरणी में परिणाम होगा ।) यह मुद्रण की जरूरत नहीं है: जम्मू स्वचालित रूप से एक अभिव्यक्ति का परिणाम प्रिंट करता है। मुझे उम्मीद है कि यह पर्याप्त स्पष्टीकरण था, यदि नहीं, तो कृपया कुछ ऐसा पूछें जो टिप्पणियों में अभी तक स्पष्ट नहीं है। यह उत्तर भी हो सकता है'0'&=(या=&'0'), लेकिन मुझे लगा किb='0'यह स्पष्ट था।
=&'0'समान बाइट्स के लिए काम करता है।
{1^}%
GolfScript एसटीडीआईएन से पूरे इनपुट को पढ़ता है और इसे स्टैक पर स्ट्रिंग के रूप में रखता है।
{}% स्ट्रिंग में सभी वर्णों के माध्यम से जाता है और उन सभी के लिए कोड ब्लॉक निष्पादित करता है।
1^ 1. "0" के साथ ASCII कोड के अनन्य OR वर्णों की गणना करता है और ASCII कोड 48, "1" से ASCII कोड 49 से मेल खाता है।
के बाद से 48 ^ 1 = 49और 49 ^ 1 = 48, इस 0 के बदल जाता है 0 के में 1 है और 1 के में।
एक बार समाप्त होने के बाद, गोल्फस्क्रिप्ट संशोधित स्ट्रिंग को प्रिंट करता है।
q1f^
इस Xor के हर चरित्र के साथ 1.
अन्य CJam उत्तर के विपरीत, मुझे नहीं लगता कि इनपुट पहले से ही स्टैक पर है।
इसे http://cjam.aditsu.net/ पर आज़माएं
f।
खैर, यह फिर से कम हो गया! एक असंबंधित चुनौती के लिए एक समाधान लिखने के बाद , मैंने देखा कि एक ही चाल यहाँ भी लागू की जा सकती है। तो अब हम शुरू करें:
00000000 b4 08 cd 21 35 01 0a 86 c2 eb f7 |...!5......|
0000000b
टिप्पणी विधानसभा:
org 100h
section .text
start:
mov ah,8 ; start with "read character with no echo"
lop:
; this loop runs twice per character read; first with ah=8,
; so "read character with no echo", then with ah=2, so
; "write character"; the switch is performed by the xor below
int 21h ; perform syscall
; ah is the syscall number; xor with 0x0a changes 8 to 2 and
; viceversa (so, switch read <=> write)
; al is the read character (when we did read); xor the low
; bit to change 0 to 1 and reverse
xor ax,0x0a01
mov dl,al ; put the read (and inverted character) in dl,
; where syscall 2 looks for the character to print
jmp lop ; loop
मुझे लगता है कि यह इससे ज्यादा छोटा नहीं है।असल में, यह किया! @Ninjalj का शुक्रिया एक और बाइट बंद करने के लिए।
00000000 b4 08 cd 21 34 01 92 b4 02 cd 21 eb f3 |...!4.....!..|
0000000d
इस संस्करण में उन्नत इंटरएक्टिविटी ™ की विशेषता है - इसे कमांड लाइन से चलाने के बाद, यह "उल्टे" वर्णों को तब तक बाहर निकालता है जब तक आप इनपुट अंक लिखते हैं (जो कि गूंज नहीं हैं); बाहर निकलने के लिए, बस एक Ctrl-C करें।
पिछले समाधान के विपरीत, इसमें DosBox में चलने में कुछ परेशानी है - चूंकि DosBox Ctrl-C को सही ढंग से समर्थन नहीं करता है , यदि आप बाहर निकलना चाहते हैं तो आपको DosBox विंडो को बंद करने के लिए मजबूर किया जाता है। VM में DOS 6.0 के साथ, इसके बजाय, यह इच्छानुसार चलता है।
NASM स्रोत:
org 100h
section .text
start:
mov ah,8
int 21h
xor al,1
xchg dx,ax
mov ah,2
int 21h
jmp start
इसने कमांड लाइन से इसके इनपुट को स्वीकार किया; DosBox में .COM फ़ाइल के रूप में आसानी से चलता है।
00000000 bb 01 00 b4 02 8a 97 81 00 80 f2 01 cd 21 43 3a |.............!C:|
00000010 1e 80 00 7c f0 c3 |...|..|
NASM इनपुट:
org 100h
section .text
start:
mov bx, 1
mov ah, 2
loop:
mov dl, byte[bx+81h]
xor dl, 1
int 21h
inc bx
cmp bl, byte[80h]
jl loop
exit:
ret
xchg dx,ax1 बाइट से कम हैmov dl,al
tr 01 10
STDIN से इनपुट लेता है।
या
y/01/10/
y 01 10
tr...
:~:!
माना जाता है कि मूल स्ट्रिंग पहले से ही स्टैक पर है। संशोधित स्ट्रिंग प्रिंट करता है।
निम्नलिखित कोड चिपकाकर इसे ऑनलाइन आज़माएं :
"10101110101010010100010001010110101001010":~:!
:~स्ट्रिंग के प्रत्येक वर्ण का मूल्यांकन करता है, अर्थात, यह वर्ण 0 को पूर्णांक 0 से बदलता है ।
:!प्रत्येक पूर्णांक की तार्किक संख्या की गणना करता है। यह 0 में 1 का और 1 का 0 में बदल जाता है।
>,[>,]<[<]>[<+++++++[>-------<-]<+>>[++<]<[>]++++++++[>++++++<-]>.[-]>]
स्पष्टीकरण:
>,[>,] Read characters until there are none left.
<[<] Return to start
>[< Loop as long as there are characters to invert
+++++++[>-------<-] Subtract 49 (ASCII value of 1)
>[++<] If not 0, add 2
+++[<++++>-]<[>>++++<<-]>> Add 48
. Print
[-] Set current cell to 0
>] Loop
aके लिए 11।
Put this tasty pancake on top!
[]
Put this delicious pancake on top!
[#]
Put this pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
Put this supercalifragilisticexpialidociouseventhoughtheso pancake on top!
Flip the pancakes on top!
Take from the top pancakes!
Flip the pancakes on top!
Take from the top pancakes!
Put this supercalifragilisticexpialidociouseventhoughthes pancake on top!
Put the top pancakes together!
Show me a pancake!
If the pancake is tasty, go over to "".
यह मानता है कि इनपुट एक अशक्त चरित्र द्वारा समाप्त हो गया है। रणनीति इस प्रकार है:
1।0( 1अगर हमारे पास था 0, या 0अगर हमारे पास था 1)0इसे करने के लिएi(char*s){*s^=*s?i(s+1),1:0;}
इसे यहाँ ऑनलाइन आज़माएँ ।
XOR चाल, डेनिस को इंगित करने के लिए धन्यवाद।
i(char*s){while(*s)*s++^=1;}
whileसाथ अपने को प्रतिस्थापित करना for।
ओह यह कितना पहला चूसता है। बहुत बदसूरत, यह एक है। 63 वर्ण।
print''.join([bin(~0)[3:] if x == '0' else bin(~1)[4:] for x in ''])यह एक सा बेहतर है लेकिन फिर भी यह कल्पना नहीं है। 44 चरस।
print''.join([str(int(not(int(x)))) for x in ''])के बाद से int(x) and 1रिटर्न int(x)अगर यह 0 और नहीं तो झूठी नहीं है। समाधान को 36 वर्णों तक कम किया जा सकता है।
print''.join([str(1-int(x)) for x in ''])चूंकि join()एक जनरेटर लेता है कोष्ठक हटाया जा सकता है। 32 चरस।
print''.join(str(1-int(x))for x in'')और इसके बजाय बैकटिक्स का उपयोग किया जा सकता है str()
print''.join(`1-int(x)`for x in'')@TheRare से पॉइंटर्स के लिए 34 धन्यवाद से कम 44
bin(-int)-0bxxx के ऊपर से रिटर्न के बाद से किसी के पूरक का पता लगाना मुश्किल है ।
(int(x) and 1) == int(x)
'' == Falseऔर'hi' == True
''.join(`1-int(x)`for x in'')
repr(x)फि < , x <अधिकतम के लिए समान हैstr(x)
'y/10/01/'
9 वां वर्ण 'p' ध्वज है
उपयोग:
$ echo '10101001' | perl -pe 'y/10/01/'
y/10/01/लेकिन एक चार छोटा क्योंकि इसे किसी भी झंडे की जरूरत नहीं है
alert(prompt().replace(/./g,x=>x^1))s, s.replace(/./g,x=>x^1)22 वर्ण हैं।
p=prompt(p().replace(/./g,x=>x^1))
(p=prompt)(p().replace(/./g,x=>x^1))और यही लंबाई होगी।
(भूलभुलैया इस चुनौती से नया है, इसलिए यह जवाब प्रतिस्पर्धा नहीं करता है - ऐसा नहीं है कि यह वैसे भी जीत रहा है ...)
1,
.$@
यह कोड मानता है कि STDIN में केवल अंक होते हैं (विशेष रूप से, कोई अनुगामी न्यूलाइन नहीं)।
निर्देश पॉइंटर (IP) दाएं से बाएं बाएं कोने में शुरू होता है। जबकि पढ़ने के लिए अंक हैं यह बाएं हाथ 2x2 ब्लॉक के माध्यम से एक तंग लूप में चक्र होगा: 11 धक्का, ,एक अंक पढ़ें, $XOR इसे 1 के साथ अंतिम बिट टॉगल करें, .परिणाम प्रिंट करें। आईपी इस लूप को लेता है क्योंकि XOR के बाद स्टैक का शीर्ष सकारात्मक होता है, जैसे कि यह एक दाहिना-मोड़ लेगा। जब हम ईओएफ से टकराते हैं, तो बदले में ,लौटते -1हैं। तब XOR उपज देगा -2और इस ऋणात्मक मान के साथ आईपी एक बाएं-मुड़ता है @और प्रोग्राम समाप्त होता है।
यह समाधान Labyrinth के लिए इष्टतम किया जाना चाहिए: आप की जरूरत ,है और .एक आई / ओ पाश के लिए और @कार्यक्रम समाप्त करने के लिए। अंतिम बिट को टॉगल करने के लिए आपको कम से कम दो वर्ण (यहां 1और $) चाहिए। और आपको लूप के लिए कम से कम एक न्यूलाइन की आवश्यकता होती है जिसे समाप्त किया जा सकता है।
जब तक ... अगर हम STDERR को नजरअंदाज करते हैं, यानी एक त्रुटि के साथ समाप्त करने की अनुमति दें तो हम बचा सकते हैं @और हमें दो रास्तों के बीच स्विच करने के लिए किसी भी तरह की आवश्यकता नहीं है। हम केवल तब तक पढ़ते और छपाई करते रहते हैं जब तक कि हम गलती से एक नकारात्मक मान ( -2) को मुद्रित करने का प्रयास नहीं करते । यह कम से कम दो 5-बाइट समाधान के लिए अनुमति देता है:
1,
.$
,_1$.
p $<.read.tr("01","10")
इस ऑनलाइन टीएम सिम्युलेटर द्वारा आवश्यक नियम तालिका सिंटैक्स का उपयोग करना । कुछ महीने पहले मैंने अपने गूगोलॉजी विकी यूजर ब्लॉग पर किए गए पोस्ट से उधार लिया था।
0 0 1 r *
0 1 0 r *
0 _ _ * halt
आप इस जावा कार्यान्वयन का उपयोग करके इसका परीक्षण भी कर सकते हैं ।
print''.join(`1-int(x)`for x in raw_input())इसे जटिल क्यों बनाते हैं, या कुछ धोखा देने योग्य चर का उपयोग करते हैं?
print''.join('1-int(x)'for x in'input()'):। मैं टिप्पणी कोड में backticks नहीं मिल सकता है इसलिए उन्हें 'द्वारा प्रतिस्थापित किया।
`a\`b`-> a`b।
पूरा कार्यक्रम। संकेत देता है।
∊⍕¨~⍎¨⍞⍞ शीघ्र
⍎¨ प्रत्येक चरित्र को निष्पादित करें
~ तार्किक नहीं
⍕¨ प्रत्येक वर्ण को पाठ के रूप में प्रारूपित करें
∊ ϵ nlist (समतल)
<kbd>टैग का दुरुपयोग दुरुपयोग ।
यह एक फ़ंक्शन है जो Ansइनपुट के रूप में एक बाइनरी स्ट्रिंग (के माध्यम से ) लेता है और आउटपुट को उलटा (उलटा नहीं) स्ट्रिंग के रूप में निर्दिष्ट के रूप में वापस करता है। अधिक मदद के लिए, आप not(TI-BASIC wiki पर सूची आवेदन के माध्यम से पढ़ सकते हैं । मैं संकलित संस्करण का उपयोग कर रहा हूं क्योंकि यह छोटा है:
»*r>Õ¸r
हेक्स में:
BB 2A 72 3E D5 B8 72
व्याख्या
»*r - फ़ंक्शन इनपुट को स्ट्रिंग के रूप में लें और सूची में बदलें
> - अगले ऑपरेटरों को सूची दी गई पाइप
Õ¸r - सूची का उलटा लौटाएं
»*r>Õ¸r ?
expr(Ans:Returnnot(Ans; 2. क्योंकि स्ट्रिंग कॉमा से अलग नहीं होती है, और यह ए से शुरू नहीं होती है {, यह 1000010011 जैसे एक पूर्णांक को विकसित करेगी, सूची नहीं; 3. Returnआपके द्वारा लिखे गए तरीके से काम नहीं करता है; 4. यह एक सूची के रूप में आउटपुट देता है, न कि एक स्ट्रिंग।
map(\c->"10"!!read[c])
मैं इस चुनौती के हास्केल समाधानों की कमी से हैरान था, इसलिए यहां एक है। यह एक फ़ंक्शन का मूल्यांकन करता है जो एक स्ट्रिंग लेता है और इसका उलटा लौटाता है।
यहां कुछ भी नहीं फैंसी।
map(\c-> ) -- For each character c in the input string:
[c] -- wrap c into a string,
read -- convert to integer,
"10"!! -- and index the string "10" with it.
0>~1+:#v_$>:#,_@
^ -1<
खाली स्टैक और ईओएफ दोनों को पढ़कर मान लें -1।
0 शून्य टर्मिनेटर के रूप में एक \ 0 धक्का देता है
>~1+:#v_ एक इनपुट लूप है, यह ascii पढ़ता है, 1 जोड़ता है, EOF + 1 = 0 के लिए चेक,
^ -1< अन्यथा 1 घटाता है और स्टैक पर धकेल दिया गया एस्की मूल्य छोड़ देता है।
$>:#,_@ स्टैक के शीर्ष पर शून्य की अतिरिक्त कॉपी को गिराता है, फिर बाइनरी स्ट्रिंग को ऊपर से नीचे की ओर प्रिंट करता है
यदि खाली स्टैक 0 पढ़ता है, तो 2 बाइट्स के साथ सहेजें
>~:1+#v_$>:#,_@
^ -1<
यदि EOF = 0 है, तो इसी एल्गोरिथ्म का उपयोग करके लगभग 15 बाइट्स का एक संस्करण संभव है, लेकिन मेरे पास परीक्षण के लिए ऐसा कार्यान्वयन काम नहीं है।
'a#@~-,
प्रत्येक वर्ण के लिए, cइनपुट में, यह उस चरित्र को अंकित करता है 94 - c, जिसमें 94 '0' + '1' या 'a' का मान है।
मेथिंक्स पायथन इसके लिए सबसे अच्छी भाषा नहीं है। :)
for i in input():print(1-int(i),end='')
यदि आप आउटपुट के बाद एक नई लाइन होने की परवाह करते हैं, तो यहां एक 43-वर्ण विकल्प है:
print(''.join("01"[i<"1"]for i in input()))
end=''सिर्फ एक के बिना काम ,करेगा :) - जब तक आप कोई जगह नहीं होने के बारे में परवाह करते हैं
printफ़ंक्शन को endप्रत्येक प्रिंट के अंत में एक नई रेखा को दबाने के लिए पैरामीटर को ट्विक करने की आवश्यकता होती है । इसके अलावा, ओपी के विनिर्देश के अनुसार, मुझे लगता है कि मैं इस बारे में परवाह करता हूं कि कोई स्थान नहीं है। :) टिप्पणी के लिए धन्यवाद, हालांकि!
J में बूलियन मान को पूर्णांक के रूप में दर्शाया जाता है 0और 1, निश्चित रूप से सरणियों में मान्य सूचक भी हैं (इस मामले में, 2-वर्ण सरणी '01')
'01'{~'0'&=
पार्टी में थोड़ी देर हो गई, लेकिन यहां मेरा है। :)
using System;class R{static void Main(string[]a){foreach(var v in a[0].ToCharArray()){Console.Write(int.Parse(v.ToString())^1);}}}
भाषा को प्रश्न के रूप में पोस्ट न करना
Iv2 0 12
>e>S SS
e1e0
^< <P
हाइलाइटिंग के साथ:
