Pazartesi akşamınız için basit bir zorluk (peki ya da dünyanın diğer yarısında Salı sabahı ...)

Girdi olarak iç içe geçmiş, potansiyel olarak düzensiz bir pozitif tam sayı dizisi olarak verilmiştir:

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

Göreviniz, listedeki herhangi bir tamsayı için en büyük yuva derinliği olan derinliğini belirlemektir. Bu durumda, derinliği 11IS 6büyük, hangi.

Dizilerden hiçbirinin boş kalmayacağını varsayabilirsiniz.

STDIN (veya en yakın alternatif), komut satırı argümanı veya işlev argümanı yoluyla giriş alarak ve sonucu STDOUT (veya en yakın alternatif), fonksiyon dönüş değeri veya function (out) parametresi ile çıktı alarak bir program veya işlev yazabilirsiniz.

Giriş, gerçek bilgiler önceden işlenmediği sürece dikdörtgen olmayan dizileri (farklı derinliklere sahip iç içe dizilerle) destekleyen herhangi bir uygun listede veya dize biçiminde alınabilir.

Dizilerin şekli ile ilgili hiçbir bileşen kullanmamalısınız (bu sorunu çözen, iç içe bir dizinin boyutlarını elde eden yerleşikler dahil). Bunun tek istisnası bir dizinin uzunluğunu almak.

Standart kod-golf kuralları geçerlidir.

Test Kılıfları

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

K, 4 bayt

#,/\

K'de ,/bir listenin tüm öğelerini birleştirecek. Ortak deyim ,//, rasgele iç içe geçmiş bir listeyi tamamen düzleştirerek sabit bir noktaya yinelenir. ,/\Sabit bir noktaya benzer şekilde yinelenecek, ancak ara sonuçların bir listesini toplayacaktır. Sabit noktaya ( #) ulaşmadan önce kaç ara sonucun geldiğini sayarak , istediğimiz cevabı alıyoruz: maksimum yuvalama derinliği.

Msgstr "Sabit nokta taraması üzerinde birleştirme sayısı".

Eylemde:

 (#,/\)'(,1
        1 2 3
        ,1 2 3
        (3;(3;,3;3);3)
        ,((,1;2);(3;,4)))
1 1 2 3 4

Retina , 10

• @ ӍѲꝆΛҐӍΛПҒЦꝆ sayesinde 1 bayt kaydedildi
• @ MartinBüttner sayesinde 14 fazla bayt kaydedildi

{} | + '\ W

{

Burada giriş formatı biraz tartışılır - _karakterler liste ayırıcılar için kullanılır, böylece bir giriş şöyle görünür.{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Aşama 1 - art arda kaldır }{ve diğer tüm \wkarakterler. Bunun, a) tüm listelerin her seviyede tek bir unsurdan oluşması ve b) liste dışı yapısal karakterlerin çıkarılması etkisine sahiptir.
• Aşama 2 - kalan sayım {. Bu, en derin iç içe yerleştirme seviyesini verir.

Çevrimiçi deneyin.

Çok fazla gerginlik varsa, önceki cevap şuydu:

Retina , 13

Listelerin kaşlı ayraçlar içinde bulunduğunu varsayar {}.

+ `[^} {] |} {

{

Çevrimiçi deneyin .

Python 2,33 bayt

f=lambda l:l>{}and-~max(map(f,l))

Bir sayının derinliğinin 0 olduğunu ve bir listenin derinliğinin elemanlarının maksimum derinliğinden daha fazla olduğunu söyleyerek derinliği tekrarlı olarak tanımlar. Sayılara karşı liste, {}sayıların üzerine düşen ancak Python 2'nin yerleşik türlerdeki isteğe bağlı sıralamasında listelenen boş sözlükle karşılaştırılarak kontrol edilir .

Pyth - 11 10 7 bayt

@Dennis sayesinde 1 bayt kaydedildi

@Thomas Kwa sayesinde 4 bayt kurtarıldı

eU.usNQ

Burada çevrimiçi deneyin .

Diziyi değiştirmeyi bırakana kadar toplamaya devam eder, bu sadece bir sayı anlamına gelir, tüm ara sonuçların kaydedilmesini sağlamak için kümülatif bir şekilde yapar ve listeyle aynı uzunlukta bir kroner yaparak ve son elemanı alarak uzunluğu alır.

Haskell, 43 bayt

'['#x=x-1
']'#x=x+1
_#x=x
maximum.scanr(#)0

Kullanım örneği: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"-> 5.

Haskell'de karışık listeler ( Integerkarışık List of Integer) yoktur, bu nedenle bazı liste algılama işlevlerinden yararlanamıyorum ve dizgeyi ayrıştırmam gerekiyor.

Sağdan başlayıp 0her ]birine 1 ekledim, her birine 1 çıkarın [ve değeri başka bir yerde saklayın. scanrtüm ara sonuçları tutar, bu yüzden maximumişe yarar.

JavaScript (ES6), 35 bayt

f=a=>a[0]?Math.max(...a.map(f))+1:0

açıklama

Bir dizinin maksimum derinliğini döndüren veya 0bir sayı geçtiğinde özyinelemeli işlev .

var solution =

f=a=>
  a[0]?                   // if a is an array
    Math.max(...a.map(f)) // return the maximum depth of each element in the array
    +1                    // add 1 to increase the depth
  :0                      // if a is a number, return 0

// Test cases
result.textContent =
`[1]                                                              -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7`
.split`\n`.map(t=>(c=t.split`->`.map(p=>p.trim()),c[0]+" == "+c[1]+": "+(solution(eval(c[0]))==c[1]?"Passed":"Failed"))).join`\n`

<input type="text" id="input" value="[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]" />
<button onclick="result.textContent=solution(eval(input.value))">Go</button>
<pre id="result"></pre>

MATL , 11 14 15 bayt

'}{'!=dYsX>

Kıvrımlı kaşlı ayraçlar MATL'de bu tür diziler için kullanılır. Neyse, girdi bir dizge olarak alınır ve işlenir, böylece köşeli parantezler eşit şekilde kullanılabilir ve koddaki iki karakter değiştirilir.

Çevrimiçi deneyin!

          % implicitly take input as a string (row array of chars)
'}{'!     % 2x1 (column) char array with the two curly brace symbols
=         % 2-row array. First / second row contains 1 where '}' / '{' is found
d         % second row minus first row
Ys        % cumulative sum of the array
X>        % maximum of the array
          % implicitly display result

Octave, 29 bayt

@(a)max(cumsum(92-(a(a>90))))

Harita [1 ve ]-1, kümülatif toplamının maksimum alır.

Giriş, formun bir dizesidir

S6 = '[1, [[3]], [5, 6], [[[[8]]]], 1]';

İdeone üzerinde örnek çalışması .

Julia, 55 26 bayt

f(a)=0a!=0&&maximum(f,a)+1

Bu, tür içeriğine sahip tek boyutlu bir diziyi kabul eden Anyve bir tamsayı döndüren özyinelemeli bir işlevdir . Fonksiyon için bir dizi geçerken, bütün parantez önüne Any, yani f(Any[1,Any[2,3]]).

Yaklaşım oldukça basittir. Bir giriş için a , biz çarpın bir 0 ve tarafından değil, bunu biliyoruz Eğer sonuç sayıl 0. olup olmadığını kontrol bir biz her elemana işlevini uygulamak, böylece bir dizidir bir , en fazla alıp 1 ekleyin.

Dennis sayesinde 29 byte kurtarıldı!

Ruby, 53 bayt

i=0;p gets.chars.map{|c|i+=('] ['.index(c)||1)-1}.max

STDIN'den giriş, STDOUT'ya çıkış.

i=0;                 initialize counter variable
p                    output to STDOUT...
gets                 get line of input
.chars               enumerator of each character in the input
.map{|c|             map each character to...
i+=                  increment i (and return the new value) by...
('] ['.index(c)||1)  returns 0 for ], 2 for [, 1 for anything else
-1                   now it's -1 for ], 1 for [, 0 for anything else
                     therefore: increment i on increase in nesting, decrement i
                       on decrease, do nothing otherwise
}.max                find the highest nesting level that we've seen

Jöle, 10 7 bayt

¬;/SпL

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

Nasıl çalışır

¬;/SпL  Main link. Input: A (list)

¬        Negate all integers in A. This replaces them with zeroes.
    п   Cumulative while loop.
   S       Condition: Compute the sum of all lists in A.
                      If the sum is an integer, it will be zero (hence falsy).
 ;/        Body:      Concatenate all lists in A.
      L  Count the number of iterations.

Güncelleştirme

Bu cevabı yazarken, Jelly'in düzensiz listeler için oldukça tuhaf davrandığını fark ettim, çünkü bir listenin derinliğini, öğelerinin asgari derinliklerinin artmış olarak hesapladım .

Bu en son sürümde ele alındığından, aşağıdaki kod ( 6 bayt ) şimdi çalışacaktı.

¬SSпL

Bu onları birleştirmek yerine dizinin satırlarını toplar.

Mathematica, 18 bayt

Max@#+1&//@(0#-1)&

Mathematica, 27 20 bayt

Max[#0/@#]+1&[0#]-1&

Basit özyinelemeli fonksiyon.

PHP, 61 bayt

function d($a){return is_array($a)?1+max(array_map(d,$a)):0;}

her öğeyi derinliği ile değiştirmek için kendisini bir eşleme işlevi olarak kullanan özyinelemeli işlev.

PHP, 84 72 64 63 60 bayt

Not: birleşik karşılaştırma operatörü için PHP 7 gerektirir. Ayrıca IBM-850 kodlamasını kullanır

for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;

Bu şekilde koş:

php -r 'for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;' "[1, [[3]], [5, 6], [[[[8]]]], 1]"

• Dize gösterimi için parantezleri sayarak 12 bayt kurtarıldı
• Dize karşılaştırmalarını basitleştirerek ve durumdaki karakterin sıra sayısını kullanarak 8 bayt kurtarıldı [ve]
• $iBir int için değil, bir bayt kaydedildi . Dize ofsetleri, dolaylı olarak bir int için kullanılır
• Sıra numarası yerine birleşik karşılaştırma işleci kullanılarak 3 bayt kaydedildi

C, 98 69 bayt

29 byte kapalı @DigitalTrauma !!

r,m;f(char*s){for(r=m=0;*s;r-=*s++==93)r+=*s==91,m=r>m?r:m;return m;}

Girdi olarak bir dize alır ve sonucu tamsayı olarak döndürür.

Canlı örnek: http://ideone.com/IC23Bc

Python 3, 42 39 bayt

Sp3000 sayesinde -3 bayt

Bu aslında xnor'ın Python 2 çözümünün bir limanıdır :

f=lambda l:"A"<str(l)and-~max(map(f,l))

Ne yazık ki, [] > {}bir unorderable typeshata döndürür , böylelikle xnor'ın zekice bir numarası kullanılamaz. Onun yerine -0123456789ASCII değerinde , dizgelerin karşılaştırılmasından Adaha düşük bir değere sahiptir [].

CJam (15 bayt)

q~{__e_-M*}h],(

Çevrimiçi demo

teşrih

q~      e# Read line and parse to array
{       e# Loop...
  _     e#   Leave a copy of the array on the stack to count it later
  _e_-  e#   Remove a flattened version of the array; this removes non-array elements from
        e#   the top-level array.
  M*    e#   Remove one level from each array directly in the top-level array
}h      e# ...until we get to an empty array
],(     e# Collect everything together, count and decrement to account for the extra []

Aynı uzunluk için, ama daha çirkin hack bölgelerinde daha fazla,

q'[,-{:~_}h],2-

Sed, 40 karakter

(39 karakter kod + 1 karakter komut satırı seçeneği.)

s/[^][]+//g
:;s/]\[//;t
s/]//g
s/\[/1/g

Giriş: string, output: unary sayı.

Örnek çalışma:

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;s/]//g;s/\[/1/g' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111

Sed, 33 karakter

(32 karakter kod + 1 karakter komut satırı seçeneği.)

Çıktıda izleyen boşluklara izin verilirse.

s/[^][]+//g
:;s/]\[//;t
y/[]/1 /

Giriş: string, output: unary sayı.

Örnek çalışma:

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;y/[]/1 /' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111      

Altıgen , 61 bayt

Düzenleme : Teşekkürler @Martin Ender ♦ müthiş -1 hile bana 1 byte kaydettiğin için!

|/'Z{>"-\..(.."/'&<'..{>-&,=+<$.{\$._{..><.Z=/...({=Z&"&@!-"

Test durumlarını doğrulamak için çevrimiçi deneyin!

Aşağıdaki resimler değiştirilmemiştir ancak akış temel olarak aynıdır. Ayrıca -1, giriş bir dizi değilse (yani, olmadan []) bunun döneceğini unutmayın .

Altıgen içinde çok fazla ameliyat yok ... Sanırım kesinlikle daha çok golf oynayabilir.

açıklama

Kısacası, -1a [ile karşılaştığında ve a ile 1karşılaştığında ekler ]. Sonunda, sahip olduğu maksimum değeri yazdırır.

Dize boyunca çalıştığında davranışını görmek için Test Durumu 5 boyunca çalışalım [1, [[3]], [5, 6], [[[[8]]]], 1]:

Başlangıçta başlar ve girişini W köşesine alır:

Hala girdi olduğundan (boş karakter \0veya EOL değil), yukarı doğru sarılır ve koyu kırmızı yolunu başlatır.

İşte oradan şirin olana kadar olan şey ><:

,okur [tampona ve {ve Z90 olmak için sürekli bir Z ayarlar 'Diff için hareket eder ve -bir fark hesaplar. Çünkü [ve ]fark sırasıyla 1ve 3olacaktır. Sayılar, boşluklar ve virgüller için negatif olacaktır.

Sonra çalıştırmak (almak için (kızıl yolu, yeşil yolda sarılmasının ardından başlangıcında birinin sonunda defa) iki kez -1ve 1için respin [ve ]. Burada adlandırma değiştirmek Diffiçin Value. Derinlik için bu değeri ekleyin. ( Z&Doğru komşuyu kopyaladığından emin olmak için kullanılır ). Sonra hesaplar lastMin - Depthve Hafıza kenarında bir sayı buluruz minLR.

Sonra &(yeşil yolun sonunda) aşağıdakilere uygulanır minLR: Sayı <= 0 ise, soldaki değeri (yani lastMin - Depth <= 0 => lastMin <= Depth) kopyalar , aksi takdirde doğru değeri alır.

Yatay mavi yola sararız ve Z&hangisini kopyaladığını tekrar görürüz minLR. Sonra biz "&hesaplanan min bir kopyasını yaptı. Parantezlerin dengeli olduğu varsayılmıştır, bu nedenle min <= 0 olmalıdır. Kaydırdıktan sonra, mavi yol sola ve vurularak (kopyayı 1asgari dakikadan daha az hale getirir . Yeniden kullandığınızda -, arabellek komşusu olarak bir 1-kopyalı kopya oluşturduk:

Not: copyolarak yeniden adlandırıldı1-off

Ne zaman mavi yol hit \ve güzel got "ve <yakalar geri ana döngü.

Ne zaman döngü hit 1, ,ya girdi olarak ya da diğer numaraları:

Diff negatif olacaktır ve bir sonraki giriş için ana döngüye geri yansır.

Her şey ana döngüden geçtiğinde, Tampon yapan EOL'ye ulaşırız -1ve sonunda alt kenara gider:

'MP taşır 1-off copyve )artışlarla bunu, ile ~reddi bunun ile basılır doğru Maksimum Derinlik değer var!

Ve hikaye bir ile biter @.

Sanırım işleri biraz daha karmaşık hale getirmeliyim. Artırma ve olumsuzlama olmadan yalnızca "geri taşı" ve "yazdır" yapmak zorunda kalsaydım, tam Hexagon'u kullanmadan 2 baytı iyi bir şekilde kurtarırdım.

Büyük teşekkür Timwi için Ezoterik IDE ve Hexagony Colorer !

brainfuck, 48 bayt

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

biçimlendirilmiş:

,
[
  <++[>-<------]>++
  [
    not close paren
    +
    [
      not open paren
      <
    ]
    >>[-]
  ]
  +<,
]
-[<[>+<-]>>]
<.

Gibi biçimlendirilmiş girişi alır (1, ((3)), (5, 6), ((((8)))), 1)ve bir bayt değeri çıkarır .

Çevrimiçi deneyin.

Bu, derinliği hafıza konumuna göre saklar, işaretçiyi sağa (ve sola hareket ettirir )ve diğer karakterleri yok sayar. Ziyaret edilen hücreler bir 1bayrakla işaretlenir, bu nedenle ana döngünün sonunda depth + 1mevcut hücrenin sağında bayraklar bulunur. Bunlar daha sonra nihai sonucu yazdırmak için eklenir.

Farklı bir yaklaşım kullanan önceki 69 baytlık bir çözüm:

,
[
  >>++[<<->>------]<-<++
  [
    not close paren
    >++<+
    [
      not open paren
      >-<[-]
    ]
  ]
  <
  [
    [>+>]
    <[<-<]
    >
  ]
  >>[<+> >+<-]
  ,
]
<.

Bu versiyonda, derinlik ve maksimum derinlik açıkça hücrelerde depolanır.

Pyth, 15 13 bayt

@Maltysen tarafından -2 bayt

eSm-F/Ld`Y._z

Kümülatif sayım arasındaki farkı sayar [ve ]maksimumu alır. Yboş dizidir ve dizgi temsili ( `) uygun şekildedir [].

Burada dene .

CJam, 19 22 23 bayt

0l{_91=\93=-+_}%:e>

MATL cevabıma benzer bir fikir.

Peter Taylor'a 3 byte'ı ayırdığı için teşekkürler

Burada dene

0                            push a 0
l                            read line as string
{            }%              map this block on the string
  _91=\93=-                  1 if it's an opening bracket, -1 if closing
           +_                cumulative sum
               :e>           fold maximum function

Perl 5, 34 bayt

32, artı iki -p

{s&]\[|[^][]&&g&&redo}$_=@a=/]/g

Dan Çalıntı Dijital Travma 'ın Retina cevap ... bundan daha% 26 daha kısadır.:-)

Veya eşit olarak:

{s&]\[|[^][]&&g&&redo}$_=y///c/2

Yakut, 51 karakter

(İçin iyileştirme öneri olarak başladı Doorknob 'ın Yakut cevap ama farklı şekilde sona erdi. Bu yüzden ayrı bir cevap olarak yayınlanmıştır. Derinlik sayma fikri (için upvotes ?\\<=>$&inen '] ['.index(c)) orijinal cevap gitmelidir.)

m=i=0
gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max}
p m

Giriş: string, output: sayı.

Örnek çalışma:

bash-4.3$ ruby -e 'm=i=0;gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max};p m' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
6

Perl 6, 53 bayt

Kapatma:

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}

Bir tartışma gerekiyor, örneğin:

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}("[[[3]][2]]")
3

Açıklama:

{ my ($m,$d);                 # start closure, declare variables    

  /                           # start regex match

   [                          # start (non-capturing) group

     \[ {$d++;$m=max $m,$d} | # match [ and track depth; OR

     \] {$d--}              | # match ] and track depth; OR

     .                        # match one character

   ]*                         # repeat group

  /;                          # end regex

  $m                          # return max depth
}

Minkolang 0.15 , 31 29 24 bayt

Luis Mendo'nun CJam'in cevabı üzerine ilham aldığım algoritmamı yeniledi ve 5 bayt kurtardı!

od5&j$ZN.d"["=$r"]"=~++d

Burada dene!

açıklama

Temel olarak, bu kodun yaptığı, her biri için +1 ve her biri [için -1 olan ], toplamda ulaşılan maksimum değeri izleyerek çalışan maksimum tutarı takip etmek. Döngü, Minkolang'ın kod kutusunun toroidal doğası ile ele alınır.

od           Take character from input and duplicate it (0 if input is empty)
  5&         Pop top of stack and skip the following five spaces if 0
    j$Z      Push the maximum value of the stack
       N.    Output as number and stop.

  d                  Duplicate top of stack for character tests
   "["=              +1 if the character is [
       $r            Swap top two items of stack
         "]"=~       -1 if the character is ]
              ++     Add twice
                d    Duplicate top of stack for the running total

Yakut, 41 karakter

f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}

Parametre: array, return: sayı.

Örnek çalışma:

2.1.5 :001 > f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}
 => #<Proc:0x0000000214d258@(irb):1 (lambda)> 

2.1.5 :002 > f[[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]]
 => 6 

Oracle SQL 11.2, 133 bayt

SELECT MAX(d)FROM(SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL)d FROM DUAL CONNECT BY LEVEL<=LENGTH(:1));

Un-golfed

SELECT MAX(d)
FROM   (
         SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL) d 
         FROM   DUAL 
         CONNECT BY LEVEL<=LENGTH(:1)
       );

CONNECT BY, giriş dizesinde karakter başına bir satır oluşturur.

SUBSTR, satır numarasına karşılık gelen karakteri izole eder.

DECODE, her '[' '1, her' '' '-1 ve diğer her karakter 0'a çevirir.

Analitik SUM, mevcut satır dahil önceki satırlardan her 1, -1 ve 0'ı toplar;

MAX toplamları derinliğidir.

Java 8, 95

Bu a için bir lambda ifadesidir ToIntFunction<String>. Giriş StringOP'nin örnekler formatında bir a olarak alınır .

s->{int d=e=-1;for(String t:s.split("[")){d=++e>d?e:d;e-=t.split("]",-1).length()-1;}return d;}

Oldukça düz. [Sınırlayıcı olarak kullanarak dizeyi bölün . Her biri için, sayacı arttırın eve sayıları ddaha büyük olacak şekilde sayaçla karşılaştırın d. Ardından, geçerli yinelemenin dizesini ]bu sefer sınırlayıcı olarak kullanarak ayırın ve fazladan bölme sayısını çıkarın e.