একটি বাইনারি গাছের গভীরতম নোডটি সন্ধান করুন

Question

একটি প্রোগ্রাম লিখুন যা বাইনারি গাছটিকে ইনপুট হিসাবে গ্রহণ করে এবং সবচেয়ে গভীর নোড এবং এর গভীরতা আউটপুট করে। যদি কোনও টাই থাকে তবে সমস্ত জড়িত নোডের পাশাপাশি তাদের গভীরতাও মুদ্রণ করুন। প্রতিটি নোড হিসাবে প্রতিনিধিত্ব করা হয়:

T(x,x)

T(x)

T

যেখানে Tএক বা একাধিক বর্ণানুক্রমিক অক্ষরের শনাক্তকারী এবং প্রত্যেকটিই xঅন্য নোড।

বাইনারি গাছের একটি সাধারণ সংজ্ঞা এখানে দেওয়া হয়েছে:

• বাইনারি গাছের মাথায় একটি নোড থাকে।
• বাইনারি গাছের একটি নোডে সর্বাধিক দুটি শিশু থাকে।

উদাহরণস্বরূপ, ইনপুট A(B(C,D(E)))(নীচে) আউটপুট হবে 3:E।

নিম্নলিখিত গাছটি 5, 11 এবং 4 এর মধ্যে একটি ত্রি-মুখী টাই এবং তাদের গভীরতাও 3 (0 থেকে শুরু):

ইনপুট 2(7(2,6(5,11)),5(9(4)))(নীচে) আউটপুট হবে 3:5,11,4।

এটি কোড গল্ফ, তাই বাইট জিতে পরিমাপ করা সংক্ষিপ্ততম কোড।

Comments

@ নিকট-ভোটার: আপনি কী সম্পর্কে অস্পষ্ট?

— জোভস্তি

সম্ভবত সত্য যে কোনও ইনপুট বা আউটপুট স্পেসিফিকেশন নেই, বা সেই ইনপুট এবং আউটপুটগুলির জন্য পরীক্ষার কেস।

— ডুরকনব

এটি ঠিক করার চেষ্টা করা হচ্ছে তবে আমার ফোনটি সাফল্য পেয়েছে ...: পি এটি তবে ভাল।

— জোস্টি

প্রথম গাছটি এ (বি (সি, ডি (ই)) হওয়া উচিত নয়?

— বেকেরগ

@ বাকেরগ ঠিক আছে, আমার ভুল সংশোধন করা হয়েছে।

— জোস্টি

Answer 1

সিজেম, 49 47

0q')/{'(/):U;,+:TW>{T:W];}*TW={U]',*}*T(}/;W':@

 

0                 " Push 0 ";
q                 " Read the whole input ";
')/               " Split the input by ')' ";
{                 " For each item ";
  '(/             " Split by '(' ";
  )               " Extract the last item of the array ";
  :U;             " Assign the result to U, and discard it ";
  ,               " Get the array length ";
  +               " Add the top two items of the stack, which are the array length and the number initialized to 0 ";
  :T              " Assign the result to T ";
  W>{             " If T>W, while W is always initialized to -1 ";
    T:W];         " Set T to W, and empty the stack ";
  }*
  TW={            " If T==W ";
    U]',*         " Push U and add a ',' between everything in the stack, if there were more than one ";
  }*
  T(              " Push T and decrease by one ";
}/
;                 " Discard the top item, which should be now -1 ";
W                 " Push W ";
':                " Push ':' ";
@                 " Rotate the 3rd item to the top ";

Comments

এটিকে সামঞ্জস্যপূর্ণ এবং কম দ্বিপাক্ষিক করার জন্য আমি আউটপুট ফর্ম্যাটটিতে সামান্য পরিবর্তন করেছি, তবে খুব বেশি অসুবিধে হওয়া উচিত নয়।

— জোস্টি

@ জোস্টি এটি কোড-গল্ফ না হলে এটি করা উচিত নয়।

— jimmy23013

ঠিক আছে, এটি কোড-গল্ফ ... তবে যাইহোক, চমৎকার

— জমাটি

আপনি কিভাবে দয়া করে ব্যাখ্যা করতে পারেন?

— জেরি যেরেমিয়া

@ জেরি জেরেমিয়া সম্পাদিত।

— জিমি 23013

Answer 2

হাস্কেল, 186 বাইট

p@(n,s)%(c:z)=maybe((n,s++[c])%z)(\i->p:(n+i,"")%z)$lookup c$zip"),("[-1..1];p%_=[p]
(n,w)&(i,s)|i>n=(i,show i++':':s)|i==n=(n,w++',':s);p&_=p
main=interact$snd.foldl(&)(0,"").((0,"")%)

সম্পূর্ণ প্রোগ্রাম, গাছে stdinতোলে, নির্দিষ্ট আউটপুট ফর্ম্যাট এ উত্পাদন করে stdout:

& echo '2(7(2,6(5,11)),5(9(4)))' | runhaskell 32557-Deepest.hs 
3:5,11,4

& echo 'A(B(C,D(E)))' | runhaskell 32557-Deepest.hs 
3:E

গল্ফের কোডের জন্য গাইড (আরও ভাল নাম যুক্ত করুন, স্বাক্ষরগুলি লিখুন, মন্তব্যগুলি দিন এবং কিছু সূক্ষ্ম এক্সপ্রেশনগুলি টেনে এনে নামকরণ করা হয়েছে - তবে অন্যথায় একই কোড; একটি অজলফ সংস্করণ সংখ্যার সাথে নোডে বিভক্ত হওয়া বা আরও গভীর খুঁজে পাওয়া যাবে না) আউটপুট বিন্যাস সহ।) :

type Label = String         -- the label on a node
type Node = (Int, Label)    -- the depth of a node, and its label

-- | Break a string into nodes, counting the depth as we go
number :: Node -> String -> [Node]
number node@(n, label) (c:cs) =
    maybe addCharToNode startNewNode $ lookup c adjustTable
  where
    addCharToNode = number (n, label ++ [c]) cs
        -- ^ append current character onto label, and keep numbering rest

    startNewNode adjust = node : number (n + adjust, "") cs
        -- ^ return current node, and the number the rest, adjusting the depth

    adjustTable = zip "),(" [-1..1]
        -- ^ map characters that end node labels onto depth adjustments
        -- Equivalent to [ (')',-1), (',',0), ('(',1) ]

number node _ = [node]      -- default case when there is no more input

-- | Accumulate into the set of deepest nodes, building the formatted output
deepest :: (Int, String) -> Node -> (Int, String)
deepest (m, output) (n, label)
    | n > m     = (n, show n ++ ':' : label)    -- n is deeper tham what we have
    | n == m    = (m, output ++ ',' : label)    -- n is as deep, so add on label
deepest best _ = best                           -- otherwise, not as deep

main' :: IO ()
main' = interact $ getOutput . findDeepest . numberNodes
  where
    numberNodes :: String -> [Node]
    numberNodes = number (0, "")

    findDeepest :: [Node] -> (Int, String)
    findDeepest = foldl deepest (0, "")

    getOutput :: (Int, String) -> String
    getOutput = snd

Comments

এই কোডটি আমাকে আতঙ্কিত করে।

— seequ

বিস্তৃত বর্ণনামূলক কোড যুক্ত হয়েছে! সন্ত্রাস আপনাকে আরও শক্তিশালী করে তুলুক !!

— এমটিএনভিউমার্ক

আপনি এটির জন্য একটি +1 প্রাপ্য।

— দেখুন

ওহে আমার godশ্বর, এবং আমি তালিকার সাথে লড়াই করছি: পি

— আর্টুর ট্রাপ

Answer 3

গল্ফস্ক্রিপ্ট (75 টি অক্ষর)

বিশেষভাবে প্রতিযোগিতামূলক নয়, তবে এটির কিছুটা আগ্রহ রয়েছে তা যথেষ্ট পরিমাণে মোচড় দিয়েছে:

{.48<{"'^"\39}*}%','-)](+0.{;.@.@>-\}:^;@:Z~{2$2$={@@.}*;}:^;Z~\-])':'@','*

কোডটির তিনটি পর্যায় রয়েছে। প্রথমত আমরা ইনপুট স্ট্রিংটি প্রিপ্রোসেস করি:

# In regex terms, this is s/([ -\/])/'^\1'/g
{.48<{"'^"\39}*}%
# Remove all commas
','-
# Rotate the ' which was added after the closing ) to the start
)](+

আমরা যেমন রুপান্তরিত করে থাকেন A(B(C,D(E)))করতে 'A'^('B'^('C'^'D'^('E'^)''^)''^)। যদি আমরা একটি উপযুক্ত ব্লক বরাদ্দ করি তবে আমরা স্ট্রিংটি ^ব্যবহার করে দরকারী প্রক্রিয়াজাতকরণ করতে পারি ~।

দ্বিতীয়ত, আমরা সর্বাধিক গভীরতা খুঁজে পাই:

0.
# The block we assign to ^ assumes that the stack is
#   max-depth current-depth string
# It discards the string and updates max-depth
{;.@.@>-\}:^;
@:Z~

শেষ পর্যন্ত আমরা গভীর নোডগুলি নির্বাচন করি এবং আউটপুট তৈরি করি:

# The block we assign to ^ assumes that the stack is
#   max-depth current-depth string
# If max-depth == current-depth it pushes the string under them on the stack
# Otherwise it discards the string
{2$2$={@@.}*;}:^;
# Eval
Z~
# The stack now contains
#   value1 ... valuen max-depth 0
# Get a positive value for the depth, collect everything into an array, and pop the depth
\-])
# Final rearranging for the desired output
':'@','*

Answer 4

পার্ল 5 - 85

^{অক্ষর গণনা সংশোধন করতে দয়া করে এই পোস্টটি সম্পাদনা করতে নির্দ্বিধায়। আমি sayবৈশিষ্ট্যটি ব্যবহার করি তবে পতাকাগুলি সঠিকভাবে চালিত করার জন্য পতাকাগুলি সম্পর্কে আমি জানি না use 5.010;।}

$_=$t=<>,$i=0;$t=$_,$i++while s/\w+(\((?R)(,(?R))?\))?/$1/g,/\w/;@x=$t=~/\w+/gs;say"$i:@x"

আইডিয়োনে ডেমো

আউটপুটটি কমা-বিচ্ছিন্নের পরিবর্তে স্থান-পৃথক।

কোডটি কেবল বনের গাছের গোড়া মুছে ফেলার জন্য পুনরাবৃত্তিকারী রেজেক্স ব্যবহার করে, যতক্ষণ না এটি করা সম্ভব না হয়। তারপরে শেষের স্ট্রিংটিতে গভীর স্তরের সমস্ত পাতাগুলি থাকবে।

নমুনা রান

2
0:2

2(3(4(5)),6(7))
3:5

2(7(2,6(5,11)),5(9(4)))
3:5 11 4

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

Answer 5

VB.net

Function FindDeepest(t$) As String
  Dim f As New List(Of String)
  Dim m = 0
  Dim d = 0
  Dim x = ""
  For Each c In t
    Select Case c
      Case ","
        If d = m Then f.Add(x)
        x = ""
      Case "("
        d += 1
        If d > m Then f.Clear() :
        m = d
        x = ""
      Case ")"
        If d = m Then f.Add(x) : x = ""
        d -= 1
      Case Else
        x += c
    End Select
  Next
  Return m & ":" & String.Join(",", f)
End Function

আসাম্প্শান: নোড মানগুলি থাকতে পারে না ,, (,)

Comments

এটি মোটেও গল্ফড বলে মনে হচ্ছে না। আপনি কি বেশিরভাগ শ্বেতস্পেসটি মুছতে পারবেন না (আমি ভিবি জানি না)?

— seequ

কিছু সাদা জায়গা নির্ভর করে তা উল্লেখযোগ্য।

— অ্যাডাম স্পাইট

Answer 6

জাভাস্ক্রিপ্ট (E6) 120

Iterative সংস্করণ

m=d=0,n=[''];
prompt().split(/,|(\(|\))/).map(e=>e&&(e=='('?m<++d&&(n[m=d]=''):e==')'?d--:n[d]+=' '+e));
alert(m+':'+n[m])

অসম্পূর্ণ এবং পরীক্ষামূলক

F= a=> (
    m=d=0,n=[''],
    a.split(/,|(\(|\))/)
    .map(e=>e && (e=='(' ? m < ++d && (n[m=d]='') : e==')' ? d-- : n[d]+=' '+e)),
    m+':'+n[m]
)

টেস্ট ফায়ারফক্স কনসোল:

['A', '2(7(2,6(5,11)),5(9(4)))', 'A(B(C,D(E)))']
.map(x => x + ' --> ' + F(x)).join('\n')

আউটপুট

"এ -> 0: এ

2 (7 (2,6 (5,11)), 5 (9 (4))) -> 3: 5 11 4

এ (বি (সি, ডি (ই))) -> 3: ই "