Dê-me a lista de código cinza da largura do bit n

11

O Gray Code é uma sequência de números binários de largura de bits em nque números sucessivos diferem apenas em um bit (veja exemplo de saída).

Referência

Exemplo de entrada:

3

Exemplo de saída:

000
001
011
010
110
111
101
100

Notas:

  • Esta questão parece ter um engano, mas não é, pois essa pergunta não é um código-golfe e exige uma saída diferente. No entanto, ajudará a verificar as respostas.
  • Você pode assumir uma variável nque contém a entrada.
ToonAlfrink
fonte
6
Considerando que a outra pergunta é um desafio de código de código mais rápido sem um critério de vitória objetivo (mais rápido medido como?), Proponho fechar a outra e reabrir esta.
Dennis
2
Concordo com @dennis e, portanto, votei a seguinte resposta impopular na pergunta original. "Se a resposta que você procura é estritamente um resultado rápido, então se você declarar uma matriz (dos códigos cinza) ..." No entanto, a pergunta original já tem uma resposta de 7 e 4 caracteres, então eu não Não vejo muito espaço para melhorias. Portanto, não estou votando reabrir no momento.
Level River St
3
É muito semelhante ao Traverse todos os números com apenas uma aleta pouco por passo embora ...
Dennis
A primeira pergunta sobre o código Gray não é ótima, mas ela já tem respostas que são basicamente as mesmas que as desejadas e que provavelmente não serão melhoradas. Eu acho que teria feito mais sentido deixar este fechado e mudar o outro para um código de golfe.
Peter Taylor

Respostas:

2

JavaScript (77)

for(i=0;i<1<<n;)alert((Array(n*n).join(0)+(i>>1^i++).toString(2)).substr(-n))

Versão mais amigável ao navegador (console.log e prompt ()):

n=prompt();for(i=0;i<1<<n;)console.log((Array(n*n).join(0)+(i>>1^i++).toString(2)).substr(-n))
Дамян Станчев
fonte
Talvez essa matriz ... juntar-se é um exagerofor(i=0;i<(l=1<<n);i++)console.log((i^(i>>1)|l).toString(2).slice(1));
edc65
2

Python 2 (47)

for i in range(2**n):print bin(2**n+i/2^i)[3:]

A expressão i/2^ipara o inúmero do código de cinza é da resposta a esta . Para adicionar zeros à esquerda que preenchem o comprimento n, adiciono 2**nantes de converter em uma sequência binária, criando uma sequência de comprimento n+1. Em seguida, trunco ​​o prefixo inicial 1e do tipo de número 0bcom [3:].

xnor
fonte
2

APL (Dyalog Classic) , 11 bytes

2≠/0,↑,⍳n2

Experimente online!

n⍴2is 2 2...2- um vetor de ndois

são os índices de uma nmatriz tridimensional com forma 2 2...2- ou seja, uma matriz 2 × 2 × ... × 2 de vetores aninhados. Como usamos 0-indexing ( ⎕IO←0), esses são todos vetores binários de comprimento n.

,achatar a 2 × 2 × ... × 2 forma, então temos um vector de 2 n aninhados vetores binários

"mix" - converte o vetor de vetores em uma matriz sólida 2 n × n. Se parece com isso:

0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

0, precede zeros à esquerda da matriz

2≠/calcula o par ( 2) xor ( ) ao longo da última dimensão ( /em oposição a ); em outras palavras, todo elemento é xorodado com seu vizinho direito e a última coluna desaparece

0 0 0
0 0 1
0 1 1
0 1 0
1 1 0
1 1 1
1 0 1
1 0 0
ngn
fonte
você se importaria de adicionar uma explicação rápida?
Jonah
1
@Jonah certeza, adicionado
ngn
muito inteligente, thx
Jonah
2

Japonês , 14 12 bytes

2pU Ç^z)¤ùTU

Raspou dois bytes graças a ETHproductions .

Experimente online!

Nit
fonte
Exemplo perfeito de como ùé usado. Como N.z(n)é a divisão inteira com o padrão arg = 2, você pode salvar dois bytes com 2pU Ç^z)¤ùTU: Experimente online!
ETHproductions
@ETHproductions Obrigado, ainda sinto falta dos argumentos padrão de vez em quando. Muito útil, muito obrigado.
Nit
1

Python - 54

Baseado em um algoritmo a partir da referência fornecida no desafio:

for i in range(2**n):print'{1:0{0}b}'.format(n,i>>1^i)

Ungolfed:

# For each of the possible 2**n numbers...
for num in range(2**n):
    gray = num>>1 ^ num

    # Print in binary and pad with n zeros.
    print '{1:0{0}b}'.format(grey)
BeetDemGuise
fonte
1

PowerShell (168)

O PowerShell amador volta com mais uma tentativa de golF! Espero que você não se importe! No mínimo, essas perguntas são divertidas e uma experiência de aprendizado para começar. Assumindo que n foi inserido, temos:

$x=@('0','1');for($a=1;$a-lt$n;$a++){$x+=$x[($x.length-1)..0];$i=[Math]::Floor(($x.length-1)/2);0..$i|%{$x[$_]='0'+$x[$_]};($i+1)..($x.length-1)|%{$x[$_]='1'+$x[$_]}}$x

Como o PowerShell com o qual estou trabalhando é de apenas 2,0, não posso usar nenhum cmdlets de mudança de bits que possam resultar em códigos mais curtos. Então, aproveitei um método diferente descrito na fonte da pergunta , invertendo o array e adicionando-o a ele mesmo, acrescentando um 0 na frente da metade superior e um 1 na metade inferior.

fuandon
fonte
1

F # (86) (84) (80)

for i in 0..(1<<<n)-1 do printfn"%s"(Convert.ToString(i^^^i/2,2).PadLeft(n,'0'))

Provavelmente isso poderia ser melhorado ainda mais.

Observe também que, se for executado no FSI, você precisará open System;;primeiro. Se você deseja evitar a importação, (e se não se importa com a ordem em que os valores são impressos), pode usar esta versão de 82 caracteres:

for i in 0..(1<<<n)-1 do(for j in 0..n-1 do printf"%i"((i^^^i/2>>>j)%2));printfn""
pswg
fonte
1

Ruby - 42 39

Mesmo algoritmo, idioma diferente:

(2**n).times{|b|puts"%0#{n}b"%(b>>1^b)}

Mudar de #mappara #timescomo sugere @voidpigeon salva 3 caracteres.

OI
fonte
1
Em vez de [*0...2**n].mapvocê pode usar (2**n).times.
afuous 07/07
1

J, 24 bytes

[:#:@(22 b.<.@-:)[:i.2^]

Experimente online!

Implementação direta do algoritmo "XOR com sua própria metade do piso". Observe que 22 b.é XOR.

Jonah
fonte
1

MATL , 10 bytes

W:qt2/kZ~B

Experimente online!

O bom e velho método "XOR n com n >> 2".

W- calcular 2 ^ (entrada) (obtém entrada implicitamente)
:q- criar intervalo de números de 0 a 2 ^ n - 1
t - duplicar esse intervalo
2/k- MATL não possui deslocamento de bits, portanto divida (cada número) por 2 e piso
Z~ - XOR elementwise esse resultado com a matriz original de 0 a 2 ^ n - 1
B - converta cada número no resultado em binário
(exibir implicitamente a saída).

sundar - Restabelecer Monica
fonte
1

K (ngn / k) , 25 bytes

{(x-1){,/0 1,''|:\x}/0 1}

Experimente online!


  • |:\xé "varredura reversa x". aplica reverso para x até que a saída seja igual à entrada e mostra cada iteração. retorna (0 1; 1 0) na primeira passagem.
  • 0 1,''é "0 1 junte cada um". junta um 0 a cada valor do 1º elem e 1 a cada valor do 2º elem, dando ((0 0; 0 1); (1 1; 1 0)) na primeira passagem
  • ,/ é "junte-se" e nivela a lista.
  • (x-1){...}/0 1é "aplicar {func} mais de 0 1x-1 vezes". toma a saída da última iteração como entrada
rabisco
fonte
0

APL (22)

{(0,⍵)⍪1,⊖⍵}⍣(n-1)⍪0 1

Isso gera uma matriz n-por-2 ^ n contendo os bits como suas linhas:

      n←3
      {(0,⍵)⍪1,⊖⍵}⍣(n-1)⍪0 1
0 0 0
0 0 1
0 1 1
0 1 0
1 1 0
1 1 1
1 0 1
1 0 0

Explicação:

  • {... }⍣(n-1)⍪0 1: executa os n-1tempos de função com a entrada inicial da matriz (0 1)T(que é o código cinza de 1 bit)

    • (0,⍵): cada linha com um 0prefixo,
    • : Em cima de,
    • 1,⊖⍵: cada linha com um 1prefixo, em ordem inversa
marinus
fonte
0

Jq 1.5 , 105 100 bytes

def g(n):if n<2then. else map([0]+.)+(reverse|map([1]+.))|g(n-1)end;[[0],[1]]|g(N)[]|map("\(.)")|add

Assume que N fornece entrada. por exemplo

def N: 3 ;

Expandido

def g(n):  # recursively compute gray code
  if n < 2
  then .
  else map([0]+.) + (reverse|map([1]+.)) | g(n-1)
  end;

  [[0],[1]]                 # initial state
| g(N)[]                    # for each element in array of gray codes
| map("\(.)")|add           # covert to a string

Experimente online!

jq170727
fonte
-1

T-SQL 134

Esse desafio está pedindo o retorno do poder cartesiano de {(0), (1)}. Esse trecho cria o código que executaria o produto cartesiano de {(0), (1)} n vezes.

DECLARE @ int=4,@s varchar(max)='SELECT*FROM's:set @s+='(VALUES(0),(1))t'+ltrim(@)+'(b)'if @>1set @s+=','set @-=1if @>0goto s exec(@s)
confortavelmente
fonte
Está pedindo o poder cartesiano em uma ordem específica. Seu código explica isso?
ToonAlfrink