Bu soyguncunun ipliği. Polisin parçacığı burada .

Bir yılan matrisi, bu modeli takip eden kare bir matristir:

3-ile-3:

1  2  3
6  5  4
7  8  9

ve 4 x 4:

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

Göreviniz, bir giriş alan nve böyle bir matris oluşturan, bir polis postasıyla aynı dilde ve polisin normal ifadesiyle eşleşen bir kod yazmaktır. Kodunuzun çıktı biçimi, polis kodunun çıktı biçimiyle eşleşmelidir.

Lütfen polisin görevinin altına kırdığınızı belirtmek için bir yorum bırakın.

Kazanan kriter:

Kazanan, en çok başvuruda bulunan kullanıcı olacaktır. Beraberlik durumunda, birden fazla kazanan olacak.

Jelly , 9 bayt, çatlaklar @Dennis 'cevabı

²sµUFḤ$¦G

Çevrimiçi deneyin!

Şimdi doğru olmalı; Ne yaptığımı yeniden düşünmek zorunda kaldım.

açıklama

Bu sorunun en zor kısmı, ¦(belirli endekslerde bir işlem uygular) içindeki çift endekslerin bir listesini almaktır. Tüm programın girdisini ikinci işlenen için varsayılan olarak kullanan çoğu işlemden farklı olarak ¦, en son görülen değeri varsayılan olarak kullanır (çünkü kavramsal olarak çoğu şey gibi sol ve sağ işlenen yerine iki sol işlenen vardır iki değer alır).

Bununla birlikte, o anda geçerli değerde olan girdinin 1 ila yarısı arasındaki tüm tamsayılar da dahil olmak üzere bir sayı listemiz olduğunu gözlemleyebiliriz. Bu nedenle, düzleştirme ve ikiye katlama, bize tüm çift endeksleri de dahil olmak üzere çift sayıların bir listesini verir (ayrıca diğer bazı çift sayılar ama bunları umursamıyoruz). µAyrıştırma belirsizliğinden kaçınmak için 9 tane harcamak bile mümkündür .

²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

Bu benim ilk defa 05AB1E kullanıyordu. Biraz yardım aldım. Bu eğlenceliydi. :)

UXFXLNX*+N2BSR1k_iR}ˆ

Çevrimiçi deneyin

Açıklama:

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

Aslında bu benzer programı kendi başıma buldum, ancak çıktı biçimi farklı:

UXFXLNX*+N2BSR1k_iR}=

Çevrimiçi deneyin

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

Önceki iki denemem için düzenleme geçmişine bakın.

Python 2, Dennis

Bu eğlenceli bir jeton golf problemidir.

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

Normal ifade doğrulaması

Ohm, Nick Clifford

İlk denemem Ohm.
Tekrar kullanmak için sabırsızlandığım gerçekten güzel bir dil :)

²@┼σ▓_^è?R

açıklama

²             # 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

Bir dizi ve int ekleme olarak çalışmadı ilk denemem mümkün değil:

@┼MDR┼+;W

Normal ifadeyle eşleşmeyen ikinci denemem:

²@┼σ▓_^MR

05AB1E, Emigna (2. gönderim)

05AB1E ile ilk kez çalışıyor.

VYLUYFYXDˆ+RU

Çevrimiçi deneyin! | Normal ifade doğrulaması

açıklama

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

Tüm hat beslemeleri kozmetik amaçlıdır ve programı etkilemeden çıkarılabilir.

Çevrimiçi deneyin!

açıklama

Lynn {|}izin verilen karakterler listesinden çıkarıldıktan sonra yeni bir şey denemek zorunda kaldım. Hala rastgele dizeler yapıp bunları kod olarak değerlendirebileceğimiz ortaya çıkıyor.

İlk olarak, yığına biraz değer katmamız gerekiyor. İlk başka bir şey haşhaş olmadan (ve girdi okumadan) bir şey itmek sadece yerleşik ins vardır es, eave et. Bunların hepsinden şu ya da bu şekilde başlayabileceğinize eminim, ama esşu anki zaman damgasını iten gittim . Ben gerçek değeri hakkında herhangi bir varsayımda istemiyordu beri, onun ile asallık sınamak mp(veren 0ve 1) ve değerin asallık yine bir var olmak için o testi 0yığın. A 1daha yararlı olacaktır, bu yüzden onu hesaplar ve exp(0)ile mebir tamsayıya dönüştürürüz i. Böylece tüm sayılarla başlar:

esmpmpmei

Şimdi birlikte çalışmamız gereken bir sürü tekil matematik operatörümüz var:

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)

Ayrıca, aşağıdakilerin daha ayrıntılı işlevleri için birkaç yerleşik öğeyi birleştirebiliriz 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.

Bunları kullanarak, 0 <= x < 12810 adımdan daha az bir sürede herhangi bir sayı (ve diğerleri) elde edebiliriz 1. Eminim bu komutların çok daha küçük bir alt kümesi de yeterli olacaktır. Tüm bu parçacıkları belirlemek için küçük bir Mathematica programı yazdım (çok okunabilir değil, üzgünüm):

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]

Bununla birlikte, her birini cdaha sonra bir karaktere dönüştürerek rastgele bir karakter kodları listesini itebiliriz . Yürütmek istediğimiz tüm kodu ittikten sonra, 95( ]) düğmesine basarız . Birini ~diğerleriyle bir dizeye sarmak için değerlendiririz ve sonra bu dizeyi~ .

Programın sonunda çalıştırılan gerçek kod tekrar:

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

Bir açıklama için önceki çözümüme bakın .

Python 3, TuukkaX

Üzgünüz, kullandığınız normal ifadeyi önemsizleştirmek çok kolaydı. Hayır 0, #ya da ? Sorun değil!

Örnek çıktıyı yanlış yorumlamış olabilirim ama 45 yedek karakterim kaldığından ince ayar yapmak hala oldukça kolay

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

Test örnekleri:

> 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 

Ve normal ifade onayı: https://regex101.com/r/OB8ZIM/1

Da sahiptim:

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

aynı çıktıyı verir ve aynı normal ifadeyle eşleşir .

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="||||||"}

Bu, bu PCRE normal ifadeyle eşleşir anonim fonksiyonudur: ^{(\|[^\/#\s]*){8}$.

Çevrimiçi deneyin!

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
)

Alt komutuyla ilk bölümü oluşturur 1 2 3 4, 9 10 11 12ve ikinci parça oluşturur 8 7 6 5,16 15 14 13 . Dış sort -nkısım, yılan desenini oluşturmak için bunları düzgün bir şekilde karıştırır.

Tek ve çift çizgileri basmak için hileyi /superuser//a/101760 adresinde kullandım. Teşekkürler Marcos, gerçekten eğlenceli bir tane.

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)

• Doğrulayın: https://regex101.com/r/GI1Zvh/1

Polisin normal ifadesinin biraz analiz edilmesi sabit bir şablon gösterir:

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

_dışında herhangi bir karakter nerede [ '"#]ve^ herhangi bir[int()2/] .

"*n)Sonunda açıkça gösterir eval("..."*n)veya exec("..."*n)sadece emin olmak gerekir, böylece oluyor "..."baskılar j-inci satır.

Bu for i in range(j,, dizenin sonuna çok yakın, herhangi bir liste olmadan anlaşılmasını ima ediyor if. Bu yüzden i-th sütununu i%n, 2*nbunları kullanarak yapmamız gerekiyor .

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

Bu benim bir polis ve soyguncular yarışmasına ilk girişimdi ve çok eğlendim. Eşleştirilmesi gereken regex basitti, ^[^# !]{59}$bu temelde bu 3 karakteri kullanmadan işimi bir golf oyununa dönüştürdü. Başlangıçta 60 baytın altına düşmekte zorlanıyordum, ama sonunda çatladım.

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

Çevrimiçi deneyin!

Açıklama:

Kodum N ² ile bir döngü kullanıyorKodum, yinelemeli , sıfır tabanlı bir sayaç (1D) tutar ve karşılık gelen matris satırı ve sütun (r, c) koordinatlarına göre hangi sayının yazdırılması gerektiğini hesaplar.

N = 4 ise ne demek istediğimin örneği:

 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

Karmaşık görünüyor, ancak ara adım faydalıdır. Ayrıca, başlangıçtan itibaren 2 döngü kullanmayı denedim, ama normal ifade karakter sınırının üstünde kaldım. Her yinelemede sayı üretimi (sıfır temelli):

• eğer r % 2 = 0(normal sıra),n = (r * N) + c = counter
• if r % 2 = 1(ters satır),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

Veya bir kerede, tek bir numaralandırma olarak: 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.

Güç kalkanı, ConnorLSW

çatlak

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

Soruna daha küçük bir çözümle başladım ve regex'in eşleşmesi için değişken isimlerimi doldurdum. Sanırım kolon için bir kullanım bulmaya çalışmak kafamı sarmak için en zor kısımdı.

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

açıklama

# 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

Bunun gibi bir şey:

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

Tüm beyaz alanlar ... "okunabilirlik" ... içindir ve Lynn'in normal ifadesine uymayabilir.

Çevrimiçi deneyin!

açıklama

Normal ifade, sorunu yalnızca aşağıdakileri kullanarak çözmemizi gerektirir:

• Küçük harfler.
• {}, blok oluşturmak için kullanılabilir.
• |, çoğunlukla bitsel OR için kullanılır.
• ~, "eval" ve bitwise NOT (ayrıca "dump array", ama ben kullanmayacağım).

Sahip olduğumuzdan beri, ~ olduğumuzdan, rastgele dizeler oluşturabilirsek, rastgele kod çalıştırabiliriz. Ancak, ilk başta bunun nasıl yapılacağı açık değildir.

Bulmacanın ilk parçası, blokların dizgilere dönüşebilen değerlendirilmemiş kod parçaları olmasıdır s. Yani {abc}sbize verdiği "{abc}". Sonra, eubu dizeleri büyük harfe dönüştürmek için kullanabiliriz .

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

Bunun yararı, büyük harflerin önceden başlatılmış değişkenler olmasıdır, bu nedenle böyle bir dize oluşturarak ve iki kez değerlendirerek çok sayıda sabit değer elde edebiliriz (bir kez dizeyi bir blok haline getirmek için ve bir kez o bloğu yürütün). Tüm harfleri alamıyoruz, çünkü bazıları xgeçerli komutlar değildir (böylece CJam bunları içeren bir bloğu ayrıştırmayı reddeder). Kullanamayızf , çünkü bunu başka bir komut izlemelidir, ancak fbiki değeri birlikte VEYA kullanabiliriz . Aynı şekilde eeyerine de kullanabiliriz e. Bunun üzerine, biz numaralarını alabilirsiniz 0, -1, 3ve 10hiç19 . -1Biz bir dizeye (çevirmek çünkü eğer, uygun "-1"(daha sonra bir karakter haline)'-) ve sonra değerlendirirsek, çıkarma veya fark belirleyebiliriz. Dediğim gibi, biz alamayan X(için 1), ama biz mutlak değerini alabilir -1ile z.

Ayrıca kullanabiliriz s bir boşluk içeren bir dize ve kullanımını almak için cbir boşluk dönüfltürmeye karakteri :

{s}seu~~c

Bu uygundur, çünkü oradan alanı çeşitli sayılarla ORing yaparak alt ASCII aralığında birçok yararlı komut alabiliriz. Kod noktasının üstündeki bazı karakterleri almak 48için, karakteri '0temel olarak kullanırız:

{t}seu~~si

Bu zaten rasgele dizeler oluşturmak için yeterlidir, çünkü '+aşağıdaki snippet'ten alabiliriz (toplama ve dize birleştirme):

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

Ve tam anlamıyla 1 sadece bu yüzden sadece boşluk karakterlerini itebilir, onları ihtiyacımız olan değere yükseltebilir ve sonra hepsini bir araya getirebiliriz, ancak bu biraz sıkıcıdır ve kod büyük olur.

Bunun yerine, oluşturulan ettik [ve] onları , böylece aradığım tüm karakterler otomatik olarak bir dizeye sarılır. Bu iki çizgi:

{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~

Ve son olarak, ihtiyacımız olacak fve ~ürettiğimiz dizgide. Bunlar zaten geçerli karakterler olsa da, dizgi değişmezleri veya karakter değişmezleri yok, bu yüzden bunları da üretmek zorundayız ve uzaydan daha büyük kod noktaları oluşturmak biraz sinir bozucu. Bunun yerine, burada set çıkarma işleminden yararlandım, ancak (kurtulmak için {}) iki blok çıkarıyorum :

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

Bunun hemen hemen hepsi var. Değerlendiriyoruz [. Sahip olduğumuz birkaç yerleşik sabitten çeşitli hesaplamalarla elde edilen tüm karakterleri itiyoruz |,- (eval yoluyla) ve +(eval yoluyla). Değerlendiriyoruz ]. Her şeyi bir dizeye yassıyoruz, çünkü bir noktada listeye bazı dizeler veya sayılar ekledim. Keyfi dizemizi~ .

ri...pGerçek nihai programın parçası olan, ancak kodlamayı gerekmez çünkü onları çıkarılan ettik.

Son olarak, aslında çalıştırdığımız program bu:

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

Çevrimiçi deneyin!

Bu f, yanıtı döndüren bir işlevi tanımlar . Ayrıca stdout için tanımladığım işlevlerin adlarını da yazdırıyor, ancak bunun önemli olmadığını düşünüyorum, çünkü en azından kod golf için [çıkış akışımızı seçmemize izin veriliyor]. Eğer büyük bir sorunsa, sanırım bunları basmamak için ayarlayabilirim. Bunu nasıl yaptım? Oldukça standart bir şeyle başladım:

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

Sonra, bunun gibi fonksiyon tanımlarını dönüştürebildiğini gözlemledim:

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

olur

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

Ve işlev şöyle çağırır:

(a x y)

olur

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

qİkincisini yapmak için kayıtta saklanan bu özyinelemeli Vim makrosunu kullandım (jk eşledim <Esc>):f s(v(h(q(jkea))))jk@q .

Bu iki dönüşüm tüm alanları ortadan kaldırmak için yeterliydi.

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

Doğrulama: 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~')?>

• Doğrulayın: https://regex101.com/r/81pUrB/1
• TIO: https://tio.run/#aNvF0

221 bayt çok uzun (bu yüzden yılan) ve boşluk boşluğu kolayca çözülebilir.

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~')
?>

Jelly, uzunluk 12, @JonathanAllan

Ḷ-*m@"s@²$G

Çevrimiçi deneyin!

Nasıl çalışır

Ḷ-*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.

Jöle , 12 bayt, çatlaklar @ JonathanAllan'ın ikinci cevabı

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

Çevrimiçi deneyin!

açıklama

Bu neredeyse diğer cevabımla aynı . Sadece iki değişiklik yaptım:

İlk olarak U("her elemanı ters çevir") Ṛ€(her elemanı "ters çevir") olarak değiştirdim. Bu kendi başına yardımcı olmuyor, çünküṚ aynı zamanda yasaklanmıştır.

Sonra, Ṛ("ters") ;@/( /" orijinal listenin tersi " ;"birleştirme" @"yerine") olarak değiştirdim. Bu, tüm yasaklı karakterlerden kaçınır ve geçerli bir çözüm sunar.

Bir sonraki adımın atomlara ek olarak dizi manipülasyonu hızlılarını yasaklamaya başlamak olacağını varsayalım .

Jelly, uzunluk 13, @JonathanAllan

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

Çevrimiçi deneyin!

Nasıl çalışır

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.

Jelly, uzunluk 14, @JonathanAllan

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

Çevrimiçi deneyin!

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

Bir süredir Scala'ya dokunmadım, tekrar ziyaret etmek eğlenceliydi. Ne yazık ki, bu çözüm Scala'nın birçok harika özelliğini kaçırıyor.

Burada deneyin

Normal İfade Onayı

QBasic (QB64), @DLosc

Not beri .eşleşmeyen \n(U 000A, LF), burada satır a, \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

Doğrulayın:

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

Ana zorluk, sonra nasıl bir kelime eklemek ;. Neyse ki, QB64 CR'yi yeni bir hat olarak ele alırken Python'un normal ifadesi bunu yapmaz, bu yüzden REM\rburada kayarız . İzin verilen beş normal regex aromasından,

• Perl kabul ediyor "\r" =~ /./
• JavaScript reddeder !/./.test('\r') ( \n, \r, \u2028, \u2029tüm satır ayırıcılar )
• Python kabul eder re.match('.', '\r')( sadece \nsatır sonu olarak kabul edilir )
• Golang kabul eder regexp.Match(".", "\r")
• Ruby kabul eder /./ =~ "\r"

Bu çatlak JavaScript'ten bahsetmediğimiz sürece iyi ... fine

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

Normal ifade doğrulaması

><>, 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');}

The program cannot contain numbers, but we can get numbers via:

1. c, commonly known as "argc", which is always 2.
2. + and - are available, so we can create 0 with n-n, and create 1 with 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-~]* means "I can write anything I like :)"

tinylisp, @DLosc

A very straightforward solution, and totally unoptimized :)

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

Call as (disp (f 4)).

• (p m n) computes m + n using subtraction s (m + n == m - ((1 - 1) - n))
• (j f g) generates (f f+1 f+2 ... g-1)
• (r f g) generates (g-1 g-2 g-3 ... f)
• (k m o f g n) generate one row of the snake matrix, and then recurve itself for the next row, until n rows are created. The arguments m, o are substituted by j/r to generate increasing or decreasing rows. The arguments f, g are running indices to know which row we are on.
• (f n) calls (k j r 1 1 n) to start the generation.

PHP, @Ionut Botizan

In the moment I have no better idea to crack the original solution.

Supports n<=15

It is the first time that I use getopt. Maybe not the best idea to use options as input.

start from the command line like this

php hack.php -a=4

Original Regex

Level 1:

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

Very nice combination of letters. Feel free to vote up the cops thread.

It blocks me functions like - strrev - array_reverse - get_defined_vars

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

Level 2:

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

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

Solution

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

Level 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)
)
?>