Sei fdie Funktion, die ein Bitfeld ( {0 1}) der Größe n+1auf ein Bitfeld der Größe abbildet, nindem sie XORauf das th- iund i+1th-Bit angewendet und das Ergebnis in das neue Bitfeld geschrieben wird.

Beispiel: f("0101") = "111"

Informelle Berechnung:

0 XOR 1 = 1

1 XOR 0 = 1

0 XOR 1 = 1

Sei f_inversedie Umkehrfunktion von f. Da die Inverse nicht eindeutig ist, wird f_inverseeine gültige Lösung zurückgegeben.

Eingabe: Bitfeld als String (dh "0101111101011") und eine gegebene natürliche Zahlk

Output: Bitfeld als String, so dass die Saite des Ergebnisses enthält , wenn f_inverseangewendet wird , kmal mit dem Eingang Bitfeld. (ie f_inverse(f_inverse(f_inverse(input))))

Gewinnkriterien: Wenigste Charaktere

Bonus:

-25Zeichen, wenn f_inversenicht rekursiv / iterativ angewendet, stattdessen wird die Ausgabezeichenfolge direkt berechnet

Testskript:

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)

Sie können es zum Beispiel hier einfügen und dann ausprobieren.

Pyth, 33 30 - 25 = 5 Bytes

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

Führen Sie es durch Eingabe von stdin wie (Online-Interpreter: https://pyth.herokuapp.com/ ):

111
3

und das Ergebnis wird nach stdout geschrieben.

Dies ist eine direkte Übersetzung von:

Python 2, 127 118 79 - 25 = 54 Bytes

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)

Nennen Sie es wie i("111", 3), und das Ergebnis wird in stdout geschrieben.

Beachten Sie, dass wir davon ausgehen, dass k nicht zu groß ist, da die innere Schleife für Code-Golfing-Zwecke O (2 ^k ) -mal ausgeführt wird.

Ich denke, wir nennen diese Operation normalerweise "xorshift" oder so. Wenn wir die Eingabe als Big-Endian-Ganzzahlen ausdrücken, lautet die Funktion f einfach:

• f (x) = x ⊕ (x ≫ 1)

Wenn wir gelten f zweimal werden wir erhalten:

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

Die dreimalige Anwendung hat jedoch ein anderes Muster:

• f ³ (x) = x ≤ (x ≤ 1) ≤ (x ≤ 2) ≤ (x ≤ 3)

Wenn Sie sich 4 Mal bewerben, kehren Sie zum Basisformular zurück:

• f ⁴ (x) = x ⊕ (x ≫ 4)

Und so weiter:

• f ^{2 k} (x) = x ⊕ (x ≫ 2 ^k )

Beachten Sie, dass, wenn wir 2 ^k groß genug wählen , (x ≫ 2 ^k ) = 0 ist, was f ^{2 k} (x) = x bedeutet, und das Gegenteil ist trivial die Identitätsfunktion!

So ist die Strategie für die Suche nach f ^k (x) ohne Aufruf f ^-1 (x) überhaupt ist:

1. Finde K so, dass:

   • K ≥ k
   • K> log ₂ x
   • K ist eine Potenz von 2

2. Express f ^k (x) = f ^{-K + (Kk)} (x) = f ^-K (f ^Kk (x)) = f ^Kk (x)

3. Das Ergebnis fheißt also Kk-mal

4. 25 Zeichen Gewinn: p

Update 1 : Verwendete eine Oktaldarstellung anstelle einer Binärdarstellung, sodass wir durch %Formatierung viele Bytes sparen konnten.

Update 2 : Nutzen Sie die periodische Struktur von f. Die iterative Version wurde zurückgezogen, da die nicht iterative Version auch ohne den Bonus von -25 Byte kürzer ist.

Update 3 : Reduziert 3 Bytes von Pyth, danke isaacg!

CJam, 15 bis 14 Bytes

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

Nimmt Eingaben wie

"111" 3

Teste es hier.

Erläuterung

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.";

Das Ergebnis wird am Ende des Programms automatisch ausgedruckt.

Ich sage "string / array", weil ich mit einem String beginne (das ist nur ein Array von Zeichen), aber ich nehme weiterhin XORs zwischen diesen und zwischen Zahlen. Character Character ^Gibt eine ganze Zahl (basierend auf dem XOR der Codepunkte) Character Integer ^und Integer Character ^ein Zeichen (basierend auf dem XOR der Zahl mit dem Codepunkt - interpretiert als Codepunkt). Und Integer Integer ^natürlich gibt es nur eine ganze Zahl.

Die Typen fliegen also überall herum, aber glücklicherweise ist es immer dann, wenn ich eine Ganzzahl habe, entweder 0oder 1und wenn ich ein Zeichen habe, entweder '0und '1und das Ergebnis ist immer das gewünschte (in beiden Typen). Da Strings nur Arrays von Zeichen sind, ist das Mischen von Zeichen mit Zahlen überhaupt kein Problem. Und am Ende, wenn alles gedruckt ist, erhalten die Zeichen keine speziellen Begrenzer, sodass die Ausgabe nicht davon betroffen ist, welches Bit als Zahl oder Zeichen dargestellt wird.

J, 17 Zeichen

Verwenden Sie immer 0 als führende Ziffer.

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

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

Beginnend mit dem 128 1-Status der obersten Zeile (links) und einem Zufallsstatus (rechts), werden die letzten 128 Ziffern der ersten 129 Iteration angezeigt.

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

APL 11

((0,≠\)⍣⎕)⎕

Erläuterung:

≠\  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

Versuchen Sie es auf tryapl.org

CJam, 25 - 25 = 0 Bytes

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

Dies ist nur eine direkte CJam-Portierung der unten stehenden GolfScript-Antwort, da nach dem Lesen von Martin Büttners Antwort ich erkannte, dass ich ein Byte einsparen konnte, da CJam Integer- und Zeichentypen handhabte. (Grundsätzlich benötigt CJam 1&im GolfScript-Code keine ASCII-Zeichen, die zum Erzwingen von Bits verwendet werden, erfordert jedoch ein vorangestelltes qLesen der Eingabe.) Normalerweise würde ich einen solchen einfachen Port als billigen Trick betrachten, aber eine Null-Punktzahl erzielen es lohnt sich meiner Meinung nach.

In jedem Fall funktioniert dieses Programm genauso wie das Original-GolfScript-Programm unten. Lesen Sie daher die Beschreibung und die Gebrauchsanweisung. Mit diesem Online-Interpreter können Sie wie gewohnt die CJam-Version testen .

GolfScript, 26 - 25 = 1 Byte

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

Diese Lösung durchläuft die Eingabezeichenfolge nur einmal. Ich glaube, sie qualifiziert sich für den 25-Byte-Bonus. Es funktioniert, indem intern ein k- Element-Array verwaltet wird, das das aktuelle Bit von jedem der Elemente speichert k vorge iteriert.

Die Eingabe sollte über stdin erfolgen, und zwar im Format "1111111" 3, dh in Anführungszeichen 0und 1Zeichen, gefolgt von der Zahl k . Die Ausgabe erfolgt als Bitstring ohne Anführungszeichen auf stdout.

Testen Sie diesen Code online.(Wenn das Programm eine Zeitüberschreitung aufweist, versuchen Sie es erneut. Der Web GolfScript-Server ist für zufällige Zeitüberschreitungen bekannt.)

Hier ist eine erweiterte Version dieses Programms mit Kommentaren:

~             # 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

Grundsätzlich kann dieser Code wie die meisten iterativen Lösungen so verstanden werden, dass die Wiederholung angewendet wird

        b _{i , j} : = b _{i , ( j - 1)} ≤ b _{( i - 1), ( j -1)} ,

wobei b _{0, j} das j- te Eingangsbit ist (für j ≥ 1), b _{k , j} das j- te Ausgangsbit ist und b _{i , 0} = 0, vorausgesetzt. Der Unterschied besteht darin, dass die iterativen Lösungen tatsächlich die Wiederholung "zeilenweise" berechnen (dh zuerst b _{1, j} für alle j , dann b _{2, j} usw.), diese Lösung sie stattdessen "spaltenweise" berechnet Spalte "(oder genauer" Diagonale für Diagonale "), wobei zuerst b _{i , i} für 1 ≤ berechnet wird b _{i , i +1} , dann b i≤ k , dann usw. _{i , i +2}

Ein (theoretischer) Vorteil dieses Ansatzes besteht darin, dass dieses Verfahren im Prinzip eine beliebig lange Eingabezeichenfolge nur unter Verwendung von O ( k ) -Speicher verarbeiten kann. Natürlich liest der GolfScript-Interpreter automatisch alle Eingaben in den Speicher, bevor er das Programm trotzdem ausführt, was diesen Vorteil größtenteils zunichte macht.

Python, 94 78

Wird mindestens einmal ausgeführt und ergibt somit das gleiche Ergebnis für n=0undn=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

Alte Version, die den String in ein numerisches Array konvertiert und Modulo 2 "integriert"

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

Python 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

Eine absolut wiederverwendbare Lösung. Es ist einfacher zu verstehen, wenn es in zwei Funktionen unterteilt ist

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

Dabei werden faufeinanderfolgende Differenzen berechnet und n-mal mit sich selbst gkomponiert f.

Die Funktion fberechnet die kumulativen XOR-Summen von l, was die inverse Operation zu aufeinanderfolgenden XOR-Differenzen ist. Da die Eingabe als Zeichenfolge angegeben wird, müssen wir sie extrahieren int(l[0]), beim Zeichenfolgenvergleich jedoch kürzer l>='1'.

Python 2, 69

Eine iterative Lösung mit einer execSchleife stellte sich als 1 Zeichen länger heraus.

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

Vielleicht gibt es einen kürzeren Weg, mit der Saite umzugehen. Wenn es sich bei Ein- / Ausgängen um Zahlenlisten handeln könnte, würden 5 Zeichen gespart

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

Perl 5, 34

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

Auf der Standardeingabe angegebene Parameter, durch ein Leerzeichen getrennt.

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

Javascript ES6, 47 Zeichen

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

Übrigens gibt es keine Nebenwirkungen :)

C # - 178 161 115 Zeichen

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);}

Ungolfed mit Geschirr

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])));
        }
    }
}

CJam, 20 Bytes

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

Eingabe ist wie "111" 3

Probieren Sie es hier online aus