Wyzwanie

Napisz najkrótszy możliwy fragment kodu, tak że gdy jego N kopii zostanie połączonych razem, liczba znaków wyjściowych to N ² . N będzie dodatnią liczbą całkowitą.

Na przykład, jeśli fragment kodu byłby soln();, wtedy uruchomienie soln();wypisuje dokładnie 1 znak, a uruchomienie soln();soln();wypisuje dokładnie 4 znaki, a uruchomienie soln();soln();soln();wypisuje dokładnie 9 znaków itp.

Dowolne znaki mogą znajdować się na wyjściu, o ile całkowita liczba znaków jest poprawna. Aby uniknąć pomyłek między systemami operacyjnymi, \r\nznaki nowej linii są liczone jako jeden znak.

Programy nie mogą odczytywać własnego źródła, rozmiaru pliku ani wykorzystywać innych takich luk. Traktuj to jak surowe wyzwanie quine .

Dane wyjściowe mogą przejść do standardowego lub pliku lub podobnej alternatywy. Brak danych wejściowych.

Komentarze w kodzie są w porządku, podobnie jak zamykanie w trakcie wykonywania.

W programie mogą znajdować się dowolne znaki. Najkrótsze przesłanie w bajtach wygrywa.

TECO, 4 bajty

V1\V

Vwypisuje zawartość bieżącego wiersza w buforze tekstowym. 1\wstawia ciąg reprezentujący liczbę 1 w bieżącej pozycji.

Tak więc podczas N iteracji programu, pierwsza Vwyśle N - 1 kopii znaku 1, następnie doda kolejną 1do tekstu, a następnie wyśle Ns 1 .

Brainfuck, 17 16 bajtów

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

Możesz to przetestować tutaj . Po prostu skorzystaj z faktu, że .n2+2n+1=(n+1)2

Brainfuck, 11

Zobaczyłem pierwszą odpowiedź Brainfuck i pomyślałem, że to zdecydowanie za długo :)

[.<]>[.>]+.

Wynik może być łatwiejszy do zauważenia, jeśli zamienisz plus na znacznie więcej plusów.

Podczas N-tej iteracji każda pętla wyprowadza N-1 kopii znaku o wartości ASCII 1, a następnie jeszcze jedną za pomocą +..

Python 2, 22

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

Wyświetla pusty ciąg, potem dwa x, potem xcztery i tak dalej. Z nowym wierszem po każdym łańcuchu pojawia się n*nznak.

Jedna kopia: "\n"(1 znak)
Dwie kopie: "\nxx\n"(4 znaki)
Trzy kopie: "\nxx\nxxxx\n"(9 znaków)

Aby powstrzymać ainicjalizację zmiennej początkowej przed każdym uruchomieniem, kończę kod za pomocą ;a, który sam w sobie jest łagodny, ale w połączeniu z następną pętlą tworzy kozła ofiarnego, aaktóry ma zostać przypisany. Ta sztuczka nie jest moja; Widziałem to w poprzedniej odpowiedzi. Byłbym wdzięczny, gdyby ktoś mógł mnie skierować, abym mógł wyrazić uznanie.

CJam, 6 bajtów

LLS+:L

Wykorzystuje fakt, że .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 bajtów

Jestem pewien, że istnieje bardzo krótki i pokręcony sposób rozwiązania tego problemu w ///, ale nie mogłem znaleźć niczego poza „bezpośrednim” sposobem:

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

Jest to oparte na podejściu drukowania kolejnych liczb nieparzystych. Fragment składa się z 1drukowanego na początku fragmentu i dwóch zamienników, które dodają dwa kolejne 1s do pierwszej części każdej kolejnej kopii fragmentu. Przejdźmy przez to do N = 3. W grupach po 3 lub więcej wierszy należy czytać: 1. bieżący kod, 2. przetworzony token (y), 3. (i następujące) komentarz do tego, co robi powyższy token.

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

Co ciekawe, działa równie dobrze, jeśli przejdziemy 1do końca:

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

> <> , 14 bajtów

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

Wykorzystuje pomysł „suma kolejnych nieparzystych liczb całkowitych, zaczynając od 1”. Zaczyna się od 1 i za każdym razem mnoży ją przez 100, stopniowo zwiększając długość wyjścia o 2.

Na przykład dodanie 5 kopii daje

1100100001000000100000000

Przetestowałem, przesyłając dane wyjściowe do pliku i nie widziałem końcowego nowego wiersza.

Awaria

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 bajtów

],)_S*a*~

Wypisuje N ² spacji gdzieN jest liczba kopii kodu.

Rozszerzenie kodu :

],            "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";

Wypróbuj online tutaj

Python 2, 20 bajtów

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

Java - 91 bajtów

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

To rozwiązanie jest równoważne temu drugiemu w Pythonie. Na pewno nie wygra, ale było fajnie :)

Perl, 14 bajtów

print;s//__/;

Należy to uruchomić za pomocą -lprzełącznika poleceń Perla , co powodujeprint dodanie nowych linii.

Wyświetla zmienną domyślną $_ , a następnie zastępuje dwa znaki podkreślenia przez podstawienie.

Przykład:

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

__
____
______

Brainfuck, 10 znaków

Oba poprzednie rozwiązania brainfuck były waaay zbyt długi (16 do 11 znaków), więc tutaj jest krótszy:

+[.->+<]>+

W n-tym bloku wypisuje 2*n-1znaki (z kodowymi punktami od 2*n-1do 1)

Preludium , 18 12 bajtów

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

To drukuje N. ² kart. Zakłada on zgodny ze standardami interpreter, który drukuje znaki zamiast cyfr, więc jeśli używasz interpretera Python , musisz ustawić NUMERIC_OUTPUTna False.

Chodzi o to, aby po prostu użyć górnej części stosu (która początkowo wynosi 0) jako 2(N-1) i wydrukować 2N-1zakładki, a następnie zwiększyć górę stosu o 2. Dlatego każde powtórzenie drukuje kolejną nieparzystą liczbę zakładek.

Java - 59/44 (w zależności od wymagań)

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

Najwyraźniej wolno nam zakładać, że kod działa w klasie.

Jeśli może wejść do głównej metody:

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

C, 87 bajtów

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

Używa to dwóch magicznych makr. __COUNTER__to makro, które rozwija się 0przy pierwszym użyciu, 1drugim itd. Jest to rozszerzenie kompilatora, ale jest dostępne zarówno w gcc, clang, jak i Visual Studio. __FILE__to nazwa pliku źródłowego. Dołączenie pliku w C / C ++ jest dosłownie tym samym, co wklejenie go bezpośrednio do kodu źródłowego, więc korzystanie z niego było trochę trudne.

W dalszym ciągu byłoby możliwe zastosowanie tej techniki __COUNTER__. W takim przypadku do #ifinstrukcji __LINE__można użyć standardowego zabezpieczenia przed dwukrotnym użyciem kodu i zliczenia potrzebnej liczby znaków.

Dyalog APL, 20 19 bajtów

Rozwiązanie oparte na matrycy.

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

Wypróbuj tutaj . Zwraca ciąg powtórzeń z . Wyjaśnienie przez wybuch dla :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

Kończy się nowy wiersz, aby upewnić się, że instrukcja display (di) działa. Najpierw wyświetl aktualną liczbę w $ a newlines (i jeden dodatkowy z domyślnego wyświetlania). Następnie dodaj 2 do $ a.

Wykorzystuje podejście do liczb parzystych (tzn. Podejście do liczb nieparzystych minus 1) za każdym razem z dodatkową nową linią.

T-SQL 117

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

Zwróć uwagę na spację końcową, aby za każdym razem poprawnie sprawdzać warunek if.

Wykorzystuje podejście do liczb nieparzystych. Nie jestem pewien, czy na wybranych instrukcjach jest nowy wiersz.

Nie jestem pewien, czy istnieje krótszy sposób na utworzenie tabeli, jeśli ona nie istnieje.

PostScript, 35 znaków

count dup 2 mul 1 add string print

Każde przejście „przecieka” jedną rzecz na stosie, więc count za każdym razem wzrasta o 1. Następnie po prostu używa sumy sztuczki z liczbami nieparzystymi.

Dane wyjściowe bajtów są, \000ponieważ jest to wartość początkowa ciągów.

Haskell, 72

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

Wyjaśnienie

Operator wprowadzania $działa tak, jakbyś umieszczał otaczające nawiasy wokół reszty wiersza (są wyjątki, ale w tym przypadku działa). aputStrto funkcja, która pobiera ciąg znaków w formacie „abc ...”, gdzie „abc” jest pierwiastkiem kwadratowym długości ciągu, łącznie z abc. Przetwarza ciąg jako liczbę całkowitą i zwraca ciąg rozpoczynający się od abc + 1 i mający kwadratową długość. Z powodu $operatora będzie to wywoływane rekurencyjnie na „1” N razy.

Pyth, 8 bajtów

*d*2Z~Z1

Polega to na tym, że N ² jest równe sumie Nliczb nieparzystych. Teraz Pyth auto drukuje nową linię, więc muszę po prostu wydrukować Z * 2znaki w każdym kodzie gdzie Zidzie od 0celu N - 1.

Rozszerzenie kodu :

*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";

Wypróbuj online tutaj

Golflua, 23 bajty

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

wyprowadza kombinację znaków &i \n.

Równoważny kod Lua

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

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

Za każdym razem, gdy fragment kodu jest uruchamiany, generuje o 2 znaki wyjściowe więcej niż ostatnim razem, zaczynając od 1 znaku. printFunkcja dodaje do nowej linii, to zainicjować X 0 zamiast 1.

ActionScript - 27/26 bajtów

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

lub

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

Jak to działa:

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

Po prostu komentuje pierwszą linię. Uwaga: tracedodaje nowy wiersz. A może wszystkie używane przeze mnie IDE robią to automatycznie.

GML, 27

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