{"id":726,"date":"2025-07-21T16:50:02","date_gmt":"2025-07-21T11:20:02","guid":{"rendered":"https:\/\/codeanddebug.in\/blog\/?p=726"},"modified":"2025-07-21T16:50:04","modified_gmt":"2025-07-21T11:20:04","slug":"check-if-there-exists-a-subsequence-with-sum-k","status":"publish","type":"post","link":"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/","title":{"rendered":"Check if there exists a subsequence with sum = K | Backtracking Solution in Python"},"content":{"rendered":"\n<p>Hey students! If you&#8217;re exploring&nbsp;recursion and&nbsp;backtracking, this&nbsp;problem is a&nbsp;great follow-up to subsets&nbsp;or subsequences. It&#8217;s&nbsp;like the &#8220;Subsets with&nbsp;Sum K&#8221; but simpler, instead of&nbsp;finding all, we&nbsp;just check if&nbsp;at least one&nbsp;exists. <\/p>\n\n\n\n<p>We&#8217;ll&nbsp;use backtracking to&nbsp;explore possibilities, and I&#8217;ll explain&nbsp;it in easy terms&nbsp;so you can grasp&nbsp;how it works. Remember, this&nbsp;is for learning&nbsp;recursion, so&nbsp;we&#8217;ll focus on&nbsp;the concept even&nbsp;if it&#8217;s not the&nbsp;fastest way.<\/p>\n\n\n\n<p>Here&#8217;s the [<strong><a href=\"https:\/\/www.geeksforgeeks.org\/problems\/check-if-there-exists-a-subsequence-with-sum-k\/0\" target=\"_blank\" rel=\"noreferrer noopener\"><mark style=\"background-color:rgba(0, 0, 0, 0)\" class=\"has-inline-color has-vivid-purple-color\"><span style=\"text-decoration: underline;\">Problem Link<\/span><\/mark><\/a><\/strong>] to begin with.<\/p>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<p>Given an array&nbsp;<strong>arr&nbsp;<\/strong>and&nbsp;<code>target sum&nbsp;<strong>k<\/strong><\/code>,&nbsp;check whether&nbsp;there exists a subsequence&nbsp;such that the sum of all elements in the subsequence equals the given&nbsp;<code>target sum(k).<\/code><\/p>\n\n\n\n<p><br><strong>Example:<\/strong><\/p>\n\n\n\n<pre class=\"wp-block-preformatted\"><strong>Input: <\/strong> arr = [10,1,2,7,6,1,5], k = 8.\n<strong>Output: <\/strong> Yes\n<strong>Explanation: <\/strong> Subsequences like [2, 6], [1, 7] sum upto 8\n\n<strong>Input: <\/strong> arr = [2,3,5,7,9], k = 100. \n<strong>Output: <\/strong> No\n<strong>Explanation: <\/strong> No subsequence can sum upto 100<\/pre>\n\n\n\n<p><strong>Your Task:<\/strong><br>You don&#8217;t need to read or print anything. Your task is to complete the boolean function&nbsp;<strong>checkSubsequenceSum()<\/strong>&nbsp;which takes N, arr and K as input parameter and returns true\/false based on the whether any subsequence with sum K could be found.<\/p>\n\n\n\n<p><strong>Expected Time Complexity:<\/strong>&nbsp;O(N * K).<br><strong>Expected Auxiliary Space:<\/strong>&nbsp;O(N * K).<\/p>\n\n\n\n<p><strong>Constraints:<\/strong><br>1 &lt;= arr.length &lt;= 2000.<br>1 &lt;= arr[i] &lt;= 1000.<br>1 &lt;= target &lt;= 2000.<\/p>\n\n\n<div style=\"max-width: -moz-fit-content; \" class=\"wp-block-ub-table-of-contents-block ub_table-of-contents ub_table-of-contents-collapsed\" id=\"ub_table-of-contents-8dff2a02-aa92-4f4e-b864-1bb97fa3cba3\" data-linktodivider=\"false\" data-showtext=\"show\" data-hidetext=\"hide\" data-scrolltype=\"auto\" data-enablesmoothscroll=\"true\" data-initiallyhideonmobile=\"true\" data-initiallyshow=\"false\"><div class=\"ub_table-of-contents-header-container\" style=\"\">\n\t\t\t<div class=\"ub_table-of-contents-header\" style=\"text-align: left; \">\n\t\t\t\t<div class=\"ub_table-of-contents-title\">Contents:<\/div>\n\t\t\t\t<div class=\"ub_table-of-contents-header-toggle\">\n\t\t\t<div class=\"ub_table-of-contents-toggle\" style=\"\">\n\t\t\t\u00a0[<a class=\"ub_table-of-contents-toggle-link\" href=\"#\" style=\"\">show<\/a>]\n\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t<\/div>\n\t\t<\/div><div class=\"ub_table-of-contents-extra-container\" style=\"\">\n\t\t\t<div class=\"ub_table-of-contents-container ub_table-of-contents-1-column ub-hide\">\n\t\t\t\t<ul style=\"\"><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#0-solution-backtracking-approach\" style=\"\">Solution: Backtracking Approach<\/a><ul><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#1-intuition\" style=\"\">Intuition<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#2-detailed-approach\" style=\"\">Detailed Approach<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#3-code\" style=\"\">Code<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#4-code-explanation\" style=\"\">Code Explanation<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#5-time-and-space-complexity\" style=\"\">Time and Space Complexity<\/a><\/li><\/ul><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/check-if-there-exists-a-subsequence-with-sum-k\/#6-simplifying-it\" style=\"\">Simplifying It<\/a><\/li><\/ul>\n\t\t\t<\/div>\n\t\t<\/div><\/div>\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"0-solution-backtracking-approach\">Solution: Backtracking Approach<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"1-intuition\">Intuition<\/h3>\n\n\n\n<p>Backtracking is all about trying choices and undoing them if they don&#8217;t work. Here, for each element in the array, we have two options: include it in our current sum or skip it. We start from the first element, try including it (add to sum, move to next), check if we hit K, and if not, backtrack (remove it from sum) and try skipping. It&#8217;s like searching for a path in a maze where each step is &#8220;pick&#8221; or &#8220;not pick,&#8221; and we stop as soon as we find a path that sums to K.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"2-detailed-approach\">Detailed Approach<\/h3>\n\n\n\n<ol class=\"wp-block-list\">\n<li><strong>Recursive Function<\/strong>: Use a helper&nbsp;<code>backtrack<\/code>&nbsp;that takes the current subset (for tracking), index, and current total sum.<\/li>\n\n\n\n<li><strong>Base Cases<\/strong>:\n<ul class=\"wp-block-list\">\n<li>If total == K, we&#8217;ve found a valid subsequence &#8211; return True.<\/li>\n\n\n\n<li>If index &gt;= N, we&#8217;ve checked all elements without hitting K &#8211; return False.<\/li>\n<\/ul>\n<\/li>\n\n\n\n<li><strong>Include Choice<\/strong>: Add the current element to the subset and sum, recurse to the next index. If this path returns True, we&#8217;re done.<\/li>\n\n\n\n<li><strong>Backtrack<\/strong>: Remove the element from the subset (pop) to undo.<\/li>\n\n\n\n<li><strong>Exclude Choice<\/strong>: Recurse to the next index without adding to sum.<\/li>\n\n\n\n<li><strong>Start Recursion<\/strong>: Call with empty subset, index 0, total 0.<\/li>\n\n\n\n<li><strong>Return Result<\/strong>: If any path returns True, yes (1); else no (0).<\/li>\n<\/ol>\n\n\n\n<p>This explores the decision tree until it finds one valid subsequence or exhausts all options.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"3-code\">Code<\/h3>\n\n\n\n<div class=\"wp-block-kevinbatdorf-code-block-pro padding-bottom-disabled cbp-has-line-numbers\" data-code-block-pro-font-family=\"Code-Pro-JetBrains-Mono\" style=\"font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;--cbp-line-number-color:#D4D4D4;--cbp-line-number-width:calc(2 * 0.6 * .875rem);line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)\"><span style=\"display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#1E1E1E\"><svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"54\" height=\"14\" viewBox=\"0 0 54 14\"><g fill=\"none\" fill-rule=\"evenodd\" transform=\"translate(1 1)\"><circle cx=\"6\" cy=\"6\" r=\"6\" fill=\"#FF5F56\" stroke=\"#E0443E\" stroke-width=\".5\"><\/circle><circle cx=\"26\" cy=\"6\" r=\"6\" fill=\"#FFBD2E\" stroke=\"#DEA123\" stroke-width=\".5\"><\/circle><circle cx=\"46\" cy=\"6\" r=\"6\" fill=\"#27C93F\" stroke=\"#1AAB29\" stroke-width=\".5\"><\/circle><\/g><\/svg><\/span><span role=\"button\" tabindex=\"0\" data-code=\"class Solution:\n    def backtrack(self, subset, index, total):\n        if total == K:\n            # result.append(subset.copy())  # Uncomment if you want to collect the subset\n            return True\n        if index &gt;= N:\n            return False\n        \n        subset.append(arr[index])\n        pick = self.backtrack(subset, index + 1, total + arr[index])\n        if pick == True:\n            return True\n        \n        e = subset.pop()\n        # No need for Sum -= e; just pass total for not pick\n        return self.backtrack(subset, index + 1, total)\n    \n    def checkSubsequenceSum(self, N, arr, K):\n        return self.backtrack([], 0, 0)\" style=\"color:#D4D4D4;display:none\" aria-label=\"Copy\" class=\"code-block-pro-copy-button\"><svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" style=\"width:24px;height:24px\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" stroke-width=\"2\"><path class=\"with-check\" stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4\"><\/path><path class=\"without-check\" stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2\"><\/path><\/svg><\/span><pre class=\"shiki dark-plus\" style=\"background-color: #1E1E1E\" tabindex=\"0\"><code><span class=\"line\"><span style=\"color: #569CD6\">class<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #4EC9B0\">Solution<\/span><span style=\"color: #D4D4D4\">:<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">    <\/span><span style=\"color: #569CD6\">def<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #DCDCAA\">backtrack<\/span><span style=\"color: #D4D4D4\">(<\/span><span style=\"color: #9CDCFE\">self<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">subset<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">index<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">total<\/span><span style=\"color: #D4D4D4\">):<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">if<\/span><span style=\"color: #D4D4D4\"> total == K:<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">            <\/span><span style=\"color: #6A9955\"># result.append(subset.copy())  # Uncomment if you want to collect the subset<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">            <\/span><span style=\"color: #C586C0\">return<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #569CD6\">True<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">if<\/span><span style=\"color: #D4D4D4\"> index &gt;= N:<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">            <\/span><span style=\"color: #C586C0\">return<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #569CD6\">False<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        subset.append(arr[index])<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        pick = <\/span><span style=\"color: #569CD6\">self<\/span><span style=\"color: #D4D4D4\">.backtrack(subset, index + <\/span><span style=\"color: #B5CEA8\">1<\/span><span style=\"color: #D4D4D4\">, total + arr[index])<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">if<\/span><span style=\"color: #D4D4D4\"> pick == <\/span><span style=\"color: #569CD6\">True<\/span><span style=\"color: #D4D4D4\">:<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">            <\/span><span style=\"color: #C586C0\">return<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #569CD6\">True<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        e = subset.pop()<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #6A9955\"># No need for Sum -= e; just pass total for not pick<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">return<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #569CD6\">self<\/span><span style=\"color: #D4D4D4\">.backtrack(subset, index + <\/span><span style=\"color: #B5CEA8\">1<\/span><span style=\"color: #D4D4D4\">, total)<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">    <\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">    <\/span><span style=\"color: #569CD6\">def<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #DCDCAA\">checkSubsequenceSum<\/span><span style=\"color: #D4D4D4\">(<\/span><span style=\"color: #9CDCFE\">self<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">N<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">arr<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">K<\/span><span style=\"color: #D4D4D4\">):<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">return<\/span><span style=\"color: #D4D4D4\"> <\/span><span style=\"color: #569CD6\">self<\/span><span style=\"color: #D4D4D4\">.backtrack([], <\/span><span style=\"color: #B5CEA8\">0<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #B5CEA8\">0<\/span><span style=\"color: #D4D4D4\">)<\/span><\/span><\/code><\/pre><span style=\"display:flex;align-items:flex-end;padding:10px;width:100%;justify-content:flex-end;background-color:#1E1E1E;color:#c7c7c7;font-size:12px;line-height:1;position:relative\">Python<\/span><\/div>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"4-code-explanation\">Code Explanation<\/h3>\n\n\n\n<p>The&nbsp;<code>backtrack<\/code>&nbsp;function builds a subset while tracking the sum. It first checks if the current sum equals K (success!). If not, and we&#8217;re past the array, it&#8217;s a failure. We try including the current element (append to subset, add to total, recurse). If that path finds a match (pick == True), return True early. Otherwise, undo (pop) and try excluding (recurse without changing total). The function returns True if any path succeeds, else False. In&nbsp;<code>checkSubsequenceSum<\/code>, we start the process and return the boolean (can be converted to 1\/0 if needed).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"5-time-and-space-complexity\">Time and Space Complexity<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Time Complexity:<\/strong>&nbsp;O(2^N) &#8211; We explore up to 2^N paths in the worst case (each element picked or not).<\/li>\n\n\n\n<li><strong>Space Complexity:<\/strong>&nbsp;O(N) &#8211; Recursion stack depth up to N, plus subset space.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"6-simplifying-it\">Simplifying It<\/h2>\n\n\n\n<p>Backtracking is your &#8220;try everything&#8221; tool for choice-based problems. It&#8217;s like shopping with a budget: for each item, decide &#8220;buy&#8221; (add to cart\/sum) or &#8220;skip.&#8221; If your cart totals K, success! If not, remove the last item (backtrack) and try without it. We stop early when we find one (no need to check all if we just want existence). It&#8217;s intuitive and builds on subset generation, but remember to backtrack to avoid wrong states.<\/p>\n\n\n\n<p><strong><mark style=\"background-color:rgba(0, 0, 0, 0)\" class=\"has-inline-color has-vivid-purple-color\"><em>Note:&nbsp;This backtracking approach may cause TLE (Time Limit Exceeded) on large test cases (e.g., N up to 40), which is perfectly fine as we&#8217;re focusing on learning recursion. For optimization, we could add pruning (e.g., if total &gt; K and positives only, skip) or use DP for efficiency, but that&#8217;s for later lessons!<\/em><\/mark><\/strong><\/p>\n\n\n\n<p>Practice by drawing the recursion tree, it&#8217;ll help visualize the choices. If you have questions, drop them below. Happy coding! \ud83d\ude80<\/p>\n\n\n\n<div class=\"wp-block-buttons is-content-justification-center is-layout-flex wp-container-core-buttons-is-layout-16018d1d wp-block-buttons-is-layout-flex\">\n<div class=\"wp-block-button\"><a class=\"wp-block-button__link wp-element-button\" href=\"https:\/\/codeanddebug.in\/course\/zero-to-hero-python-dsa\" target=\"_blank\" rel=\"noreferrer noopener\">Join our Advance DSA COURSE<\/a><\/div>\n<\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<p><em>For any changes to the article, kindly email at <a href=\"mailto:code@codeanddebug.in\" target=\"_blank\" rel=\"noreferrer noopener\">code@codeanddebug.in<\/a> or contact us at <a href=\"tel:+91-9712928220\" target=\"_blank\" rel=\"noreferrer noopener\">+91-9712928220<\/a>.<\/em><\/p>\n\n\n\n<p><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Hey students! If you&#8217;re exploring&nbsp;recursion and&nbsp;backtracking, this&nbsp;problem is a&nbsp;great follow-up to subsets&nbsp;or subsequences. It&#8217;s&nbsp;like the &#8220;Subsets with&nbsp;Sum K&#8221; but simpler, instead of&nbsp;finding all, we&nbsp;just check if&nbsp;at least one&nbsp;exists. We&#8217;ll&nbsp;use backtracking to&nbsp;explore possibilities, and I&#8217;ll explain&nbsp;it in easy terms&nbsp;so you can grasp&nbsp;how it works. Remember, this&nbsp;is for learning&nbsp;recursion, so&nbsp;we&#8217;ll focus on&nbsp;the concept even&nbsp;if it&#8217;s not the&nbsp;fastest<\/p>\n","protected":false},"author":1,"featured_media":727,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3,6],"tags":[32,19],"class_list":{"0":"post-726","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-data-structures-and-algorithm","8":"category-intermediate","9":"tag-advance-recursion","10":"tag-medium"},"featured_image_src":"https:\/\/codeanddebug.in\/blog\/wp-content\/uploads\/2025\/07\/check-if-subsequence-exists-with-SumK-featured-image.png","author_info":{"display_name":"codeanddebug","author_link":"https:\/\/codeanddebug.in\/blog\/author\/codeanddebug\/"},"_links":{"self":[{"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/posts\/726","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/comments?post=726"}],"version-history":[{"count":2,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/posts\/726\/revisions"}],"predecessor-version":[{"id":729,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/posts\/726\/revisions\/729"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/media\/727"}],"wp:attachment":[{"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/media?parent=726"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/categories?post=726"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/tags?post=726"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}