13

आज्ञा देना fसमारोह है कि एक बिटफ़ील्ड {0 1}का आकार ( ) के आकार n+1के बिटफील्ड के लिए वें और वें बिट पर nलागू XORकरने और नए बिटफील्ड में परिणाम लिख रहा है।ii+1

उदाहरण: f("0101") = "111"

अनौपचारिक गणना:

0 XOR 1 = 1

1 XOR 0 = 1

0 XOR 1 = 1

आज्ञा देना f_inverseउलटा कार्य करते हैं f। चूंकि व्युत्क्रम अद्वितीय नहीं है, f_inverseएक वैध समाधान लौटाता है।

इनपुट: बिटफील्ड स्ट्रिंग (यानी "0101111101011") और एक प्राकृतिक संख्या के रूप मेंk

आउटपुट: स्ट्रिंग के रूप में बिटफील्ड, ताकि इनपुट बिटफील्ड के लिए बार f_inverseलागू होने पर स्ट्रिंग में परिणाम हो k। (यानी f_inverse(f_inverse(f_inverse(input))))

जीत के मापदंड: सबसे कम वर्ण

बक्शीश:

-25वर्ण यदि f_inverseपुनरावर्ती / पुनरावृत्त रूप से लागू नहीं होते हैं, इसके बजाय आउटपुट स्ट्रिंग की सीधे गणना की जाती है

Testscript:

a = "011001"
k = 3

def f(a):
    k = len(a)
    r = ""
    for i in xrange(k-1):
        r += str(int(a[i]) ^ int(a[i+1]))
    return r

def iterate_f(a, k):
    print "Input ", a
    for i in xrange(k):
        a = f(a)
        print "Step " + str(i+1), a

iterate_f(a, k)

आप इसे यहां उदाहरण के लिए पेस्ट कर सकते हैं और फिर इसे आज़मा सकते हैं।

code-golf

— NVIDIA
स्रोत

3

क्या आप सत्यापित करने के लिए कुछ परीक्षण मामले दे सकते हैं।

— ऑप्टिमाइज़र

3

क्या आप कृपया उन्हें कॉल करना बंद कर सकते हैं- {0-1}बिटफील्ड्स? इसके अलावा, मुझे यह समझ में नहीं आता कि fकहां iसे आता है? XOR का दूसरा तर्क क्या है? हम कैसे प्राप्त करते 111हैं 0101?

— मनिीप

बेहतर नाम क्या है? मैं सूचकांक को दर्शाता है

— nvidia

बस एक "बिटफील्ड" करना होगा। / मान / का क्या है i? "0 XOR 1" = 1 "1 XOR 0" = 1 "0 XOR 1" = 1कुछ भी नहीं समझाता है: मुझे पता है कि XOR कैसे काम करता है, लेकिन वास्तव में हम XORing क्या कर रहे हैं और हम परिणाम कहां जमा कर रहे हैं?

— मनिीप

9

मुझे लगता है कि उसका मतलब है f([a,b,c,d]) = [a^b, b^c, c^d]:। और वह है कि समारोह के प्रतिलोम, यानी चाहता है f'([x,y,z]) = [a,b,c,d]ऐसा है कि a^b=x, b^c=y, c^d=z।

— मारीनस

14

Pyth, 33 30 - 25 = 5 बाइट्स

Jiz8K+lzQ%"%0*o",KuxG/G8rQ^2KJ

इसे stdin जैसे इनपुट से चलाएं (ऑनलाइन दुभाषिया: https://pyth.herokuapp.com/ ):

111
3

और परिणाम stdout को लिखा जाएगा।

यह इसका सीधा अनुवाद है:

पायथन 2, 127 118 79 - 25 = 54 बाइट्स

def i(s,k):
 l=int(s,8);t=len(s)+k
 while k<1<<t:l^=l/8;k+=1
 print'%0*o'%(t,l)

इसे कॉल करें i("111", 3), और परिणाम stdout को लिखा जाएगा।

ध्यान दें कि हम उम्मीद करते हैं कि k बहुत बड़ा नहीं होगा, क्योंकि कोड-गोल्फ उद्देश्य के लिए इनर लूप O (2 ^k ) बार के लिए चलेगा ।

मुझे लगता है कि हम आम तौर पर इस ऑपरेशन को "ज़ोर्शिफ्ट" या कुछ और कहते हैं। यदि हम इनपुट को बड़े-एंडियन पूर्णांकों के रूप में व्यक्त करते हैं, तो फ़ंक्शन एफ बस है:

f (x) = x ⊕ (x x 1)

यदि हम दो बार f लागू करते हैं तो हमें मिलेगा:

f ² (x) = x ⊕ (x = 2)

हालांकि 3 बार आवेदन करने का एक अलग पैटर्न होगा:

f ³ (x) = x ⊕ (x ⊕ 1) x (x ⊕ 2) ⊕ (x ≫ 3)

4 बार आवेदन करने से मूल फॉर्म वापस मिल जाएगा:

f ⁴ (x) = x = (x = 4)

और इसी तरह:

f ^{2 ^k} (x) = x) (x) 2 ^k )

ध्यान दें कि यदि हम एक बड़ा-पर्याप्त 2 ^k चुनते हैं , तो (x ) 2 ^k ) = 0, जिसका अर्थ है f ^{2 ^k} (x) = x, और व्युत्क्रम पहचान का कार्य है!

च को खोजने के लिए रणनीति तो ^-k बुला च बिना (एक्स) ^-1 (एक्स) सब पर है:

K को ऐसे खोजें:
- के ≥ के
- K> लॉग ₂ x
- K, 2 की शक्ति है
एक्सप्रेस f ^-k (x) = f ^{-K + (Kk)} (x) = f ^-K (f ^K-k (x)) = f ^K-k (x)
इस प्रकार, परिणाम को fकेके समय कहा जाता है
25 रुपये का लाभ: पी

अद्यतन 1 : बाइनरी के बजाय ऑक्टल प्रतिनिधित्व का उपयोग किया ताकि हम %बहुत सारे बाइट्स को बचाने के लिए स्वरूपण का उपयोग कर सकें ।

अद्यतन 2 : की आवधिक संरचना को उजागर करें f। गैर-पुनरावृत्ति वाले के बाद से पुनरावृत्त संस्करण सेवानिवृत्त -25 बाइट्स बोनस के बिना भी कम है।

अपडेट 3 : पायथ से 3 बाइट्स घटाए, धन्यवाद इस्साक!

— kennytm
स्रोत

जैसा कि युक्तियों में वर्णित है: codegolf.stackexchange.com/a/45280/20080 आप लूप और असाइनमेंट को कम करने के लिए बदल सकते हैं, इस तरह:Jiz8K+lzQ%"%0*o",KuxG/G8rQ^2KJ

— isaacg

11

CJam, 15 14 बाइट्स

l~{0\{1$^}/]}*

जैसे इनपुट लेता है

"111" 3

इसका परीक्षण यहां करें।

व्याख्या

l~{0\{1$^}/]}*
l~             "Read and evaluate input.";
  {         }* "Repeat k times.";
   0\          "Push a 0 and swap it with the string/array.";
     {   }/    "For each element in the string/array.";
      1$       "Copy the previous element.";
        ^      "XOR.";
           ]   "Wrap everything in a string/array again.";

परिणाम स्वचालित रूप से कार्यक्रम के अंत में मुद्रित किया जाता है।

मैं "स्ट्रिंग / सरणी" कहता हूं, क्योंकि मैं एक स्ट्रिंग के साथ शुरू करता हूं (जो कि वर्णों का एक सरणी है), लेकिन मैं उनके बीच और साथ ही संख्याओं के बीच XORs लेता रहता हूं। Character Character ^एक पूर्णांक (कोड बिंदुओं के XOR के आधार पर) देता है, Character Integer ^और Integer Character ^एक चरित्र देता है (कोड बिंदु के साथ संख्या के XOR के आधार पर - एक कोड बिंदु के रूप में व्याख्या की जाती है)। और Integer Integer ^निश्चित रूप से सिर्फ एक पूर्णांक देता है।

प्रकार के जगह पर सभी उड़ान कर रहे हैं, लेकिन सौभाग्य से तो, जब भी मैं एक पूर्णांक है यह या तो है 0या 1और यह या तो है जब भी मैं एक चरित्र है '0और '1और परिणाम हमेशा होता है (किसी भी प्रकार में) एक वांछित। चूँकि तार केवल वर्णों के सरणियाँ हैं, वर्णों को संख्याओं के साथ मिलाना कोई समस्या नहीं है। और अंत में, जब सब कुछ मुद्रित होता है, तो पात्रों को कोई विशेष सीमांकक नहीं मिलता है, इसलिए आउटपुट प्रभावित नहीं होता है, जिसमें बिट को संख्या या वर्ण के रूप में दर्शाया जाता है।

— मार्टिन एंडर
स्रोत

सीजेम में चरित्र / संख्या प्रकार के व्यवहार की आपकी उत्कृष्ट व्याख्या ने मुझे 25- 25 = 0 बाइट्स तक पहुंचाने वाले मेरे समाधान को बाइट करने दिया । धन्यवाद, और +1!

— इल्मरी करोनें

2

उस प्रकार का व्यवहार भयानक (+1) है।

— बॉलस्टेस्टा

8

जे, 17 वर्ण

हमेशा अग्रणी अंक के रूप में 0 का उपयोग करना।

   (~:/\@]^:[,~[$0:)

   3 (~:/\@]^:[,~[$0:) 1 1 1 
0 0 0 1 0 0

शीर्ष पंक्ति के 128 1 के राज्य (बाएं) और एक यादृच्छिक राज्य (दाएं) से शुरू होकर, पहले 129 पुनरावृत्ति के माध्यम से अंतिम 128 अंक दिखा रहा है।

   viewmat (~:/\)^:(<129) 128$1               viewmat (~:/\)^:(<129) ?128$2

भूखंड

— randomra
स्रोत

6

एपीएल 11

((0,≠\)⍣⎕)⎕

स्पष्टीकरण:

≠\  compare increasing number of elements (1 1 1 ->1 0 1)
0,    add a starting zero
()⍣⎕  repeat the function in parenthesis ⎕ times, ⎕ is the second argument
()⎕   apply all to ⎕, that is first argument

Tryapl.org पर कोशिश करें

— मोरिस ज़ुक्का
स्रोत

इसे tryapl पर नहीं चलाया जा सकता (आप इनपुट कैसे देते हैं?) लेकिन ≠\ इसके बजाय काम नहीं करेंगे 2|+\ ?

— यादृच्छिक

the के इनपुट्स हैं, यदि आप उसी अभिव्यक्ति का उपयोग करते हैं जो मैंने लिखा था, तो प्रोग्राम आपको उन नंबरों के लिए पूछना चाहिए जो आप चाहते हैं, पहले बाइनरी वेक्टर, फिर पुनरावृत्तियों की संख्या के लिए दूसरी बार। मैंने tryapl के लिंक में a और b का उपयोग किया है, इसलिए इसे बिना पूछे चीजों के द्वारा निष्पादित किया जाता है। ≠ \ _ के लिए भी धन्यवाद !!

— मोरिस ज़ूका

यदि मैं कॉपी करता ((0,≠\)⍣⎕)⎕हूं तो मुझे अमान्य टोकन मिलता है। Tryapl आदानों को संभाल नहीं सकता है?

— रैंडम

1

हम्म्म्म ... आप सही कह रहे हैं, यह मेरे साथ भी ऐसा ही हो रहा है। मैं Dyalog एपीएल का उपयोग कर रहा हूं और फिर यहां पोस्ट करने के लिए ट्रायप्ल कर रहा हूं, इसलिए मैंने कभी गौर नहीं किया, इसके बारे में खेद है।

— मोरिस ज़ूका

5

सीजाम, 25 - 25 = 0 बाइट्स

q~1,*_@{[\{1$^}/_](;)\}/;

यह नीचे दिए गए गोल्फस्क्रिप्ट जवाब का सिर्फ एक सीधा सीजेएम पोर्ट है, क्योंकि मार्टिन बंटनर के जवाब को पढ़ने के बाद , मुझे एहसास हुआ कि मैं सीजेएम के पूर्णांक और चरित्र प्रकारों को संभालने के कारण एक बाइट बचा सकता हूं। (मूल रूप से, CJam 1&को गोल्फस्क्रिप्ट कोड में ASCII वर्णों को बिट्स में बाध्य करने के लिए उपयोग करने की आवश्यकता नहीं है , लेकिन qइनपुट को पढ़ने के लिए एक पूर्वनिर्धारित की आवश्यकता है ।) मैं आमतौर पर इस तरह के एक तुच्छ बंदरगाह को एक सस्ती चाल पर विचार करूंगा, लेकिन एक शून्य से प्राप्त किया जा सकता है। यह IMO सार्थक है।

किसी भी स्थिति में, यह कार्यक्रम नीचे दिए गए मूल गोल्फस्क्रिप्ट कार्यक्रम की तरह ही काम करता है, इसलिए कृपया इसके विवरण और उपयोग के निर्देश देखें। हमेशा की तरह, आप इस ऑनलाइन दुभाषिया का उपयोग करके सीजेएम संस्करण का परीक्षण कर सकते हैं ।

गोल्फस्क्रिप्ट, 26 - 25 = 1 बाइट

~1,*.@{[1&\{1$^}/.](;)\}/;

यह समाधान केवल एक बार इनपुट स्ट्रिंग पर आधारित है, इसलिए मेरा मानना है कि यह er25 बाइट बोनस के लिए योग्य है। यह आंतरिक रूप से एक k -element सरणी को बनाए रखने के द्वारा काम करता है जो k- पूर्व-पुनरावृत्तियों में से प्रत्येक के वर्तमान बिट को संग्रहीत करता है।

इनपुट को स्टैडिन के माध्यम से, प्रारूप में "1111111" 3, अर्थात के के अक्षर 0और 1वर्ण के रूप में दिया जाना चाहिए , उसके बाद नंबर k होगा । आउटपुट स्टैडआउट होगा, उद्धरण के बिना एक बिटस्ट्रिंग के रूप में।

इस कोड को ऑनलाइन टेस्ट करें। (यदि प्रोग्राम का समय समाप्त हो गया है, तो इसे पुनः चलाने का प्रयास करें; वेब गोल्फस्क्रिप्ट सर्वर यादृच्छिक समय के लिए कुख्यात है।)

यहाँ इस कार्यक्रम का एक विस्तारित संस्करण है, टिप्पणियों के साथ:

~             # eval the input, leaving a string and the number k on the stack

1,*           # turn the number k into an array of k zeros ("the state array")
.             # make a copy of the array; it will be left on the stack, making up the
              # first k bits of the output (which are always zeros)

@             # move the input string to the top of the stack, to be iterated over
{
  [           # place a start-of-array marker on the stack, for later use
  1&          # zero out all but the lowest bit of this input byte
  \           # move the state array to the top of the stack, to be iterated over

  { 1$^ } /   # iterate over each element of the state array, XORing each
              # element with the previous value on the stack, and leave
              # the results on the stack

  .           # duplicate the last value on the stack (which is the output bit we want)
  ]           # collect all values put on the stack since the last [ into an array
  (;          # remove the first element of the array (the input bit)
  )           # pop the last element (the duplicated output bit) off the array
  \           # move the popped bit below the new state array on the stack
}
/             # iterate the preceding code block over the bytes in the input string

;             # discard the state array, leaving just the output bits on the stack

मूल रूप से, अधिकांश पुनरावृत्त समाधानों की तरह, इस कोड को पुनरावृत्ति को लागू करने के रूप में समझा जा सकता है

ख _{मैं , जे} : = ख _{मैं , ( जे -1)} ⊕ ख _{( मैं -1), ( जे -1)} ,

जहां ख _{0, जे} है j वें इनपुट बिट (के लिए जे ≥ 1), ख _{कश्मीर , जे} है j वें उत्पादन बिट, और ख _{मैं , 0} = 0 धारणा के द्वारा। अंतर यह है कि, जबकि पुनरावृत्त समाधान, वास्तव में, पुनरावृत्ति की गणना "पंक्ति द्वारा पंक्ति" (यानी पहले बी _{1, जे के} लिए सभी जे , फिर बी _{2, जे} , आदि), यह समाधान इसके बजाय "कॉलम" द्वारा गणना करता है। स्तंभ "(या, और अधिक सही," विकर्ण द्वारा "विकर्ण), पहली कंप्यूटिंग ख _{मैं , मैं} 1 के लिए ≤ मैं≤ k , फिर b _{i , i +1} , फिर b _{i , i +2} , आदि।

इस दृष्टिकोण का एक (सैद्धांतिक) लाभ यह है कि, सिद्धांत रूप में, यह विधि केवल O ( k ) स्टोरेज का उपयोग करके मनमाने ढंग से लंबे इनपुट स्ट्रिंग को संसाधित कर सकती है । बेशक, गोल्फस्क्रिप्ट दुभाषिया कार्यक्रम को चलाने से पहले मेमोरी में सभी इनपुट को स्वचालित रूप से पढ़ता है, वैसे भी ज्यादातर इस लाभ को नकारते हैं।

— इल्मरी करोनें
स्रोत

2

पायथन, 94 78

एक बार कम से कम निष्पादित किया जाएगा और इस प्रकार के लिए एक ही परिणाम देता है n=0औरn=1

def f(x,n):
 c='0'
 for i in x:c+='10'[i==c[-1]]
 return f(c,n-1)if n>1 else c

पुराना संस्करण जो स्ट्रिंग को एक संख्यात्मक सरणी में परिवर्तित करता है और "modulo 2" को एकीकृत करता है

from numpy import*
g=lambda x,n:g(''.join(map(str,cumsum(map(int,'0'+x))%2)),n-1)if n>0 else x

— DenDenDo
स्रोत

2

अजगर 2, 68

g=lambda l,n,s=0:n and g(`s`+(l and g(l[1:],1,s^(l>='1'))),n-1)or l

एक पूरी तरह से पुनरावृत्ति समाधान। यह समझना आसान है कि क्या दो कार्यों में टूट गया

f=lambda l,s=0:`s`+(l and f(l[1:],s^(l>='1')))
g=lambda l,n:n and g(f(l),n-1)or l

जहाँ fक्रमिक भिन्नता की गणना करता है और n समय के साथ खुद को gबनाता है f।

यह फ़ंक्शन fसंचयी XOR-sums की गणना करता है l, जो क्रमिक XOR- अंतरों के लिए उलटा ऑपरेशन है। चूंकि इनपुट को एक स्ट्रिंग के रूप में दिया गया है, इसलिए हमें निकालने की आवश्यकता है int(l[0]), लेकिन स्ट्रिंग तुलना के साथ इतना छोटा है l>='1'।

अजगर २, ६ ९

एक execलूप का उपयोग करके एक पुनरावृत्त समाधान 1 चार लंबे समय तक निकला।

l,n=input()
exec"r=l;l='0'\nfor x in r:l+='10'[l[-1]==x]\n"*n
print l

शायद स्ट्रिंग से निपटने का एक छोटा तरीका है। यदि हम इनपुट / आउटपुट संख्या की सूची हो सकते हैं, तो यह 5 वर्णों को बचाएगा

l,n=input()
exec"r=l;l=[0]\nfor x in r:l+=[l[-1]^x]\n"*n
print l

— XNOR
स्रोत

1

पर्ल 5, 34

#!perl -p
s/ .*//;eval's/^|./$%^=$&/eg;'x$&

एक अंतरिक्ष द्वारा अलग किए गए मानक इनपुट पर दिए गए पैरामीटर।

$ perl a.pl  <<<"1101 20"
101111011011011011010110

— nutki
स्रोत

1

जावास्क्रिप्ट ईएस 6, 47 वर्ण

f=(s,k)=>k?f(0+s.replace(s=/./g,x=>s^=x),--k):s

वैसे, कोई साइड इफेक्ट नहीं है :)

— Qwertiy
स्रोत

आपको पुनरावृत्तियों की संख्या के लिए ak पैरामीटर को स्वीकार करने की आवश्यकता है। (-25 बोनस वास्तव में पुनरावृत्तियों का प्रदर्शन किए बिना पुनरावृत्तियों के परिणाम की गणना के लिए है।)

— ब्रिलियन

मुझे स्पेसिफिकेशन को ध्यान से पढ़ना चाहिए (

— फेसपालम

1

सी # - 178 161 115 वर्ण

static string I(string a, int k){var s = "0";foreach(var c in a)s+=c==s[s.Length-1]?'0':'1';return k<2?s:I(s,--k);}

निर्दयता के साथ अनगढ़

using System;
using System.Text;

namespace InverseXOR
{
    class Program
    {
        static string I(string a, int k)
        {
            var s = "0";
            foreach (var c in a)
                s += c == s[s.Length - 1] ? '0' : '1';
            return k < 2 ? s : I(s, --k);
        }

        static void Main(string[] args)
        {
            Console.WriteLine(I(args[0], Convert.ToInt32(args[1])));
        }
    }
}

— RomSteady
स्रोत

0

सीजेएम, 20 बाइट्स

q~{:~0\{1$!_!?}/]s}*

इनपुट की तरह है "111" 3

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

"011,001" अपने इनपुट लेकिन इसकी सही नहीं के लिए अपने कोड से परिणाम अगर आप की जाँच है

— NVIDIA

@ user3613886 क्षमा करें, पुराने संस्करण की प्रतिलिपि बनाई गई है। अब ठीक किया गया

— अनुकूलक

व्युत्क्रम XOR की गणना करें