Imprima un negativo de su código

100

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.

Martin Ender
fuente
¿Se acepta el valor de retorno de una función o debe imprimirse en STDOUT?
Paul Guyot
1
@PaulGuyot Para este desafío, adhiérase a los programas completos y STDOUT (ya que, en términos generales, es una variante quine).
Martin Ender
Debe aclarar que el tamaño del tablero debe ser N> 0 . Veo que su ejemplo especifica N> 1 (¿y quiso decir N> = 1 ?), Pero esto no está en las reglas propiamente dichas.
Imallett
2
@imallett implicado por "También requerimos que cada fila y cada columna contengan al menos 1 espacio y 1 carácter no espacial". Espere. No. No lo es. Buen punto. Sin embargo, implica N == 0 || N> 1.
John Dvorak, el
1
@jpcooper Sí, es un cuadrado, pero no satisface "También requerimos que cada fila y cada columna contengan al menos 1 espacio y 1 carácter no espacial". porque las primeras m columnas no contienen espacios y las últimas n columnas no contienen espacios.
Martin Ender

Respuestas:

18

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.

Dennis
fuente
104

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      
ossifrage aprensivo
fuente
10
Este es uno de los mejores códigos que he visto en mucho tiempo.
Kasran
Directo y simple, pero bastante aburrido. Todavía +1.
Nova
8
Sería aún más genial si mostrara un 7hecho de 7. :)
AL
1
@AL Solo necesito 8 caracteres más (7 espacios y una nueva línea).
Qix
77

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í

Optimizador
fuente
22
También tiene 4 votos a favor, pero estoy a punto de estropearlo. ¡Lo siento! :-D
ossifrage aprensivo
77
Tal vez podamos llegar a 44? +1 :)
Pomo de la puerta
44
Mantenga el ritmo hasta 4 ^ 4
Optimizer
17
¿4 ^ 4 == 0? ;)
zennehoy
1
Sí, no me gusta el hecho de que XOR bit a bit robó el símbolo que debería haberse usado para exponentes. Desordena la legibilidad del código, honestamente.
SuperJedi224
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

¡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.

Imagen de la Junta

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.

es1024
fuente
99
Votación a favor de la representación gráfica de la fuente.
Riking
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]]

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.

Sp3000
fuente
33

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)
Greg
fuente
18

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")} 
Kuilin Li
fuente
Ahh, sí, vaya, ya veo lo que quieres decir. Lo estoy arreglando ahora, lo siento.
Kuilin Li
Tienes algunas variables globales unitarias allí: P
Tomáš Zato
16

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.";
Martin Ender
fuente
Las respuestas explosivas de CJam y Pyth son, con mucho, mi cosa favorita en el sitio. Tener un voto al estilo Reddit.
Soham Chowdhury
14

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.
PurkkaKoodari
fuente
Befunge siempre recibe un +1 de mi parte. Agradable con el !-; Eso es algo que haría. Dato curioso: en Funge-98, zes un NOP.
Kasran
@Kasran Sí. zno fue incluido en el wiki y he usado este para la codificación, lo que significaba ningún comando no volcó la dirección IP. Más o menos tuvo que refactorizar el 70% del código debido a un lugar que debería ser NOP.
PurkkaKoodari
Bueno, la ventaja de hacerlo es que su código se ejecutará en Befunge-95 (que no creo que tenga un NOP no espacial) y 98; Como es mucho más difícil usar 95, siempre he encontrado esas respuestas extra impresionantes.
Kasran
13

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
grc
fuente
2
Acabo de intentar jugar con (a,*b,c)="12345"... la asignación destacada es interesante :)
Sp3000
@ sp3000 tipo de haskell-esque. yo uso manera pitón más de Haskell, ¿Cómo no sé
undergroundmonorail
11

Rubí, 8x8

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

Salida:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7
agosto
fuente
9

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:

           |
           |
           |
           |
           |
           |
           |
           |
~~~~~~~~~~~ 
           |
           |
           |
Luke
fuente
5

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 !

tngreene
fuente
4

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.

Dennis
fuente
4

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.

dzaima
fuente
3

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 
Psiconauta
fuente
3

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
m-chrzan
fuente
3

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        #
 :}"    #
FlipTack
fuente
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 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.

betaveros
fuente
3

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
Kevin Cruijssen
fuente
2

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 
Dom Hastings
fuente
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:

Salida:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        
Psiconauta
fuente
1

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!

gastropner
fuente
" También requerimos que cada fila y cada columna contengan al menos 1 espacio y 1 carácter no espacial " . A su primera columna le falta un carácter no espacial.
Kevin Cruijssen
@KevinCruijssen De alguna manera me perdí el criterio de columnas, así que están todos equivocados. Se rehacerá cuando tenga una computadora real a mano.
Gastropner
1

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.

Bubbler
fuente