İkili bir ağacın yüksekliği, kök düğümden kök çocuğuna kökten en uzak olan mesafedir.

Aşağıda bir örnek verilmiştir:

           2 <-- root: Height 1
          / \
         7   5 <-- Height 2
        / \   \
       2   6   9 <-- Height 3
          / \  /
         5  11 4 <-- Height 4 

İkili ağacın yüksekliği: 4

İkili Ağacın Tanımı

Ağaç, işaretli bir tam sayı değeri ve bunlara iki ağaç veya işaretçi içeren bir nesnedir.

İkili ağaç yapısının yapısı aşağıdaki gibi görünür:

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

Meydan okuma:

Giriş

İkili ağacın kökü

Çıktı

İkili bir ağacın yüksekliğini temsil eden sayı

Girdi olarak bir ikili ağacın kökü verildiğini varsayarsak, bir ikili ağacın yüksekliğini hesaplayan ve yüksekliği döndüren en kısa programı yazın. En az bayt (muhasebe boşlukları) olan program kazanır.

Jöle , 3 bayt

ŒḊ’

Ağacı temsil eden bir listeyi kabul eden monadik bir Bağlantı: [root_value, left_tree, right_tree]burada her biri left_treeve right_treebenzer yapılardır (gerekirse boştur), bu da yüksekliği verir.

Çevrimiçi deneyin!

Nasıl?

Jelly'de oldukça önemsiz:

ŒḊ’ - Link: list, as described above
ŒḊ  - depth
  ’ - decremented (since leaves are `[value, [], []]`)

Python 2 ,  35  33 bayt

Arnauld'a bir gözetim ve tasarruf sağladığı için teşekkür ederiz 4.

f=lambda a:a>[]and-~max(map(f,a))

Ağacı temsil eden bir listeyi kabul eden özyinelemeli işlev: [root_value, left_tree, right_tree]burada her biri left_treeve right_treebenzer yapılardır (gerekirse boştur), yüksekliği döndürür.

Çevrimiçi deneyin!

^{[]Geri döneceğini unutmayın False, ancak Python False==0.}

Haskell, 33 bayt

h L=0 
h(N l r _)=1+max(h l)(h r)

data T = L | N T T IntMeydan okumada verilen C yapısının Haskell eşdeğeri olan özel ağaç türünü kullanarak .

Çevrimiçi deneyin!

Perl 6 , 25 bayt

{($_,{.[*;*]}...*eqv*)-2}

Giriş 3 elemanlı bir listedir (l, r, v) . Boş ağaç boş listedir.

Çevrimiçi deneyin!

açıklama

{                       }  # Anonymous block
    ,        ...  # Sequence constructor
  $_  # Start with input
     {.[*;*]}  # Compute next element by flattening one level
               # Sadly *[*;*] doesn't work for some reason
                *eqv*  # Until elements doesn't change
 (                   )-2  # Size of sequence minus 2

Eski çözüm, 30 bayt

{+$_&&1+max map &?BLOCK,.[^2]}

Çevrimiçi deneyin!

05AB1E , 11 7 5 bayt

Δ€`}N

@ExpiredData sayesinde -4 bayt . @Grimy
sayesinde -2 bayt .

Ağaç temsil eden bir listesi: Girdi biçimi jöle yanıt olarak benzer olan [root_value, left_tree, right_tree], her biri burada left_treeve right_treebenzeri yapılardır (isteğe bağlı olarak boş). yani[2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]] meydan okuma açıklamasındaki ağacı temsil eder.

Çevrimiçi deneyin veya birkaç test vakasını doğrulayın .

Açıklama:

Δ     # Loop until the (implicit) input-list no longer changes:
  €`  #  Flatten the list one level
}N    # After the loop: push the 0-based index of the loop we just finished
      # (which is output implicitly as result)

05AB1E 0 tabanlı olmasına rağmen, change-loop'un Δçıktı dizininin doğru olmasına neden olduğundan, artık değişmediğini kontrol etmek için ek bir yinelemeye ihtiyaç duyduğunu unutmayın.

JavaScript (ES6),  35  33 bayt

Giriş yapısı: [[left_node], [right_node], value]

f=([a,b])=>a?1+f(f(a)>f(b)?a:b):0

Çevrimiçi deneyin!

Yorumlananlar

f =                       // f is a recursive function taking
([a, b]) =>               // a node of the tree split into
                          // a[] = left child, b[] = right child (the value is ignored)
  a ?                     // if a[] is defined:
    1 +                   //   increment the final result for this branch
    f(                    //   and add:
      f(a) > f(b) ? a : b //     f(a) if f(a) > f(b) or f(b) otherwise
    )                     //
  :                       // else:
    0                     //   stop recursion and return 0

C, 43 bayt

h(T*r){r=r?1+(int)fmax(h(r->l),h(r->r)):0;}

İkili ağacın yapısı aşağıdaki gibidir:

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

JavaScript (Node.js) , 32 bayt

f=a=>/,,/.test(a)&&f(a.flat())+1

Çevrimiçi deneyin!

Veya flatyerine adı kullanmak kod golf için harika bir fikirdir.flattensmoosh

Kullanılması []ağacında boş düğüm için ve [left, right, value]düğümleri için. valueİşte bir tamsayı.

Wolfram Dili (Mathematica) , 10 bayt

Depth@#-2&

Çevrimiçi deneyin! Girişi iç içe bir liste olarak alır {v, l, r}.

Haskell, 28 bayt

Aşağıdaki veri tanımını kullanarak:

data T a = (:&) a [T a]

Yükseklik:

h(_:&x)=foldr(max.succ.h)0 x

Şema, 72 Bayt

(define(f h)(if(null? h)0(+ 1(max(f(car(cdr h)))(f(car(cdr(cdr h))))))))

Daha Okunabilir Sürüm:

(define (f h)
   (if (null? h)
      0
      (+ 1 
         (max
             (f (car (cdr h)))
             (f (car (cdr (cdr h))))
         )
      )
   )
)

Bir ağacı temsil etmek için form listelerini (veri, sol, sağ) kullanma. Örneğin

   1
  / \
  2  3
 /\
 4 5

is represented as: (1 (2 (4 () ()) (5 () ())) (3 () ())

(1
   (2
      (4 () ())
```   (5 () ())
   (3 () ())
)

Çevrimiçi deneyin!

R , 51 bayt

function(L){while(is.list(L<-unlist(L,F)))T=T+1;+T}

Çevrimiçi deneyin!

• Girdi: biçiminde iç içe bir liste:list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

• Algoritma: Ağacı düz bir vektör haline gelene kadar tek bir düzeye kadar düz olarak düzleştirir: yineleme sayısı maksimum derinliğe karşılık gelir.

@KevinCruijssen çözümünden ilham alındı

Özyinelemeli alternatif:

R , 64 bayt

`~`=function(L,d=0)'if'(is.list(L),max(L[[2]]~d+1,L[[3]]~d+1),d)

Çevrimiçi deneyin!

'~'Bir liste yapısında depolanan bir ağacın maksimum derinliğini hesaplayabilmesini sağlayan işlevi / operatörü yeniden tanımlar.

Bir ağacın liste yapısı şu biçimdedir: list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

• @Giuseppe sayesinde -2

Japt , 8 bayt

@eU=c1}a

Dene

Orijinal, 9 bayt

Ω¡ÒßXÃrw

Dene

K (ngn / k) , 4 bayt

Çözüm:

#,/\

Çevrimiçi deneyin!

Açıklama:

Bence bu noktayı kaçırmış olabilirim.

Bir ağacı 3 öğeli liste olarak temsil eden (ebeveyn-düğüm; sol-çocuk; sağ-çocuk), örnek şu şekilde temsil edilebilir:

(2;
  (7;
    (,2);
    (6;
      (,5);
      (,11)
    )
  );
  (5;
    ();
    (9;
      (,4);
      ()
    )
  )
)

veya: (2;(7;(,2);(6;(,5);(,11)));(5;();(9;(,4);()))).

Dolayısıyla çözüm yinelemeli olarak düzleştirmek ve yinelemeleri saymaktır:

#,/\ / the solution
   \ / iterate
 ,/  / flatten
#    / count

Kömür , 29 bayt

⊞θ⁰⊞υθＦυ«≔⊕⊟ιθＦΦι∧κλ⊞υ⊞Ｏκθ»Ｉθ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. İşleme sırasında ağacı geçici olarak değiştirir. Açıklama:

⊞θ⁰

Kök düğüme sıfır basın.

⊞υθ

Kök düğümü tüm düğümlerin listesine itin.

Ｆυ«

Ağacın ilk genişlik aramasını yapın.

≔⊕⊟ιθ

Bu düğümün derinliğini alın.

ＦΦι∧κλ

Alt düğümlerin üzerinden döngü yapın.

⊞υ⊞Ｏκθ

Alt düğüme ebeveyninin derinliğini söyleyin ve tüm düğümlerin listesine itin.

»Ｉθ

Tüm düğümler geçildikten sonra son düğümün derinliğini yazdırın. Geçiş ilk önce genişlik olduğundan, bu ağacın yüksekliği olacaktır.

Stax , 5 bayt

▐▌µ╡⌂

Çalıştır ve hata ayıkla

Stax ne işaretçiler ne de null değerlere sahiptir, bu nedenle [2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]] . Belki bu haksız bir avantajdır, ancak alabileceğim en yakın şeydi.

Paketten çıkarılmış, çözülmemiş ve yorum yapılmıştır, kod şöyle görünür.

        The input starts on top of the input stack
Z       Tuck a zero underneath the top value in the stack.  Both values end up on the main stack.
D       Drop the first element from array
F       For each remaining element (the leaves) run the rest of the program
  G^    Recursively call the entire program, then increment
  T     Get maximum of the two numbers now ow the stack

Bunu çalıştır

Kotlin, 45 bayt

val Tree.h:Int get()=1+maxOf(l?.h?:0,r?.h?:0)

Aşağıdaki sınıfın tanımlandığı varsayılarak

class Tree(var v: Int, var l: Tree? = null, var r: Tree? = null)

Çevrimiçi deneyin

Julia, 27 bayt

f(t)=t≢()&&maximum(f,t.c)+1

İkili ağacı temsil eden aşağıdaki yapı ile:

struct Tree
    c::NTuple{2,Union{Tree,Tuple{}}}
    v::Int
end

csol ve sağ düğümleri temsil eden bir demet olup boş demet ()bir düğümün olmadığını belirtmek için kullanılır.

Kotlin , 42 bayt

fun N.c():Int=maxOf(l?.c()?:0,r?.c()?:0)+1

Çevrimiçi deneyin!

Nerede

data class N(val l: N? = null, val r: N? = null, val v: Int = 0)