Imprimir um negativo do seu código

100

Considere um quadrado de caracteres ASCII imprimíveis (pontos de código 0x20 a 0x7E) para o comprimento lateral N , como o seguinte (aqui, N = 6 ):

=\    
 g \  
7     
m+y "g
  L ~ 
e> PHq

Também exigimos que cada linha e cada coluna contenha pelo menos 1 espaço e 1 caractere não espacial . (O exemplo acima satisfaz isso.)

Definimos o negativo de tal quadrado, como um quadrado do mesmo tamanho, onde cada espaço é substituído por um não-espaço e vice-versa. Por exemplo, o seguinte seria um negativo válido do exemplo acima:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

A escolha de caracteres não espaciais é irrelevante (desde que sejam do intervalo ASCII imprimível).

O desafio

Você deve escrever um programa, com um código-fonte quadrado com o comprimento do lado N> 1 , que imprima um negativo para STDOUT. Os espaços à direita devem ser impressos. Você pode ou não imprimir uma única linha nova à direita.

As regras habituais de quine também se aplicam, portanto, você não deve ler seu próprio código fonte, direta ou indiretamente. Da mesma forma, você não deve assumir um ambiente REPL, que imprime automaticamente o valor de cada expressão inserida.

O vencedor é o programa com o menor comprimento lateral N . Em caso de empate, o envio com o menor número de caracteres não espaciais no código-fonte vence. Se ainda houver um empate, a resposta mais antiga vence.

Martin Ender
fonte
O valor de retorno de uma função é aceito ou deve ser impresso em STDOUT?
Paul Guyot 29/11
1
@PaulGuyot Para este desafio, siga os programas completos e o STDOUT (como é, em termos gerais, uma variante de quine).
Martin Ender
Você deve esclarecer que o tamanho da placa deve ser N> 0 . Vejo que seu exemplo especifica N> 1 (e você quis dizer N> = 1 ?), Mas isso não está nas regras apropriadas.
imallett
2
@imallett implícito em "Também exigimos que cada linha e cada coluna contenha pelo menos 1 espaço e 1 caractere não espacial". Esperar. Não. Não é. Bom ponto. No entanto, implica N == 0 || N> 1.
John Dvorak
1
@jpcooper Sim, é um quadrado, mas não satisfaz "Também exigimos que cada linha e cada coluna contenham pelo menos 1 espaço e 1 caractere não espacial". porque as primeiras m colunas não contêm espaços e as últimas n colunas não contêm não-espaços.
Martin Ender

Respostas:

18

CJam, 4 x 4 (8 não espaços)

 L _
{ _ 
 _ }
_ p 

Experimente online no intérprete CJam .

Resultado

{ _ 
 _ }
{ _ 
 _ }

Como funciona

  • Lempurra uma matriz vazia e _empurra uma cópia dela.

  • O bloco

    { _ 
     _ }
    

    empurra esse bloco na pilha.

  • _empurra uma cópia do bloco de código e o pimprime, seguido por um avanço de linha.

  • Finalmente, o intérprete imprime todos os itens restantes na pilha: duas matrizes vazias que não afetam a saída e o bloco de código original.

Versão alternativa

 L ~
{ _ 
 p }
_ ~ 

Experimente online no intérprete CJam .

Resultado

{ _ 
 p }
{ _ 
 p }

Como funciona

  • Lempurra uma matriz vazia e a ~despeja. A pilha está vazia novamente.

  • O bloco

    { _ 
     p }
    

    empurra esse bloco na pilha.

  • _empurra uma cópia do bloco e ~executa a cópia.

    A parte _interna da cópia do bloco enviará uma cópia do bloco original, que pserá impresso, seguido de um avanço de linha.

  • Finalmente, o intérprete imprime o item restante na pilha: o bloco de código original.

Dennis
fonte
104

Perl, 7 × 7 (42 não espaços)

for$i( 
1..56 )
{$_= $i
%8? $i%
7? $":7
: $/;1;
 print}

Resultado:

      7
     7 
    7  
   7   
  7    
 7     
7      
ossifrage melindroso
fonte
10
Este é um dos melhores códigos que eu já vi há muito tempo.
Kasran
Direto e simples, mas bastante chato. Ainda +1.
Nova
8
Seria ainda mais legal se exibisse um 7feito 7. :)
AL
1
@AL Só precisa de mais 8 caracteres (7 espaços e uma nova linha).
Qix
77

CJam, 4X4 ( 12 10 não espaços)

 6, 
SS +
* 4/
 N* 

Resultado:

0  1
  2 
 3  
4  5

Versão anterior com 12 não espaços:

 4a4
* 4S
** 4
/N* 

E a saída é

4   
 4  
  4 
   4

Como apontado por Martin, esta versão tem

  • 4 Espaços,
  • 4 * ,
  • 4 4 ,
  • 4 outros caracteres e
  • 4 4 como a saída

;)

Experimente online aqui

Optimizer
fonte
22
Ele também tem quatro votos positivos, mas estou prestes a estragar isso para você. Desculpa! :-D
squishish ossifrage
7
Talvez possamos chegar a 44? +1 :)
Maçaneta da porta
4
Mantenha o ritmo até 4 ^ 4
Optimizer
17
Não 4 ^ 4 == 0? ;)
zennehoy
1
Sim, eu não gosto do fato de que o XOR bit a bit roubou o símbolo que deveria ter sido usado para expoentes. Desarruma a legibilidade do código, honestamente.
precisa saber é o seguinte
50

Marbelous - 16x16

....@0..@1....  
@3..0A08..@2  ..
/\--....>1  ..Hp
..@2..\\  =0@3..
ss..//  --\\\\..
@0/\  @1/\Hp..!!
:s  #the-cake-is
  2020#a-pie/lie

Teste aqui! Espaços como espaços em branco, placa cilíndrica e bibliotecas de inclusão devem ser verificados.

Resultado

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

Explicação

Existem duas placas aqui: a placa principal (mostrada abaixo) e a ssplaca, que não recebe entradas e gera dois espaços (0x20) para STDOUT.

Uma célula em branco é equivalente a a .., e qualquer coisa após a #é um comentário.

Foto do Conselho

Cada tick ssgera dois espaços para STDOUT.

O caminho verde é um loop simples que gera uma nova linha (0x0A) no final de cada 7º tick.

O caminho azul produzirá os números ( Hpimprime uma bola de gude com dois dígitos hexadecimais) presentes na saída, no final de cada sexto tique.

Depois de imprimir 01uma vez, o loop termina e desce o caminho vermelho, que duplica esse mármore.

Uma duplicata é impressa (a segunda 01) e a outra é enviada pelo caminho preto, que termina a placa na !!célula. Devido à localização do Hpusado nesta última impressão, ele 01aparece antes dos dois espaços do mesmo tick, e não depois, do comportamento de todas as outras Hpchamadas.

es1024
fonte
9
Voto positivo para a representação gráfica da fonte.
Riking 01/12/19
35

Python - 11x11

import re
[print(
    re.sub(
"0",   " ",
bin(x)[
2:].zfill(
11)))for x
in[19,15,
1920,116,
15,1,5,3,
3,3, 67]]

Resultado

      1  11
       1111
1111       
    111 1  
       1111
          1
        1 1
         11
         11
         11
    1    11

É uma solução bastante bagunçada e chata, mas pensei em mostrar isso ...

  1. Isso pode ser feito em Python
  2. Se você pode compactar informações sobre seu código mais curtas que seu código, pode executar algo assim :)

Esta solução tira proveito do fato de que, se você estiver dentro de um par de colchetes no Python, poderá dividir seu código em várias linhas e adicionar espaços arbitrariamente sem obter um IndentationError. Outra maneira de fazer algo assim é encerrando a linha com uma barra invertida.

Sp3000
fonte
33

Python - 7x7 (37 não espaços)

print( 
'%+7s' 
'\n'%1 
*6+'%' 
'-7s'% 
111111 
      )

Resultado

      1
      1
      1
      1
      1
      1
111111 

Usa o antigo %operador de formatação de string do Python para fazer o trabalho: +7e -7cuida da justificação direita / esquerda e do último espaço para corresponder ao parêntese de fechamento, printem particular. Ao preparar a string de formato, também temos

  • concatenação automática de literais de string através de linhas e
  • repetição de string por multiplicação (fornecendo vários campos de substituição pelo preço de um)
Greg
fonte
18

JavaScript (9x9)

 i=9;q=""
; for(;++
i< 91;){;
var q=q+(
!(i% 10.0
)?1:" ");
;i%9|| (q
+="\n") }
alert(q) 

Resultado

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Notas

Criei e joguei golfe (da melhor maneira possível) para um quadrado com diagonal de qualquer tamanho n:

q="";for(i=***n***;++i<***n^2+n+1***;i%***n***||(q+="\n"))q+=i%***n+1***?"0":1

substituindo os números *** asdf *** por constantes, dependendo do comprimento do lado n, por exemplo, para n = 6:

q="";for(i=6;++i<43;i%6||(q+="\n"))q+=i%7?" ":1

Mas, mesmo que esse código tenha o tamanho 46, não consegui alinhar o espaço constante com um espaço na diagonal do código até que fosse tão grande quanto um 9x9, com uma linha desperdiçada (a 5ª)

Editar: alterado para adicionar alerta (). Antes:

 i=9;q=""
; while((
++ i)<91)
{q= q+""+
""+( "")+
(!((i %10
))?1:" ")
;i%9||( q
+="\n")} 
Kuilin Li
fonte
Ahh, sim, oops, entendo o que você quer dizer. Estou corrigindo agora, desculpe.
Kuilin Li
Você tem algumas variáveis ​​globais unitizadas por lá: P
Tomáš Zato
16

CJam, 5x5, 12 não espaços

Não sou um vencedor, mas queria adicionar um envio pequeno e esparso , pois a maioria das respostas imprime apenas uma diagonal.

 1 ]
D * S
 * 5
/ N *
 1 ; 

impressões

1 1 1
 1 1 
1 1 1
 1 1 
1 1 1

Teste aqui.

Os dois últimos caracteres do código não fazem nada; portanto, ele possui apenas 10 bytes de código real. Para uma grade menor, eu poderia reduzi-la em mais dois bytes para 8, mas isso não se encaixa em 3x3, e esse código não funciona para tamanhos de grade iguais.

Como funciona:

1]           "Push [1].";
  D*         "Repeat 13 times.";
    S*       "Riffle with spaces.";
      5/     "Split into runs of five elements.";
        N*   "Join those with line breaks.";
          1; "Push and pop a 1. No-op.";
Martin Ender
fonte
As respostas explodidas de CJam e Pyth são, de longe, a minha coisa favorita no site. Tenha um voto positivo, no estilo Reddit.
Soham Chowdhury
14

Befunge , 9x9

Eu não tenho idéia do por que fiz isso. Levou caminho muito longo. Eu tenho uma dor de cabeça enorme agora.

8>v_20gv 
v9<^v#<4 
1@,/<>^6 
v1,*$:<p 
->,!-^87 
:^*25<^g 
_88g,^^4 
9vp\v#6< 
        @

Resultado:

        @
        @
        @
        @
        @
        @
        @
        @
$$$$$$$$ 

Alguma explicação

O código usa gpara ler os @caracteres da grade "on the fly" (e também o espaço final, que é @ / 2), e pmodificar o loop para escrever a última linha de saída.

Cada caractere único no código é usado em algum momento, como código ou como dados (o 9e o @nas duas últimas linhas).

Eu basicamente tive que fazer várias soluções alternativas para fazer o código funcionar. O ponteiro de instruções faz várias interseções durante a execução, das quais algumas são saltadas. (Eu não poderia usar nenhuma instrução lá para direções diferentes, pois elas interfeririam. Não existe NOP.) Em outros lugares, eu reutilizei o mesmo caractere ou apenas o desfiz (veja $:no meio).

Também fiz alguns trabalhos criativos na pilha:

  • Quando o loop de gravação de caracteres (interno) termina (todos os espaços feitos para esta linha), a pilha possui n,0. Eu então tenho que diminuir n. A solução óbvia seria $1-, mas consegui reduzi-la usando !-.
  • Quando o loop de escrita da linha (externa) termina (todas as linhas normais impressas), a pilha possui a 0. Organizei o changer de código ( 20g46p7g46\p) para usá-lo 0, em vez de desperdiçar 2 caracteres $0.
PurkkaKoodari
fonte
Befunge sempre recebe um +1 de mim. Bom com o !-; isso é algo que eu faria. Curiosidade: No Funge-98, zé um NOP.
Kasran
@Kasran Yeah. znão estava listado no wiki e eu usei isso para codificação, o que significava que qualquer não-comando invertia a direção do IP. Bastante teve que refatorar 70% do código devido a um local que deveria ser NOP.
precisa saber é o seguinte
Bem, a vantagem de fazer isso é que seu código será executado no Befunge-95 (que não acredito que tenha um NOP que não seja o espaço) e também no 98; como é muito mais difícil usar 95, sempre achei essas respostas impressionantes.
Kasran
13

Python 3, 8x8

Existem 50 caracteres não espaciais e 14 espaços. A última linha tem um caráter inútil, mas tudo o mais é necessário.

(*_,q,n 
)=p=''' 
       p
'''[2:] 
print(p 
*2+q*7, 
n+p*4+p 
[0:-1]) 

Resultado:

       p
       p
ppppppp 
       p
       p
       p
       p
       p
grc
fonte
2
Só tentei brincar com (a,*b,c)="12345"... atribuição estrelada é :) interessante
SP3000
@ sp3000 tipo de haskell-esque. i usar python muito mais do que Haskell, como é que eu não sei que isso
undergroundmonorail
11

Ruby, 8x8

 (0...8)
. map(){
|x |$><<
32. chr*
x+[x ]*'
'<<32 .\
chr*(7 -
x)+?\n} 

Resultado:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7
agosto
fonte
9

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

E a saída é

    1
    1
    1
    1
1111 

Eu estava tão perto da solução 4X4. <sigh>Veja minha outra resposta

Experimente online aqui

Optimizer
fonte
9

C ++, 12x12

Edit: Então, fiquei um pouco obcecado com esse desafio e consegui reduzi-lo de 17x17 para 12x12. Demorei um pouco para perceber que eu poderia usar /**/como um delimitador de token. Esse código tira proveito do fato de que uma emenda de linha ainda funciona em Clang com um espaço a seguir, apesar de emitir avisos e arruinar a coloração do código pelo Xcode.

#include<c\ 
stdio>/***/ 
int/**/mai\ 
n(){for(in\ 
t/**/i=0;i\ 
<12;++i)pr\ 
intf(i^8?"\ 
           \
|\n":"~~~~\ 
~~~~~~~\x2\ 
0\n");}/**/ 

Resultado:

           |
           |
           |
           |
           |
           |
           |
           |
~~~~~~~~~~~ 
           |
           |
           |
Lucas
fonte
5

Befunge-98 , 8x8 (56 não espaços [11 nops])

Nota: No interesse de uma boa pessoa esportiva, ela lê sua própria fonte ', tornando-a um truque para alguns. Leia o debate aqui .

Programa

 07'?>:8v
v y+da:%<
<v ':vj!-
,+# '<zzv
v1#a vj!<
>z,\1 -\v
z>+,$v z<
1_@#:<v -
zzzzzv<z 

Resultado

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

Explicação

A versão sem golfe

07'?>:8%:ad+y-!jv>'n,$v
  !jv   a,\1-\v > 's,  
    >         >       v
    v-1_@#:           <

(não-espaço e espaço são substituídos por 'n' e 'para facilitar a leitura.)

Essa solução é baseada no fato de que, usando um índice [0, width ^ 2) mod, a largura do quadrado pode dizer se você está no final da linha ou na diagonal. Como todos os espaços são colocados ao longo da diagonal, é fácil saber quando imprimir um não espaço!

Em Pseudocódigo

const int WIDTH = 8
push 0    //Because of the way the 'y' instruction works when picking
int row=7 //8-1 rows
int i=63  //Starting at the end allows for the cheaper i != 0
do
{
    pick variable row from the stack bottom + 1//ad+y
    if(i%WIDTH == row)
    {
        print non-space
    }
    else
    {
        print space
        if(i%WIDTH == 0)
        {
            print new-line
            --row
        }
    }
  --i
}
while(i != 0);

Discussão

Estou muito orgulhoso disso, apesar de desejar ter feito de todos os não-espaços também um não-nop. Também estou orgulhoso de não ter usado o padrão Befunge get-increment-put trope! Ele imprime símbolos diferentes para o não-espaço, porque eu tinha espaço para isso e não queria ser chato.

Experimente no Windows com o BefungeSharp !

tngreene
fonte
4

CJam, 4 x 4 (8 não espaços)

 N a
` S 
 * N
X $ 

Experimente online no intérprete CJam .

Resultado

[ " 
 " ]
[ " 
 " ]

Como funciona

  • Nenvia um avanço de linha como uma sequência de singleton. aquebra essa string em uma matriz.

  • ` inspeciona o resultado, ou seja, empurra uma representação de string da matriz.

    Este é o resultado:

    ["
    "]
    
  • S*une a sequência resultante (matriz de caracteres), separando seus elementos usando espaços. Em outras palavras, coloca um caractere de espaço entre todos os pares de caracteres adjacentes da sequência.

    Este é o resultado:

    [ " 
     " ]
    
  • N empurra outro avanço de linha.

  • X$ copia o item da pilha no índice 1 (contando a partir do topo), ou seja, a sequência de várias linhas.

  • Por fim, o intérprete imprime todos os itens da pilha: a sequência de múltiplas linhas original, o avanço de linha e a cópia da sequência de várias linhas.

Dennis
fonte
4

SOGL V0.12 , 2x2 (2 não espaços)

2 
 ╚

Experimente aqui!

Resultado

 /
/ 

Explicação

No SOGL, todas as linhas, exceto a última, estão substituindo as linhas - ele substitui em todo lugar no código contínuo o último caractere da linha por tudo o que está antes. Então a primeira linha aqui é replace space with 2 in the next line.
Em seguida, a próxima linha - 2╚é executada: 2empurra 2 e cria uma diagonal de tamanho 2.

dzaima
fonte
3

CBM BASIC v2.0 (8 × 8)

Uma melhoria em relação à minha resposta anterior , usando uma abordagem completamente diferente:

1s=56/8 
2?sP7); 
3?"?":: 
4s=s-+1 
5ifsgO2 
6?-8^6; 
7?sP1): 
       8

Resultado:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 
Psychonaut
fonte
3

Rubi, 8x8 7x7

 print(
 (?f+"\
 "*6+?\
 )*6).!
 $><<"\
 f"<<!1
;      

Resultado:

f      
f      
f      
f      
f      
f      
 ffalse

Versão anterior, 8x8 com 20 espaços:

  puts((
  "ff"+#
  ?\s*6+
  ?\n)*7
  );$><<
  ?\s*2+
  ?f;p:p
.!

Resultado:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse
m-chrzan
fonte
3

Pushy , quadrado 4x4

Não competir, pois o idioma pós o desafio:

Código:

 H32
2 C4
:" } 
\o/

Saídas:

d   
 d  
  d 
   d

Experimente online!

Como o espaço em branco é irrelevante no Pushy, o código é facilmente organizado para corresponder ao negativo de sua saída. O programa atual é assim:

H      \ Push char 100, 'd'
32 2C  \ Push char 32, a space, and make 2 extra copies
       \ We now have the string 'd   '
4:     \ 4 times do:
  "    \   Print the string
   }   \   Cyclically shift it right, once

As barras invertidas iniciam um comentário; portanto, o final \o/está lá para concluir o negativo e parecer legal.


Como alternativa, para a mesma pontuação, podemos ter as seguintes soluções:

Code    Output

 35;    #
3 2j     #
2C 4      #
:"}        #

K 36     #
33 2      #
Ct4        #
 :}"    #
FlipTack
fonte
3

Haskell, 10 × 10

main=let{ 
0&c='\32' 
!c;n&c=c! 
'\32'>>(n 
-1)&c;a!b 
=putStrLn 
$(b<$[1.. 
10])++[a] 
}in(9&'*' 
         )

Define uma função auxiliar a ! bque imprime uma linha do formulário bbbbbbbbbae uma função recursiva n & cque imprime nlinhas do formulário ccccccccc␣seguidas por uma linha do formulário ␣␣␣␣␣␣␣␣␣c.

Usa <$( fmap const, novamente) em um intervalo para repetir um caractere. Observe que <$só está disponível sem importações desde o GHC 7.10, que pós-data deste desafio. Não tenho muita certeza se isso torna este envio não competitivo.

Nada realmente emocionante com a escolha do layout ou algoritmo aqui; Eu não tinha muitos bytes de sobra e é uma sorte que as quebras de linha ocorram putStrLnda maneira que ocorreram .

betaveros
fonte
3

05AB1E , 3x3 (6 bytes sem espaço )

 3Ð
Λ q
°° 

Resultado:

3  
 3 
  3

Experimente online.

Explicação:

3Ð       # Push three 3s to the stack
  Λ      # Canvas with parameters num; filler; pattern
         #  num: The amount of characters to display (3)
         #  filler: The character to display ('3')
         #  pattern: The available options are single-digit integers in the range [0,7]
         #           indicating the direction to print in.
         #           (Option 3 is a top-left to bottom-right diagonal line)
    q    # Exit the program
°°       # no-ops to complete the pattern
Kevin Cruijssen
fonte
2

Perl, 6x6 (26 não espaços)

Passei um tempo analisando essas informações e tinha certeza de que haveria uma solução Perl menor que 7x7 de alguma forma ... Um desafio muito divertido! Esta solução requer -E.

say+( 
$"x5, 
"5$/" 
)x5,5 
x5,$" 
     ;

Uso:

perl -E 'say+( 
$"x5, 
"5\n" 
)x5,5 
x5,$" 
     ;'

Resultado:

     5
     5
     5
     5
     5
55555 
Dom Hastings
fonte
2

CBM BASIC v2.0 (9 × 9)

0dA8,7,6 
1dA5,4, 3
2dA2,1 ,0
3rEs: rem
4?sP s)::
5:? "*";:
6p =8---s
7 ?sPp):?
 8ifsgO3:

Resultado:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        
Psychonaut
fonte
1

C (gcc) , 7x7 8x8

EDIT: versão anterior teve comportamento incorreto.

 main(i)
{ for(;i
<9 ;pri\
ntf ("%\
*d%" "*\
c",i, 1,
9-i,10 )
,i++);} 

Experimente online!

gastropner
fonte
" Também exigimos que cada linha e cada coluna contenha pelo menos 1 espaço e 1 caractere não espacial . " Sua primeira coluna está faltando um caractere não espacial.
Kevin Cruijssen
@KevinCruijssen De alguma forma, eu perdi o critério das colunas, então elas estão erradas. Vou refazer quando tiver um computador real em mãos.
Gastropner 26/07/18
1

Gelatina , 4 x 4 (12 não espaços)

 4=þ
¢ +⁴
¢+ ⁴
¢ỌY

Experimente online!

Resultado:

!   
 !  
  ! 
   !

Isso foi bem divertido.

Como funciona

 4=þ    Link 1 (nilad): Generate an identity matrix of size 4
¢ +⁴    Link 2 (nilad): Add 16 to above
¢+ ⁴    Link 3 (nilad): Add 16 again
¢ỌY     Main link (nilad): Convert the above to ASCII chars, and join by newline

Parte fácil: o Jelly ignora os espaços em branco (desde que apenas os bytes de um byte sejam usados).

Parte difícil: cada linha no Jelly é um link (ou função) separado, portanto não é muito curto espalhar uma declaração constante em várias linhas. Usar um literal de cadeia de caracteres é um bom candidato, mas não faz ideia de como gerar o negativo.

Bubbler
fonte