{"id":71105,"date":"2025-01-30T15:33:04","date_gmt":"2025-01-30T10:03:04","guid":{"rendered":"https:\/\/www.guvi.in\/blog\/?p=71105"},"modified":"2026-04-01T10:48:51","modified_gmt":"2026-04-01T05:18:51","slug":"star-patterns-in-java-for-your-next-interview","status":"publish","type":"post","link":"https:\/\/www.guvi.in\/blog\/star-patterns-in-java-for-your-next-interview\/","title":{"rendered":"Master These 15 Star Patterns in Java to Ace Your Interview"},"content":{"rendered":"\n

Ever walked into a Java interview and blanked on a pattern question you’d seen a dozen times before? You’re not alone. Star patterns in Java are console-output exercises that use nested for loops to print asterisks (*) in shapes, triangles, pyramids, diamonds, hourglasses, and more. They seem simple, but that’s exactly why interviewers love them.<\/p>\n\n\n\n

Companies like TCS, Infosys, Wipro, Cognizant, and Accenture use pattern questions in screening rounds because they test three things quickly: whether you understand nested loops, whether you can trace logic manually before writing code, and whether you can explain your thought process clearly. <\/p>\n\n\n\n

This article walks you through 15 star patterns, with full Java code, inline comments, expected output, and the concept each one tests. Whether you’re prepping for your first interview or brushing up, you’ll leave here ready.<\/p>\n\n\n\n

Quick Answer: <\/strong><\/p>\n\n\n\n

The 15 star patterns covered: Right Triangle, Inverted Right Triangle, Left Triangle, Pyramid, Inverted Pyramid, Full Pyramid (Diamond-body), Right Pascal’s Triangle, Hollow Pyramid, Diamond, Hollow Diamond, Sandglass, Hourglass, Butterfly, Hollow Butterfly, Hollow Square.<\/p>\n\n\n\n

Quick Reference: All 15 Star Patterns at a Glance<\/strong><\/h2>\n\n\n\n
#<\/strong><\/td>Pattern Name<\/strong><\/td>Difficulty<\/strong><\/td>Concept Tested<\/strong><\/td>Asked At<\/strong><\/td><\/tr>
1<\/td>Right Triangle<\/td>Easy<\/td>Basic nested loop<\/td>Infosys, Wipro<\/td><\/tr>
2<\/td>Inverted Right Triangle<\/td>Easy<\/td>Decrementing outer loop<\/td>Wipro, HCL<\/td><\/tr>
3<\/td>Left Triangle<\/td>Easy<\/td>Space + star alignment<\/td>TCS, Accenture<\/td><\/tr>
4<\/td>Pyramid<\/td>Easy<\/td>Spaces + increasing stars<\/td>TCS, Accenture<\/td><\/tr>
5<\/td>Inverted Pyramid<\/td>Easy<\/td>Spaces + decreasing stars<\/td>Cognizant<\/td><\/tr>
6<\/td>Full Pyramid<\/td>Medium<\/td>Combining two pyramids<\/td>Infosys<\/td><\/tr>
7<\/td>Right Pascal’s Triangle<\/td>Medium<\/td>Upper + inverted join<\/td>Wipro, HCL<\/td><\/tr>
8<\/td>Hollow Pyramid<\/td>Medium<\/td>Conditional border printing<\/td>TCS<\/td><\/tr>
9<\/td>Diamond<\/td>Medium<\/td>Pyramid + inverted pyramid<\/td>All companies<\/td><\/tr>
10<\/td>Hollow Diamond<\/td>Medium<\/td>Border-only condition<\/td>TCS, Cognizant<\/td><\/tr>
11<\/td>Sandglass<\/td>Medium<\/td>Inverted + upright pyramid<\/td>HCL<\/td><\/tr>
12<\/td>Hourglass<\/td>Medium<\/td>Symmetric contraction<\/td>Wipro<\/td><\/tr>
13<\/td>Butterfly<\/td>Hard<\/td>Mirror + space logic<\/td>Cognizant<\/td><\/tr>
14<\/td>Hollow Butterfly<\/td>Hard<\/td>Border-only mirror<\/td>Accenture<\/td><\/tr>
15<\/td>Hollow Square<\/td>Medium<\/td>Border condition on 2D grid<\/td>Wipro, HCL<\/td><\/tr><\/tbody><\/table>
All 15 Star Patterns at a Glance<\/strong><\/figcaption><\/figure>\n\n\n\n

How to Approach Any Star Patterns Problem<\/strong><\/h2>\n\n\n\n

Every star pattern in Java<\/a>, no matter how complex, breaks down the same way. You don’t need to memorise every pattern, you need to understand this mental framework:<\/p>\n\n\n\n

    \n
  1. Count the rows<\/strong> \u2014 the outer loop always runs n times (user input or fixed)<\/li>\n\n\n\n
  2. Identify what each row contains<\/strong> \u2014 spaces? stars? both?<\/li>\n\n\n\n
  3. Write one inner loop per element type<\/strong> \u2014 one for spaces, one for stars<\/li>\n\n\n\n
  4. Add <\/strong>if conditions<\/strong><\/a> only for hollow patterns<\/strong> \u2014 print * on borders, space inside<\/li>\n\n\n\n
  5. Test manually with n = 4<\/strong> \u2014 trace on paper before running<\/li>\n<\/ol>\n\n\n\n

    Once you have this framework, any new pattern becomes a variation you can figure out on the spot.<\/p>\n\n\n\n

    The 15 Star Patterns Programs<\/strong><\/h2>\n\n\n\n

    1. Right Triangle Star Patterns<\/strong><\/h3>\n\n\n\n

    A great starting point, the most fundamental nested loop pattern. The outer loop counts rows, the inner loop prints one star per column up to the row number.<\/p>\n\n\n\n

    import java.util.Scanner;\n\npublic class RightTriangleStarPattern {\n\n    public static void main(String[] args) {\n\n        Scanner scanner = new Scanner(System.in);\n\n        System.out.print(\"Enter number of rows: \");\n\n        int rows = scanner.nextInt();\n\n        for (int i = 1; i <= rows; i++) {          \/\/ outer loop: row number\n\n            for (int j = 1; j <= i; j++) {         \/\/ inner loop: stars = row number\n\n                System.out.print(\"*\");\n\n            }\n\n            System.out.println();                  \/\/ move to next line\n\n        }\n\n    }\n\n}\n\n```\n\n**Output (n=5):**\n\n```\n\n*\n\n**\n\n***\n\n****\n\n*****<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Basic nested loop, incrementing inner loop<\/p>\n\n\n\n
    2. Inverted Right Triangle Star Patterns<\/strong><\/h3>\n\n\n\n
    Flip the logic, start from the full row and count down. Just change the outer loop to decrement from rows to 1.<\/p>\n\n\n\n
    for (int i = rows; i >= 1; i--) {   \/\/ outer loop counts down\n\n    for (int j = 1; j <= i; j++) {  \/\/ stars = current row count\n\n        System.out.print(\"*\");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=5):**\n\n```\n\n*****\n\n****\n\n***\n\n**\n\n*<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Decrementing outer loop<\/p>\n\n\n\n
    3. Left Triangle Star Patterns<\/strong><\/h3>\n\n\n\n
    Same star count as the right triangle, but now you print spaces before the stars to push them right-aligned.<\/p>\n\n\n\n
    for (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows - i; j++) {  \/\/ spaces for alignment\n\n        System.out.print(\" \");\n\n    }\n\n    for (int j = 1; j <= i; j++) {         \/\/ stars\n\n        System.out.print(\"*\");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n   *\n\n  **\n\n ***\n\n****<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Two inner loops, space management<\/p>\n\n\n\n
    4. Pyramid Star Patterns<\/strong><\/h3>\n\n\n\n
    The classic. You need spaces on the left for centering, and an odd number of stars per row (2i – 1). Interviewers love asking this one because the space logic trips up many candidates.<\/p>\n\n\n\n
    for (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows - i; j++) {    \/\/ leading spaces\n\n        System.out.print(\" \");\n\n    }\n\n    for (int j = 1; j <= 2 * i - 1; j++) {  \/\/ stars: 1, 3, 5, 7...\n\n        System.out.print(\"*\");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n   *\n\n  ***\n\n *****\n\n*******<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Space + star calculation, 2i – 1 formula<\/p>\n\n\n\n
    \ud83d\udca1 Did You Know?<\/strong> 

    The formula 2i – 1 always gives odd numbers, that’s why a pyramid always has a clean point at the top. Row 1 = 1 star, row 2 = 3 stars, row 3 = 5 stars. Spot the pattern? It’s an arithmetic sequence with common difference 2.<\/div>\n\n\n\n
    5. Inverted Pyramid Star Patterns<\/strong><\/h3>\n\n\n\n
    Start with the widest row at the top, then shrink it. Space count increases as stars decrease.<\/p>\n\n\n\n
    for (int i = rows; i >= 1; i--) {\n\n    for (int j = 1; j <= rows - i; j++) {    \/\/ increasing spaces\n\n        System.out.print(\" \");\n\n    }\n\n    for (int j = 1; j <= 2 * i - 1; j++) {  \/\/ decreasing stars\n\n        System.out.print(\"*\");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n*******\n\n *****\n\n  ***\n\n   *<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Inverse relationship between spaces and stars<\/p>\n\n\n\n
    6. Full Pyramid Star Patterns(Upward + Downward Combined)<\/strong><\/h3>\n\n\n\n
    You join a pyramid and an inverted pyramid to form a rhombus shape. Two separate loop blocks, one going up, one going down.<\/p>\n\n\n\n
    \/\/ Upper pyramid\n\nfor (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\n\/\/ Lower inverted pyramid (skip the middle row with rows-1)\n\nfor (int i = rows - 1; i >= 1; i--) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n   *\n\n  ***\n\n *****\n\n*******\n\n *****\n\n  ***\n\n   *<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Two-part pattern, mirroring logic<\/p>\n\n\n\n
    If you want to be more confident about Java and learn all its knacks, then consider enrolling for HCL GUVI’s <\/a>Free Self-Paced Java Programming Course<\/a> that covers everything from variables and control flow to OOP, at your own pace, in your language.<\/p>\n\n\n\n
    7. Right Pascal’s Triangle<\/strong> Star Patterns<\/strong><\/h3>\n\n\n\n
    An upper right triangle joined with a downward-pointing one. Think of it as a “mountain” lying on its side.<\/p>\n\n\n\n
    for (int i = 1; i <= rows; i++) {         \/\/ upper: increasing\n\n    for (int j = 1; j <= i; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\nfor (int i = rows - 1; i >= 1; i--) {    \/\/ lower: decreasing\n\n    for (int j = 1; j <= i; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n*\n\n**\n\n***\n\n****\n\n***\n\n**\n\n*<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Combining ascending and descending triangles<\/p>\n\n\n\n
    8. Hollow Pyramid Star Patterns<\/strong><\/h3>\n\n\n\n
    Same outer structure as the pyramid, but only border stars are printed. An if condition gates the interior, only the first column, last column, and bottom row get a *.<\/p>\n\n\n\n
    for (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) {\n\n        if (j == 1 || j == 2 * i - 1 || i == rows) { \/\/ border condition\n\n            System.out.print(\"*\");\n\n        } else {\n\n            System.out.print(\" \");\n\n        }\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n   *\n\n  * *\n\n *   *\n\n*******<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Conditional printing, border vs interior distinction<\/p>\n\n\n\n
    9. Diamond Star Patterns<\/strong><\/h3>\n\n\n\n
    A diamond is a pyramid on top of an inverted pyramid, sharing no duplicate middle row. This is one of the most commonly asked medium-difficulty patterns.<\/p>\n\n\n\n
    \/\/ Upper half\n\nfor (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\n\/\/ Lower half\n\nfor (int i = rows - 1; i >= 1; i--) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n   *\n\n  ***\n\n *****\n\n*******\n\n *****\n\n  ***\n\n   *<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Pyramid + inverted pyramid combination<\/p>\n\n\n\n
    10. Hollow Diamond Star Patterns<\/strong><\/h3>\n\n\n\n
    A hollow diamond prints only the outermost stars, spaces fill the inside. The condition checks if the star is on the first or last column of each row.<\/p>\n\n\n\n
    \/\/ Upper hollow pyramid\n\nfor (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) {\n\n        if (j == 1 || j == 2 * i - 1) System.out.print(\"*\"); \/\/ only borders\n\n        else System.out.print(\" \");\n\n    }\n\n    System.out.println();\n\n}\n\n\/\/ Lower hollow inverted pyramid\n\nfor (int i = rows - 1; i >= 1; i--) {\n\n    for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\n    for (int j = 1; j <= 2 * i - 1; j++) {\n\n        if (j == 1 || j == 2 * i - 1) System.out.print(\"*\");\n\n        else System.out.print(\" \");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n   *\n\n  * *\n\n *   *\n\n*     *\n\n *   *\n\n  * *\n\n   *<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Border-only condition on a symmetric shape<\/p>\n\n\n\n
    11. Sandglass Star Patterns<\/strong><\/h3>\n\n\n\n
    Wide at the top and bottom, narrow in the middle \u2014 like a sandglass. Start with the inverted pyramid, then build upward.<\/p>\n\n\n\n
    \/\/ Top: inverted pyramid\nfor (int i = rows; i >= 1; i--) {\n\u00a0\u00a0\u00a0\u00a0for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\u00a0\u00a0\u00a0\u00a0for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");\n\u00a0\u00a0\u00a0\u00a0System.out.println();\n}\n\/\/ Bottom: upright pyramid\nfor (int i = 2; i <= rows; i++) {\n\u00a0\u00a0\u00a0\u00a0for (int j = 1; j <= rows - i; j++) System.out.print(\" \");\n\u00a0\u00a0\u00a0\u00a0for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");\n\u00a0\u00a0\u00a0\u00a0System.out.println();\n}\n```\n**Output (n=4):**\n```\n*******\n\u00a0*****\n\u00a0\u00a0***\n\u00a0\u00a0\u00a0*\n\u00a0\u00a0***\n\u00a0*****\n*******<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Inverted + upright pyramid join, loop starting point<\/p>\n\n\n\n
    12. Hourglass Star Patterns<\/strong><\/h3>\n\n\n\n
    Similar to sandglass but the widest rows are at the outer edges and the narrowest in the middle. Start from row rows counting down, then continue from row 2 counting up.<\/p>\n\n\n\n
    java<\/p>\n\n\n\n
    for (int i = rows; i >= 1; i--) {<\/p>\n\n\n\n
        for (int j = 1; j <= rows - i; j++) System.out.print(\" \");<\/p>\n\n\n\n
        for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");<\/p>\n\n\n\n
        System.out.println();<\/p>\n\n\n\n
    }<\/p>\n\n\n\n
    for (int i = 2; i <= rows; i++) {<\/p>\n\n\n\n
        for (int j = 1; j <= rows - i; j++) System.out.print(\" \");<\/p>\n\n\n\n
        for (int j = 1; j <= 2 * i - 1; j++) System.out.print(\"*\");<\/p>\n\n\n\n
        System.out.println();<\/p>\n\n\n\n
    }<\/p>\n\n\n\n
    ```<\/p>\n\n\n\n
    **Output (n=4):**<\/p>\n\n\n\n
    ```<\/p>\n\n\n\n
    *******<\/p>\n\n\n\n
     *****<\/p>\n\n\n\n
      ***<\/p>\n\n\n\n
       *<\/p>\n\n\n\n
      ***<\/p>\n\n\n\n
     *****<\/p>\n\n\n\n
    *******<\/p>\n\n\n\n
    Concept tested:<\/strong> Symmetric contraction and expansion<\/p>\n\n\n\n
    13. Butterfly Star Patterns<\/strong><\/h3>\n\n\n\n
    This one challenges you to print two mirrored right triangles on the same row, separated by a gap. The gap shrinks as rows increase.<\/p>\n\n\n\n
    \/\/ Upper half\n\nfor (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= i; j++) System.out.print(\"*\");          \/\/ left wing\n\n    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(\" \"); \/\/ gap\n\n    for (int j = 1; j <= i; j++) System.out.print(\"*\");          \/\/ right wing\n\n    System.out.println();\n\n}\n\n\/\/ Lower half\n\nfor (int i = rows; i >= 1; i--) {\n\n    for (int j = 1; j <= i; j++) System.out.print(\"*\");\n\n    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(\" \");\n\n    for (int j = 1; j <= i; j++) System.out.print(\"*\");\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n*      *\n\n**    **\n\n***  ***\n\n********\n\n***  ***\n\n**    **\n\n*      *<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Three inner loops per row, mirror symmetry, gap formula<\/p>\n\n\n\n
    14. Hollow Butterfly Patterns<\/strong><\/h3>\n\n\n\n
    Same structure as the butterfly, but only border positions print a star. Add a border condition inside each wing.<\/p>\n\n\n\n
    for (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= i; j++) {\n\n        if (j == 1 || j == i) System.out.print(\"*\"); else System.out.print(\" \");\n\n    }\n\n    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(\" \");\n\n    for (int j = 1; j <= i; j++) {\n\n        if (j == 1 || j == i) System.out.print(\"*\"); else System.out.print(\" \");\n\n    }\n\n    System.out.println();\n\n}\n\nfor (int i = rows; i >= 1; i--) {\n\n    for (int j = 1; j <= i; j++) {\n\n        if (j == 1 || j == i) System.out.print(\"*\"); else System.out.print(\" \");\n\n    }\n\n    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(\" \");\n\n    for (int j = 1; j <= i; j++) {\n\n        if (j == 1 || j == i) System.out.print(\"*\"); else System.out.print(\" \");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=4):**\n\n```\n\n*      *\n\n**    **\n\n* *  * *\n\n*  **  *\n\n*  **  *\n\n* *  * *\n\n**    **\n\n*      *<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> Border conditions on mirrored wings<\/p>\n\n\n\n
    15. Hollow Square Patterns<\/strong><\/h3>\n\n\n\n
    A 2D grid where only the border cells print a star. The condition is simple, first row, last row, first column, or last column.<\/p>\n\n\n\n
    for (int i = 1; i <= rows; i++) {\n\n    for (int j = 1; j <= rows; j++) {\n\n        if (i == 1 || i == rows || j == 1 || j == rows) \/\/ border check\n\n            System.out.print(\"*\");\n\n        else\n\n            System.out.print(\" \");\n\n    }\n\n    System.out.println();\n\n}\n\n```\n\n**Output (n=5):**\n\n```\n\n*****\n\n*   *\n\n*   *\n\n*   *\n\n*****<\/code><\/pre>\n\n\n\n
    Concept tested:<\/strong> 2D grid traversal<\/a>, multi-condition border check<\/p>\n\n\n\n
    Common Mistakes to Avoid in Interviews<\/strong><\/h2>\n\n\n\n
    Even if you know the code, these slip-ups can cost you:<\/p>\n\n\n\n