Рассмотрим квадрат печатных символов ASCII (кодовые точки от 0x20 до 0x7E) для длины стороны N , как показано ниже (здесь N = 6 ):

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

Мы также требуем, чтобы каждая строка и каждый столбец содержали как минимум 1 пробел и 1 непробельный символ. (Приведенный выше пример удовлетворяет этому.)

Мы определяем отрицание такого квадрата, чтобы быть квадратом того же самого размера, где каждое пространство заменено не-пробелом и наоборот. Например, следующее будет действительным отрицанием приведенного выше примера:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

Выбор символов без пробелов не имеет значения (если они находятся в диапазоне ASCII для печати).

Соревнование

Вам нужно написать программу с квадратным исходным кодом с длиной стороны N> 1 , которая печатает свой отрицательный результат в STDOUT. Конечные пробелы должны быть напечатаны. Вы можете или не можете печатать один завершающий символ новой строки.

Также применяются обычные правила quine, поэтому вы не должны читать свой собственный исходный код, прямо или косвенно. Аналогично, вы не должны предполагать среду REPL, которая автоматически печатает значение каждого введенного выражения.

Победителем является программа с самой низкой длиной стороны N . В случае связывания выигрывает представление с наименьшим количеством непробельных символов в исходном коде. Если еще есть галстук, выигрывает самый ранний ответ.

CJam, 4 x 4 (8 не пробелов)

 L _
{ _ 
 _ }
_ p 

Попробуйте онлайн в интерпретаторе CJam .

Выход

{ _ 
 _ }
{ _ 
 _ }

Как это устроено

• Lтолкает пустой массив и _копирует его.

• Блок

  { _ 
   _ }
  

  толкает этот блок в стеке.

• _выдвигает копию блока кода и pпечатает ее, после чего следует перевод строки.

• Наконец, интерпретатор печатает все оставшиеся элементы в стеке: два пустых массива, которые не влияют на вывод, и исходный блок кода.

Альтернативная версия

 L ~
{ _ 
 p }
_ ~ 

Попробуйте онлайн в интерпретаторе CJam .

Выход

{ _ 
 p }
{ _ 
 p }

Как это устроено

• Lтолкает пустой массив и ~сбрасывает его. Стек снова пуст

• Блок

  { _ 
   p }
  

  толкает этот блок в стеке.

• _толкает копию блока и ~выполняет копию.

  _Внутри копии блока будет толкать копию исходного блока, который pбудет печататься, с последующим переводом строки.

• Наконец, интерпретатор печатает оставшийся элемент в стеке: оригинальный блок кода.

Perl, 7 × 7 (42 без пробелов)

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

Выход:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 не пробелов)

 6, 
SS +
* 4/
 N* 

Выход:

0  1
  2 
 3  
4  5

Предыдущая версия с 12 без пробелов:

 4a4
* 4S
** 4
/N* 

И вывод

4   
 4  
  4 
   4

Как указал Мартин, эта версия имеет

• 4 пробела,
• 4 * ,
• 4 4 ,
• 4 других персонажа и
• 4 4 в качестве выхода

;)

Попробуйте онлайн здесь

Marbelous - 16x16

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

Проверьте это здесь! Пробелы в виде пробелов, цилиндрической доски и включаемых библиотек все должны быть проверены.

Выход

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

объяснение

Здесь есть две платы: основная плата (показанная ниже) и ssплата, которая не принимает входных данных и выводит два пробела (0x20) в STDOUT.

Пустая ячейка эквивалентна a .., а все, что после a, #является комментарием.

Каждый тик ssвыводит два пробела в STDOUT.

Зеленый путь - это простой цикл, который выводит новую строку (0x0A) в конце каждого 7-го тика.

Синий путь выведет числа ( Hpпечатает мрамор в виде двух шестнадцатеричных цифр), присутствующих в выходных данных, в конце каждого 6-го тика.

После того как мы напечатали 01один раз, цикл заканчивается и движется по красной дорожке, которая дублирует этот мрамор.

Один дубликат печатается (второй 01), а другой отправляется по черному пути, который завершает доску в !!ячейке. Из-за расположения Hpиспользуемого в этом последнем отпечатке, поведение перед каждым другим вызовом 01появляется перед двумя пробелами того же тика, а не после него Hp.

Питон - 11х11

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

Выход

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

Это довольно грязное и скучное решение, но я просто подумал, что покажу это ...

1. Это можно сделать на Python
2. Если вы можете сжать информацию о вашем коде короче, чем ваш код, то вы можете выполнить что-то вроде этого :)

Это решение использует тот факт, что, если вы находитесь в паре скобок в Python, вы можете разбить свой код на несколько строк и произвольно добавить пробелы, не получая IndentationError. Еще один способ сделать что-то подобное - завершить строку обратной косой чертой.

Python - 7x7 (37 не пробелов)

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

Выход

      1
      1
      1
      1
      1
      1
111111 

Использует старый %оператор форматирования строки Python для выполнения работы: +7и -7заботится о выравнивании вправо / влево и последнем пробеле, для которого, printв частности, соответствует закрывающая скобка . При подготовке строки формата мы также имеем

• автоматическое объединение строковых литералов между строками и
• Повторение строки путем умножения (дает нам несколько полей замены по цене одного)

JavaScript (9x9)

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

Выход

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

Примечания

Я сделал и поиграл в гольф (в меру своих возможностей) для квадрата с диагональю любого размера n:

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

замена чисел *** asdf *** на константы в зависимости от длины стороны n, например, для n = 6:

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

Но, несмотря на то, что этот код имеет длину 46, я не мог заставить постоянный пробел совпадать с пробелом в диагонали кода, пока он не стал таким большим, как 9x9, с пропущенной линией (пятая)

Изменить: изменено, чтобы добавить предупреждение (). До:

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

CJam, 5x5, 12 без пробелов

Не победитель, но я хотел добавить довольно маленькое и редкое представление, так как большинство ответов просто печатают диагональ.

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

печать

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

Проверьте это здесь.

Последние два символа кода ничего не делают, поэтому на самом деле он содержит всего 10 байтов реального кода. Для сетки меньшего размера я мог бы даже уменьшить ее еще на два байта до 8, но это не подходит для 3x3, и этот код не работает даже для размеров сетки.

Как это устроено:

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

Я понятия не имею, почему я это сделал. Потребовалось путь слишком долго. У меня сейчас сильная головная боль.

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

Выход:

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

Некоторое объяснение

Код используется gдля чтения @символов из сетки «на лету» (а также последнего пробела, который есть @ / 2), а также pдля изменения цикла для записи последней строки вывода.

Каждый отдельный символ в коде используется в какой-то момент, либо как код, либо как данные ( 9и @в двух последних строках).

В основном мне пришлось сделать много обходных путей, чтобы код работал. Указатель инструкции делает несколько пересечений во время выполнения, некоторые из которых перепрыгивают. (Я не мог использовать там никакие инструкции для разных направлений, поскольку они мешали бы. Нет NOP.) В другом месте я либо использовал один и тот же символ, либо просто отменил его (см. $:В середине).

Я также сделал некоторую творческую работу над стеком:

• Когда (внутренний) цикл записи символов завершается (все пробелы сделаны для этой строки), стек имеет n,0. Затем я должен уменьшить n. Очевидное решение было бы $1-, но мне удалось сократить его с помощью !-.
• Когда цикл записи (внешней) строки завершается (печатаются все нормальные строки), в стеке есть символ 0. Затем я организовал Code Changer ( 20g46p7g46\p), чтобы использовать его 0, вместо того, чтобы тратить 2 символа на $0.

Python 3, 8x8

Есть 50 непробельных символов и 14 пробелов. В последней строке есть один бесполезный символ, но все остальное необходимо.

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

Выход:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Рубин, 8х8

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

Выход:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

И вывод

    1
    1
    1
    1
1111 

Я был так близко к решению 4X4. <sigh>Смотрите мой другой ответ

Попробуйте онлайн здесь

C ++, 12x12

Редактировать: Итак, я стал немного одержим этим вызовом и сумел снизить его с 17x17 до 12x12. Мне потребовалось немного времени, чтобы понять, что я могу использовать /**/в качестве разделителя токенов. Этот код использует тот факт, что слияние строк все еще работает в Clang с пробелом после него, хотя он выдает предупреждения и разрушает раскраску кода Xcode.

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

Выход:

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

Befunge-98 , 8x8 (56 без пробелов [11 nops])

Примечание: в интересах хорошего спортивного человека, он читает свой собственный источник ', делая его чит-квинтом для некоторых. Прочитайте дебаты здесь .

программа

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

Выход

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

объяснение

Версия без гольфа

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

(без пробела и пробела заменяются на 'n и' для удобства чтения.)

Это решение основано на том факте, что с помощью мода index [0, width ^ 2) ширина квадрата может сказать вам, находитесь ли вы в конце строки или на диагонали. Поскольку все пробелы расположены вдоль диагонали, легко определить, когда печатать не пробел!

В псевдокоде

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

обсуждение

Я очень горжусь этим, хотя хотел бы, чтобы каждое не-пространство также было не-нет. Я также горжусь тем, что не использовал стандартную форму Befunge get-increment-put! Он печатает разные символы для не пробелов, потому что у меня было место для этого и я не хотел быть скучным.

Попробуйте это на Windows с BefungeSharp !

CJam, 4 x 4 (8 не пробелов)

 N a
` S 
 * N
X $ 

Попробуйте онлайн в интерпретаторе CJam .

Выход

[ " 
 " ]
[ " 
 " ]

Как это устроено

• Nвыдвигает перевод строки как одиночную строку. aоборачивает эту строку в массив.

• ` проверяет результат, т. е. выдвигает строковое представление массива.

  Это результат:

  ["
  "]
  

• S*объединяет результирующую строку (массив символов), разделяя ее элементы пробелами. Другими словами, он помещает пробел между всеми парами смежных символов строки.

  Это результат:

  [ " 
   " ]
  

• N выдвигает другой перевод строки.

• X$ копирует элемент стека с индексом 1 (считая сверху), т.е. многострочной строкой.

• Наконец, интерпретатор печатает все элементы в стеке: исходную многострочную строку, перевод строки и копию многострочной строки.

SOGL V0.12 , 2x2 (2 не пробела)

2 
 ╚

Попробуй здесь!

Выход

 /
/ 

объяснение

В SOGL все строки, кроме последней, заменяют строки - везде в продолжающемся коде он заменяет последний символ строки всем, что находится перед ним. Так что 1-я строка здесь replace space with 2 in the next line.
Затем выполняется следующая строка 2╚: 2нажимает 2 и ╚создает диагональ размера 2.

CBM BASIC v2.0 (8 × 8)

Улучшение по сравнению с моим предыдущим ответом с использованием совершенно другого подхода:

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

Выход:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Рубин, 8х8 7х7

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

Выход:

f      
f      
f      
f      
f      
f      
 ffalse

Предыдущая версия, 8x8 с 20 пробелами:

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

Выход:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Напористый , квадрат 4х4

Не конкурирует, так как язык ставит перед нами задачу:

Код:

 H32
2 C4
:" } 
\o/

Выходы:

d   
 d  
  d 
   d

Попробуйте онлайн!

Поскольку пробелы в Pushy не имеют значения, код легко упорядочить так, чтобы он соответствовал отрицательному результату его вывода. Фактическая программа выглядит так:

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

Обратная косая черта начинается с комментария, поэтому трейлинг \o/только для завершения негатива и выглядит круто.

В качестве альтернативы, для того же результата мы можем предложить следующие решения:

Code    Output

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

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

Хаскелл, 10 × 10

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

Определяет вспомогательную функцию, a ! bкоторая печатает строку формы bbbbbbbbba, и рекурсивную функцию, n & cкоторая печатает nстроки формы, ccccccccc␣за которыми следует одна строка формы ␣␣␣␣␣␣␣␣␣c.

Использует <$( fmap constопять же) диапазон для повторения символа. Обратите внимание, что <$он доступен только без импорта, начиная с GHC 7.10, который датирует эту проблему. Я не совсем уверен, делает ли это представление неконкурентным.

Ничего особенного в выборе макета или алгоритма здесь нет; У меня не было большого количества байтов, и мне просто повезло, что разрывы строк происходят putStrLnтак, как они это делали.

05AB1E , 3x3 (6 непробельных байтов )

 3Ð
Λ q
°° 

Выход:

3  
 3 
  3

Попробуйте онлайн.

Объяснение:

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 не пробелов)

Я потратил много времени, просматривая их, и был уверен, что Perl-решение будет меньше, чем 7x7 ... Очень веселая задача! Это решение требует -E.

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

Использование:

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

Выход:

     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:

Выход:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

РЕДАКТИРОВАТЬ: предыдущая версия имела неправильное поведение.

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

Попробуйте онлайн!

Желе , 4 х 4 (12 не пробелов)

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

Попробуйте онлайн!

Выход:

!   
 !  
  ! 
   !

Это было довольно весело.

Как это устроено

 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

Легкая часть: Jelly игнорирует пробелы (если используются только однобайтовые встроенные функции).

Сложная часть: каждая строка в Jelly представляет собой отдельную ссылку (или функцию), поэтому не так уж и быстро распределить константу в несколько строк. Использование строкового литерала является хорошим кандидатом, но не знаю, как генерировать негатив.