Meydan okuma

N kodları bir araya getirildiğinde, çıktı karakterlerinin sayısı N ^{2 olacak şekilde} mümkün olan en kısa kod pasajını yazın . N pozitif bir tamsayı olacaktır.

Örneğin, snippet olsaydı, soln();çalıştırma soln();tam olarak 1 karakter soln();soln();yazdırır ve koşmak tam olarak 4 karakter soln();soln();soln();yazdırır ve koşmak tam olarak 9 karakter yazdırırdı.

Toplam karakter sayısı doğru olduğu sürece herhangi bir karakter çıktıda olabilir. İşletim sistemleri arası karışıklığı önlemek için \r\nyeni satırlar bir karakter olarak sayılır.

Programlar kendi kaynaklarını okuyamaz, dosya boyutlarını okuyamaz veya bu gibi boşlukları kullanamaz. Sıkı gibi bu tedavi quine meydan.

Çıktı stdout'a veya bir dosyaya veya benzer bir alternatife gidebilir. Giriş yok.

Koddaki yorumlar, yürütmenin ortasındayken olduğu gibi iyidir.

Herhangi bir karakter programda olabilir. Bayt cinsinden en kısa gönderme kazanır.

TECO, 4 bayt

V1\V

VGeçerli satırın içeriğini metin arabelleğinde yazdırır. 1\1 numarasının dize gösterimini geçerli konuma ekler.

Öyleyse N programının inci iterasyon, ilk Virade çıkış N - 1 karakterinin kopyalar 1, sonra başka eklemek 1metin, daha sonra çıkış için N 1 s.

Brainfuck, 17 16 bayt

[>+>-..+<<-]-.>+

Burada test edebilirsiniz . Sadece gerçeği kullan .n2+2n+1=(n+1)2

Brainfuck, 11

İlk Brainfuck'ın cevabını gördüm ve çok uzun sürdüğünü düşündüm :)

[.<]>[.>]+.

Artıyı daha fazla artıyla değiştirip değiştirmeyeceğinizi görmek daha kolay olabilir.

N 'yinelemede, her döngü ASCII değer 1 olan karakterin N - 1 kopyasını ve ardından bir tane daha verir +..

Python 2, 22

a='';print a;a+='xx';a

Boş dizeyi, ardından iki x's, sonra x' dört vb. Yazdırır . Her dizgiden sonraki yeni satırda bu, n*nkarakterlerle ortaya çıkar .

Bir kopya: "\n"(1 karakter)
İki kopya: "\nxx\n"(4 karakter)
Üç kopya: "\nxx\nxxxx\n"(9 karakter)

aHer bir çalıştırmada başlangıç ​​değişkeninin yeniden başlatılmasını durdurmak için , kodu ;akendi başıma huylu olan ancak aayerine atanacak günah keçisini oluşturmak için bir sonraki döngü ile birleştiren bir sonlandırıyorum . Bu numara benim değil; Daha önceki bir cevapta gördüm. Biri beni işaret ederse, kredi verebilirsem memnun olurum.

CJam, 6 bayt

LLS+:L

Bu gerçeği kullanır .n2 + n + (n+1) = (n+1)2

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

/// , 21 bayt

Bunu /// içinde çözmek için gerçekten kısa ve bükülmüş bir yol olduğuna eminim, ancak henüz "basit" yolun ötesinde bir şey bulamadım:

1/1\//112\///2\//1\//

Bu ardışık tek sayıların yazdırılması yaklaşımına dayanır. Snippet 1, basılan bir başlangıçtan 1ve snippet'in ardışık her kopyasının ilk kısmına iki tane daha ekleyen iki değiştirmeden oluşur . Bunun için bunun üzerinden gidelim N = 3. Aşağıdakiler 3 veya daha fazla satırlık gruplar halinde okunmalıdır: 1. mevcut kod, 2. işlenmiş jeton (lar), 3. (ve sonraki) yukarıdaki kodun ne yaptığı yorum.

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

İlginç bir 1şekilde, sonuna kadar hareket edersek iyi çalışır :

/1\//112\///2\//1\//1

> <> , 14 bayt

1:na*a*';'10p!

"1'den başlayan ardışık garip tam sayıların toplamı" fikrini kullanır. 1 ile başlar ve her seferinde 100 ile çarparak, çıktının uzunluğunu kademeli olarak 2'lik artışlarla arttırır.

Örneğin, 5 kopya eklemek

1100100001000000100000000

Çıkışı bir dosyaya bağlayarak test ettim ve sonunda yeni bir satır görmedim.

Yıkmak

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

CJam, 10 9 bayt

],)_S*a*~

Bu baskılar, N ² alanlarda Nkod kopya sayısıdır.

Kod genişletme :

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

Burada çevrimiçi deneyin

Python 2, 20 bayt

g=0
print'g'*g;g+=2#

Java - 91 bayt

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

Bu çözüm eşdeğerdir bu diğeri Python. Kesinlikle kazanamayacak ama eğlenceliydi :)

Perl, 14 bayt

print;s//__/;

Bunun Perl'in -lkomut anahtarıyla çalıştırılması gerekiyor ve bu da printyeni satırlar ekliyor.

Varsayılan değişkeni yazdırır $_, sonra ikame ile iki alt çizgi hazırlar.

Örnek:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

Brainfuck, 10 karakter

Hem önceki Brainfuck çözümleri vardı waaay yüzden burada bir kısa olan çok uzun (16 ve 11 karakter):

+[.->+<]>+

In n-inci bloğunun yazdırdığı 2*n-1(dan codepoints karakterleri 2*n-1için 1)

Prelude , 18 12 bayt

^1+(9!1-)#2+

Bu N ² sekmelerini yazdırır . Sayılar yerine karakterleri basan standartlara uygun bir tercüman olduğu varsayılmaktadır, bu nedenle Python tercümanı kullanıyorsanız ayarlamanız NUMERIC_OUTPUTgerekir False.

Buradaki fikir basitçe yığının tepesini (başlangıçta 0'dır) kullanmak 2(N-1)ve 2N-1sekmeleri yazdırmak , ardından yığının tepesini 2 arttırmaktır. Bu nedenle, her bir tekrarlama sonraki sıradaki sekmeleri yazdırır.

Java - 59/44 (gereksinimlere bağlı olarak)

static String n="1";
static{System.out.print(n);n+="11";}//

Görünüşe göre kodun bir sınıfta çalıştığını varsaymamıza izin veriyor.

Ana yöntemin içine girebilirse:

String n="1";
System.out.print(n);n+="11";//

C, 87 bayt

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

Bu iki sihirli makro kullanır. ilk kullanılana, ikincisi, vb. __COUNTER__genişleyen bir makrodur . kaynak dosyanın adıdır. C / C ++ içine bir dosya eklemek, kelimenin tam anlamıyla onu doğrudan kaynak kodunuza yapıştırmakla aynıdır, bu nedenle kullanımı biraz zordu.01__FILE__

Bu tekniği olmadan kullanmak yine de mümkün olacaktır __COUNTER__. Bu durumda, kodun iki kez kullanılmasına karşı standart koruma #ififadesi __LINE__için kullanılabilir ve gereken karakter sayısını saymak için kullanılabilir.

Dyalog APL, 20 19 bayt

Matris tabanlı bir çözüm.

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

Burada dene . Bir tekrar dizesini döndürür . Patlama ile açıklama :N2aN = 2

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

STATA 20

di _n($a)
gl a=$a+2

Display (di) ifadesinin çalıştığından emin olmak için takip eden yeni bir satır var. Öncelikle mevcut numarayı $ a yeni satırlar halinde gösteriniz (ve ekranın varsayılan değerinden bir ek). Sonra 2 ila $ a ekleyin.

Her seferinde ekstra bir yeni satırla çift sayılar yaklaşımını (yani tek sayılar eksi 1'e yaklaşır) kullanır.

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

Her koşulda if koşulunun doğru şekilde kontrol edildiğinden emin olmak için takip alanına dikkat edin.

Tek sayılar yaklaşımını kullanır. Belirli ifadelerde yeni bir satır olup olmadığından emin değilim.

Varsa, bir tablo oluşturmak için daha kısa bir yol olup olmadığından emin değilim.

PostScript, 35 karakter

count dup 2 mul 1 add string print

Her countseferinde yığında bir şey "sızıntı", bu yüzden her seferinde 1 artar. Sonra justs tuhaf numaraların toplamını kullanır.

Bayt çıkışının tümü \000, dizelerin başlangıç ​​değeri olduğundandır.

Haskell, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

açıklama

Uygulayıcı işleci $, etraftaki parantezleri satırın geri kalanının etrafına yerleştiriyormuş gibi davranır (bunun istisnaları vardır, ancak bu durumda çalışır). aputStr"abc ..." biçiminde bir dize alan, "abc", abc de dahil olmak üzere dize uzunluğunun karekökü olan bir işlevdir. Dize bir tamsayı olarak ayrıştırır ve abc + 1 ile başlayan ve bu uzunluğu kareye sahip olan bir dize döndürür. $Operatör nedeniyle , bu tekrar tekrar "1" N kere çağırılır.

Pyth, 8 bayt

*d*2Z~Z1

Bu, N olduğu gerçeğine dayanır ² toplamına eşittir Ntek sayı. Şimdi Pyth auto yeni bir satır yazdırıyor, bu yüzden Z * 2her bir kod için nereye Zgittiğini yazmam 0gerekiyor N - 1.

Kod Genişletme :

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

Burada çevrimiçi deneyin

Golflua, 23 bayt

X=2+(X|-2)w(S.t("&",X))

bir kombinasyonu çıkışları &ve \nkarakter.

Eşdeğer Lua kodu

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

Kod pasajının her çalıştırılışında, 1 karakterden başlayarak en son 2 karakterden daha fazla çıktı üretir. printI, 0 1 yerine X başlatmak böylece fonksiyonu, yeni satır ekler.

ActionScript - 27/26 bayt

var n=""
trace(n);n+="11"//

veya

var n=1
trace(n);n+="11"//

Nasıl çalışır:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

Basitçe ilk satırı yorumlar. Not: Yeni tracebir satır ekler. Ya da belki de kullandığım tüm IDE'ler bunu otomatik olarak yapar.

GML, 27

a=''show_message(a)a+='xx'a