Considere un cuadrado de caracteres ASCII imprimibles (puntos de código 0x20 a 0x7E) para la longitud del lado N , como el siguiente (aquí, N = 6 ):

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

También requerimos que cada fila y cada columna contengan al menos 1 espacio y 1 carácter no espacial . (El ejemplo anterior satisface esto).

Definimos lo negativo de tal cuadrado, para que sea un cuadrado del mismo tamaño, donde cada espacio se reemplaza por un no espacio y viceversa. Por ejemplo, lo siguiente sería un negativo válido del ejemplo anterior:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

La elección de los caracteres no espaciales es irrelevante (siempre que sean del rango ASCII imprimible).

El reto

Debe escribir un programa, con código fuente cuadrado con longitud lateral N> 1 , que imprime un negativo de sí mismo en STDOUT. Los espacios finales tienen que ser impresa. Puede o no imprimir una sola línea final.

Las reglas habituales de quine también se aplican, por lo que no debe leer su propio código fuente, directa o indirectamente. Del mismo modo, no debe asumir un entorno REPL, que imprime automáticamente el valor de cada expresión ingresada.

El ganador es el programa con la longitud del lado más bajo N . En caso de empate, gana el envío con la menor cantidad de caracteres no espaciales en el código fuente. Si todavía hay un empate, la primera respuesta gana.

CJam, 4 x 4 (8 sin espacios)

 L _
{ _ 
 _ }
_ p 

Pruébelo en línea en el intérprete de CJam .

Salida

{ _ 
 _ }
{ _ 
 _ }

Cómo funciona

• Lempuja una matriz vacía y _empuja una copia de la misma.

• El bloque

  { _ 
   _ }
  

  empuja ese bloque en la pila.

• _empuja una copia del bloque de código y lo pimprime, seguido de un salto de línea.

• Finalmente, el intérprete imprime todos los elementos restantes en la pila: dos matrices vacías que no afectan la salida y el bloque de código original.

Versión alternativa

 L ~
{ _ 
 p }
_ ~ 

Pruébelo en línea en el intérprete de CJam .

Salida

{ _ 
 p }
{ _ 
 p }

Cómo funciona

• Lempuja una matriz vacía y la ~descarga. La pila está vacía de nuevo.

• El bloque

  { _ 
   p }
  

  empuja ese bloque en la pila.

• _empuja una copia del bloque y ~ejecuta la copia.

  El _interior de la copia del bloque empujará una copia del bloque original, que pse imprimirá, seguido de un salto de línea.

• Finalmente, el intérprete imprime el elemento restante en la pila: el bloque de código original.

Perl, 7 × 7 (42 no espacios)

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

Salida:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 sin espacios)

 6, 
SS +
* 4/
 N* 

Salida:

0  1
  2 
 3  
4  5

Versión anterior con 12 no espacios:

 4a4
* 4S
** 4
/N* 

Y la salida es

4   
 4  
  4 
   4

Como señaló Martin, esta versión tiene

• 4 espacios,
• 4 * ,
• 4 4 ,
• 4 otros personajes, y
• 4 4 como salida

;)

Pruébalo en línea aquí

Marbelous - 16x16

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

¡Pruébalo aquí! Los espacios en blanco, el tablero cilíndrico y las bibliotecas de inclusión deben ser verificados.

Salida

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

Explicación

Aquí hay dos placas: la placa principal (que se muestra a continuación) y la ssplaca, que no toma entradas y emite dos espacios (0x20) a STDOUT.

Una celda en blanco es equivalente a a .., y cualquier cosa después de a #es un comentario.

Cada tick, ssgenera dos espacios para STDOUT.

La ruta verde es un bucle simple que genera una nueva línea (0x0A) al final de cada séptima marca.

El camino azul generará los números ( Hpimprime una canica como dos dígitos hexadecimales) presentes en la salida, al final de cada sexta marca.

Después de imprimir 01una vez, el bucle termina y se mueve hacia abajo por el camino rojo, que duplica esta canica.

Se imprime un duplicado (el segundo 01) y el otro se envía por el camino negro, que termina el tablero en la !!celda. Debido a la ubicación del Hputilizado en esta última impresión, 01aparece antes de los dos espacios de la misma marca, en lugar de después, el comportamiento de cada otra Hpllamada.

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]]

Salida

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

Es una solución bastante desordenada y aburrida, pero solo pensé en mostrar eso ...

1. Se puede hacer en Python
2. Si puede comprimir información sobre su código más corto que su código, entonces puede lograr algo como esto :)

Esta solución aprovecha el hecho de que, si está dentro de un par de paréntesis en Python, puede dividir su código en varias líneas y agregar espacios arbitrariamente sin obtener un IndentationError. Otra forma de hacer algo como esto es terminando la línea con una barra invertida.

Python - 7x7 (37 sin espacios)

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

Salida

      1
      1
      1
      1
      1
      1
111111 

Utiliza el antiguo %operador de formato de cadena de Python para hacer el trabajo: +7y -7se ocupa de la justificación derecha / izquierda, y el último espacio para que coincida con el paréntesis de cierre printen particular. Al preparar la cadena de formato, también tenemos

• concatenación automática de literales de cadena a través de líneas, y
• repetición de cuerda por multiplicación (dándonos múltiples campos de reemplazo por el precio de uno)

JavaScript (9x9)

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

Salida

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Notas

Hice un código de golf (lo mejor que pude) para un cuadrado con diagonal de cualquier tamaño n:

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

reemplazando los números *** asdf *** con constantes dependiendo de la longitud del lado n, por ejemplo para n = 6:

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

Pero, aunque ese código tiene una longitud 46, no pude conseguir que el espacio constante se alineara con un espacio en la diagonal del código hasta que fuera tan grande como un 9x9, con una línea desperdiciada (la quinta)

Editar: modificado para agregar alerta (). Antes de:

 i=9;q=""
; while((
++ i)<91)
{q= q+""+
""+( "")+
(!((i %10
))?1:" ")
;i%9||( q
+="\n")} 

CJam, 5x5, 12 sin espacios

No es un ganador, pero quería agregar una presentación bastante pequeña y dispersa , ya que la mayoría de las respuestas solo imprimen una diagonal.

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

huellas dactilares

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

Pruébalo aquí.

Los dos últimos caracteres del código, no hacen nada, por lo que en realidad solo tiene 10 bytes de código real. Para una cuadrícula más pequeña, incluso podría reducirlo en otros dos bytes a 8, pero eso no cabe en 3x3, y este código no funciona incluso para tamaños de cuadrícula.

Cómo 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.";

Befunge , 9x9

No tengo idea de por qué hice esto. Se tomó forma demasiado tiempo. Tengo un dolor de cabeza masivo ahora.

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

Salida:

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

Alguna explicación

El código se usa gpara leer los @caracteres de la cuadrícula "sobre la marcha" (y también el espacio final, que es @ / 2), yp para modificar el bucle para escribir la última línea de salida.

Todos los caracteres del código se usan en algún momento, ya sea como código o como datos (el 9y el@ en las dos últimas líneas).

Básicamente tuve que hacer muchas soluciones para que el código funcionara. El puntero de instrucción hace múltiples intersecciones durante la ejecución, de las cuales algunas se saltan. (No pude usar ninguna instrucción allí para diferentes direcciones, ya que interferirían. No hay NOP). En otro lugar o reutilicé el mismo personaje o simplemente lo deshice (vea el$: en el medio).

También hice un trabajo creativo en la pila:

• Cuando termina el ciclo de escritura de caracteres (interno) (todos los espacios realizados para esta línea), la pila tiene n,0. Entonces tengo que decrementar n. La solución obvia sería $1-, pero logré acortarlo usando !-.
• Cuando finaliza el bucle de escritura de línea (exterior) (todas las líneas normales impresas), la pila tiene un 0. Luego organicé el cambiador de código ( 20g46p7g46\p) para usar eso 0, en lugar de desperdiciar 2 caracteres $0.

Python 3, 8x8

Hay 50 caracteres no espaciales y 14 espacios. La última línea tiene un carácter inútil, pero todo lo demás es necesario.

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

Salida:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Rubí, 8x8

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

Salida:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

Y la salida es

    1
    1
    1
    1
1111 

Estaba tan cerca de la solución 4X4. <sigh>Mira mi otra respuesta

Pruébalo en línea aquí

C ++, 12x12

Editar: Entonces, me obsesioné un poco con este desafío y logré reducirlo de 17x17 a 12x12. Me tomó un tiempo darme cuenta de que podía usarlo /**/como un delimitador de tokens. Este código aprovecha el hecho de que un empalme de línea todavía funciona en Clang con un espacio después, aunque da advertencias y arruina la coloración de Xcode del código.

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

Salida:

           |
           |
           |
           |
           |
           |
           |
           |
~~~~~~~~~~~ 
           |
           |
           |

Befunge-98 , 8x8 (56 no espacios [11 nops])

Nota: En interés de un buen deportista, esto lee su propia fuente ', lo que lo convierte en una trampa para algunos. Lee el debate aquí .

Programa

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

Salida

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

Explicación

La versión sin golf

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

(no espacio y espacio se reemplazan con 'ny' por razones de legibilidad).

Esta solución se basa en el hecho de que al usar un índice [0, ancho ^ 2) mod, el ancho del cuadrado puede decirle si está al final de la fila o en la diagonal. Dado que todos los espacios se colocan a lo largo de la diagonal, es fácil saber cuándo imprimir un no espacio.

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

Discusión

Estoy muy orgulloso de ello, aunque desearía haber hecho que todos los no-espacios también sean no-nop. ¡También estoy orgulloso de no haber usado el tropo estándar Befunge get-increment-put! Imprime diferentes símbolos para el no espacio porque tenía espacio para él y no quería ser aburrido.

¡Pruébalo en Windows con BefungeSharp !

CJam, 4 x 4 (8 sin espacios)

 N a
` S 
 * N
X $ 

Pruébelo en línea en el intérprete de CJam .

Salida

[ " 
 " ]
[ " 
 " ]

Cómo funciona

• Nempuja un salto de línea como una cadena singleton. aenvuelve esa cadena en una matriz.

• ` inspecciona el resultado, es decir, empuja una representación de cadena de la matriz.

  Este es el resultado:

  ["
  "]
  

• S*une la cadena resultante (matriz de caracteres), separando sus elementos usando espacios. En otras palabras, coloca un carácter de espacio entre todos los pares de caracteres adyacentes de la cadena.

  Este es el resultado:

  [ " 
   " ]
  

• N empuja otro salto de línea.

• X$ copia el elemento de la pila en el índice 1 (contando desde arriba), es decir, la cadena de varias líneas.

• Finalmente, el intérprete imprime todos los elementos de la pila: la cadena de líneas múltiples original, el avance de línea y la copia de la cadena de líneas múltiples.

SOGL V0.12 , 2x2 (2 no espacios)

2 
 ╚

Pruébalo aquí!

Salida

 /
/ 

Explicación

En SOGL, todas las líneas, excepto la última, son líneas de reemplazo; reemplaza en todas partes en el código continuo el último carácter de la línea con todo lo que está antes. Así que la primera línea aquí es replace space with 2 in the next line.
Luego 2╚se ejecuta la siguiente línea : 2empuja 2 y ╚crea una diagonal de tamaño 2.

CBM BASIC v2.0 (8 × 8)

Una mejora con respecto a mi respuesta anterior , utilizando un enfoque completamente diferente:

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

Salida:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Rubí, 8x8 7x7

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

Salida:

f      
f      
f      
f      
f      
f      
 ffalse

Versión anterior, 8x8 con 20 espacios:

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

Salida:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Pushy , cuadrado 4x4

No competir ya que el lenguaje es posterior al desafío:

Código:

 H32
2 C4
:" } 
\o/

Salidas:

d   
 d  
  d 
   d

Pruébalo en línea!

Debido a que el espacio en blanco es irrelevante en Pushy, el código se organiza fácilmente para que coincida con el negativo de su salida. El programa real se ve así:

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

Las barras diagonales inversas comienzan un comentario, por lo que el final \o/solo está ahí para completar lo negativo y lucir genial.

Alternativamente, para el mismo puntaje, podemos tener las siguientes soluciones:

Code    Output

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

K 36     #
33 2      #
Ct4        #
 :}"    #

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 una función auxiliar a ! bque imprime una línea del formulario bbbbbbbbbay una función recursiva n & cque imprime nlíneas del formulario ccccccccc␣seguidas de una línea del formulario ␣␣␣␣␣␣␣␣␣c.

Usa <$( fmap const, de nuevo) en un rango para repetir un personaje. Tenga en cuenta que <$solo está disponible sin importaciones desde GHC 7.10, que es posterior a este desafío.No estoy completamente seguro de si esto hace que esta presentación no sea competitiva.

Nada realmente emocionante con la elección del diseño o algoritmo aquí; No tenía muchos bytes de sobra y es una suerte que uno pueda obtener los saltos de línea en putStrLnla forma en que lo hicieron.

05AB1E , 3x3 (6 bytes sin espacio )

 3Ð
Λ q
°° 

Salida:

3  
 3 
  3

Pruébalo en línea.

Explicación:

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

Perl, 6x6 (26 no espacios)

Pasé un rato mirando a través de estos y estaba seguro de que habría una solución Perl más pequeña que 7x7 de alguna manera ... ¡Un desafío muy divertido! Esta solución requiere -E.

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

Uso:

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

Salida:

     5
     5
     5
     5
     5
55555 

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:

Salida:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

EDITAR: La versión anterior tenía un comportamiento incorrecto.

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

Pruébalo en línea!

Gelatina , 4 x 4 (12 sin espacios)

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

Pruébalo en línea!

Salida:

!   
 !  
  ! 
   !

Esto fue muy divertido.

Cómo 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: Jelly ignora los espacios en blanco (siempre y cuando solo se utilicen los builtins de un byte).

Parte difícil: cada línea en Jelly es un enlace (o función) separado, por lo que no es muy corto extender una declaración constante en varias líneas. Usar un literal de cadena es un buen candidato, pero no tengo idea de cómo generar el negativo.