Wyzwanie to jest luźno zainspirowane niewdrożonym esolangiem Pada .

Rozważ tablicę 8 bitów, wszystkie zainicjowane na zero. Wprowadzimy bardzo minimalistyczny zestaw instrukcji do drukowania dowolnych ciągów. Istnieją dwie instrukcje, z których obie pobierają parametr Nbędący indeksem bitów:

• t Ndla t oggle: Zmienia wartość bitu N.
• p Ndla p rint: interpretuje wszystkie 8 bitów jako bajt, zaczynając od bitu Ni zawijając na końcu . Znak odpowiadający temu bajtowi jest drukowany na STDOUT.

Spójrzmy na przykład. Chcemy wydrukować :=. Naiwnie osiągamy to w następujący sposób (indeksy bitowe oparte na 0):

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 == '='

Zamiast tego możemy skorzystać z funkcji cyklicznej pi zapisać dwie instrukcje:

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 == '='
                      ^

Więc p 7po prostu zaczyna się odczytywanie wartości bajtu z ostatniego bitu zamiast pierwszego.

Wyzwanie

Biorąc pod uwagę niepusty łańcuch drukowalnych znaków ASCII (od 0x20 do 0x7E włącznie), przygotuj optymalną listę instrukcji (jeden wiersz na instrukcję), aby wydrukować ten ciąg w powyższym systemie. Jeśli istnieje wiele optymalnych rozwiązań (prawie zawsze tak będzie), wygeneruj tylko jedno z nich.

Możesz wybrać indeksowanie bitów od 0 do 1, ale podaj swój wybór.

Możesz napisać program lub funkcję, pobierając dane wejściowe przez STDIN (lub najbliższą alternatywę), argument wiersza poleceń lub argument funkcji i wypisując wynik przez STDOUT (lub najbliższą alternatywę), wartość zwracaną funkcji lub parametr funkcji (wyjściowej). Jeśli nie wydrukujesz wyniku do STDOUT, nadal powinien to być pojedynczy ciąg oddzielony znakiem nowej linii.

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

Przypadki testowe

Każdy przypadek testowy to pojedynczy wiersz zawierający ciąg wejściowy, po którym następuje optymalna liczba instrukcji, a następnie jedno możliwe rozwiązanie.

Należy nie wyjściowa liczba instrukcji w rozwiązania - jest to zawarte tutaj tylko tak można sprawdzić poprawności kodu, jeśli drukuje inną listę instrukcji.

?
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

Przypadki testowe zostały wygenerowane przy użyciu tej referencyjnej implementacji CJam .

CJam, 67 bajtów

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

Wypróbuj online

Wyjaśnienie:

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.

Ruby, 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}

Funkcja Ruby, która jest tylko dwukrotnie większa niż implementacja referencyjna. :)

Wypróbuj online: http://ideone.com/ysYyFP

Program jest dość prosty: zaczyna się od 8 bitów ustawionych na 0 i przechodzi przez znaki. Na każdym kroku przebiega najkrótsza droga z bieżącego stanu do stanu, który umożliwi wydrukowanie znaku. Zwraca ciąg znaków w określonym formacie.

Wstępna (mniej golfowa) wersja programu jest dostępna tutaj .

CJam, 81 76 bajtów

Wciąż dużo do golfa.

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

Wypróbuj online .