Розглянемо квадрат друкованих символів 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. Пробіли повинні бути надруковані. Ви можете або не можете надрукувати один простий новий рядок.

Також застосовуються звичайні правила кволі, тому ви не повинні читати власний вихідний код прямо чи опосередковано. Так само не слід приймати середовище 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 як вихід

;)

Спробуйте його онлайн тут

Марбелус - 16х16

....@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 #- коментар.

Кожна галочка 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, з пропущеним рядком (5-й)

Редагувати: Змінено, щоб додати сповіщення (). Перед:

 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для зміни циклу, щоб записати останній рядок виводу.

Кожен окремий символ у коді використовується в якийсь момент, або як код або як дані (the 9 та в @останніх двох рядках).

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

Я також зробив кілька творчих робіт над стеком:

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

Пітон 3, 8х8

Є 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 ніс])

Примітка. На користь хорошого спортивного судна, він читає власне джерело, завдяки 'чому це стає чіт-quine для деяких. Читайте дебати тут .

Програма

 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 і' з метою читабельності.)

Це рішення засноване на тому, що за допомогою індексу [0, ширини ^ 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);

Обговорення

Я дуже пишаюся цим, хоча хочу, щоб я міг зробити кожен непростір також нон-нопом. Я також пишаюся тим, що я не використовував стандартний троп Beputge-приріст! Він друкує різні символи для простору, тому що я мав місце для цього і не хотів бути нудним.

Спробуйте його на 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 всі рядки, крім останнього, замінюють рядки - він замінює всюди у продовжувальному коді останній символ рядка усім, що передує. Так ось перший рядок тут 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

Попередня версія, 8х8 з 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

EDIT: Попередня версія мала неправильну поведінку.

 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 є окремою ланкою (або функцією), тому не дуже коротко поширювати константний вислів у декілька рядків. Використання рядкового літералу є хорошим кандидатом, але не має уявлення, як генерувати мінус.