{"id":717,"date":"2025-07-21T16:26:49","date_gmt":"2025-07-21T10:56:49","guid":{"rendered":"https:\/\/codeanddebug.in\/blog\/?p=717"},"modified":"2025-07-21T16:26:51","modified_gmt":"2025-07-21T10:56:51","slug":"print-all-subsequences","status":"publish","type":"post","link":"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/","title":{"rendered":"Print all subsequences\/Power Set: Complete\u00a0Guide with Backtracking"},"content":{"rendered":"\n<p>Hey students! If you&#8217;re diving\u00a0into recursion\u00a0and backtracking, the\u00a0&#8220;Subsets&#8221; problem\u00a0(also known as\u00a0generating the\u00a0power set or\u00a0all subsequences) is\u00a0a perfect starting\u00a0point. It&#8217;s like\u00a0deciding what\u00a0to pack for a\u00a0trip, for each\u00a0item, you choose\u00a0to take it or\u00a0leave it, and\u00a0all combinations\u00a0are possible. <\/p>\n\n\n\n<p>Here&#8217;s the [<strong><a href=\"https:\/\/leetcode.com\/problems\/subsets\/description\/\" 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<p>Today, we&#8217;ll\u00a0focus on solving\u00a0it using\u00a0<strong>backtracking<\/strong>,\u00a0a technique that&#8217;s\u00a0super useful\u00a0for exploring\u00a0all possibilities. I&#8217;ll explain\u00a0it in simple\u00a0terms, step by\u00a0step, so even\u00a0beginners can\u00a0follow along. Let&#8217;s get started!<\/p>\n\n\n\n<p>Given an integer array&nbsp;<code>nums<\/code>&nbsp;of&nbsp;<strong>unique<\/strong>&nbsp;elements, return&nbsp;<em>all possible<\/em>&nbsp;<em>subsets<\/em>&nbsp;<em>(the power set)<\/em>.<\/p>\n\n\n\n<p>The solution set&nbsp;<strong>must not<\/strong>&nbsp;contain duplicate subsets. Return the solution in&nbsp;<strong>any order<\/strong>.<\/p>\n\n\n\n<p><strong>Example 1:<\/strong><\/p>\n\n\n\n<pre class=\"wp-block-preformatted\"><strong>Input:<\/strong> nums = [1,2,3]<br><strong>Output:<\/strong> [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]<\/pre>\n\n\n\n<p><strong>Example 2:<\/strong><\/p>\n\n\n\n<pre class=\"wp-block-preformatted\"><strong>Input:<\/strong> nums = [0]<br><strong>Output:<\/strong> [[],[0]]<\/pre>\n\n\n\n<p><strong>Constraints:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>1 &lt;= nums.length &lt;= 10<\/code><\/li>\n\n\n\n<li><code>-10 &lt;= nums[i] &lt;= 10<\/code><\/li>\n\n\n\n<li>All the numbers of\u00a0<code>nums<\/code>\u00a0are\u00a0<strong>unique<\/strong>.<\/li>\n<\/ul>\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-b1e6abd7-3945-4c89-b03f-672a369a4f38\" 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\/print-all-subsequences\/#0-solution-backtracking-approach\" style=\"\">Solution: Backtracking Approach<\/a><ul><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/#1-intuition\" style=\"\">Intuition<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/#2-detailed-approach\" style=\"\">Detailed Approach<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/#3-code\" style=\"\">Code<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/#4-code-explanation\" style=\"\">Code Explanation<\/a><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/#5-time-and-space-complexity\" style=\"\">Time and Space Complexity<\/a><\/li><\/ul><\/li><li style=\"\"><a href=\"https:\/\/codeanddebug.in\/blog\/print-all-subsequences\/#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 like exploring a maze where you try different paths, and if you hit a dead end, you go back (backtrack) and try another way. For subsets, think of it as making choices for each element in the array: &#8220;Do I include this number in my current subset or not?&#8221; We start from the first element, make a choice to include it (add it to our subset and move to the next), then backtrack by removing it and trying the &#8220;exclude&#8221; choice. This builds a tree of decisions, and each complete path gives us one subset. It&#8217;s perfect for generating all combinations without duplicates!<\/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>: We create a helper function\u00a0<code>solve<\/code>\u00a0that takes the current index in the array, the current subset being built, the original array, and the result list.<\/li>\n\n\n\n<li><strong>Base Case<\/strong>: If the index reaches the end of the array (we&#8217;ve made choices for all elements), add a copy of the current subset to the result.<\/li>\n\n\n\n<li><strong>Include Choice<\/strong>: Add the current element to the subset, then recurse to the next index.<\/li>\n\n\n\n<li><strong>Backtrack<\/strong>: After exploring the &#8220;include&#8221; path, remove the last element (pop it) to undo the choice.<\/li>\n\n\n\n<li><strong>Exclude Choice<\/strong>: Recurse to the next index without adding the current element.<\/li>\n\n\n\n<li><strong>Start Recursion<\/strong>: Call the function with index 0 and an empty subset.<\/li>\n\n\n\n<li><strong>Return Result<\/strong>: The result list will contain all subsets.<\/li>\n<\/ol>\n\n\n\n<p>This way, we systematically explore all 2^n possibilities (for n elements).<\/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=\"from typing import List\n\nclass Solution:\n    def solve(self, index: int, subset: List[int], nums: List[int], result: List[List[int]]):\n        # Base case: We've processed all elements, add current subset to result\n        if index &gt;= len(nums):\n            result.append(subset.copy())  # Use copy to avoid modifying later\n            return\n        \n        # Choice 1: Include the current element in the subset\n        subset.append(nums[index])    # Add to current subset\n        self.solve(index + 1, subset, nums, result)  # Recurse to next index\n        \n        # Backtrack: Undo the inclusion to try the exclude choice\n        subset.pop()                  # Remove the last added element\n        \n        # Choice 2: Exclude the current element\n        self.solve(index + 1, subset, nums, result)  # Recurse without adding\n\n    def subsets(self, nums: List[int]) -&gt; List[List[int]]:\n        result = []                   # List to store all subsets\n        self.solve(0, [], nums, result)  # Start from index 0 with empty subset\n        return result\" 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: #C586C0\">from<\/span><span style=\"color: #D4D4D4\"> typing <\/span><span style=\"color: #C586C0\">import<\/span><span style=\"color: #D4D4D4\"> List<\/span><\/span>\n<span class=\"line\"><\/span>\n<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\">solve<\/span><span style=\"color: #D4D4D4\">(<\/span><span style=\"color: #9CDCFE\">self<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">index<\/span><span style=\"color: #D4D4D4\">: <\/span><span style=\"color: #4EC9B0\">int<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">subset<\/span><span style=\"color: #D4D4D4\">: List[<\/span><span style=\"color: #4EC9B0\">int<\/span><span style=\"color: #D4D4D4\">], <\/span><span style=\"color: #9CDCFE\">nums<\/span><span style=\"color: #D4D4D4\">: List[<\/span><span style=\"color: #4EC9B0\">int<\/span><span style=\"color: #D4D4D4\">], <\/span><span style=\"color: #9CDCFE\">result<\/span><span style=\"color: #D4D4D4\">: List[List[<\/span><span style=\"color: #4EC9B0\">int<\/span><span style=\"color: #D4D4D4\">]]):<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #6A9955\"># Base case: We&#39;ve processed all elements, add current subset to result<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">if<\/span><span style=\"color: #D4D4D4\"> index &gt;= <\/span><span style=\"color: #DCDCAA\">len<\/span><span style=\"color: #D4D4D4\">(nums):<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">            result.append(subset.copy())  <\/span><span style=\"color: #6A9955\"># Use copy to avoid modifying later<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">            <\/span><span style=\"color: #C586C0\">return<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #6A9955\"># Choice 1: Include the current element in the subset<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        subset.append(nums[index])    <\/span><span style=\"color: #6A9955\"># Add to current subset<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #569CD6\">self<\/span><span style=\"color: #D4D4D4\">.solve(index + <\/span><span style=\"color: #B5CEA8\">1<\/span><span style=\"color: #D4D4D4\">, subset, nums, result)  <\/span><span style=\"color: #6A9955\"># Recurse to next index<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #6A9955\"># Backtrack: Undo the inclusion to try the exclude choice<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        subset.pop()                  <\/span><span style=\"color: #6A9955\"># Remove the last added element<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #6A9955\"># Choice 2: Exclude the current element<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #569CD6\">self<\/span><span style=\"color: #D4D4D4\">.solve(index + <\/span><span style=\"color: #B5CEA8\">1<\/span><span style=\"color: #D4D4D4\">, subset, nums, result)  <\/span><span style=\"color: #6A9955\"># Recurse without adding<\/span><\/span>\n<span class=\"line\"><\/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\">subsets<\/span><span style=\"color: #D4D4D4\">(<\/span><span style=\"color: #9CDCFE\">self<\/span><span style=\"color: #D4D4D4\">, <\/span><span style=\"color: #9CDCFE\">nums<\/span><span style=\"color: #D4D4D4\">: List[<\/span><span style=\"color: #4EC9B0\">int<\/span><span style=\"color: #D4D4D4\">]) -&gt; List[List[<\/span><span style=\"color: #4EC9B0\">int<\/span><span style=\"color: #D4D4D4\">]]:<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        result = []                   <\/span><span style=\"color: #6A9955\"># List to store all subsets<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #569CD6\">self<\/span><span style=\"color: #D4D4D4\">.solve(<\/span><span style=\"color: #B5CEA8\">0<\/span><span style=\"color: #D4D4D4\">, [], nums, result)  <\/span><span style=\"color: #6A9955\"># Start from index 0 with empty subset<\/span><\/span>\n<span class=\"line\"><span style=\"color: #D4D4D4\">        <\/span><span style=\"color: #C586C0\">return<\/span><span style=\"color: #D4D4D4\"> result<\/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\u00a0<code>solve<\/code>\u00a0function is our backtracking hero. It starts at index 0 with an empty subset. For each element, it first tries including it (append to subset, recurse), then backtracks (pop) and tries excluding it (just recurse without appending). When it reaches the end (index == len(nums)), it means we&#8217;ve made choices for every element, so we add a copy of the subset to the result. The copy is important because subsets are lists, and we don&#8217;t want future changes to affect already added ones. This builds all subsets by exploring the decision tree.<\/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>\u00a0O(n * 2^n) &#8211; We explore 2^n subsets (each element has 2 choices), and copying each subset takes O(n) time in the worst case.<\/li>\n\n\n\n<li><strong>Space Complexity:<\/strong>\u00a0O(n) &#8211; The recursion stack can go up to depth n, plus space for the current subset. (Result space is separate, as it&#8217;s the output.)<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"6-simplifying-it\">Simplifying It<\/h2>\n\n\n\n<p>Backtracking is like playing a choose-your-own-adventure game. At each step (element), you have two adventures: &#8220;include me&#8221; or &#8220;skip me.&#8221; You try one, see where it leads (recurse), then come back (backtrack) and try the other. When you finish the book (reach the end of the array), you note down the story (add the subset). It&#8217;s a systematic way to try all possibilities without missing any or creating duplicates. Perfect for problems like subsets, permutations, or combinations!<\/p>\n\n\n\n<p>This backtracking approach is elegant and helps build intuition for more complex problems. Practice it by drawing the recursion tree for small inputs, it&#8217;ll click fast! If you have questions or need more examples, let me know. 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 diving\u00a0into recursion\u00a0and backtracking, the\u00a0&#8220;Subsets&#8221; problem\u00a0(also known as\u00a0generating the\u00a0power set or\u00a0all subsequences) is\u00a0a perfect starting\u00a0point. It&#8217;s like\u00a0deciding what\u00a0to pack for a\u00a0trip, for each\u00a0item, you choose\u00a0to take it or\u00a0leave it, and\u00a0all combinations\u00a0are possible. Here&#8217;s the [Problem Link] to begin with. Today, we&#8217;ll\u00a0focus on solving\u00a0it using\u00a0backtracking,\u00a0a technique that&#8217;s\u00a0super useful\u00a0for exploring\u00a0all possibilities. I&#8217;ll explain\u00a0it in<\/p>\n","protected":false},"author":1,"featured_media":719,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3,6],"tags":[32,19],"class_list":{"0":"post-717","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\/print-all-subsequences-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\/717","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=717"}],"version-history":[{"count":1,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/posts\/717\/revisions"}],"predecessor-version":[{"id":720,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/posts\/717\/revisions\/720"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/media\/719"}],"wp:attachment":[{"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/media?parent=717"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/categories?post=717"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codeanddebug.in\/blog\/wp-json\/wp\/v2\/tags?post=717"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}