To jest nić rabusia. W gwint policjanta jest tutaj .

Macierz węża to macierz kwadratowa, która ma następujący wzór:

3 na 3:

1  2  3
6  5  4
7  8  9

i 4 na 4:

1  2  3  4
8  7  6  5
9  10 11 12
16 15 14 13

Twoim zadaniem jest napisanie kodu, który pobiera dane wejściowe ni tworzy taką matrycę, w tym samym języku, co post gliniarza, oraz z kodem pasującym do wyrażenia regularnego gliny. Format wyjściowy kodu musi być zgodny z formatem wyjściowym kodu policjanta.

Pozostaw komentarz pod postem gliniarza, aby wskazać, że go złamałeś.

Kryterium wygranej:

Zwycięzcą zostanie użytkownik, który złamał najwięcej zgłoszeń. W przypadku remisu będzie wielu zwycięzców.

Galaretka , 9 bajtów, pęka odpowiedź @Dennis

²sµUFḤ$¦G

Wypróbuj online!

Powinno być teraz poprawne; Musiałem raczej przemyśleć to, co robiłem.

Wyjaśnienie

Najtrudniejszą częścią tego problemu jest uzyskanie listy parzystych indeksów wewnątrz ¦(która stosuje operację przy określonych indeksach). W przeciwieństwie do większości operacji, które używają danych wejściowych do całego programu jako domyślnego dla drugiego operandu, ¦używa ostatnio widzianej wartości jako domyślnej (ponieważ koncepcyjnie ma dwa lewe operandy, a nie lewy i prawy operand, jak większość rzeczy, które przyjąć dwie wartości).

Możemy jednak zauważyć, że mamy listę liczb, w tym wszystkie liczby całkowite od 1 do połowy wartości wejściowej, już w bieżącej wartości w tym czasie. Jako takie, spłaszczanie i podwojenie daje nam listę liczb parzystych, w tym wszystkie wskaźniki parzyste (także niektóre inne liczby parzyste, ale nie dbamy o to). Można nawet wydać jeden, µaby uniknąć dwuznaczności i nadal zawierać 9 znaków.

²sµUFḤ$¦G
 s         Split
²          {the list of numbers from 1 to} the square of {the input}
  µ        into a number of pieces equal to {the input};
   U       then reverse
       ¦   the elements at indexes
    F      obtained by flattening the split list
      $    and
     Ḥ     doubling each element in the flattened list;
        G  finally, format it into a grid.         

05AB1E, Emigna

To był mój pierwszy raz, kiedy użyłem 05AB1E. Mam to z niewielką pomocą. To było zabawne. :)

UXFXLNX*+N2BSR1k_iR}ˆ

Wypróbuj online

Wyjaśnienie:

U                       Assign input to X
 XF                     For N in range(0,X):
   XL                   Push list [1 .. X]
     NX*+               Add N*X to each element of the list
         N2BSR1k_       Super clever way to get N%2:
                            not bool(reversed(str(bin(N))).index('1')) (N%2 is odd)
                 iR}    if N%2 is odd, then reverse the list
                    ˆ   Add row to global array
                        Implicit print

Właściwie sam znalazłem ten podobny program, ale format wyjściowy jest inny:

UXFXLNX*+N2BSR1k_iR}=

Wypróbuj online

[1, 2, 3, 4]
[8, 7, 6, 5]
[9, 10, 11, 12]
[16, 15, 14, 13]

Zobacz historię edycji moich poprzednich dwóch prób.

Python 2, Dennis

To zabawny problem z golfem.

while ord>eval:1;int,eval=int<1and(int,eval+1)or(-input(),1);i=int;ord=i*i;print'%*s'%(-i,(eval+~i+~-eval%-i*~1,eval)[eval/i&1])+'\nt'[:-1<eval%int],

Weryfikacja wyrażenia regularnego

Ohm, Nick Clifford

Mój pierwszy raz próbuję Ohma.
Naprawdę fajny język, którego nie mogę się doczekać :)

²@┼σ▓_^è?R

Wyjaśnienie

²             # square input
 @            # range [1 ... input^2]
  ┼σ          # split in input sized chunks
    ▓         # perform the following block on each element of the array
     _        # current element
      ^è?     # if index is odd
         R    # reverse

Moja pierwsza próba, która nie działała jako dodanie tablicy i int, nie jest możliwa:

@┼MDR┼+;W

Moja druga próba, która nie pasowała do wyrażenia regularnego:

²@┼σ▓_^MR

05AB1E, Emigna (2. przedłożenie)

Pierwsza praca z 05AB1E.

VYLUYFYXDˆ+RU

Wypróbuj online! | Weryfikacja wyrażenia regularnego

Wyjaśnienie

VYLUYFYXDˆ+RU  # Implicit input
V              # Save input to Y
 YL            # Push [1 .. Y]
   U           # Save list to X
    YF         # Repeat Y times:
      YX       # Push Y, then X
        Dˆ     # Add X into the global array (could've used X here instead)
          +    # Push X + Y
           R   # Reverse top of stack
            U  # Save updated list to X
               # Implicit loop end
               # Implicit global array print if stack is empty

CJam , Lynn

esmpmpmeimtmemqmememqicelic
esmpmpmeimememqmlmtmemoc
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimeiscic
esmpmpmeimemeimfsic
esmpmpmeisciscimqmtmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeimemomqmqmemeic
esmpmpmeisciscimfsimqic
esmpmpmeimeiscic
esmpmpmeisciscimfsimqic
esmpmpmeimemomqmemqmemtmemoc
esmpmpmeiscic
esmpmpmeimemomeimqmeic
esmpmpmeimemeimqmlmtmeic
esmpmpmeimtmtmqmemtmtmeic
esmpmpmeimemomqmqmtmeic
esmpmpmeimemqmqmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeiscimqmtmtmtmqmemeic
esmpmpmeimeimemtmqmemeic
esmpmpmeimeiscimlmlmtmlmtic
esmpmpmeimemeimqmlmtmeic
~~

Wszystkie kanały są przeznaczone do celów kosmetycznych i można je usunąć bez wpływu na program.

Wypróbuj online!

Wyjaśnienie

Po usunięciu Lynna {|}z listy dozwolonych postaci musiałem spróbować czegoś nowego. Okazuje się, że nadal możemy konstruować dowolne ciągi i oceniać je jako kod.

Najpierw musimy zdobyć pewną wartość na stosie. Jedynymi dostępnymi wbudowanymi funkcjami, które wypychają coś bez uprzedniego wyskakiwania czegoś innego (i bez czytania danych wejściowych) są es, eai et. Jestem pewien, że możesz zacząć od tych wszystkich sposobów, ale poszedłem z tym, esco przesuwa aktualny znacznik czasu. Ponieważ nie chciałem przyjmować żadnych założeń dotyczących jego rzeczywistej wartości, testuję jej pierwotność za pomocą mp(co daje 0i 1) i testuję pierwotność tej wartości ponownie, aby upewnić się, że mam 0na stosie. 1Będzie bardziej przydatny, więc obliczamy exp(0)ze mei przekształcić go w liczbie całkowitej z i. Wszystkie liczby zaczynają się od:

esmpmpmei

Teraz mamy całą masę jednoargumentowych operatorów matematyki do współpracy:

i    int(x) (floor for positive numbers, ceiling for negative)
me   exp(x)
ml   ln(x)
mq   sqrt(x)
mo   round(x)
mt   tan(x)

Możemy również połączyć kilka wbudowanych funkcji, aby uzyskać bardziej rozbudowane funkcje x:

sci     Extract first digit of x and add 48 (convert to string, convert
        to character, convert to integer).
ceui    Convert to character, convert to upper case, convert to integer.
celi    Convert to character, convert to lower case, convert to integer.
mfsi    Get a sorted list of prime factors of x and concatenate them into 
        a new number.
mfseei  Get a sorted list of prime factors, interleave it with 1,2,3,..., and
        concatenate the result into a new number.

Korzystając z nich, możemy uzyskać dowolną liczbę w 0 <= x < 128(i wiele innych) w mniej niż 10 krokach od 1. Jestem pewien, że wystarczyłby znacznie mniejszy podzbiór tych poleceń. Napisałem mały program Mathematica, aby określić wszystkie te fragmenty (przepraszam, nie jest to zbyt czytelne):

codes = SortBy[
  Select[Nest[Select[DeleteDuplicatesBy[SortBy[Join @@ (Through[{
               List,
               If[1 <= # < 50, {Exp@#, #2 <> "me"}, Nothing] &,
               If[# >= 1, {Log@#, #2 <> "ml"}, Nothing] &,
               If[# > 1, {Sqrt@#, #2 <> "mq"}, Nothing] &,
               {If[# > 0, Floor@#, Ceiling@#], #2 <> "i"} &,
               {Floor[# + 1/2], #2 <> "mo"} &,
               {Tan@#, #2 <> "mt"} &,               
               If[NumberQ@# && # >= 0, {First@
                   ToCharacterCode@ToString@#, #2 <> "sci"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToUpperCase@FromCharacterCode@#, #2 <> "ceui"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToLowerCase@FromCharacterCode@#, #2 <> "celi"}, 
                 Nothing] &,
               If[IntegerQ@# && # > 0, ## & @@ {
                   {FromDigits[
                    "" <> (ToString /@ (f = 
                    Join @@ Table @@@ FactorInteger@#))], #2 <> 
                    "mfsi"},
                   {FromDigits[
                    "" <> (ToString /@ 
                    MapIndexed[## & @@ {#2[[1]] - 1, #} &, f])], #2 <>
                     "mfeesi"}
                   }, Nothing] &
               }@##] &) @@@ #, StringLength@*Last], 
       First], #[[1]] < 1000000 &] &, {{1, "esmpmpmei"}}, 9], 
   IntegerQ@# && 0 <= # < 128 &@*First], First]

Dzięki temu możemy po prostu przesunąć dowolną listę kodów znaków, a następnie przekształcić każdy z nich w znak c. Po wypchnięciu całego kodu, który chcemy wykonać, naciskamy 95( ]). Ewaluujemy ten jeden, ~aby owinąć wszystkie pozostałe w ciąg, a następnie ewaluujemy ten ciąg~ .

Rzeczywisty kod uruchamiany na końcu programu to ponownie:

ri__2#,:)/2/[1W]f.%:~<p

Zobacz moje poprzednie rozwiązanie, aby uzyskać wyjaśnienie.

Python 3, TuukkaX

Przepraszamy, użyty regex był zbyt łatwy do trywializacji. No 0, #albo ? Nie ma problemu!

Mogłem źle zinterpretować przykładowe wyjście, ale wciąż jest dość łatwe do poprawiania, ponieważ mam 45 wolnych znaków

n=int(input())
print(str(n)+":")
x=1-1
exec("print([*range(1+x*n,1+n*-~x)][::(1,-1)[x%2]]);x+=1;"*n)
"no-op:a_string_that_doesnt_actually_matter"

R, MickyT

lets_make_a_snake<-function(n)`for`(i,1:n,cat(i*n+1-`if`(i%%2,n:1,1:n),"\n"))

Przypadki testowe:

> lets_make_a_snake(4)
1 2 3 4 
8 7 6 5 
9 10 11 12 
16 15 14 13 
> lets_make_a_snake(7)
1 2 3 4 5 6 7 
14 13 12 11 10 9 8 
15 16 17 18 19 20 21 
28 27 26 25 24 23 22 
29 30 31 32 33 34 35 
42 41 40 39 38 37 36 
43 44 45 46 47 48 49 

I potwierdzenie wyrażenia regularnego: https://regex101.com/r/OB8ZIM/1

Również miałem:

invisible(sapply(1:(n=scan()),function(i)cat(i*n+1-`if`(i%%2,n:1,1:n),"\n")))

co daje ten sam wynik i pasuje do tego samego wyrażenia regularnego .

Röda , fergusq

{|i|;a=1;while[a<=i]do;b=a*i-i+1;c=[];while[b<=a*i]do;c+=b;b++;done;{d=[];x=0;while[x<i]do;d+=c[i-x-1];x++;done[d]}if[a%2<1]else{[c]};a++;done;r="||||||"}

Jest to anonimowa funkcja, która pasuje do tej PCRE regex: ^{(\|[^\/#\s]*){8}$.

Wypróbuj online!

Bash, @Marcos M.

sort -n <(seq 1 $((n * n)) | xargs -n$n | sed -n 'p;n'; seq $((n * n)) 1 | xargs -n$n | sort -n | sed -n 'n;p')

Prettified:

sort -n <(               # feed the stdout of this subshell into stdin for `sort -n`
    seq 1 $((n * n)) |   #   generate 1 2 3 ... n²
        xargs -n$n |     #     add line break every n numbers
        sed -n 'p;n';    #     print only odd lines
    seq $((n * n)) 1 |   #   generate n² ... 3 2 1
        xargs -n$n |     #     add line break every n numbers
        sort -n |        #     reverse all lines (keeping each row decreasing)
        sed -n 'n;p'     #     print only even lines
)

Pierwszą część komendy wygeneruje 1 2 3 4, 9 10 11 12oraz druga część generuje 8 7 6 5, 16 15 14 13. Zewnętrznysort -n odpowiednio je wymieszają, tworząc wzór węża.

Użyłem triku w /superuser//a/101760, aby wydrukować nieparzyste i parzyste linie. Dziękuję Marcos, naprawdę fajna.

JavaScript, Tom

f=(a,i=1,j=0)=>Array(a).fill(0).map(b=>Array(a).fill(0).map(a=>i++)).map(a=>j++%2?a.reverse():a).map(a=>a)

console.log(f(4))

Python 3, TuukkaX

n=int(input());j=0;exec("print([(j-+i%n-n++2*n-0,j+i%n+1)[1&int(i/n)//1^(0x1)//1]*(2*(i%n)*0+2222222//2222222)for i in range(j,j+n)]);j+=n;"*n)

• Sprawdź: https://regex101.com/r/GI1Zvh/1

Nieznaczna analiza wyrażenia regularnego policjanta pokazuje ustalony szablon:

________________________"___________i%n____2*n-____i%n__________i/n)//1_____)//1___2*(i%n)____^^^^^^^^^^^^^^^^for i in range(j,____])______"*n)

gdzie _jest dowolna postać oprócz [ '"#]i ^którakolwiek z [int()2/].

Na "*n)końcu wyraźnie widać eval("..."*n)lub exec("..."*n)trwa, więc musimy tylko upewnić się, że "..."wydrukuje rząd j-ty.

for i in range(j,Jest zbyt blisko końca łańcucha, sugerując listowych bez if. Więc musimy skonstruować i-tej kolumny przy użyciu tych i%n, 2*nrzeczy.

n = int(input())
j=0
exec("""print([
    (
        j - +i%n - n ++ 2*n - 0,    # equivalent to (n + j - i%n) for the decreasing rows
        j + i%n + 1                 # equivalent to (j + i%n + 1 == i + 1) for the increasing rows
    )[1 & int(i/n)//1 ^ (0x1)//1]   # int(i/n)   ->    get row number 0, 1, 2, 3, ...; 
                                    # 1 & int(i/n)//1    ->    0 for increasing rows, 1 for decreasing rows, 
                                    # 1 & int(i/n)//1 ^ (0x1)//1    ->   flip 0 and 1
    * (2*(i%n)*0+2222222//2222222)  # multiply by the constant 1.
    for i in range(j,j+n)
]); j+=n; "*n)

dc , Mitchell Spector

To był mój pierwszy udział w wyzwaniu dla gliniarzy i rabusiów, i miałem dużo zabawy. Wyrażenie wymagające dopasowania było proste, ^[^# !]{59}$co w zasadzie zmieniło moją pracę w golfa, bez użycia tych 3 znaków. Początkowo miałem problemy ze spadkiem poniżej 60 bajtów, ale ostatecznie go złamałem.

?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdlNd*>L]dsLxqqq

Wypróbuj online!

Wyjaśnienie:

Mój kod używa jednej pętli z N ² iteracjami , utrzymując licznik zerowy (1D), i oblicza, jaka liczba musi zostać wydrukowana na podstawie odpowiedniego wiersza macierzy i współrzędnych kolumny (r, c).

Przykład tego, co mam na myśli, jeśli N = 4:

 0  1  2  3            (0,0) (0,1) (0,2) (0,3)             1  2  3  4
 4  5  6  7     ->     (1,0) (1,1) (1,2) (1,3)     ->      8  7  6  5
 8  9 10 11            (2,0) (2,1) (2,2) (2,3)             9 10 11 12
12 13 14 15            (3,0) (3,1) (3,2) (3,3)            16 15 14 13

Wygląda na skomplikowane, ale krok pośredni jest pomocny. Dodatkowo próbowałem użyć 2 pętli od samego początku, ale skończyłem na limicie znaków wyrażenia regularnego. Generowanie liczb przy każdej iteracji (w oparciu o zero):

• jeśli r % 2 = 0(normalny rząd),n = (r * N) + c = counter
• jeśli r % 2 = 1(odwrócony wiersz),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

Lub wszystkie naraz, jako jedna numeracja: n = counter + ((N - (2 * c) - 1) * (r % 2)); n++

?sN0             # read input, save as N, initialize iteration counter
[AP]sP           # macro 'P' that prints a newline (ASCII code 10 = A)
[                # start loop
    ddlN~        # push N, calculate row and column coordinates:
                 #r = int(counter / N), c = counter % N, '~' calculates both
    _2*lN+1-     # c is on top, so this does: N - (2 * c) - 1
    r2%*+        # now r is on top, do: (r % 2) * (previous result) + counter
    1+n32P       # do: n++, print space (ASCII code 32)
    1+           # increment counter
    dlN%0=P      # call macro 'P' every Nth printed number
    dlNd*>L      # if: N * N > counter, repeat loop
]dsLx            # this saves the loop to macro 'L', then executes it
qqq              # my script was shorter, so I added a bunch of quit commands to
                 #fit the regex limit. Use of comments ('#') was prohibited.

PowerShell, ConnorLSW

Pęknięcie

$mySnakeIndex=1;$seq=1..$args[0];$seq|%{$rowNum=$seq|%{($mySnakeIndex++)};if(!($_%2)){[array]::Reverse($rowNum)};$rowNum-join" "}

Zacząłem od mniejszego rozwiązania tego problemu i wstawiłem nazwy zmiennych, aby dopasować wyrażenie regularne. Podejrzewam, że próba znalezienia zastosowania dla jelita grubego była najtrudniejsza do oplotu.

$a=1..$args[0];$i=1;$a|%{$r=$a|%{($i++)};if(!($_%2)){[array]::Reverse($r)};$r-join" "}

Wyjaśnienie

# Initialize a counter that starts at one.
$mySnakeIndex=1
# Save the integer array from 1 to the input value. 
$seq=1..$args[0]
# For each row of the output...
$seq|%{
    # Build the integer array for this row sequentially
    $rowNum=$seq|%{
        # Increase the integer index while sending it down the pipeline
        ($mySnakeIndex++)}
        # Check if this is and odd row. If so reverse the integer array.
        if(!($_%2)){[array]::Reverse($rowNum)}
        # Take this row and join all the numbers with spaces.
        $rowNum-join" "

CJam, Lynn

Coś takiego:

ri
{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~c{a}seu~~|
{s}seu~~c{c}seu~~|
{t}seu~~sc{a}seu~~|
{s}seu~~c{a}seu~~|{w}seu~~z{w}seu~~sc~c
{s}seu~~sc{fb}seu~~||
{s}seu~~sc{i}seu~~|
{s}seu~~sc{fb}seu~~||
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c
{a}seu~~scs
{w}seu~~
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c
{fb}s{b}s{w}seu~~sc~
{s}seu~~sc{ee}seu~~||
{s}seu~~sc{z}seu~~|{w}seu~~{w}seu~~sc~{w}seu~~{w}seu~~sc~
{t}seu~~sc{a}seu~~|
{~}s{}s{w}seu~~sc~
{t}seu~~sc{c}seu~~|

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~
s~
p

Cała biała spacja służy do ... „czytelności” ... i można ją pominąć, aby była zgodna z wyrażeniem regularnym Lynn.

Wypróbuj online!

Wyjaśnienie

Wyrażenie regularne wymaga rozwiązania problemu przy użyciu tylko:

• Małe litery.
• {}, które można wykorzystać do tworzenia bloków.
• |, używane głównie do bitowego OR.
• ~, „eval” i bitowe NIE (także „zrzut tablicy”, ale nie zamierzam jej używać).

Ponieważ mamy ~ , jeśli możemy konstruować dowolne ciągi, możemy uruchomić dowolny kod. Jednak na początku nie jest oczywiste, jak to zrobić.

Pierwszą częścią układanki jest to, że bloki to nieocenione fragmenty kodu, które mogą zamieniać się w ciągi znaków s. Więc {abc}sdaje nam "{abc}". Następnie możemy użyć eudo konwersji tych ciągów na wielkie litery.

{abc}seu  e# gives "{ABC}"

Zaletą tego jest to, że wielkie litery są zmiennymi wstępnie zainicjalizowanymi, dzięki czemu możemy uzyskać wiele stałych wartości, tworząc taki ciąg i sprawdzając go dwukrotnie (raz, aby zmienić ciąg z powrotem w blok, a raz, aby wykonać ten blok). Nie możemy uzyskać wszystkich liter, ponieważ niektóre, na przykład, xnie są poprawnymi poleceniami (więc CJam odmówi parsowania bloku zawierającego je). Nie możemy używać ftak, jak jest, ponieważ po nim musi następować inne polecenie, ale możemy użyć, fba następnie LUB dwóch wartości razem. Podobnie możemy użyć eezamiast e. Dzięki temu możemy uzyskać numery 0, -1, 3, i 10do 19. Jest -1to wygodne, ponieważ jeśli przekształcimy go w ciąg ("-1" ), to w znak ('-), a następnie ewaluować, możemy uzyskać odjęcie lub ustawić różnicę. Jak powiedziałem, nie możemy dostać ), ale możemy wziąć wartość bezwzględną z .X (za1-1z

Możemy również użyć, saby uzyskać ciąg zawierający spację i użyć, caby przekształcić go w znak spacji :

{s}seu~~c

Jest to wygodne, ponieważ stamtąd możemy uzyskać wiele przydatnych poleceń w dolnym zakresie ASCII poprzez ORingowanie przestrzeni za pomocą różnych liczb. Aby uzyskać niektóre znaki powyżej punktu kodu 48, używamy tego znaku '0jako podstawy:

{t}seu~~si

To już wystarcza do skonstruowania dowolnych ciągów, ponieważ możemy uzyskać '+(dodawanie i łączenie ciągów) z następującego fragmentu:

{s}seu~~c{b}seu~~|

I mamy literał 1 dzięki czemu możemy po prostu przesuwać znaki spacji, zwiększać je do potrzebnej wartości, a następnie łączyć je wszystkie razem, ale to trochę nudne i kod stałby się ogromny.

Zamiast tego, jakie generowane [i ]i evalled je tak, że wszystkie znaki wciskam pomiędzy owinięte są w ciąg automatycznie. To te dwie linie:

{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

...

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~

I w końcu będziemy potrzebować fiw ~ciągu, który generujemy. Chociaż są to już prawidłowe znaki, nie mamy literałów łańcuchowych ani literałów znakowych, więc musielibyśmy je również wygenerować, a budowanie większych punktów kodu z przestrzeni jest nieco denerwujące. Zamiast tego skorzystałem z odejmowania zestawu tutaj, ale odejmując dwa bloki (aby się go pozbyć {}):

{fb}s{b}s{w}seu~~sc~
...
{~}s{}s{w}seu~~sc~

To prawie wszystko. Ewaluujemy [. Wypychamy wszystkie znaki, uzyskane przez różne obliczenia z kilku wbudowanych stałych |, -(poprzez eval) i +(przez eval). Ewaluujemy ]. Spłaszczamy całą rzecz w ciąg, ponieważ w pewnym momencie dodałem kilka ciągów lub liczb do listy. Analizujemy nasz dowolny ciąg znaków za pomocą~ .

The ri...pSą częścią rzeczywistego programu końcowego, ale ja ich ekstrakcji, ponieważ nie trzeba kodowanie.

Wreszcie jest to program, który faktycznie uruchamiamy:

ri___*,:)/2/[1-1]f.%:~<p

ri      e# Read input and convert to integer.
__      e# Make two copies.
_*      e# Square the last copy.
,       e# Turn into range [0 1 ... n^2-1].
:)      e# Increment each to get [1 2 ... n^2].
/       e# Split into chunks of length n, creating a square.
2/      e# Split into pairs of lines.
[1-1]   e# Push [1 -1].
f.%     e# Use this to reverse the second line in each pair. If n was odd,
        e# this will pair a -1 with the last line.
:~      e# Flatten the pairs back into the square.
<       e# Truncate to n lines to get rid of that extraneous -1 for odd inputs.
p       e# Pretty-print.

tinylisp , @DLosc

(v(c(h(q(d)))(c(h(q(f)))(q((c(q(n))(q((g(v(h(q(n))))(s(v(h(q(n))))(v(h(q(1)))))())))))))))(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((i(l(v(h(q(x))))(v(h(q(y)))))x(mod(s(v(h(q(x))))(v(h(q(y)))))y))))))))))(v(c(h(q(d)))(c(h(q(range)))(q((c(c(h(q(x)))(c(h(q(y)))(c(h(q(z)))(q(w)))))(q((i(l(times(v(h(q(z))))(v(h(q(x))))(v(h(q(0)))))(times(v(h(q(z))))(v(h(q(y))))(v(h(q(0))))))(range(v(h(q(x))))(s(v(h(q(y))))(v(h(q(z)))))z(c(s(v(h(q(y))))(v(h(q(z)))))w))w)))))))))(v(c(h(q(d)))(c(h(q(times)))(q((c(c(h(q(x)))(c(h(q(y)))(q(acc))))(q((i(l(v(h(q(x))))(v(h(q(0)))))(times(s(v(h(q(0))))(v(h(q(x)))))(s(v(h(q(0))))(v(h(q(y)))))acc)(i(e(v(h(q(x))))(v(h(q(0)))))acc(times(s(v(h(q(x))))(v(h(q(1)))))y(a(v(h(q(y))))(v(h(q(acc))))))))))))))))(v(c(h(q(d)))(c(h(q(g)))(q((c(c(h(q(n)))(c(h(q(w)))(q(r))))(q((i(l(v(h(q(w))))(v(h(q(0)))))r(g(v(h(q(n))))(s(v(h(q(w))))(v(h(q(1)))))(c(i(e(v(h(q(0))))(mod(v(h(q(w))))(v(h(q(2))))))(range(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))(a(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))n)1())(range(a(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))n)(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))(s(v(h(q(0))))(v(h(q(1)))))()))r)))))))))))

Wypróbuj online!

Definiuje funkcję, fktóra zwraca odpowiedź. Wyświetla także nazwy funkcji, które zdefiniowałem na standardowe wyjście, ale zakładam, że to nie ma znaczenia, ponieważ [wolno nam wybrać nasz strumień wyjściowy] przynajmniej dla golfa kodowego. Jeśli to wielka sprawa, myślę, że mogę ją ulepszyć, aby nie drukować. Jak to zrobiłem? Zacząłem od czegoś dość standardowego:

(d f (q ((n)
  (g n (s n 1) ()))))

(d mod (q((x y)
  (i (l x y) x
    (mod (s x y) y)))))

(d range (q((x y z w)
  (i (l (times z x 0) (times z y 0))
    (range x (s y z) z (c (s y z) w))
    w))))

(d times (q ((x y acc)
  (i (l x 0) (times (s 0 x) (s 0 y) acc)
  (i (e x 0) acc
    (times (s x 1) y (a y acc)))))))

(d g (q ((n w r)
  (i (l w 0) r
    (g n (s w 1)
       (c (i (e 0 (mod w 2))
             (range (a 1 (times w n 0)) (a (a 1 (times w n 0)) n) 1 ())
             (range (a (times w n 0) n) (times w n 0) (s 0 1) ()))
          r))))))

Następnie zauważyłem, że można przekształcić definicje funkcji w następujący sposób:

(d mod (q ((x y) (body))))

staje się

(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((body)))))))))

I wywołania funkcji takie jak to:

(a x y)

staje się

(a(v(h(q(x))))y)

Użyłem tego rekurencyjną Vima makro, przechowywaną w rejestrze q, aby wykonać drugi (Mam jkodwzorowane na <Esc>) f s(v(h(q(jkea))))jk@q.

Te dwie transformacje były wystarczające do wyeliminowania wszystkich przestrzeni.

Swift, @James Webster

{n in for j in 0..<n{print((1...n).map{j%2==0 ?$0+j*n:j*n+n+1-$0})}} as(CShort)->()

Weryfikacja: https://regex101.com/r/7ukrM0/1

PHP, @ JörgHülsermann

<?=(function($n,$snake){foreach(array_chunk(range(1,$n*$n),$n)as$i=>$a){if($i%2)$a=array_reverse($a);echo"\n",join('',array_map(function($e){return(sprintf("%3d",$e));},$a));}})($argv[1],'-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')?>

• Sprawdź: https://regex101.com/r/81pUrB/1
• TIO: https://tio.run/#aNvF0

221 bajtów jest za długich (a więc węża), a brak białych znaków można łatwo obejść.

Prettified:

<?=
(
    function($n, $snake) {
        foreach (array_chunk(range(1, $n*$n), $n) as $i => $a) {
            if($i % 2)
                $a = array_reverse($a);
            echo "\n", join('', array_map(function($e) {
                return (sprintf("%3d", $e));
            }, $a));
        }
    }
)($argv[1], '-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')
?>

Galaretka, długość 12, @JathanathanAllan

Ḷ-*m@"s@²$G

Wypróbuj online!

Jak to działa

Ḷ-*m@"s@²$G  Main link. Argument: n

Ḷ            Unlength; yield [0, ..., n-1].
 -*          Yield [(-1)**0, ..., (-1)**(n-1)].
         $   Combine the two links to the left into a chain.
        ²    Yield n².
      s@     Split [1, ..., n²] into chunks of length n.
   m@"       Take the lists to the right modulo the units to the left, 1 being
             normal order and -1 being reversed.

Galaretka , 12 bajtów, pęka przy drugiej odpowiedzi Jonathana Alllana

²sµ;@/€FḤ$¦G

Wypróbuj online!

Wyjaśnienie

To prawie taka sama jak moja inna odpowiedź . Właśnie dokonałem dwóch zmian:

Najpierw zmieniłem U(„odwróć każdy element”) na Ṛ€(„odwróć” „każdy element”). To samo w sobie nie pomaga, ponieważ Ṛjest również zakazane.

Następnie zmieniłem Ṛ(„rewers”) na ;@/( /„fold przez” ;„konkatenację” @„w kolejności odwrotnej do oryginalnej listy”). Pozwala to uniknąć wszystkich zbanowanych postaci, dając prawidłowe rozwiązanie.

Zakładam, że następnym krokiem byłoby wprowadzenie zakazu szybkich manipulacji tablicami , oprócz atomów.

Galaretka, długość 13, @JonathanAllan

1r-*Nm@"s@²$G

Wypróbuj online!

Jak to działa

1r-*Nm@"s@²$G  Main link. Argument: n

1r             Range 1; yield [1, ..., n].
 -*            Yield [(-1)**1, ..., (-1)**n].
   N           Negate each unit.
           $   Combine the two links to the left into a chain.
          ²    Yield n².
        s@     Split [1, ..., n²] into chunks of length n.
     m@"       Take the lists to the right modulo the units to the left, 1 being
               normal order and -1 being reversed.

Galaretka, długość 14, @JathanathanAllan

²sµðạ"J×2$$¦GµL.xị"ḅ1µ$

Wypróbuj online!

Scala, @Soapy

def g(n:Int) = {
    var vec = Vector.fill(0)(Vector.fill(0)(1))
    for (p <- 1 to n) {
        var vec2 = Vector.fill(0)(1)
        for (q <- (p-1)*n+1 to p*n) {
            vec2 = vec2 ++ Vector(q)
        }
        if (p%2==1) vec = vec ++ Vector(vec2)
        else vec = vec ++ Vector(vec2.reverse)

    }
    println(vec)
}

Od jakiegoś czasu nie dotknąłem Scali, fajnie było wrócić do niej. Niestety, w tym rozwiązaniu brakuje wielu fajnych funkcji Scali.

Wypróbuj tutaj

Potwierdzenie Regex

QBasic (QB64), @DLosc

Zauważ, że ponieważ .nie pasuje \n(U + 000A, LF), nowa linia tutaj to \r(U + 000D, CR).

INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM
NEXT:PRINT:NEXT

Zweryfikować:

>>> re.match('^([A-Z]+.)+$', 'INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM\rNEXT:PRINT:NEXT')
<_sre.SRE_Match object; span=(0, 141), match='INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR >

Główna trudność polega na tym, jak wstawić słowo po ; . Na szczęście QB64 traktuje CR jako nową linię, podczas gdy regex Pythona nie, więc moglibyśmy pominąćREM\r tu . Z pięciu dozwolonych smaków regex,

• Perl akceptuje "\r" =~ /./
• JavaScript Rejects !/./.test('\r') ( \n, \r, \u2028, \u2029są wszystkie separatory liniowe )
• Python akceptuje re.match('.', '\r')( tylko \nuważa się za podział wiersza) )
• Golang akceptuje regexp.Match(".", "\r")
• Ruby akceptuje /./ =~ "\r"

Więc ten crack jest w porządku, o ile nie wspominamy o JavaScript ... 🤐

Python 3, kennytm

def S(N,A=1,K=1,E=list,r=range):print(E(r(A,A+N)[::K]))or(A>N*N-N)or(((S(N,A+N,-K))))

Weryfikacja wyrażenia regularnego

> <>, torcado

!v &0_!
_<>~ao1+>_v_
?______;__>:&:&=?;::2%:}+&:&*{3+0$.
?!v1+:n' 'o:&:&%_
?!v:n' 'o1-:&:&%_

C, Yimin Rong

main(int c,char**p){int n=atoi(*++p),i=n-n,t,o=c;for(--o;i<n;++i)for(t=o;t<=n;++t)printf("%-*d%c",n-o,i%c?i*n+n+o-t:i*n+t,t%n?' ':'\n');}

Program nie może zawierać liczb, ale możemy uzyskać liczby poprzez:

1. c, powszechnie znany jako „argc”, czyli zawsze 2.
2. +i -są dostępne, więc możemy utworzyć 0 za pomocą n-ni utworzyć 1 za pomocą o=c;--o.

Ruby, @Value Ink

->n{(1..n).map{|r|x=(r*n-n+1..r*n).to_a;if(r.modulo(2)==1)then(x)else(x.reverse)end}}#1-2-3-4-5-6--

[(-=Z-~]* oznacza „Mogę pisać wszystko, co lubię :)”

Tinylisp @DLosc

Bardzo proste rozwiązanie i całkowicie niezoptymalizowane :)

(d p(q((m n)(s m(s(s 1 1)n)))))(d j(q((f g)(i(l f g)(c f(j(p f 1) g))()))))(d r(q((f g)(i(l f g)(c(s g 1)(r f(s g 1)))()))))(d k(q((m o f g n)(i(l n g)()(c(m f(p f n))(k o m(p f n)(p g 1) n))))))(d f(q((n)(k j r 1 1 n))))

Jak zadzwonić (disp (f 4)).

• (p m n) oblicza m + n za pomocą odejmowania s (m + n == m - ((1 - 1) - n))
• (j f g) generuje (f f+1 f+2 ... g-1)
• (r f g) generuje (g-1 g-2 g-3 ... f)
• (k m o f g n)wygeneruj jeden wiersz macierzy węża, a następnie przeprowadź go ponownie do następnego wiersza, dopóki nie zostanie utworzonych n wierszy. Argumenty m, osą podstawione j/ rdo wytworzenia zwiększenie lub zmniejszenie wierszy. Argumenty f, gdziałają indeksy wiedzieć, które rząd jesteśmy na.
• (f n)połączenia, (k j r 1 1 n)aby rozpocząć generowanie.

PHP, @Ionut Botizan

W tej chwili nie mam lepszego pomysłu na złamanie oryginalnego rozwiązania.

Obsługuje n <= 15

Po raz pierwszy korzystam z getopt. Może nie jest to najlepszy pomysł na użycie opcji jako danych wejściowych.

zacznij od wiersza poleceń w ten sposób

php hack.php -a=4

Original Regex

Poziom 1:

^<[^'"\d{vV;<$]+$

Bardzo ładna kombinacja liter. Zapraszam do głosowania w wątku gliniarzy.

Blokuje mi takie funkcje jak - strrev - array_reverse - get_defined_vars

https://regex101.com/r/5rGTnw/2

Poziom 2:

^<[^'"\d{v;<$_~|&A-Z]+$

https://regex101.com/r/XtVl9G/1

Rozwiązanie

 <?php
    error_reporting(~E_NOTICE)&
    define(A,a.chr(E_COMPILE_ERROR-E_NOTICE+E_WARNING))
    &define(B,getopt(A,[])[a])&print_r(array_chunk(
    array_slice(
    array_merge(
    range(E_ERROR,B)
    ,range(E_WARNING*B,E_ERROR+B)
    ,range(E_WARNING*B+E_ERROR,(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B,+E_ERROR+(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B+E_ERROR,(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B,+E_ERROR+(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B+E_ERROR,(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B,+E_ERROR+(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B+E_ERROR,(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B,E_ERROR+(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B+E_ERROR,(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B,E_ERROR+(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B+E_ERROR,(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B,E_ERROR+(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B+E_ERROR,(E_CORE_ERROR-E_ERROR)*B)
    )
    ,B-B,B*B
    ),B)
    )
    ?>

Poziom 2:

<?php
define(aa,a.chr(ord(strtoupper(a))-ord(h)+ord(a)))and
define(bb,getopt(aa,[])[a])and
define(us,chr(ord(a)-true-true))and
(prin.t.(us).r)(
(arra.y.(us).chunk)(
(arra.y.(us).slice)(
(arra.y.(us).merge)(
range((ord(b)-ord(a)),bb)
,range((ord(c)-ord(a))*bb,(ord(b)-ord(a))+bb)
,range((ord(c)-ord(a))*bb+(ord(b)-ord(a)),((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(q)-ord(a))-(ord(b)-ord(a)))*bb)
)
,bb-bb,bb*bb
),bb)
)
?>