{"id":1310,"date":"2026-07-14T09:52:07","date_gmt":"2026-07-14T04:22:07","guid":{"rendered":"https:\/\/lastroundai.com\/blog\/?p=1310"},"modified":"2026-07-14T09:52:07","modified_gmt":"2026-07-14T04:22:07","slug":"big-o-time-complexity","status":"publish","type":"iq","link":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity","title":{"rendered":"Big-O, Explained: The Interview Concept You Can’t Fake"},"content":{"rendered":"

Ask a candidate to swap a nested loop for a hash map, and most can do it. Ask them why that change drops the runtime from O(n\u00b2) to O(n), and the room goes quiet. That gap, not the code itself, is what separates a strong technical round from a shaky one. Big-O time complexity is the language interviewers use to talk about that gap, and it’s a lot more specific than “how fast is it.”<\/p>\n

What Big-O time complexity actually measures<\/h2>\n

Big-O describes how the runtime (or memory) of an algorithm grows as the input size, usually written n, gets arbitrarily large. It’s not a stopwatch measurement. It’s a shape. The NIST Dictionary of Algorithms and Data Structures<\/a> defines it formally: f(n) = O(g(n)) means there exist positive constants c and k such that 0 \u2264 f(n) \u2264 c\u00b7g(n) for all n \u2265 k. Stripped of the math notation, that says: past some point, f never grows faster than a constant multiple of g. Everything before that point doesn’t count.<\/p>\n

That last part does a lot of quiet work. Big-O throws away constant factors, so a loop that does 3n operations and one that does 300n operations are both, technically, “O(n).” It throws away lower-order terms, so O(n\u00b2 + n) collapses to O(n\u00b2), because the n\u00b2 term dominates once n gets big enough. And it says nothing about small inputs. An O(n\u00b2) solution can easily beat an O(n log n) one when n is 12, because the crossover point depends on exactly those constants Big-O just deleted. If a problem caps the input at, say, 15 or 20 elements, saying so out loud, and picking the simpler O(n\u00b2) approach on purpose, tends to read better than reaching for a more complex algorithm nobody asked for.<\/p>\n

How to derive the complexity of a snippet, step by step<\/h2>\n

Most candidates don’t derive Big-O, they pattern-match. “I see a loop, so it’s O(n).” That gets you through easy problems and falls apart the moment two loops interact, or a loop hides inside a function call. The actual method is duller than people expect: count the operations, drop the constants, keep the term that dominates.<\/p>\n

for i in range(n):        # runs n times\n    for j in range(n):    # runs n times, for EACH i\n        check(arr[i], arr[j])   # O(1) work per call\n\n# total operations: n * n = n^2 -> O(n^2)<\/code><\/pre>\n
Swap the inner loop for a set lookup and the shape of the whole function changes:<\/p>\n
seen = set()\nfor num in nums:              # runs n times\n    if target - num in seen:  # O(1) average\n        return True\n    seen.add(num)              # O(1) average\n\n# total operations: n * O(1) -> O(n)<\/code><\/pre>\n
Three rules cover nearly everything you’ll see in a coding round. Sequential blocks add: a loop of n followed by a separate loop of m gives O(n + m), which simplifies to O(max(n, m)). Nested loops multiply: an n loop inside an n loop is O(n\u00b2), never O(2n), no matter how tempting that shortcut looks. And a loop that cuts the remaining problem in half each pass, instead of walking through it linearly, is O(log n) regardless of how large n starts out. Recursion is where this method stops being a line-count exercise. You can’t just tally the loop, you need to know how many times the function calls itself and how much work each call does on top of its children, which is usually solved with a recurrence relation rather than eyeballing the code.<\/p>\n
The complexity classes worth knowing cold<\/h2>\n
Interviewers rarely ask you to define Big-O. They expect you to recognize which class a given pattern falls into, on sight, and explain why. Here are the seven that show up constantly, each with a concrete example instead of an abstract description.<\/p>\n\n\n\n\n\n\n\n\n\n
Class<\/th>\nName<\/th>\nReal example<\/th>\n<\/tr>\n
O(1)<\/td>\nConstant<\/td>\nArray index lookup (arr[5]<\/code>), hash map get on average<\/td>\n<\/tr>\n
O(log n)<\/td>\nLogarithmic<\/td>\nBinary search on a sorted array; height of a balanced BST<\/td>\n<\/tr>\n
O(n)<\/td>\nLinear<\/td>\nSingle pass through a list; the hash-set two-sum above<\/td>\n<\/tr>\n
O(n log n)<\/td>\nLinearithmic<\/td>\nMerge sort, heap sort, Python’s built-in sorted()<\/code><\/td>\n<\/tr>\n
O(n\u00b2)<\/td>\nQuadratic<\/td>\nNested loops comparing every pair; bubble sort, insertion sort<\/td>\n<\/tr>\n
O(2\u207f)<\/td>\nExponential<\/td>\nNaive recursive Fibonacci with no memoization; generating a power set<\/td>\n<\/tr>\n
O(n!)<\/td>\nFactorial<\/td>\nBrute-force permutations of n items; naive traveling-salesman<\/td>\n<\/tr>\n<\/table>\n
The jump from n\u00b2 to n! is bigger than the table makes it look. At n = 20, n\u00b2 is 400, a laptop clears that instantly. 2\u207f at n = 20 is about a million, still fine. n! at n = 20 is roughly 2.43 \u00d7 10\u00b9\u2078, which no computer built today finishes in your lifetime. That’s the entire reason interviewers care about this at all: past a certain n, the class you picked matters more than every optimization you’ll ever make inside it.<\/p>\n
Best case, worst case, and the amortized case people get wrong<\/h2>\n
Quicksort’s average case is O(n log n) and its worst case is O(n\u00b2), and both numbers are correct at the same time, they’re just describing different inputs. Best case describes the friendliest possible input (already-sorted data for insertion sort: O(n)). Worst case describes the input that hurts most (a pivot that’s always the smallest element for quicksort: O(n\u00b2)). Average case is the expected runtime across random inputs, which is the number most interviewers actually want when they ask “what’s the complexity.”<\/p>\n
Amortized is a different animal, and candidates conflate it with average case constantly. Average case is a statement about probability across possible inputs. Amortized is a guarantee about a sequence of operations on the same structure, no randomness involved. A dynamic array’s append<\/code> is a textbook case: most appends are O(1), but occasionally the array is full and has to be copied into a bigger one, which costs O(n). Spread that occasional O(n) cost across all the O(1) appends that happen between resizes, and the average cost per append works out to O(1), guaranteed, not just likely. Python documents this directly: list append is O(1) amortized worst case<\/a>, according to the language’s own complexity reference. Say “amortized” instead of “average” in an interview and you’ll usually get a small nod. Mix them up and a sharp interviewer will ask a follow-up you don’t want.<\/p>\n
Space complexity is the question that catches people who nailed the time analysis<\/h2>\n
Space complexity measures extra memory an algorithm uses beyond the input itself, and it’s easy to forget because it doesn’t show up as an explicit data structure. Recursive functions are the classic trap. A recursive factorial function looks like it uses no extra memory, no array, no hash map, but every call sits on the call stack until it returns, so a recursion that goes n levels deep costs O(n) space even with zero variables declared. Rewrite the same function iteratively with a loop and the space drops to O(1), while the time complexity stays exactly the same.<\/p>\n
Memoization makes the trade-off explicit in the other direction. Naive recursive Fibonacci is O(2\u207f) time and O(n) space (call stack only). Add a cache and it drops to O(n) time, but the space cost also becomes O(n), because now you’re storing every subproblem’s answer. Faster in time, heavier in memory. Interviewers who ask “can you do this in-place” are really asking whether you noticed you were about to pay for that speed with space, and whether you can say which trade-off you’re choosing on purpose.<\/p>\n
The data-structure cheat sheet interviewers assume you’ve memorized<\/h2>\n
Nobody expects you to derive these from scratch mid-interview. They expect you to already know them, the same way you know your own phone number.<\/p>\n\n\n\n\n\n\n\n\n\n\n
Structure \/ operation<\/th>\nAverage<\/th>\nWorst case<\/th>\n<\/tr>\n
Array\/list: index by position<\/td>\nO(1)<\/td>\nO(1)<\/td>\n<\/tr>\n
Array\/list: append at end<\/td>\nO(1) amortized<\/td>\nO(1) amortized worst<\/td>\n<\/tr>\n
Array\/list: insert at front<\/td>\nO(n)<\/td>\nO(n)<\/td>\n<\/tr>\n
Hash map: get \/ set<\/td>\nO(1)<\/td>\nO(n), on heavy collisions<\/td>\n<\/tr>\n
Set: contains \/ add<\/td>\nO(1)<\/td>\nO(n), on heavy collisions<\/td>\n<\/tr>\n
Balanced BST: search \/ insert<\/td>\nO(log n)<\/td>\nO(log n)<\/td>\n<\/tr>\n
Linked list: prepend<\/td>\nO(1)<\/td>\nO(1)<\/td>\n<\/tr>\n
Linked list: search by value<\/td>\nO(n)<\/td>\nO(n)<\/td>\n<\/tr>\n<\/table>\n
The hash map row is the one worth sitting with. Python’s own documentation lists dictionary get<\/code> and set<\/code> as O(1) on average but O(n) amortized worst case, because a bad hash function or an adversarial input can collapse a hash table into something closer to a linked list. Most interviewers won’t press you on this. A few will, especially at companies that care about systems-level thinking, and being able to say “average O(1), degrades under collisions” instead of a flat “O(1)” signals you understand the structure isn’t magic. For a deeper walkthrough of when to reach for which structure, our data structures interview guide<\/a> goes through the decision process problem by problem.<\/p>\n
How to actually say this out loud without freezing<\/h2>\n
Here’s a pattern we keep seeing in mock interview<\/a> transcripts on LastRoundAI: candidates get the final Big-O right, then get asked “why,” and stall. They know the answer, not the derivation, and under pressure those aren’t the same skill. The fix isn’t memorizing more classes. It’s narrating out loud, every time you practice, using roughly this shape: state the brute-force complexity first, name what’s slow about it (usually a nested loop or repeated linear search), state the optimized complexity, and name the trade-off, whether that’s extra space, extra constant factor, or lost simplicity.<\/p>\n
That narration habit is exactly what LastRoundAI’s AI interview copilot<\/a> is built to reinforce in the moment: it listens through a live technical round and surfaces a quick, sub-200ms complexity read as you talk through your approach, so you can check your own reasoning against it rather than freezing mid-sentence. It won’t replace knowing the seven classes above. It’s there for the moment you’re staring at a whiteboard and the “why” you knew an hour ago has gone quiet. Once the pattern recognition is solid, most of what’s left is repetition, and our coding pattern cheat sheet<\/a> is a reasonable place to drill the shapes that keep showing up.<\/p>\n
One honest caveat: none of this tells you whether a specific company still asks pure complexity-analysis questions in 2026, some have moved toward system design and take-homes instead. But if you get a live coding round, the interviewer almost always wants the Big-O said out loud, unprompted, before they ask for it. That’s usually the easiest point in the whole interview to pick up, and it’s the one candidates leave on the table most often. If you’re rounding out the rest of your prep kit at the same time, our free interview tools<\/a> cover the parts of getting hired that sit outside pure algorithms, resumes, cover letters, that kind of thing.<\/p>\n","protected":false},"excerpt":{"rendered":"
Most candidates can write the faster code. Fewer can explain, out loud, why it’s faster. Here’s how Big-O time complexity actually works: what it measures, how to derive it from a snippet, the 7 growth classes with real examples, best\/worst\/amortized, space complexity, and a data-structure cheat sheet.<\/p>\n","protected":false},"author":3,"featured_media":1702,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_kad_post_classname":"","footnotes":""},"tags":[],"class_list":["post-1310","iq","type-iq","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nBig-O Time Complexity Explained: A 2026 Cheat Sheet<\/title>\n<meta name=\"description\" content=\"Big-O time complexity explained: what it measures, how to derive it from code, all 7 growth classes with real examples, and how to say it out loud.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Big-O Time Complexity Explained: A 2026 Cheat Sheet\" \/>\n<meta property=\"og:description\" content=\"Big-O time complexity explained: what it measures, how to derive it from code, all 7 growth classes with real examples, and how to say it out loud.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity\" \/>\n<meta property=\"og:site_name\" content=\"LastRound AI\" \/>\n<meta property=\"og:image\" content=\"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-big-o-time-complexity-og.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"630\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity\",\"name\":\"Big-O Time Complexity Explained: A 2026 Cheat Sheet\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/iq-big-o-time-complexity-og.png\",\"datePublished\":\"2026-07-14T04:22:07+00:00\",\"description\":\"Big-O time complexity explained: what it measures, how to derive it from code, all 7 growth classes with real examples, and how to say it out loud.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity#primaryimage\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/iq-big-o-time-complexity-og.png\",\"contentUrl\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/07\\\/iq-big-o-time-complexity-og.png\",\"width\":1200,\"height\":630,\"caption\":\"Big O Time Complexity interview questions \u2014 LastRoundAI\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\\\/big-o-time-complexity#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/lastroundai.com\\\/blog\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Interview Questions\",\"item\":\"https:\\\/\\\/lastroundai.com\\\/interview-questions\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Big-O, Explained: The Interview Concept You Can’t Fake\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/\",\"name\":\"LastRound AI\",\"description\":\"Interview Assistant prep, tech careers and AI tools\",\"publisher\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#organization\",\"name\":\"LastRound AI\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/06\\\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png\",\"contentUrl\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/06\\\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png\",\"width\":400,\"height\":400,\"caption\":\"LastRound AI\"},\"image\":{\"@id\":\"https:\\\/\\\/lastroundai.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Big-O Time Complexity Explained: A 2026 Cheat Sheet","description":"Big-O time complexity explained: what it measures, how to derive it from code, all 7 growth classes with real examples, and how to say it out loud.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity","og_locale":"en_US","og_type":"article","og_title":"Big-O Time Complexity Explained: A 2026 Cheat Sheet","og_description":"Big-O time complexity explained: what it measures, how to derive it from code, all 7 growth classes with real examples, and how to say it out loud.","og_url":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity","og_site_name":"LastRound AI","og_image":[{"width":1200,"height":630,"url":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-big-o-time-complexity-og.png","type":"image\/png"}],"twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity","url":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity","name":"Big-O Time Complexity Explained: A 2026 Cheat Sheet","isPartOf":{"@id":"https:\/\/lastroundai.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity#primaryimage"},"image":{"@id":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity#primaryimage"},"thumbnailUrl":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-big-o-time-complexity-og.png","datePublished":"2026-07-14T04:22:07+00:00","description":"Big-O time complexity explained: what it measures, how to derive it from code, all 7 growth classes with real examples, and how to say it out loud.","breadcrumb":{"@id":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity#primaryimage","url":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-big-o-time-complexity-og.png","contentUrl":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/07\/iq-big-o-time-complexity-og.png","width":1200,"height":630,"caption":"Big O Time Complexity interview questions \u2014 LastRoundAI"},{"@type":"BreadcrumbList","@id":"https:\/\/lastroundai.com\/interview-questions\/big-o-time-complexity#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/lastroundai.com\/blog"},{"@type":"ListItem","position":2,"name":"Interview Questions","item":"https:\/\/lastroundai.com\/interview-questions"},{"@type":"ListItem","position":3,"name":"Big-O, Explained: The Interview Concept You Can’t Fake"}]},{"@type":"WebSite","@id":"https:\/\/lastroundai.com\/blog\/#website","url":"https:\/\/lastroundai.com\/blog\/","name":"LastRound AI","description":"Interview Assistant prep, tech careers and AI tools","publisher":{"@id":"https:\/\/lastroundai.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/lastroundai.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/lastroundai.com\/blog\/#organization","name":"LastRound AI","url":"https:\/\/lastroundai.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/lastroundai.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/06\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png","contentUrl":"https:\/\/lastroundai.com\/blog\/wp-content\/uploads\/2026\/06\/lastroundai-transprant-logo-optimized-BxEo2Wtq.png","width":400,"height":400,"caption":"LastRound AI"},"image":{"@id":"https:\/\/lastroundai.com\/blog\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq\/1310","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq"}],"about":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/types\/iq"}],"author":[{"embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/comments?post=1310"}],"version-history":[{"count":2,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq\/1310\/revisions"}],"predecessor-version":[{"id":1340,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/iq\/1310\/revisions\/1340"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/media\/1702"}],"wp:attachment":[{"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/media?parent=1310"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/lastroundai.com\/blog\/wp-json\/wp\/v2\/tags?post=1310"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}