Umschalten, Drucken, Wiederholen

17

Diese Herausforderung ist locker vom nicht implementierten Esolang Pada inspiriert .

Es sei ein Array von 8 Bits betrachtet, die alle auf Null initialisiert sind. Wir werden einen sehr minimalistischen Befehlssatz einführen, um beliebige Zeichenfolgen zu drucken. Es gibt zwei Befehle, die beide einen Parameter annehmen, Nder der Index eines Bits ist:

  • t Nfür t oggle: Dadurch ändert sich der Wert von Bit N.
  • p Nfor p rint: Dies interpretiert alle 8 Bits als Byte, beginnend mit Bit Nund umlaufend am Ende . Das diesem Byte entsprechende Zeichen wird auf STDOUT gedruckt.

Schauen wir uns ein Beispiel an. Wir wollen drucken :=. Naiv erreichen wir dies wie folgt (0-basierte Bitindizes):

t 2    [0 0 1 0 0 0 0 0]
t 3    [0 0 1 1 0 0 0 0]
t 4    [0 0 1 1 1 0 0 0]
t 6    [0 0 1 1 1 0 1 0]
p 0    [0 0 1 1 1 0 1 0] == 58 == ':'
t 5    [0 0 1 1 1 1 1 0]
t 6    [0 0 1 1 1 1 0 0]
t 7    [0 0 1 1 1 1 0 1]
p 0    [0 0 1 1 1 1 0 1] == 61 == '='

Stattdessen können wir die zyklische Funktion nutzen pund zwei Anweisungen speichern:

t 2    [0 0 1 0 0 0 0 0]
t 3    [0 0 1 1 0 0 0 0]
t 4    [0 0 1 1 1 0 0 0]
t 6    [0 0 1 1 1 0 1 0]
p 0    [0 0 1 1 1 0 1 0] == 58 == ':'
t 1    [0 1 1 1 1 0 1 0]
p 7    [0 1 1 1 1 0 1 0] == [0 0 1 1 1 1 0 1] == 61 == '='
                      ^

p 7Beginnt also einfach, den Bytewert vom letzten statt vom ersten Bit zu lesen.

Die Herausforderung

Erstellen Sie bei einer nicht leeren Zeichenfolge aus druckbaren ASCII-Zeichen (einschließlich 0x20 bis 0x7E) eine optimale Anweisungsliste (eine Zeile pro Anweisung), um diese Zeichenfolge mit dem obigen System zu drucken. Wenn es mehrere optimale Lösungen gibt (was fast immer der Fall sein wird), generieren Sie nur eine davon.

Sie können für die Bits zwischen 0-basierter und 1-basierter Indizierung wählen, geben Sie jedoch Ihre Wahl an.

Sie können ein Programm oder eine Funktion schreiben, indem Sie eine Eingabe über STDIN (oder die nächstgelegene Alternative), ein Befehlszeilenargument oder ein Funktionsargument vornehmen und das Ergebnis über STDOUT (oder die nächstgelegene Alternative), einen Funktionsrückgabewert oder einen Funktionsparameter (out) ausgeben. Wenn Sie das Ergebnis nicht an STDOUT ausgeben, sollte es sich weiterhin um eine einzelne durch Zeilenumbrüche getrennte Zeichenfolge handeln.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

Testfälle

Jeder Testfall ist eine einzelne Zeile mit der Eingabezeichenfolge, gefolgt von der optimalen Anzahl von Anweisungen und einer möglichen Lösung.

Sie sollten die Anweisungsanzahl in Ihrer Lösung nicht ausgeben - dies ist nur hier enthalten, damit Sie die Richtigkeit Ihres Codes überprüfen können, wenn eine andere Anweisungsliste gedruckt wird.

?
7 instructions
t 2
t 3
t 4
t 5
t 6
t 7
p 0

:=
7 instructions
t 2
t 3
t 4
t 6
p 0
t 1
p 7

0123456789
26 instructions
t 2
t 3
p 0
t 7
p 0
t 6
t 7
p 0
t 7
p 0
t 5
t 6
t 7
p 0
t 7
p 0
t 6
t 7
p 0
t 7
p 0
t 2
t 3
p 3
t 2
p 3

9876543210
28 instructions
t 2
t 3
t 4
t 7
p 0
t 7
p 0
t 0
t 7
p 5
t 4
p 5
t 0
t 5
p 0
t 7
p 0
t 5
t 6
t 7
p 0
t 7
p 0
t 6
t 7
p 0
t 7
p 0

Hello, World!
39 instructions
t 1
t 4
p 0
t 3
t 7
p 2
t 1
t 6
p 2
p 2
t 0
t 1
p 2
t 0
t 1
t 3
p 2
t 6
t 7
p 2
t 0
t 2
t 6
t 7
p 1
t 0
t 1
t 5
p 0
t 2
t 7
p 3
t 2
t 6
p 0
t 4
p 0
t 1
p 3

The quick brown fox jumps over the lazy dog.
150 instructions
t 1
t 3
t 5
p 0
t 1
t 2
p 1
t 1
t 3
t 7
p 0
t 1
t 5
t 7
p 0
t 1
t 3
t 7
p 0
t 5
p 0
t 3
t 4
t 5
p 0
t 4
t 6
p 0
t 4
p 0
t 1
t 4
t 6
t 7
p 0
t 1
t 6
p 0
t 3
p 0
t 0
t 5
p 4
t 0
t 7
p 0
t 1
p 1
t 3
t 5
t 6
t 7
p 0
t 1
t 5
t 6
p 0
t 4
t 7
p 0
t 1
t 2
p 3
t 5
t 6
t 7
p 2
t 1
t 2
t 6
p 0
t 0
p 7
t 0
t 7
p 5
t 3
t 4
t 6
t 7
p 0
t 6
t 7
p 0
t 1
t 3
t 6
t 7
p 0
t 1
t 4
t 5
t 6
t 7
p 0
t 4
p 4
t 6
p 0
t 1
t 6
p 4
t 5
t 6
t 7
p 0
t 1
t 3
t 5
p 0
t 1
p 1
t 1
t 3
t 7
p 0
t 1
t 5
t 7
p 0
t 1
t 4
t 5
p 0
t 1
p 3
t 3
t 7
p 1
t 1
t 5
p 0
t 1
t 3
t 4
t 7
p 0
t 1
t 5
p 0
t 4
t 6
t 7
p 0
t 4
p 0
t 1
t 4
t 7
p 0

Die Testfälle wurden mit dieser CJam-Referenzimplementierung generiert .

Martin Ender
quelle

Antworten:

3

CJam, 67 Bytes

U]8*l{i2b8Ue[8,{1$m>2$.^:+}$0=_@m>@1$.^ee{~{"t "op}{;}?}/"p "o\p}/;

Probieren Sie es online aus

Erläuterung:

U]8*    Build start bit array [0 0 0 0 0 0 0 0].
l       Get input.
{       Start loop over input characters.
  i       Convert character to integer.
  2b      Convert to binary array.
  8Ue[    Pad to 8 entries with leading 0.
  8,      Generate list of possible rotation amounts.
  {       Start of sort function block.
    1$      Get bit array of character.
    m>      Rotate by rotation amount.
    2$      Get previous bit array.
    .^      Element-wise xor to get different bits.
    :+      Add elements in result to get count of different bits.
  }$      Sort possible rotations by count of different bits.
  0=      Get first rotation amount in sorted list, which is the one with the
          one that results in the smallest count of different bits.
  _       Copy count. Will use original for "p" output later.
  @       Get the character bit array to top of stack.
  m>      Rotate it, to get optimal rotated bit array.
  @       Get previous bit array to top of stack.
  1$      Copy rotated bit array, will need the original as starting point
          for next character.
  .^      Element-wise xor to get different bits.
  ee      Enumerate array to get pairs of index and bit value.
  {       Loop over bits.
    ~       Unpack index bit pair.
    {       Start of if block for bit value.
      "t "o   Output "t ".
      p  Output index and newline.
    }       End of if block.
    {       Start of else block.
      ;       Pop the index value.
    }?      End of ternary if.
  }/      End loop over bits.
  "p "o   Output "p ".
  \       Swap rotation amount to top.
  p       Print rotation amount and newline.
}/      End loop over input characters.
;       Ppp current bit array off stack to prevent extra output.
Reto Koradi
quelle
5

Rubin, 171

->w{s=[0]*8
w.chars.flat_map{|c|z=0..7
*m,i=z.map{|j|z.select{|k|s[k]!=z.map{|i|c.ord[i]}.rotate(j)[k]}<<j}.min_by &:size
m.map{|m|s[m]=1-s[m];"t #{7-m}"}+["p #{i}"]}*?\n}

Eine Ruby-Funktion, die nur doppelt so groß ist wie die Referenzimplementierung. :)

Probieren Sie es online aus: http://ideone.com/ysYyFP

Das Programm ist ziemlich geradlinig: Es beginnt mit den 8 Bits, die auf 0 gesetzt sind, und durchläuft die Zeichen. Bei jedem Schritt wird der kürzeste Weg vom aktuellen Zustand zu einem Zustand genommen, der das Drucken des Zeichens ermöglichen würde. Es wird eine Zeichenfolge im angegebenen Format zurückgegeben.

Die erste (weniger Golf) Version des Programms finden Sie hier .

Cristian Lupascu
quelle
4

CJam, 81 76 Bytes

Immer noch viel zum Golfen.

0]8*q{i2b8Te[8,\fm>:X\_@\f.=::+_$W=#:YX=_@.{=M['tSUN]?U):U;}o0:U;['pSYN]o}/;

Probieren Sie es online aus .

Andrea Biondo
quelle