Bu polisin ipliği. Soyguncunun parçacığı burada .

Bir girdi alan nve bir "n-by" snake matrix "yaratan bir kod yazın .

Bir yılan matrisi, bu kalıbı izleyen bir matristir:

3-ile-3:

1  2  3
6  5  4
7  8  9

ve 4'e 4:

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

Kesin çıktı formatı isteğe bağlıdır. Örneğin çıktı [[1 2 3],[6 5 4],[7 8 9]]veya benzer bir şey olabilir .

Dil adını ve kodunuzla tam olarak eşleşen bir regex sağlamalısınız. Regex'inizin ne kadar detaylı olacağını seçebilirsiniz. Aşırı, olası her dizgiye uyan bir regex yazabilirsiniz, bu durumda kodunuzu kırmanız çok kolay olacaktır. Ayrıca çıktısını da sağlamalısınız n=4, böylece soyguncular seçtiğiniz formatı tam olarak bilirler.

Regex101.com adresinde mevcut olan regex lezzetlerinden birini veya Ruby lezzetini kullanabilirsiniz.

• PCRE (PHP)
• JavaScript
• piton
• Golang
• Yakut

Hangisini kullandığınızı belirtmelisiniz.

Notlar:

• Oldukça büyük olan her şeyi desteklemelisiniz n. Veri türü veya bellekten taşmayacağını varsayabilirsiniz. Varsayılan veri türü 8 bit işaretli tam sayılar ise, o zaman n<=11imzasız 8 bit tam sayılarsa varsayalım n<=15.
• Soyguncular, ön / arka boşluklar ve yeni çizgiler hariç, gönderinin çıktı biçimiyle eşleşmelidir, çünkü SE biçimlendirmesi tarafından kaldırılmış olabilir.

Kazanma kriteri:

Kazanan, karakter sayıları ile ölçülen en kısa regex ile açılmamış teslim olacak.

Gönderiniz 7 gün boyunca çatlak kaldıysa, istenen çözümü gönderebilir ve gönderiminizi güvenli olarak işaretleyebilirsiniz.

05AB1E , mbomb007 tarafından Çatlak

Umarım çatlamak ve çok açık değil eğlenceli.

Regex (PCRE):

^\w*[+\-*\/%]*\w*.{0,2}$

Çıktı n = 4:

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

Orijinal çözüm

UXFXLNX*+NFR}ˆ

Python 2 , uzunluk 62, kırık

Regex (PCRE)

^while ((?=\S)[1di\W]|an|eval|nput|nt|or|pr){55}s(?1){45}n...$

Örnek çıktı

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

Jöle , uzunluk 6, kırık

Regex (PCRE)

^.{9}$

Örnek çıktı

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

R, uzunluk 14 Plannapus tarafından çatlak

Umarım bu regex'i doğru anlamışımdır. Ne Söylemeye çalıştığım hariç 77 karakterdir <space>, #, ;ve [. Burada test ettim

regex

^[^ #;\[]{77}$

Örnek çıktı n = 4

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

05AB1E , Value Ink ile Kırık

Bir çentik yukarı atalım :)
Umarım güzel bir bulmaca.

Regex (PCRE)

^\w*..\w*$

Çıktı n = 4

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

> <> , uzunluk 49, Aaron tarafından Cracked

Regex (Javascript)

^.{7}\n.{12}\n\?.{6};[^v^]{27}(\n.{13}:&.{2}){2}$

Örnek çıktı (n = 4)

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

Biçimlendirme biraz garip, ancak sayı uzunluğunu kontrol etmek çok daha uzun sürebilirdi. Belki regex üzerinde biraz denize düşmüş olabilir, emin değilim!

Düzenleme: Ayrıca bahsetmeyi unuttum, her zamanki balık girdisini değil, giriş için ilk yığını (-v bayrağı) kullanıyorum. Üzgünüm!

Orijinal Kod:

<v1*2&:
 >:{:}=?v:1+
?^{r0}v;>&:&[r]{&:&2*+}::&:::&*@+@(
+:}=?v>n" "o&:&{1
0~{oa<^v?)*&::&:}

Aaron çok daha basit! Orijinal kodumun karmaşıklığı, n[r]o segmenti (satır) çevirmek için her n.

Oh , kırık

Ayrıca ilk Polislerim ve Soyguncular mücadele ediyor, bu yüzden (bu oldukça bilinmeyen bir dil olduğu için) bu kalıpla ilgili sorun olup olmadığını söyle.

Regex (PCRE)

^\S{6}\W{0,3}\w$

Çıktı (n = 4)

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

PHP, 221 Bayt ( Kırık )

Umarım yeterince zor.

Regex (PCRE): 16 bayt

^[^\s/\#6]{221}$

Boş alan yok, yorum yok, base64_decode kullanımı yok. İyi eğlenceler.

Çıktı

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

Orijinal Kod

$w=$argv[1];$s="";$r=range(1,$w**2);for($i=0;$i<$w;$i++)if($i%2)array_splice($r,$i*$w,$w,array_reverse(array_slice($r,$i*$w,$w)));foreach(($r)as$v)$s.=str_pad($v,$l=strlen(max($r))+1,"\x20",0);echo(chunk_split($s,$l*$w));

C # net46 (Kırık)

( http://ideone.com/ works)

Regex PCRE lezzet uzunluğu 58 regex101'de test edilmiştir.

^sta((?![\d%bh\/]|==|if|(\[.*){4}|(i.*){6}).){142}urn....$

Sadece yöntem düzenlidir. Yöntem, n = 4 girişi için 2d int [,] dizisini (int [4,4]) döndürür. Basılı böyle görünüyorsa:

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

Bu benim böyle bir şeye ilk girişim, yanlış bir şey yaparsam bana haber ver. Regex uzunluğunda kesin kazanmaya çalışmıyorum, sadece çatlamayı önlemede ne kadar başarılı olduğumu görmek istiyorum :)

Orijinal kod:

static int[,]g(int n){int l,j,k=n-n,c,s;var _=new int[n,n];var d=n!=n;c=k;c++;s=k;for(l=k;l<n;l++){for(j=k;j<n;j++){_[l,d?n-j-c:j]=++s;}d=!d;}return _;}

QBasic, regex uzunluğu 10 ( çatlak )

regex

Herhangi bir regex tadıyla çalışmalıyız, ama buna Python tadı diyeceğiz.

([A-Z]+.)+

NOT: Çözümüm biçimlendirilmemiş QBasic kullanıyor; biçimlendirmeden sonra, eklenen boşluklardan dolayı kod regex ile eşleşmiyor. (Ama olabilir bu bir fark yaratır tek değişiklik olduğunu anlatmaya. ([A-Z]+ ?. ?)+Hala biçimlendirilmiş sürümü üzerinde çalışıyor.)

Test amacıyla, QB64'ü kod biçimlendirme kapalıyken kullandım (Seçenekler> Kod düzeni altında). Bir şey indirmek istemiyorsanız, QBasic'i çevrimiçi olarak archive.org sitesinde de çalıştırabilirsiniz (ancak biçimlendirmeyi kapatamazsınız).

Örnek çıktı

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

Python 3, 55 bayt (Kırık)

PCRE / Python / Golang lezzet.

def [triangles=(1,SNAKE)]{27}:print[]SNAKE(--:>or[]{48}

( Tam eşleşmenin gerekli olduğunu hatırlatmak isteriz . Varsayım ^ve $test ederken.)

Örnek çıktı:

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

Orijinal çözüm:

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

4 byte kesilmiş olmalı: p

dc , Regex uzunluğu 12   Seshoumara çatladı!

^[^# !]{59}$

Bu düzenli ifade, regex'in lezzetinin önemli olmadığını düşündüğüm kadar basit - yönetim kurulu boyunca çalışması gerekiyor. (Düzenli ifadedeki # işaretinden sonraki boşluğu not edin.)

Dört tadı da regex101.com'da (PCRE / PHP, Javascript, Python ve Golang) ve rubular.com'daki Ruby versiyonunu test ettim. Dc programı, beş regex sürümünün tümünde regex ile eşleşir.

DC programı girişini stdin'e alır ve çıkışını stdout'a koyar.

Giriş 4 için örnek çıktı (her satırın sonunda bir boşluk var):

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

Orijinal kod (kırıldıktan sonra eklendi)

Bu @seshoumara tarafından kırıldı . İşte benim amaç kodum:

?sd[AP]s+0[dddld/2%rld%2*1+ldr-*+1+n2CP1+dld%0=+dvld>l]dslx

Açıklama:

?sd      Input number and store it in register d.
[AP]s+   Macro that prints a newline. The macro is stored in register '+'.
0        Push 0 on the stack, initializing a loop.  (The top of the stack is the index variable.  It will go up to d^2-1.)
[        Start a macro definition.  (The macro will be stored in register l.)
ddd      Push 3 copies of the loop index variable on the stack, so they'll be available later. I'll call this number i.
ld/      Divide the last copy of i by d (integer division); this computes the row of the square that we're in (starting with row 0).
2%       Replace the row number with 0 if the row number is even, with 1 if the row number is odd.
r        Swap the top two items on the stack, so the top item is now the next to last copy of i, and the second item on the stack is the row number mod 2.
ld%      Compute i mod d; this goes from 0 to d-1. It is the column in the square that the next number will be placed in.  (The leftmost column is column 0.)
2*1+     Top of the stack is replaced with 2*(column number)+1.
ldr      Inserts d as the second item on the stack.
-        Computes d-2*(column number)-1.
*        The second item on the stack is the row number mod 2, so multiplying yields 0 if the row number is even, and d-2*(column number)-1 if the row number is odd.
+        Add to the remaining copy of i. The sum is i itself in even-numbered rows, and it's i+d-2*(column number)-1 in odd-numbered rows.

Şimdi yığının üstündeki toplam, yazdırmak istediğimiz bir sonraki sayıdır:

• Satır sayısı eşitse bunun doğru olduğunu görmek kolaydır, o zamandan beri toplam sadece i.

• Tek numaralı satırlar için, i = d * (i / d) + (i% d) = d * (satır numarası) + sütun numarasına dikkat edin. İ + d-2 * (sütun numarası) -1 toplamının d * (satır numarası) + sütun numarası + d - 2 * (sütun numarası) - 1 = d * (satır numarası + 1) - sütun numarası olduğunu belirtir. - 1, tek sayılı satırlarda geriye doğru saymamızı sağlamak için belirtilen sıraya ve sütuna koymak istediğimiz sayıdır.

Şimdi açıklamaya geri dönelim:

n        Print the desired number for the current row and column.
2CP      Print a space.  (2C, which is computed by dc as 20 + 12, is 32, the ASCII code for a space.)
1+       The original copy of i is at the top of the stack; add 1 to it.
dld%0=+  If (the incremented value of) i is a multiple of d, call the macro at register '+', which prints a newline.
dvld>l   If d > sqrt(i) (in other words, if i < d^2), then go back to the top of the loop by calling macro l again.
]dslx    End the macro definition, store the macro in register l, and execute it.

Bash, regex uzunluğu 38, kırık ( @kennytm )

^sort -n <[1adegnopqrstx$\-*()|'; ]+$

Giriş:

n=4; <command>

Çıktı:

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

PHP

Umarım bu eğlenceli olur! : D

Çıktı (n = 4)

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

Seviye 1: PCRE (uzunluk = 17) ( Jörg Hülsermann tarafından çatladı )

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

• Tek veya çift tırnak yok, yani ... karakter yok!
• Rakam yok!
• Hayır {yani ... hayır anonim fonksiyonlar!
• Hayır, vhayır, hayır eval()!
• Hayır ;, tek bir ifade olmalı!
• Hayır <yani ... hayır Heredocne de çoklu PHP blokları!
• Büyük olan! Hayır $ so ... değişken tanımlayan iyi şanslar! >: D

@ JörgHülsermann'ın ilginç bir yaklaşımı vardı, ama aklımdan geçen bu değildi :). Bu nedenle, yeni bir zorluk seviyesi tanıtacağım (Söz veriyorum, buna uygun kodum var ve sadece seninle uğraşmıyorum):

Seviye 2: PCRE (uzunluk = 23) ( Jörg Hülsermann tarafından çatladı )

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

• Seviye 1'deki tüm kısıtlamalar
• Bu seviyede yeni: bunlardan hiçbiri _~|&A-Z! :)

İyi eğlenceler!

ORİJİNAL ÇÖZÜM

Dolayısıyla, yasaklamak, $değişkenlere düzenli bir şekilde erişilemez anlamına geliyordu, ancak bu onların kullanılamayacakları anlamına gelmiyor! extract()/compact()Değişkenleri geçerli kapsam içine almak / vermek için hala kullanabilirsiniz . :)

$i = 1;
// can be written as
extract(['i' => 1])

echo $i;
// can be written as
echo compact('i')['i'];

Ancak, bir gotcha var: compact('x')['x']++işe yaramaz çünkü PHP'deki değişkenler bir istisna dışında değere göre iletilir! Nesneleri.

$x = (object) ['i' => 1];
// is
extract(['x' => (object) ['i' => 1]]);

// and
compact('x')['x']->i++;
// works just fine!

Gerisi kolaydır.

• Sayılar 0ve 1kolayca dönüştürerek üretilir falseve truehiç intbunları ekleyerek bu +işareti
• Kullanın andve orberi &ve |yasaktır
• Yasaklı tırnak işaretleri arasında çalışmak için, yalnızca dizeler olarak tanımlanan tanımsız sabitleri kullanın.
• Tanımlanmamış sabitler kullanılarak oluşturulan bildirimleri gizlemek için @
• Yasaklı harf , yukarıdaki geçici çözümlerin kullanılmasına karşılık gelen , vkullanılarak oluşturulabilir.chr(ord('u') + 1)@chr(ord(u) + true)
• Çizgi üzerinde benzer: chr(ord('a') - 2)çevirirchr(ord(a) - true - true)
• Yasaklı karakterler içeren arama fonksiyonları callable, fonksiyonun adını içeren bir dize olabilen PHP'nin türünden yararlanılarak yapılabilir . Böylece, tanımlanmamış sabitleri ve ord()işlevin adını oluşturmak için oluşturulan tek karakterli dizeleri birleştirebilir ve onu şu şekilde çağırabilirsiniz: array_reverse()olur (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arraybir dil yapısıdır, bu yüzden tanımlanmamış sabitlere bölünür ave rray)
• Koşullu ve döngüsel yapılara gelince, yapı hemen hemen aşağıdaki ifadeye uygulanıyorsa küme parantezlerinin isteğe bağlı olması gerçeğinden yararlanın. Bu, şöyle şeyler yapabileceğiniz anlamına gelir: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

İnsan tarafından okunabilir koddaki mantık şöyle olacaktır:

if (
    $x = (object) [
        'result' => [],
        'i' => 0
    ]

    and

    define('n', $argv[1])

    and

    define('un', '_')

    and

    // create the initial set which we'll loop through
    define('segments', array_chunk(range(1, pow(n, 2)), n))
) while (
    // store each odd segment as-is and increment the "pointer"
    ($x->result[] = @segments[$x->i++])

    and

    // store each even segment reversed and increment the "pointer"
    ($x->result[] = @array_reverse(segments[$x->i++]))

    and

    // check if we need to break out of the loop
    n > $x->i

    or

    // exit and output the result if the above is false
    die(json_encode(
        // if n is odd, the above would have copied a NULL entry 
        // from the segments, so it needs to be filtered out
        array_filter($x->result)
    ))
)

Ve regex ile eşleşen dostça olmayan sürüm:

<?php if (@extract([x=>(object)[s=>[],i=>+false]])and@define(n,compact(arg.chr(ord(u)+true))[arg.chr(ord(u)+true)][+true]?:+true)and@define(un,chr(ord(a)-true-true))and@define(s,(a.rray.un.chunk)(range(+true,pow(n,true+true)),n)))while((@compact(x)[x]->s[]=s[@compact(x)[x]->i++])and(@compact(x)[x]->s[]=(a.rray.un.re.chr(ord(u)+true).erse)(s[@compact(x)[x]->i++]))and(n>@compact(x)[x]->i)or(@die((json.un.encode)((a.rray.un.filter)(@compact(x)[x]->s)))))?>

Yakut [kırık]

İlk Polisler ve Soyguncular mücadele eder. Umarım bunu çok kolaylaştırmadım.

EDIT: değiştirildi \g<1> ile (?1)onlar besbelli PCRE'nin eşdeğer çünkü.

Düzenli İfade (PCRE'nin)

^(\W?\W\w){4}..(?1){2}[(-=Z-~]*(?1){5}\w*(?1)(.)\2$

Çıktı (n = 4)

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

(Bir dizi dizisi döndürür. Bu bir lambda, BTW, ama belki bu çok fazla şey verir?)

JavaScript (Kırık)

İlk defa bir Polis ve Soyguncular mücadele ediyor, umarım doğru yapıyor.

Regex (JavaScript)

^.*(\.\w+\(.*\)){4}$

Çıktı

Eşit bir dizi:

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

Swift, regex 25 (Kırık)

Pekala, bakalım bunu çözdüm mü? Bu benim ilk polislerim ve soyguncular görevim, bu yüzden haberim oldu mu bilmiyorum!

regex

Regex101.com'da javascript tadı kullandım

^.{21}print[^/]{49}o.{7}$

Örnek çıktı

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

Orijinal Kod

(0..<n).forEach{i in print((0..<n).map{i%2>0 ?(i+1)*n-$0 :i*n+$0+1},separator:",")}

C - uzunluğu 42 karakter regex - kırık

Regex101’de kullanılan Javascript regex .

^[-h<=*c+m?{printf("\/a: %d\\',o);}]{137}$

Bunu tahmin etmek önemsiz ...

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

Çıktı sekmeyle ayrılmış \n her satırdan sonra .

Benim çözümüm, burada 0 tamsayılar - 2 vasıtasıyla elde edilmiştir t-t, t/tve t:

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

Jöle , uzunluğu 14 kırık

Dennis tarafından kırık

[^/P-`mvḊ-ṫ€]*

Python regex.

Kaymasına mizin verdikten sonra tekrar girdim.

/(hızlı azaltın);
den P(ürüne) `(iki atomlu Quick monadın);
m(modulo indeksleme);
v(eval dyad);
ila Ḋ(dequeue) ila ṫ(kuyruk); ve
€(her hızlı için)

4Maden çıkışlarının girişi için :

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

... çünkü bir liste listesini bir ızgara olarak biçimlendirdim G.

Powershell, 23 Bayt

Matt tarafından Cracked

^.+?%.{42}%.{11}:.{35}$

Orijinal Çözüm:

$n="$args";$script:r=0;$a=1..$n|%{$t=++$script:r..($script:r+=$n-1);if(!($_%2)){[Array]::Reverse($t)};,$t};$a|%{$_-join" "}

Girdiyi argüman olarak alır ve stdout'a çıkar.

Umarım bu regex tamamdır, bunun çok fazla şaşırtmadığım için kırılması çok zor olmasını beklemiyorum ve regex boşlukları doldurmak için iyi bir kaç başlangıç ​​noktası veriyor, ilk bölümde bir şey var kod golfünde çok nadir olsa da, birini yakalayabilir, bu biraz daha zor hale getirmek için orada açgözlü olmayan bir kibrit gerektiğini düşünüyorum.

Zaten ilk polisler meydan okuyor.

1..4 | % { "----$_----" ; .\snake-cops.ps1 $_  }
----1----
1
----2----
1 2
4 3
----3----
1 2 3
6 5 4
7 8 9
----4----
1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13

Röda 0.12 , uzunluk 19 (@KritixiLithos tarafından çatlak)

PCRE:

^{(\|[^\/#\s]*){8}$

Örnek çıktı (n = 4):

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

Orijinal kod:

{|n|seq(0,n-1+n%2)|push([{|i|seq(n*i+1,n*i+n)}(_)],[{|j|seq(n*j+n,n*j+1,step=-1)}(_)])|head(n)}

Çevrimiçi deneyin!

PHP 7 (Güvenli)

Orijinal Kod

for($z=0,$q="";$z<($x=$argv[1])**2;){$w=($d=intdiv($z,$x))%2?($d+1)*$x-$z%$x:($z+1);for($f=0;$f<(log10($x**2)^0)-(log10($w)^0);$f++)$q.="\x20";$q.=++$z%$x?"$w\x20":"$w\n";}print(rtrim($q));

İkinci deneme

Regex (PCRE): 29 Bayt

^[^A-Z#\/\s\>busy_heck]{189}$

Boş alan yok, yorum yok, base64_decode kullanımı yok.

Birçok fonksiyona izin verilmiyor! vurgulamak

Çıktı n = 11

  1   2   3   4   5   6   7   8   9  10  11
 22  21  20  19  18  17  16  15  14  13  12
 23  24  25  26  27  28  29  30  31  32  33
 44  43  42  41  40  39  38  37  36  35  34
 45  46  47  48  49  50  51  52  53  54  55
 66  65  64  63  62  61  60  59  58  57  56
 67  68  69  70  71  72  73  74  75  76  77
 88  87  86  85  84  83  82  81  80  79  78
 89  90  91  92  93  94  95  96  97  98  99
110 109 108 107 106 105 104 103 102 101 100
111 112 113 114 115 116 117 118 119 120 121

Çıktı n = 4

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

Çıkış n = 3

1 2 3
6 5 4
7 8 9

Matl , uzunluk 12 (güvenli)

regex

Python lezzetini kullanır:

(\w{3}\W){5}

Örnek çıktı

İçin n=4:

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

Çözüm

txU:GeG:oEq*S5M*TTx!

Bunun nasıl çalıştığını görmek için girişi düşünün n=4.

tx   % Implicit input n, duplicate, delete. So this does nothing
     % STACK: 4
U    % Square
     % STACK: 16
:    % Range
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
Ge   % Reshape as an n-row array in column major order
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
G:   % Push range [1 2 ... n]
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
               [1 2 3 4]
o    % Modulo 2
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1  0  1  0]
Eq   % Times 2, minus 1 (element-wise)
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1 -1  1 -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1 -5  9 -13;
               2 -6 10 -14
               3 -7 11 -15
               4 -8 12 -16]
S    % Sort each column
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
5M   % Push [1 -1 1 -1] again
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
              [1 -1  1  -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1  8  9  16;
               2  7 10  15;
               3  6 11  14;
               4  5 12  13]
TTx  % Push [true true] and delete it. So this does nothing
!    % Transpose. Implicitly display
     % STACK: [ 1  2  3  4;
                8  7  6  5;
                9 10 11 12;
               16 15 14 13]

Jöle , uzunluk 17 (güvenli)

[^/P-`mvÇ-ıḃ-ṫ€]*

Python regex.

Düğümü sıkılaştırmak, bu yasaklanan baytlardır, çünkü bu sizin işinize yarayacak bazı daha faydalı şeyleri yasaklar:

/PQRSTUVWXYZ[\]^_`mvÇÐÑ×ØÞßæçðñ÷øþĊċĖėĠġİıḃḄḅḊḋḌḍḞḟḢḣḤḥḲḳḶḷṀṁṂṃṄṅṆṇṖṗṘṙṚṛṠṡṢṣṪṫ€

sadece üçte biri altında!

4Maden çıkışlarının girişi için :

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

... çünkü bir liste listesini bir ızgara olarak biçimlendirdim G.

Bir çözüm:

’:2o1
Ḃ¬aẋ@0
’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G

Çevrimiçi deneyin! / regex101

Burada ana hüner kadar doğal sayılar permütasyon bir sözlük sırasında sıralanmış liste halinde dizin olduğunu , n ² (kullanarak œ?uzunluğunun listesi oluşturmaya kaçınmak n ² ! ) Ve uzunlukta parçalar halinde sonucunu bölmek n . Yukarıda belirtilen endeks, "eksiz" yılanın, önceden belirlenmiş bir şekilde elemanlara izin verilerek (bu kolayca bir sayıya dönüştürülebilir ) oluşturulduğundan, formül olan faktör sayı sisteminde temsilini oluşturarak bulunur Æ¡.

Benim Ŀsunduğum çözüm, önceki bağlantılara monad (referans yerine koyma Ñve değiştirme Ç) olarak gönderme yapmak $için kullanılıyor , ancak bu yardımcı fonksiyonların "satır içi" yerine bir sıradaki çoklu kullanılabilir. Aynı zamanda rberi kullanır Ḷve Ryasaklanmıştır.

’:2o1 - Link 1, periodic repetitions in the factorial base representation: n
’     - decrement n
 :2   - integer divide by 2
   o1 - or 1 (keep one period in the cases n=1 and n=2)

Ḃ¬aẋ@0 - Link 2, n zeros if n is even, else an empty list: n
Ḃ      - mod 2
 ¬     - not
   ẋ@0 - 0 repeated n times
  a    - and

’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G - Main link: n                    e.g. 6
’r0                        - inclusive range(n-1, 0)              [5,4,3,2,1,0]
    0ẋ$                    - 0 repeated n times                   [0,0,0,0,0,0]
   ;                       - concatenate (makes one "period")     [5,4,3,2,1,0,0,0,0,0,0,0]
        1Ŀ                 - call link 1 as a monad               2
       ẋ                   - repeat list                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,0]
           0¦              - apply to index 0 (rightmost index):
          ¬                -     not (make the last 0 a 1)        [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1]
              2Ŀ           - call link 2 as a monad               [0,0,0,0,0,0]
             ;             - concatenate                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0]
                Æ¡         - convert from factorial base          45461852049628918679695458739920
                      ¤    - nilad followed by link(s) as a nilad
                    ⁸      -     left argument, n                 6
                     ²     -     square                           36
                  œ?       - lexicographical permutation lookup   [1,2,3,4,5,6,12,11,10,9,8,7,13,14,15,16,17,18,24,23,22,21,20,19,25,26,27,28,29,30,36,35,34,33,32,31]
                       s⁸  - split into chunks of length n        [[1,2,3,4,5,6],[12,11,10,9,8,7],[13,14,15,16,17,18],[24,23,22,21,20,19],[25,26,27,28,29,30],[36,35,34,33,32,31]]
                         G - format as a grid

Pip , regex uzunluğu 3 (güvenli)

Çözüm, n'yi bir komut satırı argümanı olarak alan tam bir programdır . Komut satırı bayrakları kullanmaz.

Regex (herhangi bir lezzet)

\w+

Örnek çıktı

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

Çözümüm

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

Çevrimiçi deneyin!

strateji

Burada ediyorum kod gibi yazma için:

Y \,a
F i ,a
 I i%2
  P i*a+_.s M RVy
 E
  P i*a+_.s M y

Yani:

• Sayılar 1 ile Mağaza aiçindey
• i0 ile 0 arasındaki değerler üzerinde döngüa-1
• Tek iise, y'yi ters çevirin, i*aher öğeye ekleyin , her öğeye bir boşluk bırakın ve yazdırın
• Aksi takdirde, aynı şeyi yapın, ancak önce tersine çevirmeden

Zorluklar

Pip'deki birçok komut ve değişken harf kullanır, ancak bazı önemli olanlar şunları yapmaz:

• Menzil ve dahil menzil ( ,ve \,)
• Çoğu matematik işlemleri ( +, -, *, %, ++)
• Atama ( :)
• Birden fazla ifadeye sahip bir döngü veya fonksiyon gövdesine sahip olamayız (bu ihtiyaç duyulacaktır {})
• Önceliği zorlamak için parantez kullanamayız.

Bu sınırlamaları nasıl aşarız:

• ENYerine yerine kullanılabilir ,; sadece istediğimiz karakter sayısına sahip bir dizgeye ihtiyacımız var ve her bir alt listenin ilk öğesini benzeri bir yapıda çıkarmamız gerekiyor [[0 "H"] [1 "i"]].
• Sorunu çözüp çözebiliyorsak, herhangi bir şeyi arttırmamıza gerek yok F.
• Ank operatörü yile değişkene atayabiliriz Y.
• Dizelerle matematik yapabiliriz: Xis string multiplication, ve PUsh (veya PB"push-back") bir dizgiyi yerine başka bir dizgeyle birleştirir. Bir dizenin uzunluğunu almak için, onu ENölçebilir ve doğru listeden sonuç numarasını çıkarabiliriz.
• İşlevleri kullanarak tek ifadeli lambda işlevleri olarak yazdıkları sürece kullanabiliriz _.

Ayrıntılı Bilgiler

Programımızın yapı taşları:

Aralık

_MUENsXa

Budur map-unpack(_, enumerate(repeat(space, a)))pseudocode. Map-pack, Python'unki gibidir itertools.starmap: bir liste listesi verildiğinde, her alt listenin öğeleri üzerinde bir işlev çağırır. _ilk argümanını döndürür, böylece _MUher alt listenin ilk öğesini alır. Örneğin, eğer a = 3 ise:

     sXa  "   "
   EN     [[0 " "] [1 " "] [2 " "]]
_MU       [0 1 2]

... ki aynı ,a.

Dahil aralığı

inclusive-range(1, a)Tek bir ifadede yapmanın bir yolu olduğundan emin değilim , ama neyse ki sadece bir kere ihtiyacımız var, bu yüzden ydeğişkeni üç adımda oluşturabiliriz.

YENsXaPBs

Sahte kodda yank(enumerate(repeat(space, a).push-back(space))):

   sXa     "   "
      PBs  "    "
 EN        [[0 " "] [1 " "] [2 " "] [3 " "]]
Y          Store that in y

Sonraki POygelen ilk öğeyi çıkar ybırakarak ona ve atar[[1 " "] [2 " "] [3 " "]] .

En sonunda,

Y_MUy

Yani yank(map-unpack(_, y)),: Her bir alt listenin ilk elemanını çıkartın ve elde edilen listeyi yeniden sıralayın y. yşimdi[1 2 3] .

uzunluk

PODQENaPBs

Sahte kodda pop(dequeue(enumerate(a.push-back(space)))),. Buradaki zorluk, numaralandırmanın sadece bize sayıları vermesi len(a)-1, ama istiyoruz len(a). Bu yüzden önce abir karaktere kadar uzatarak, onu bir karakter uzatarak ve sonra len-1yeni dizgiyi alırız .

      a     "xyz"
       PBs  "xyz "
    EN      [[0 "x"] [1 "y"] [2 "z"] [3 " "]]
  DQ        [3 " "]
PO          3

Matematik

Artık dizelerin uzunluğunu alacak bir yolumuz olduğuna göre, çarpma ve sayıların eklenmesi için dizeleri kullanabiliriz:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

Birincisi sXaXbbir a*bboşluk dizisi yaratır ve sonra bunun uzunluğunu alır; ikincisi, sXaPBsXbbir bboşluk dizisini bir boşluk dizisine itmek için ayapılır ve sonra bunun uzunluğunu alır.

Güzel kısmı burada kullandığınız tüm operatörler (yani PU, PO, PB, DQ, EN, X) ile kullanılabilir _formu lambda ifadelerine. Böylece matematiksel dönüşümleri daha önce inşa ettiğimiz kapsayıcı aralıkla eşleyebiliriz.

Ayrıca i%2döngünün içini de kontrol etmemiz gerekir , ancak bu kolayca bit yönünde AND: ile gerçekleştirilir iBA1.

Onları bir araya getir

Kodun tümü, biraz boşluk eklenmiş olarak:

YENsXaPBs POy Y_MUy              Get \,a into y
F i _MUENsXa                     For i in ,a
 I iBA1                           If i%2=1
  P sPUPODQENsXiXaPBsX_PBs M RVy   Print sPUi*a+_ M RVy
 EI1                              Elseif 1 (using E would cause a parsing problem)
  P sPUPODQENsXiXaPBsX_PBs M y     Print sPUi*a+_ M y

CJam, PCRE, uzunluk 8, kırık

^[a-~]*$

4 için örnek çıktı:

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

CJam, PCRE, uzunluk 9, kırık

^[a-z~]*$

4 için örnek çıktı:

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

Şimdi {|}de yasaklandı.

Mathematica, regex uzunluğu 11, yarışmayan , çatlak

PCRE lezzet:

^[^]@]{49}$

Doğru çözüm, bir tamsayı alan ve çıktıyı iç içe geçmiş bir liste olarak döndüren bir işlev olacaktır:

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

tinylisp , regex uzunluğu 3 ( çatlak )

Tinylisp kodunu çevrimiçi deneyin! ' De test edebilirsiniz .

Regex (herhangi bir lezzet)

\S+

Sert olma zamanı.

Çıktı

Çözüm, tek bir tamsayı argümanı alan ve bunun gibi bir liste döndüren bir işlev tanımlar (n = 4 için):

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

Orijinal kodum, Brian McCutchon'un ortaya koyduğu, listeleri oluşturup değerlendirdiği aynı temel fikri kullanıyor. İşte bir satırda:

(v(c(h(q(d)))(c(h(q(d')))(c(c(h(q(q)))(c(c()(c(q(arglist))(c(c(h(q(v)))(c(c(h(q(c)))(c(c(h(q(q)))(q(d)))(q(arglist))))()))())))()))()))))(d'(seq-args(c(h(q(start)))(c(h(q(stop)))(c(h(q(step)))())))))(d'(seq(c(c(h(q(accum)))seq-args)(q((i(e(v(h(q(start))))stop)(c(v(h(q(start))))accum)(seq(c(v(h(q(stop))))accum)start(s(v(h(q(stop))))step)step)))))))(d'(f'(c(c(h(q(index)))(c(h(q(size)))seq-args))(q((i(e(v(h(q(index))))size)()(c(seq()start(v(h(q(stop))))step)(f'(a(h(q(1)))index)size(a(v(h(q(stop))))size)(a(v(h(q(start))))size)(s(h(q(0)))step)))))))))(d'(f(q((size)(f'(h(q(0)))size(h(q(1)))size(h(q(1))))))))

Tam yapı ve değerlendirme yöntemini bir keresinde, gibi tanımlamaları d'yapan bir makro tanımlamak için kullandım d, ancak argümanlarını bir listeye sardı: yerine (d x 42)bunu yapabilirsiniz (d'(x 42)). O zaman sadece boşluklara ihtiyaç duyan tanımlardaki listeleri yeniden yazmaktan ibaretti: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, uzunluk 162 (Kırık!)

regex: ^([^"' #]){24}"(?1){11}i%n(?1){4}2\*n-(?1){4}i%n(?1){10}i\/n(\)\/\/1)(?1){5}(?2)(?1){3}2\*\(i%n\)(?1){4}[int()2\/]{16}for i in range\(j,(?1){4}\]\)(?1){6}\"\*n\)$

Tamam, biliyorum, çok uzun. Neyse ki bir haftadan daha kısa sürede çatlamaz ...: 'D.

Sanırım hiçbir yerde hata yapmadım, bu boşluk kaçağına cevap verecek.

Çıkış formatı

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

Orijinal kod:n=int(input());j=0;exec("print([int(i%n+1+(2*n-(2*(i%n)+1))*((((i/n)//1+1)/2)//1)+(2*(i%n)+1)*int(int(i/n)/2))for i in range(j,j+n)]);j+=n;"*n)