Yan uzunluk N için yazdırılabilir ASCII karakterleri (kod noktaları 0x20 - 0x7E) , aşağıdaki gibi (burada, N = 6 ) bir kare düşünün :

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

Ayrıca her satırın ve her sütunun en az 1 boşluk ve 1 boşluksuz karakter içermesini istiyoruz . (Yukarıdaki örnek bunu karşılamaktadır.)

Böyle bir karenin negatifini , her boşluğun boşluksuz ve tam tersi ile değiştirildiği aynı büyüklükte bir kare olarak tanımlarız . Örneğin, aşağıdakiler yukarıdaki örneğin geçerli bir negatifi olacaktır:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

Boşluksuz karakterlerin seçimi alakasızdır (yazdırılabilir ASCII aralığından oldukları sürece).

Meydan okuma

STDOUT'a olumsuz yönde baskı yapan, N> 1 kenar uzunluğu kare kodlu bir program yazacaksınız . Çekme alanlarda var basılabilir. Sondaki tek bir satırsonunu yazdırabilir veya basmayabilirsiniz.

Normal quine kuralları da geçerlidir, bu nedenle doğrudan veya dolaylı olarak kendi kaynak kodunuzu okumamalısınız. Aynı şekilde, girilen her ifadenin değerini otomatik olarak basan bir REPL ortamı varsaymamalısınız.

Kazanan, en düşük yan uzunluğu N olan programdır . Bir beraberlik durumunda, kaynak kodunda en az boşluksuz karakter içeren gönderim kazanır. Hala bir kravat varsa, en eski cevap kazanır.

CJam, 4 x 4 (8 boşluksuz)

 L _
{ _ 
 _ }
_ p 

CJam tercümanında çevrimiçi olarak deneyin .

Çıktı

{ _ 
 _ }
{ _ 
 _ }

Nasıl çalışır

• Lboş bir dizi _iter ve bir kopyasını iter.

• Blok

  { _ 
   _ }
  

  bu bloğu yığına iter.

• _kod bloğunun bir kopyasını iter ve pyazdırır, ardından satır beslemesi yapar.

• Son olarak, yorumlayıcı yığında kalan tüm öğeleri yazdırır: çıkışı etkilemeyen iki boş dizi ve orijinal kod bloğu.

Alternatif sürüm

 L ~
{ _ 
 p }
_ ~ 

CJam tercümanında çevrimiçi olarak deneyin .

Çıktı

{ _ 
 p }
{ _ 
 p }

Nasıl çalışır

• Lboş bir diziyi iter ve ~döker. Yığın tekrar boş.

• Blok

  { _ 
   p }
  

  bu bloğu yığına iter.

• _bloğun bir kopyasını iter ve kopyayı ~yürütür.

  _Bloğun kopyası içindeki orijinal bloğun, bir kopyasını zorlayacak pbir besleme ile takip yazdırır.

• Son olarak, tercüman kalan öğeyi yığına yazdırır: orijinal kod bloğu.

Perl, 7 × 7 (42 boşluksuz)

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

Çıktı:

      7
     7 
    7  
   7   
  7    
 7     
7      

CJam, 4X4 ( 12 10 boşluksuz)

 6, 
SS +
* 4/
 N* 

Çıktı:

0  1
  2 
 3  
4  5

12 boşluksuz önceki sürüm:

 4a4
* 4S
** 4
/N* 

Ve çıktı

4   
 4  
  4 
   4

Martin tarafından belirtildiği gibi, bu sürüm

• 4 Uzay
• 4 * ,
• 4 4 ,
• 4 karakter daha ve
• 4Çıkış olarak 4

;)

Burada çevrimiçi deneyin

Mermer - 16x16

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

Burada test et! Boşluklar, silindirik panolar ve kütüphaneler içeren boşluklar kontrol edilmelidir.

Çıktı

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

açıklama

Burada iki kart vardır: ana kart (aşağıda gösterilmiştir) ve ssgiriş ve çıkış alan kart, STDOUT'a iki boşluk (0x20) çıkarır.

Boş bir hücre a ile eşdeğerdir ..ve #bir yorumdan sonraki her şey bir yorumdur.

Her tıklatma, ssSTDOUT'a iki boşluk çıkarır.

Yeşil yol, her 7. satırın sonunda bir satırsonu (0x0A) çıkaran basit bir döngüdür.

Mavi yol Hpher 6 kene sonunda, çıktıda bulunan sayıları ( iki altıgen basamaklı bir mermer basar) çıkarır.

Bir 01kere bastıktan sonra, ilmek sona erer ve bu mermeri kopyalayan kırmızı yoldan aşağı doğru hareket eder.

Bir kopya basılır (ikincisi 01), diğeri ise tahtayı !!hücrede sonlandıran siyah yoldan gönderilir . HpBu son baskıda kullanılan yer nedeniyle , aynı onay işareti, diğer çağrıların davranışından sonra değil, iki boşluktan önce01 görünür .Hp

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

Çıktı

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

Oldukça dağınık ve sıkıcı bir çözüm, ama şunu göstermeyi düşündüm ...

1. Python'da yapılabilir
2. Kodunuzla ilgili bilgileri kodunuzdan daha kısa bir süre boyunca sıkıştırabilirseniz, böyle bir şeyi kaldırabilirsiniz :)

Bu çözüm Python parantez çifti içinde iseniz, o zaman birkaç hatları üzerinden kodunuzu bölmek ve keyfi bir almadan boşluk ekleyebilir, gerçeği yararlanır IndentationError. Böyle bir şey yapmanın başka bir yolu, çizgiyi ters eğik çizgiyle sonlandırmaktır.

Python - 7x7 (37 boşluksuz)

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

Çıktı

      1
      1
      1
      1
      1
      1
111111 

%İşi yapmak için Python'un eski dize formatlama operatörünü kullanır : +7ve -7sağ / sol gerekçelerine ve printözellikle de kapanış paranteziyle eşleşen son boşluğa dikkat edin . Format dizesini hazırlarken, ayrıca

• Dize değişmezlerinin satırlar boyunca otomatik olarak birleştirilmesi ve
• çarpımla dize tekrarı (birinin fiyatı için bize birden çok yedek alan vererek)

JavaScript (9x9)

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

Çıktı

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

notlar

Herhangi bir boyutta köşegen olan bir kare için kod yazdım (yeteneğimin en iyisine):

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

*** asdf *** sayılarını, n = 6 için, yan uzunluğa bağlı olarak sabitlerle değiştirmek, örneğin:

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

Ancak, bu kodun uzunluğu 46 olsa da, kodun köşegeninde bir boşluk olacak şekilde 9x9 kadar büyük olana kadar harcanan bir satır (5.)

Düzenleme: Uyarı () eklemek için değiştirildi. Önce:

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

CJam, 5x5, 12 boşluksuz

Kazanan değil, fakat oldukça küçük ve seyrek bir gönderim eklemek istedim , çünkü çoğu cevap sadece köşegen basar.

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

baskılar

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

Burada test et.

Kodun son iki karakteri hiçbir şey yapmaz, bu yüzden sadece 10 byte gerçek kod vardır. Daha küçük bir ızgara için, onu iki bayttan 8'e bile azaltabilirim, ancak bu 3x3'e sığmaz ve bu kod ızgara boyutlarında bile çalışmaz.

Nasıl çalışır:

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

Bunu neden yaptığım hakkında hiçbir fikrim yok. O sürdü yolu çok uzun. Şimdi büyük bir baş ağrım var.

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

Çıktı:

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

Bazı açıklama

Kod g, @karakterleri "anında" ızgaradan okumak (ve aynı zamanda son boşluğu @ / 2) ve pson çıkış satırını yazmak için döngüyü değiştirmek için kullanılır.

Koddaki her karakter, bir noktada, kod veya veri olarak ( 9ve @son iki satırdaki) kullanılır.

Temel olarak kodun çalışması için birçok geçici çözüm yapmak zorunda kaldım. Komut işaretçisi, yürütme sırasında bir kısmı atlanan çoklu kesişmeler yapar. (Herhangi bir talimatı, kullanacakları farklı yönler için kullanamadım. NOP yok.) Başka bir yerde ya aynı karakteri tekrar kullandım ya da sadece undid yaptım ( $:ortada bakın).

Ayrıca yığında yaratıcı çalışmalar yaptım:

• (İç) karakter yazma döngüsü sona erdiğinde (bu satır için yapılan tüm boşluklar) yığında n,0. O zaman azaltmam gerekiyor n. Açık bir çözüm olabilirdi $1-, ancak kullanarak onu kısaltmayı başardım !-.
• (Dış) satır yazma döngüsü sona erdiğinde (tüm normal satırlar yazdırılır), yığında a 0. Daha sonra 2 karakter 20g46p7g46\pkullanmak 0yerine, onu kullanmak için kod değiştiriciyi ( ) organize ettim $0.

Python 3, 8x8

50 tane boşluksuz karakter ve 14 tane boşluk vardır. Son satırın bir işe yaramaz karakteri var, ama her şey gerekli.

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

Çıktı:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Ruby, 8x8

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

Çıktı:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

CJam, 5X5

SSSS 
1N]4 
*B11 
    S

Ve çıktı

    1
    1
    1
    1
1111 

4X4 çözümüne bu kadar yakındım. <sigh>Diğer cevabımı gör

Burada çevrimiçi deneyin

C ++, 12x12

Düzenleme: Böylece, bu zorluğa biraz takıntılı oldum ve 17x17'den 12x12'ye düşürmeyi başardım. /**/Bir belirteç sınırlayıcı olarak kullanabileceğimi anlamam biraz zaman aldı . Bu kod, bir satır ekinin hala Clang'da bir boşlukla çalıştığı gerçeğinden faydalanır, ancak Xcode'un kod renklendirmesini uyarır ve mahveder.

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

Çıktı:

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

Befunge-98 , 8x8 (56 boşluk bırakılmamış [11 düğüm])

Not: İyi bir spor-insan-geminin yararına, bu kaynaklara 'hile yapmak için kendi kaynağını okur . Tartışmayı buradan okuyun .

program

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

Çıktı

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

açıklama

Golfsüz versiyon

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

(boşluk olmayan ve boşluk okunabilirlik uğruna 'n ve' ile değiştirilir.)

Bu çözüm, [0, genişlik ^ 2) mod dizinini kullanarak karenin genişliğinin satırın sonunda veya köşegen üzerinde olup olmadığınızı size söyleyebilir. Tüm boşluklar köşegen boyunca yerleştirildiğinden, boşluksuz ne zaman basılacağını söylemek kolaydır!

Sözde Kodda

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

Tartışma

Bununla gurur duyuyorum, keşke her yeri boşuna olmayan bir alan da yapabilseydim. Ayrıca standart Befunge get-increment-put-trope kullanmadığım için gurur duyuyorum! Boşluk için farklı semboller basıyor çünkü yerim vardı ve sıkıcı olmak istemedim.

BefungeSharp ile Windows'ta deneyin !

CJam, 4 x 4 (8 boşluksuz)

 N a
` S 
 * N
X $ 

CJam tercümanında çevrimiçi olarak deneyin .

Çıktı

[ " 
 " ]
[ " 
 " ]

Nasıl çalışır

• Nbir satır beslemeyi singleton dizge olarak iter. abu diziyi bir dizide sarar.

• ` sonucu inceler, yani dizinin dizgi gösterimini iter.

  Sonuç bu:

  ["
  "]
  

• S*boşlukları kullanarak elemanlarını ayırarak ortaya çıkan dizgiye (karakter dizisi) katılır. Başka bir deyişle, dizenin tüm bitişik karakter çiftlerinin arasına bir boşluk karakteri koyar.

  Sonuç bu:

  [ " 
   " ]
  

• N başka bir satır besleme iter.

• X$ yığın öğesini 1. dizinde (üstten sayma), yani çok satırlı dizeye kopyalar.

• Son olarak, yorumlayıcı yığındaki tüm öğeleri yazdırır: orijinal çok satırlı dize, satır besleme ve çok satırlı dizenin kopyası.

SOGL V0.12 , 2x2 (2 boşluksuz)

2 
 ╚

Burada dene!

Çıktı

 /
/ 

açıklama

SOGL'de sonuncusu dışındaki tüm satırlar satırları değiştirir - devam eden koddaki her yer, satırın son karakterini her şeyden önceki her şeyle değiştirir. SO burada ilk satır replace space with 2 in the next line.
Sonra bir sonraki satır - 2╚yürütülür: 22'ye basar ve ╚2 boyutunda bir diyagonal oluşturur.

CBM TEMEL v2.0 (8 × 8)

Tamamen farklı bir yaklaşım kullanarak önceki cevabımdaki bir gelişme :

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

Çıktı:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Ruby, 8x8 7x7

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

Çıktı:

f      
f      
f      
f      
f      
f      
 ffalse

Önceki sürüm, 20 boşluklu 8x8:

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

Çıktı:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Saldırgan , 4x4 kare

Dil mücadeleden sonra rekabet etmeyen:

Kod:

 H32
2 C4
:" } 
\o/

Çıktılar:

d   
 d  
  d 
   d

Çevrimiçi deneyin!

Boşluk Pushy'de alakasız olduğundan, kod çıktısının negatifiyle eşleşecek şekilde kolayca düzenlenir. Gerçek program şöyle görünür:

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

Ters eğik çizgiler yorum yapmaya başlar, bu nedenle izleyenler \o/negatifleri tamamlamak ve sadece havalı görünmek için oradadır.

Alternatif olarak, aynı puan için aşağıdaki çözümlere sahip olabiliriz:

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&'*' 
         )

a ! bFormun bir satırını basan bir yardımcı işlevi bbbbbbbbbave ardından formun bir satırını izleyen bir özyinelemeli işlevi n & ctanımlar .nccccccccc␣␣␣␣␣␣␣␣␣␣c

Bir karakteri tekrarlamak için bir aralıkta kullanır <$( fmap const, tekrar). Bunun <$sadece GHC 7.10’dan bu yana ithalatın bulunmadığını ve bu mücadelenin tarihini belirten notun alınabileceğini unutmayın . Bu gönderinin rekabet etmemesini sağladığından emin değilim.

Buradaki düzen veya algoritma seçimi ile gerçekten heyecan verici bir şey yok; Yedeklenecek çok fazla bayt yoktu ve satır sonlarının olduğu gibi gerçekleşmesi çok şanslı putStrLn.

05AB1E , 3x3 (6 boşluksuz bayt )

 3Ð
Λ q
°° 

Çıktı:

3  
 3 
  3

Çevrimiçi deneyin.

Açıklama:

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 boşluksuz)

Bunlara bakarak bir whlie geçirdim ve 7x7'den küçük bir Perl çözümü olacağından emindim ... Çok eğlenceli bir mücadele! Bu çözüm gerektirir -E.

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

Kullanımı:

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

Çıktı:

     5
     5
     5
     5
     5
55555 

CBM TEMEL 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:

Çıktı:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

C (gcc) , 7x7 8x8

EDIT: Önceki sürümde yanlış davranış vardı.

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

Çevrimiçi deneyin!

Jöle , 4 x 4 (12 boşluksuz)

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

Çevrimiçi deneyin!

Çıktı:

!   
 !  
  ! 
   !

Bu oldukça eğlenceliydi.

Nasıl çalışır

 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

Kolay kısım: Jelly beyaz alanları yok sayar (yalnızca bir bayt yerleşikleri kullanıldığı sürece).

Sert kısım: Jelly'deki her satır ayrı bir bağlantıdır (veya işlevdir), bu nedenle sabit bir ifadeyi birden fazla satıra yaymak çok kısa değildir. Bir dize değişmezi kullanmak iyi bir adaydır, ancak negatifin nasıl üretileceği hakkında bir fikir yoktur.