Popüler (ve temel) bilgisayar bilimleri kitabında, Peter Linz'in Biçimsel Dillere ve Otomatlara Giriş , aşağıdaki biçim dili sıklıkla dile getirilmiştir:

temel olarak bu dil sonlu durumlu otomatlarla işlenemediğinden. Bu ifade, "Dil L" nin "a" dizelerinin tamamını, ardından "a" ve "b sayısının eşit ve sıfır olmayan" olduğu anlamına gelir.

Meydan okuma

Yalnızca "a" s ve "b" s içeren bir dizge alan, girdi olarak geri dönen / çıktı veren , bu dizenin biçimsel L geçerli olup olmadığını söyleyen bir çalışma programı / işlevi yazın .

• Programınız ağ, harici programlar vb. Dahil olmak üzere harici hesaplama araçlarını kullanamaz. Kabuklar bu kuralın bir istisnasıdır; Örneğin Bash, komut satırı yardımcı programlarını kullanabilir.

• Programınız sonucu "mantıksal" bir şekilde döndürmeli / vermelidir, örneğin: 0 yerine 10, "bip" sesi, stdout çıktısı vb .

• Standart kod golf kuralları geçerlidir.

Bu bir kod golfü . Bayt cinsinden en kısa kod kazanır. İyi şanslar!

Truthy test durumları

"ab"
"aabb"
"aaabbb"
"aaaabbbb"
"aaaaabbbbb"
"aaaaaabbbbbb"

Sahte test durumları

""
"a"
"b"
"aa"
"ba"
"bb"
"aaa"
"aab"
"aba"
"abb"
"baa"
"bab"
"bba"
"bbb"
"aaaa"
"aaab"
"aaba"
"abaa"
"abab"
"abba"
"abbb"
"baaa"
"baab"
"baba"
"babb"
"bbaa"
"bbab"
"bbba"
"bbbb"

MATL , 5 4 bayt

tSP-

Dize L'ye aitse boş olmayan bir 1 s dizisini ve aksi halde 0 s (her ikisi de sahte) olan boş bir diziyi veya bir diziyi yazdırır.

1 byte kapalı golf için @LuisMendo için teşekkürler!

Çevrimiçi deneyin!

Nasıl çalışır

t      Push a copy of the implicitly read input.
 S     Sort the copy.
  P    Reverse the sorted copy.
   -   Take the difference of the code point of the corresponding characters
       of the sorted string and the original.

Python 3, 32 bayt

eval(input().translate(")("*50))

Çıkış kodu ile çıkış : Yanlış için hata, Doğru hata yok.

Dize parens yerine Python kodu olarak değerlendirilir (için ave )için b. Yalnızca formdaki a^n b^nifadeler, parantezi ((()))değerlendiren , parantez içindeki iyi biçimlendirilmiş ifadeler haline gelir ().

Uyuşmayan herhangi bir par, (()())ayırıcı olmadığından, birden çok grup gibi bir hata verir . Boş dize de başarısız olur (başarılı olur exec).

Dönüşüm ( -> a, bir dönüşüm tablosu işlevi gören bir dize tarafından belirtilen karakterlerin yerine geçen ) -> bkullanılarak yapılır str.translate. 100-string string ") (" * 50 'ye bakıldığında, tablolar ilk 100 ASCII değerini aşağıdaki gibi eşler.

... Z[\]^_`abc
... )()()()()(

hangi alır ( -> a, ) -> b. Python 2'de 256 ASCII değerinin tümü için dönüşümler "ab"*128bir bayt daha uzun olacak şekilde sağlanmalıdır ; bunu işaret ettiği için isaacg sayesinde.

Retina , 12 bayt

Bağımsız olarak bu çözümü bulan FryAmTheEggman’a kredi verir.

+`a;?b
;
^;$

1Geçerli giriş için ve 0başka şekilde yazdırır .

Çevrimiçi deneyin! (İlk satır, satır besleme ayrılmış bir test takımı sağlar.)

açıklama

Dengeleme grupları pahalı sözdizimi gerektirir, bu yüzden geçerli bir girişi basit bir forma indirmeye çalışıyorum.

Aşama 1

+`a;?b
;

+Çıkışı değişen durana kadar bir döngü içinde bu aşamaya tekrarlamak Retina söyler. Ya eşleşiyor ya abda a;byerini alıyor ;. Birkaç vakayı ele alalım:

• Eğer aler ve bdizede ler aynı şekilde dengeli değildir (ve )normalde olması gerekir, bazı aveya b, dizede beri kalacaktır ba, ya b;atek çözülemeyen ve aya bkendi başına yapamaz ya. Tüm as ve s lerden kurtulmak için, her birinin sağına bkarşılık gelen bir tane bolmak zorundadır a.
• Eğer ave bhepsi iç içe değilse (örneğin ababveya gibi bir şeyimiz varsa aabaabbb), o zaman birden fazla ;(ve potansiyel olarak bazı as ve bs) ile sonuçlanırız, çünkü ilk yineleme abonları eklemek için birden fazla s bulur ve daha fazla yineleme korunur. ;dizedeki sayı .

Bu nedenle, eğer ve sadece girdi biçimindeyse , dizgede bir tane olacak.anbn;

2. aşama:

^;$

Ortaya çıkan dizgenin tek bir noktalı virgül dışında bir şey içermediğini kontrol edin. ("Kontrol et" aslında demek istediğimde "deyince, belirtilen regex'in eşleşme sayısını sayın, ancak bu regex, çapalar nedeniyle en fazla bir kez eşleşebildiğinden, bu ya 0da 1.

Haskell, 31 bayt

f s=s==[c|c<-"ab",'a'<-s]&&s>""

Liste anlama [c|c<-"ab",'a'<-s]birinin bir dize kılan 'a'her biri için 'a'de sbirer ardından 'b'her biri için 'a'de s. Bir sabit üzerinde eşleştirerek saymayı ve her bir eşleşme için bir çıktı üretmeyi önler .

Bu dizgenin orijinal dizgiye eşit olması ve orijinal dizginin boş olmaması denetlenir.

12 gr

A=\aA?\b
e`A

Çevrimiçi deneyin!

açıklama

İlk satır, bir Aharfle a, belki de olmayan Aharfle ve sonra bir harfle eşleşen bir nonterminal tanımlar b. İkinci satır bütün girişi ( e) nonterminal ile eşleştirir A.

8 bayt olmayan rekabetçi sürüm

e`\a_?\b

Bu cevabın ilk versiyonunu yazdıktan sonra _, üst seviye ifadenin adı olarak değerlendirilmek üzere Grime'yi güncelledim . Bu çözüm yukarıdakilere eşdeğerdir, ancak etiketi tekrar etmekten kaçınır A.

Brachylog , 23 19 bayt

@2L,?lye:"ab"rz:jaL

Çevrimiçi deneyin!

açıklama

@2L,                  Split the input in two, the list containing the two halves is L
    ?lye              Take a number I between 0 and the length of the input              
        :"ab"rz       Zip the string "ab" with that number, resulting in [["a":I]:["b":I]]
               :jaL   Apply juxtapose with that zip as input and L as output
                        i.e. "a" concatenated I times to itself makes the first string of L
                        and "b" concatenated I times to itself makes the second string of L

05AB1E , 9 bayt

Kod:

.M{J¹ÔQ0r

Açıklama:

.M         # Get the most frequent element from the input. If the count is equal, this
           results into ['a', 'b'] or ['b', 'a'].
  {        # Sort this list, which should result into ['a', 'b'].
   J       # Join this list.
    Ô      # Connected uniquified. E.g. "aaabbb" -> "ab" and "aabbaa" -> "aba".
     Q     # Check if both strings are equal.
      0r   # (Print 0 if the input is empty).

Girişin boş olmadığı garanti edilirse, son iki bayt atılabilir.

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Jöle , 6 bayt

Ṣ=Ṛ¬Pȧ

L'ye aitse veya boşsa, aksi takdirde 0 ise dizenin kendisini yazdırır .

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

Ṣ=Ṛ¬Pȧ  Main link. Argument: s (string)

Ṣ       Yield s, sorted.
  Ṛ     Yield s, reversed.
 =      Compare each character of sorted s with each character of reversed s.
   ¬    Take the logical NOT of each resulting Boolean.
    P   Take the product of the resulting Booleans.
        This will yield 1 if s ∊ L or s == "", and 0 otherwise.
     ȧ  Take the logical AND with s.
       This will replace 1 with s. Since an empty string is falsy in Jelly,
       the result is still correct if s == "".

Alternatif sürüm, 4 bayt (rakipsiz)

ṢnṚȦ

1 veya 0 yazdırır . Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

ṢnṚȦ  Main link. Argument: s (string)

Ṣ     Yield s, sorted.
  Ṛ   Yield s, reversed.
 n    Compare each character of the results, returning 1 iff they're not equal.
   Ȧ  All (Octave-style truthy); return 1 if the list is non-empty and all numbers
      are non-zero, 0 in all other cases.

J, 17 bayt

#<.(-:'ab'#~-:@#)

Bu boş dize için falsey vermek için doğru çalışır. Hata falsey.

Eski versiyonlar:

-:'ab'#~-:@#
2&#-:'ab'#~#   NB. thanks to miles

İspat ve açıklama

Ana fiil, bu üç fiilden oluşan bir çataldır:

# <. (-:'ab'#~-:@#)

Bu, "( <.) işaretinin uzunluğu ( #) ve sağ dişin ( (-:'ab'#~-:@#)) değeri" ne kadar küçükse o demektir .

Doğru çatal , aşağıdakilerden oluşan 4 trendir :

(-:) ('ab') (#~) (-:@#)

kGirdiyi temsil edelim . O zaman, bu eşdeğerdir:

k -: ('ab' #~ -:@#) k

-:maç operatör, bu yüzden -:monadik çatal altında değişmezlik için önde gelen testleri 'ab' #~ -:@#.

Çatalın sol kenarı bir fiil olduğundan, sürekli bir fonksiyon haline gelir. Yani, çatal eşdeğerdir:

'ab' #~ (-:@# k)

Çatalın sağ dişi ( -:) uzunluğunu ( #) k. Gözlemek# :

   1 # 'ab'
'ab'
   2 # 'ab'
'aabb'
   3 # 'ab'
'aaabbb'
   'ab' #~ 3
'aaabbb'

Şimdi, bu ksadece geçerli girdilerde, bu yüzden burada işimiz bitti.#Tuhaf uzunluktaki dizgiler için, hiçbir zaman dili tatmin etmeyen hatalar , bu yüzden de bittik.

Uzunluğun daha küçük olması ve bununla birlikte, dilimizin bir parçası olmayan boş dize, uzunluğunu verir 0ve biz de onlarla işimiz bitti.

Bison / YACC 60 (veya 29) bayt

(Peki, bir YACC programının derlemesi birkaç adımdır, bu yüzden bazıları da dahil etmek isteyebilir. Ayrıntılar için aşağıya bakınız.)

%%
l:c'\n';
c:'a''b'|'a'c'b';
%%
yylex(){return getchar();}

Resmi bir gramer açısından yorumlamayı biliyorsanız, işlev oldukça açık olmalıdır. Ayrıştırıcı, ya abda aardından gelen kabul edilebilir herhangi bir diziyi kabul eder , ardından a b.

Bu uygulama, K & R anlambilimini birkaç karakteri kaybetmeyi kabul eden bir derleyiciye dayanmaktadır.

Tanımlama yylexve arama ihtiyacım ile istediğimden daha kötü getchar.

İle derleyin

$ yacc equal.yacc
$ gcc -m64 --std=c89 y.tab.c -o equal -L/usr/local/opt/bison/lib/ -ly

(gcc seçeneklerinin çoğu sistemime özgüdür ve bayt sayımına karşı sayılmamalıdır; -std=c89listelenen değere 8 ekleyen saymak isteyebilirsiniz ).

İle koş

$ echo "aabb" | ./equal

veya eşdeğer.

Gerçek değeri işletim sistemine döndürülür ve hatalar da syntax errorkomut satırına bildirilir. Ayrıştırma işlevini tanımlayan kodun yalnızca bir kısmını sayabilirsem (bu, ikincisini %%ve sonrakileri ihmal eder) 29 baytlık bir sayı alırım.

5.10 Perl, 35 17 bayt ( -n bayrağı ile)

say/^(a(?1)?b)$/

Dizenin as ile başlamasını ve ardından s'yi tekrar çağırmasını sağlar b. Sadece her iki uzunluk da eşitse eşleşir.

Martin Ender'e teşekkürlerBayt sayısını yarıya çektiği ve regex'lerde özyineleme hakkında bana biraz bilgi verdiği ederim: D

Eşleşirse tüm dizeyi döndürür, eğer değilse hiçbir şey döndürmez.

Burada dene!

JavaScript, 54 55 44

s=>s&&s.match(`^a{${l=s.length/2}}b{${l}}$`)

İpin uzunluğuna göre basit bir regex oluşturur ve onu test eder. Bir uzunluk 4 dize ( aabb) için regex benziyor:^a{2}b{2}$

Bir truthy veya falsey değeri döndürür.

Neil sayesinde 11 bayt kurtarıldı.

f=s=>s&&s.match(`^a{${l=s.length/2}}b{${l}}$`)
// true
console.log(f('ab'), !!f('ab'))
console.log(f('aabb'), !!f('aabb'))
console.log(f('aaaaabbbbb'), !!f('aaaaabbbbb'))
// false
console.log(f('a'), !!f('a'))
console.log(f('b'), !!f('b'))
console.log(f('ba'), !!f('ba'))
console.log(f('aaab'), !!f('aaab'))
console.log(f('ababab'), !!f('ababab'))
console.log(f('c'), !!f('c'))
console.log(f('abc'), !!f('abc'))
console.log(f(''), !!f(''))

C, 57 53 Bayt

t;x(char*s){t+=*s%2*2;return--t?*s&&x(s+1):*s*!1[s];}

Eski 57 bayt uzunluğunda çözüm:

t;x(char*s){*s&1&&(t+=2);return--t?*s&&x(s+1):*s&&!1[s];}

Gcc v. 4.8.2 @Ubuntu ile derlenmiş

İpuçları için teşekkürler ugoren!

Ideone'da dene!

Retina , 22 bayt

Aynı dilde kısa bir cevap daha geldi ...

^(a)+(?<-1>b)+(?(1)c)$

Çevrimiçi deneyin!

Bu, Martin Ender tarafından tamamen açıklanmış olan, regex'teki dengeleme gruplarının bir vitrinidir .

Açıklamam bunun yarısına yaklaşmayacağından, onunla bağlantı kuracağım ve açıklamaya çalışacağım, açıklamanın ihtişamına zarar vereceği için açıklamaya çalışmayacağım.

Befunge-93, 67 bayt

0v@.<  0<@.!-$<  >0\v
+>~:0`!#^_:"a" -#^_$ 1
~+1_^#!-"b" _ ^#`0: <

Burada dene! Daha sonra nasıl çalıştığını açıklayabilir. Ayrıca, sadece vuruş için biraz daha golf oynamayı deneyebilirsiniz.

MATL , 9 bayt

vHI$e!d1=

Çevrimiçi deneyin!

Çıkış dizisi, boş değilse ve tüm girişlerinin sıfır olmadığında gerçeğe yakındır. Aksi takdirde sahtedir. İşte bazı örnekler .

v     % concatenate the stack. Since it's empty, pushes the empty array, []
H     % push 2
I$    % specify three inputs for next function
e     % reshape(input, [], 2): this takes the input implicitly and reshapes it in 2
      % columns in column major order. If the input has odd length a zero is padded at
      % the end. For input 'aaabbb' this gives the 2D char array ['ab;'ab';'ab']
!     % transpose. This gives ['aaa;'bbb']
d     % difference along each column
1=    % test if all elements are 1. If so, that means the first tow contains 'a' and
      % the second 'b'. Implicitly display

x86 makine kodu, 29 27 bayt

HexDump:

33 c0 40 41 80 79 ff 61 74 f8 48 41 80 79 fe 62
74 f8 0a 41 fe f7 d8 1b c0 40 c3

Montaj kodu:

    xor eax, eax;
loop1:
    inc eax;
    inc ecx;
    cmp byte ptr [ecx-1], 'a';
    je loop1;

loop2:
    dec eax;
    inc ecx;
    cmp byte ptr [ecx-2], 'b';
    je loop2;

    or al, [ecx-2];
    neg eax;
    sbb eax, eax;
    inc eax;
done:
    ret;

Üzerinde yinelenir a başında bayt ve aşağıdaki 'b' bayt üzerinde. İlk döngü bir sayacı artırır ve ikinci döngü onu azaltır. Daha sonra, aşağıdaki koşullar arasında bit yönünde VEYA yapar:

1. Sayaç sonunda 0 değilse, dize eşleşmiyor
2. Dizisini izleyen bayt bS 0 değilse, dize de eşleşmez

Ardından, doğruluk değerini "tersine çevirmek" zorundadır eax- eğer 0 değilse, 0 olarak ayarlayın ve bunun tersi de geçerlidir. Bunun için en kısa kodun, C ++ derleyicimin çıkışından çaldığım şu 5 baytlık kod olduğu ortaya çıktı result = (result == 0):

    neg eax;      // negate eax; set C flag to 1 if it was nonzero
    sbb eax, eax; // subtract eax and the C flag from eax
    inc eax;      // increase eax

Ruby, 24 bayt

eval(gets.tr'ab','[]')*1

(Bu sadece Xnor’ın Ruby formundaki parlak fikri . Diğer cevabım aslında kendimle bulduğum bir çözüm.)

Program dönüşümleri, girdi alır ave bkarşı [ve] sırasıyla ve değerlendirir.

Geçerli giriş iç içe geçmiş bir dizi oluşturur ve hiçbir şey olmaz. Dengesiz bir ifade programın çökmesine neden olur. Ruby'de boş girdi bir yöntem tanımlanmadığından nilçökecek olan olarak değerlendirilir .nil*

Sed, 38 + 2 = 40 bayt

s/.*/c&d/;:x;s/ca(.*)bd/c\1d/;tx;/cd/p

^{Boş olmayan bir dize çıkışı truthy}

Sonlu durum otomatları bunu yapamaz, diyorsunuz? Döngülerle sonlu durumlu otomatlar . : P

rVe nbayraklarıyla koş .

açıklama

s/.*/c&d/        #Wrap the input in 'c' and 'd' (used as markers)
:x               #Define a label named 'x'
s/ca(.*)bd/c\1d/ #Deletes 'a's preceded by 'c's and equivalently for 'b's and 'd's. This shifts the markers to the center
tx               #If the previous substitution was made, jump to label x
/cd/p            #If the markers are next to one another, print the string

JavaScript, 44 42

^{44'ü geçti, hala 44'dür;}

f=s=>(z=s.match`^a(.+)b$`)?f(z[1]):s=="ab"

Dıştaki özyinelemeyi sıyırma yoluyla ave bve seçilen iç değeri kullanarak özyinelemeli çalışır .+. ^a.+b$Solda eşleşme olmadığında, nihai sonuç, kalan dizenin kesin değer olup olmadığıdır ab.

Test durumları:

console.log(["ab","aabb","aaabbb","aaaabbbb","aaaaabbbbb","aaaaaabbbbbb"].every(f) == true)
console.log(["","a","b","aa","ba","bb","aaa","aab","aba","abb","baa","bab","bba","bbb","aaaa","aaab","aaba","abaa","abab","abba","abbb","baaa","baab","baba","babb","bbaa","bbab","bbba","bbbb"].some(f) == false)

ANTLR, 31 bayt

grammar A;r:'ab'|'a'r'b'|r'\n';

@ Dmckee en aynı kavram kullanır YACC cevap , sadece biraz daha golfed.

Test etmek için, ANTLR'nin Başlarken eğitimindeki adımları izleyin . Ardından, yukarıdaki kodu adlandırılmış bir dosyaya koyun A.g4ve şu komutları çalıştırın:

$ antlr A.g4
$ javac A*.java

Daha sonra, STDIN'e girişi vererek aşağıdakileri yapın grun A r:

$ echo "aaabbb" | grun A r

Giriş geçerliyse hiçbir şey çıkmaz; geçersiz ise, grunbir hata verecektir (ya token recognition error, extraneous input, mismatched input, veya no viable alternative).

Örnek kullanım:

$ echo "aabb" | grun A r
$ echo "abbb" | grun A r
line 1:2 mismatched input 'b' expecting {<EOF>, '
'}

C, 69 bayt

69 bayt:

#define f(s)strlen(s)==2*strcspn(s,"b")&strrchr(s,97)+1==strchr(s,98)

Yabancı olanlar için:

• strlen dizenin uzunluğunu belirler
• strcspn diğer dizginin bulunduğu dizgede ilk dizini döndürür
• strchr bir karakterin ilk oluşumuna bir işaretçi döndürür
• strrchr bir karakterin son oluşumuna bir gösterici ile döner

Titus'a büyük teşekkürler!

R, 64 61 55 bayt, 73 67 bayt (sağlam) veya 46 bayt (boş dizelere izin verilirse)

1. Yine, Xnor'ın cevabı elden geçirildi. Girişin as ve bs dizesinden oluşacağı kurallar tarafından belirtilmişse , çalışması gerekir: ifade geçerliyse NULL döndürür, atar ve hata veya başka bir şey olmaz.

   if((y<-scan(,''))>'')eval(parse(t=chartr('ab','{}',y)))
   

2. Girdi sağlam değilse ve bir miktar çöp içerebilirse, örneğin aa3bb, aşağıdaki sürüm göz önünde bulundurulmalıdır ( TRUENULL yerine gerçek test durumları için geri dönülmelidir):

   if(length(y<-scan(,'')))is.null(eval(parse(t=chartr("ab","{}",y))))
   

3. Son olarak, boş dizgilere izin verilirse, boş olmayan girdi koşullarını görmezden gelebiliriz:

   eval(parse(text=chartr("ab","{}",scan(,''))))
   

   Yine, eğer NULL ise başarı, başka bir şey.

Japt , 11 bayt

©¬n eȦUg~Y

Çevrimiçi deneyin!

Verir ya trueya falsedışında ""verir"" JS falsy olan.

Ambalajsız ve Nasıl Çalışır?

U&&Uq n eXYZ{X!=Ug~Y

U&&     The input string is not empty, and...
Uq n    Convert to array of chars and sort
eXYZ{   Does every element satisfy...?
X!=       The sorted char does not equal...
Ug~Y      the char at the same position on the original string reversed

Uyarlanan Dennis'in Matl çözümü .

C (Ansi), 65 75 Bayt

golfed:

l(b,i,j,k)char*b;{for(i=j=0;(k=b[i++])>0&k<=b[i];)j+=2*(k>97)-1;return !j;}

Açıklama:

Her b için j değerini ve j artışlarını, başka bir şey için j değerini azaltır. Önceki harfin bir sonraki harfe eşit veya daha küçük olup olmadığı kontrol edildi, bu nedenle ababın çalışmasını engelle

Düzenlemeler

Abab vakaları için çekler eklendi.

Toplu iş, 133 bayt

@if ""=="%1" exit/b1        Fail if the input is empty
@set a=%1                   Grab the input into a variable for processing
@set b=%a:ab=%              Remove all `ab` substrings
@if "%a%"=="%b%" exit/b1    Fail if we didn't remove anything
@if not %a%==a%b%b exit/b1  Fail if we removed more than one `ab`
@if ""=="%b%" exit/b0       Success if there's nothing left to check
@%0 %b%                     Rinse and repeat

Başarı durumunda ERRORLEVEL0, başarısızlık durumunda 1 döndürür . Toplu iş, boş dizelerde alt değiştirme yapmaktan hoşlanmıyor, bu yüzden bunu kontrol etmeliyiz; boş bir parametre yasal olsaydı, satır 6 gerekli olmazdı.

PowerShell v2 +, 61 52 bayt

param($n)$x=$n.length/2;$n-and$n-match"^a{$x}b{$x}$"

Girişi alır $n, bir dize olarak yaratır $xkadar half the length. Bir regex operatörü ile eşit sayıda 'nın regex'ine karşı bir -andBoole karşılaştırması yapar . Boolean veya$n-matchab$TRUE$FALSE . $n-andHesaba var"" = $FALSE.

Alternatif, 35 bayt

$args-match'^(a)+(?<-1>b)+(?(1)c)$'

Bu , PowerShell işlecinde kapsüllenen .NET dengeleme gruplarını temel alan Leaky'nin yanıtındaki regex'i kullanır -match. Truthy dizesini veya falsey için boş dizeyi döndürür.

Pyth - 13 bayt

&zqzS*/lz2"ab

Açıklaması:

  qz          #is input equal to
          "ab #the string "ab"
     *        #multiplied by
      /lz2    #length of input / 2
    S         #and sorted?
&z            #(implicitly) print if the above is true and z is not empty

Haskell, 39 bayt

p x=elem x$scanl(\s _->'a':s++"b")"ab"x

Kullanım örneği: p "aabb"-> True.

scanl(\s _->'a':s++"b")"ab"x["ab", "aabb", "aaabbb", ...]Toplam (length x)elemanların bir listesini oluşturun . Bu listede elemolup olmadığını kontrol eder x.

Python, 43 40 Bayt

lambda s:''<s==len(s)/2*"a"+len(s)/2*"b"

Leaky Nun sayesinde açık çözümü anladı

başka bir fikir, 45 bayt:

lambda s:s and list(s)==sorted(len(s)/2*"ab")

-4 bayt, len / 2 kullanarak (yarı son geldiğinde hata alıyorum)

şimdi boş dize için yanlış veriyor

Xnor sayesinde -3 bayt