Mihir Blog Site's RSS Feed

10 More Pattern Programs in Go — Spiral, Diamond & More

mihirpipermitwala.com — Tue, 03 Nov 2026 00:00:00 GMT

A follow-up to our Go pattern collection, this post covers 10 more patterns commonly asked in Go interviews. Each includes working code and output.

1. Spiral Matrix

Fill an n x n grid with numbers in spiral order.

Copy

Copy

package main

import "fmt"

func spiralMatrix(n int) {
	m := make([][]int, n)
	for i := range m {
		m[i] = make([]int, n)
	}

	num := 1
	top, bottom, left, right := 0, n-1, 0, n-1

	for top <= bottom && left <= right {
		for i := left; i <= right; i++ {
			m[top][i] = num
			num++
		}
		top++
		for i := top; i <= bottom; i++ {
			m[i][right] = num
			num++
		}
		right--
		for i := right; i >= left; i-- {
			m[bottom][i] = num
			num++
		}
		bottom--
		for i := bottom; i >= top; i-- {
			m[i][left] = num
			num++
		}
		left++
	}

	for _, row := range m {
		for _, v := range row {
			fmt.Printf("%2d ", v)
		}
		fmt.Println()
	}
}

func main() {
	spiralMatrix(4)
}

Output

Copy

 1  2  3  4
12 13 14  5
11 16 15  6
10  9  8  7

2. Hollow Diamond

Diamond outline with stars.

Copy

  *
 * *
*   *
 * *
  *

Copy

package main

import "fmt"

func hollowDiamond(n int) {
	for i := 1; i <= n; i++ {
		for j := 0; j < n-i; j++ {
			fmt.Print(" ")
		}
		if i == 1 {
			fmt.Print("*")
		} else {
			fmt.Print("*")
			for j := 0; j < 2*i-3; j++ {
				fmt.Print(" ")
			}
			fmt.Print("*")
		}
		fmt.Println()
	}
	for i := n - 1; i >= 1; i-- {
		for j := 0; j < n-i; j++ {
			fmt.Print(" ")
		}
		if i == 1 {
			fmt.Print("*")
		} else {
			fmt.Print("*")
			for j := 0; j < 2*i-3; j++ {
				fmt.Print(" ")
			}
			fmt.Print("*")
		}
		fmt.Println()
	}
}

func main() {
	hollowDiamond(3)
}

Output

Copy

  *
 * *
*   *
 * *
  *

3. Letter Triangle

Rows of consecutive letters.

Copy

A
A B
A B C
A B C D
A B C D E

Copy

package main

import (
	"fmt"
	"strings"
)

func letterTriangle(n int) {
	for i := 0; i < n; i++ {
		var row []string
		for j := 0; j <= i; j++ {
			row = append(row, string(rune('A'+j)))
		}
		fmt.Println(strings.Join(row, " "))
	}
}

func main() {
	letterTriangle(5)
}

Output

Copy

A
A B
A B C
A B C D
A B C D E

4. Number Stair

Row i repeats the number i.

Copy

Copy

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func numberStair(n int) {
	for i := 1; i <= n; i++ {
		var row []string
		for j := 0; j < i; j++ {
			row = append(row, strconv.Itoa(i))
		}
		fmt.Println(strings.Join(row, " "))
	}
}

func main() {
	numberStair(5)
}

Output

Copy

5. Fibonacci Triangle

Fibonacci numbers continue across rows.

Copy

0
1 1
2 3 5
8 13 21 34
55 89 144 233 377

Copy

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func fibonacciTriangle(n int) {
	a, b := 0, 1
	for i := 1; i <= n; i++ {
		var row []string
		for j := 0; j < i; j++ {
			row = append(row, strconv.Itoa(a))
			a, b = b, a+b
		}
		fmt.Println(strings.Join(row, " "))
	}
}

func main() {
	fibonacciTriangle(5)
}

Output

Copy

0
1 1
2 3 5
8 13 21 34
55 89 144 233 377

6. Binary Triangle

Alternating 1s and 0s.

Copy

Copy

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func binaryTriangle(n int) {
	for i := 1; i <= n; i++ {
		var row []string
		for j := 1; j <= i; j++ {
			row = append(row, strconv.Itoa((1+i+j)%2))
		}
		fmt.Println(strings.Join(row, " "))
	}
}

func main() {
	binaryTriangle(5)
}

Output

Copy

7. Plus Sign

A + made of stars.

Copy

  *
  *
*****
  *
  *

Copy

package main

import "fmt"

func plusSign(n int) {
	mid := n / 2
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if i == mid || j == mid {
				fmt.Print("*")
			} else {
				fmt.Print(" ")
			}
		}
		fmt.Println()
	}
}

func main() {
	plusSign(5)
}

Output

Copy

  *
  *
*****
  *
  *

8. Hollow Pyramid

A pyramid with hollow inside.

Copy

    *
   * *
  *   *
 *     *
*********

Copy

package main

import "fmt"

func hollowPyramid(n int) {
	for i := 1; i <= n; i++ {
		for j := 0; j < n-i; j++ {
			fmt.Print(" ")
		}
		if i == n {
			for j := 0; j < 2*n-1; j++ {
				fmt.Print("*")
			}
		} else if i == 1 {
			fmt.Print("*")
		} else {
			fmt.Print("*")
			for j := 0; j < 2*i-3; j++ {
				fmt.Print(" ")
			}
			fmt.Print("*")
		}
		fmt.Println()
	}
}

func main() {
	hollowPyramid(5)
}

Output

Copy

    *
   * *
  *   *
 *     *
*********

9. X-Shape

Diagonals of stars forming an “X”.

Copy

*   *
 * *
  *
 * *
*   *

Copy

package main

import "fmt"

func xShape(n int) {
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if i == j || i+j == n-1 {
				fmt.Print("*")
			} else {
				fmt.Print(" ")
			}
		}
		fmt.Println()
	}
}

func main() {
	xShape(5)
}

Output

Copy

*   *
 * *
  *
 * *
*   *

10. Sandglass

An inverted triangle on top of a triangle.

Copy

*****
 ***
  *
 ***
*****

Copy

package main

import "fmt"

func sandglass(n int) {
	for i := n; i >= 1; i-- {
		for j := 0; j < n-i; j++ {
			fmt.Print(" ")
		}
		for k := 0; k < 2*i-1; k++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
	for i := 2; i <= n; i++ {
		for j := 0; j < n-i; j++ {
			fmt.Print(" ")
		}
		for k := 0; k < 2*i-1; k++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
}

func main() {
	sandglass(3)
}

Output

Copy

*****
 ***
  *
 ***
*****

Conclusion

These Go patterns complete the trifecta of pattern posts on the site. Combine them with the earlier unique patterns in Go post for a complete beginner’s reference.

Happy coding!

10 More Pattern Programs in Dart — Spiral, Diamond & More

mihirpipermitwala.com — Mon, 26 Oct 2026 00:00:00 GMT

This is a follow-up to our Dart pattern collection. Below are 10 more pattern programs that show up in interviews and help solidify nested loop fundamentals.

1. Spiral Matrix Pattern

Fill an n x n grid with numbers in spiral order.

Copy

Copy

void spiralMatrix(int n) {
  List<List<int>> m = List.generate(n, (_) => List.filled(n, 0));
  int num = 1;
  int top = 0, bottom = n - 1, left = 0, right = n - 1;

  while (top <= bottom && left <= right) {
    for (int i = left; i <= right; i++) m[top][i] = num++;
    top++;
    for (int i = top; i <= bottom; i++) m[i][right] = num++;
    right--;
    for (int i = right; i >= left; i--) m[bottom][i] = num++;
    bottom--;
    for (int i = bottom; i >= top; i--) m[i][left] = num++;
    left++;
  }

  for (var row in m) {
    print(row.map((e) => e.toString().padLeft(2)).join(" "));
  }
}

void main() => spiralMatrix(4);

Output

Copy

 1  2  3  4
12 13 14  5
11 16 15  6
10  9  8  7

2. Hollow Diamond Star

Diamond outline, hollow inside.

Copy

  *
 * *
*   *
 * *
  *

Copy

void hollowDiamond(int n) {
  void row(int i) {
    String stars;
    if (i == 1) {
      stars = "*";
    } else {
      stars = "*" + " " * (2 * i - 3) + "*";
    }
    print(" " * (n - i) + stars);
  }

  for (int i = 1; i <= n; i++) row(i);
  for (int i = n - 1; i >= 1; i--) row(i);
}

void main() => hollowDiamond(3);

Output

Copy

  *
 * *
*   *
 * *
  *

3. Letter Triangle

Each row gets one more letter, starting from ‘A’.

Copy

A
A B
A B C
A B C D
A B C D E

Copy

void letterTriangle(int n) {
  for (int i = 0; i < n; i++) {
    final row = <String>[];
    for (int j = 0; j <= i; j++) {
      row.add(String.fromCharCode(65 + j));
    }
    print(row.join(" "));
  }
}

void main() => letterTriangle(5);

Output

Copy

A
A B
A B C
A B C D
A B C D E

4. Number Stair

Row i contains i copies of i.

Copy

Copy

void numberStair(int n) {
  for (int i = 1; i <= n; i++) {
    print(List.filled(i, i).join(" "));
  }
}

void main() => numberStair(5);

Output

Copy

5. Fibonacci Triangle

Each row continues the Fibonacci sequence.

Copy

0
1 1
2 3 5
8 13 21 34
55 89 144 233 377

Copy

void fibonacciTriangle(int n) {
  int a = 0, b = 1;
  for (int i = 1; i <= n; i++) {
    final row = <String>[];
    for (int j = 0; j < i; j++) {
      row.add("$a");
      int temp = a;
      a = b;
      b = temp + b;
    }
    print(row.join(" "));
  }
}

void main() => fibonacciTriangle(5);

Output

Copy

0
1 1
2 3 5
8 13 21 34
55 89 144 233 377

6. Binary Triangle

Alternating 1s and 0s, starting with 1.

Copy

Copy

void binaryTriangle(int n) {
  for (int i = 1; i <= n; i++) {
    final row = List.generate(i, (j) => (i + j) % 2);
    print(row.join(" "));
  }
}

void main() => binaryTriangle(5);

Output

Copy

7. Wave Pattern

Stars tracing a wave.

Copy

*       *
 *     *
  *   *
   * *
    *

Copy

void wavePattern(int n) {
  for (int i = 0; i < n; i++) {
    final row = StringBuffer();
    for (int j = 0; j < 2 * n - 1; j++) {
      if (i == j || i + j == 2 * n - 2) {
        row.write("*");
      } else {
        row.write(" ");
      }
    }
    print(row.toString().trimRight());
  }
}

void main() => wavePattern(5);

Output

Copy

*       *
 *     *
  *   *
   * *
    *

Note: The wave peaks where the two diagonals converge; increase n for a deeper trough.

8. Double Hill

Two mirrored hills forming an “M” shape.

Copy

*             *
**           **
***         ***
****       ****
*****     *****
******   ******
******* *******

Copy

void doubleHill(int n) {
  for (int i = 1; i <= n; i++) {
    final sides = "*" * i;
    final gap = " " * (2 * (n - i) + 1);
    print(sides + gap + sides);
  }
}

void main() => doubleHill(7);

Output

Copy

*             *
**           **
***         ***
****       ****
*****     *****
******   ******
******* *******

9. Hollow Pyramid

A pyramid with only the outline.

Copy

    *
   * *
  *   *
 *     *
*********

Copy

void hollowPyramid(int n) {
  for (int i = 1; i <= n; i++) {
    String row = " " * (n - i);
    if (i == n) {
      row += "*" * (2 * n - 1);
    } else if (i == 1) {
      row += "*";
    } else {
      row += "*" + " " * (2 * i - 3) + "*";
    }
    print(row);
  }
}

void main() => hollowPyramid(5);

Output

Copy

    *
   * *
  *   *
 *     *
*********

10. X-Shape

Diagonals of stars forming an “X”.

Copy

*   *
 * *
  *
 * *
*   *

Copy

void xShape(int n) {
  for (int i = 0; i < n; i++) {
    final row = StringBuffer();
    for (int j = 0; j < n; j++) {
      if (i == j || i + j == n - 1) {
        row.write("*");
      } else {
        row.write(" ");
      }
    }
    print(row.toString());
  }
}

void main() => xShape(5);

Output

Copy

*   *
 * *
  *
 * *
*   *

Conclusion

These Dart patterns complement the earlier creative set. The spiral matrix and hollow shapes are common in interviews, while the letter and Fibonacci triangles reinforce iteration and state management. Combined, they give you a solid pattern toolkit for any coding round.

Happy coding!

Add an MCP Server to Your React Native Tooling

mihirpipermitwala.com — Mon, 12 Oct 2026 00:00:00 GMT

Ever wished your AI assistant actually knew what was in your AppNavigator.tsx instead of guessing? That’s what MCP solves. In this guide, I’ll walk you through adding an MCP server to your React Native workflow so Claude Code can read your project structure, run Metro bundler commands, manage Expo configurations, and auto-generate navigation boilerplate.

After 3 months of using MCP with React Native, I can say it’s the missing piece for AI-assisted mobile development. Here’s the complete setup.

What is MCP for React Native?

MCP (Model Context Protocol) is an open standard that lets AI applications connect to data sources and tools safely. For React Native, an MCP server can:

Read your package.json, app.json, and metro.config.js
Analyze your src/ and components/ directories
Run npx react-native doctor and report issues
Generate navigation screens that follow your existing patterns
Execute expo start or npm run android/ios
Parse src/navigation/AppNavigator.tsx to understand your routing

Prerequisites

Node.js 18+ installed
React Native CLI or Expo CLI
Claude Code CLI (npm install -g @anthropic-ai/claude-code)
Basic React Native knowledge

Step 1: Create a Node.js/TypeScript MCP Server

Copy

mkdir mcp-react-native-server
cd mcp-react-native-server
npm init -y
npm install @modelcontextprotocol/sdk fs-extra

Note: the server code below is a reference implementation — I don’t maintain a public repo for it, so treat it as a starting point to copy into your own project rather than a supported library. It targets the official @modelcontextprotocol/sdk (check the npm page for the current version and API).

Step 2: Implement the MCP Server

Create index.js:

Copy

const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
const {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} = require("@modelcontextprotocol/sdk/types.js");
const fs = require("fs-extra");
const path = require("path");
const { exec } = require("child_process");

class ReactNativeMcpServer {
  constructor() {
    this.server = new Server(
      {
        name: "react-native-mcp-server",
        version: "1.0.0",
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );

    this.setupToolHandlers();
    this.server.onerror = (error) => console.error("[MCP Error]", error);
  }

  setupToolHandlers() {
    // Tool: Get project structure
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: "getProjectStructure",
            description: "Get the structure of a React Native project",
            inputSchema: {
              type: "object",
              properties: {
                projectPath: {
                  type: "string",
                  description: "Path to the React Native project",
                },
              },
              required: ["projectPath"],
            },
          },
          {
            name: "runRnDoctor",
            description: "Run react-native doctor to check environment health",
            inputSchema: {
              type: "object",
              properties: {
                projectPath: { type: "string" },
              },
              required: ["projectPath"],
            },
          },
          {
            name: "generateNavigationScreen",
            description: "Generate a new screen with boilerplate code matching project patterns",
            inputSchema: {
              type: "object",
              properties: {
                projectPath: { type: "string" },
                screenName: { type: "string" },
                screenType: {
                  type: "string",
                  enum: ["stack", "tab", "drawer"],
                  default: "stack",
                },
              },
              required: ["projectPath", "screenName"],
            },
          },
          {
            name: "analyzeComponents",
            description: "Scan components directory and report patterns",
            inputSchema: {
              type: "object",
              properties: {
                projectPath: { type: "string" },
              },
              required: ["projectPath"],
            },
          },
        ],
      };
    });

    // Handle tool calls
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;

      switch (name) {
        case "getProjectStructure":
          return await this.getProjectStructure(args.projectPath);
        case "runRnDoctor":
          return await this.runRnDoctor(args.projectPath);
        case "generateNavigationScreen":
          return await this.generateNavigationScreen(args);
        case "analyzeComponents":
          return await this.analyzeComponents(args.projectPath);
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    });
  }

  async getProjectStructure(projectPath) {
    const structure = {};

    // Read package.json
    try {
      const packageJson = await fs.readJson(path.join(projectPath, "package.json"));
      structure.packageJson = {
        name: packageJson.name,
        dependencies: Object.keys(packageJson.dependencies || {}),
        devDependencies: Object.keys(packageJson.devDependencies || {}),
      };
    } catch (error) {
      structure.packageJsonError = error.message;
    }

    // Scan src directory
    const srcPath = path.join(projectPath, "src");
    if (await fs.pathExists(srcPath)) {
      structure.srcTree = await this.buildFileTree(srcPath, projectPath);
    }

    // Scan components
    const componentsPath = path.join(projectPath, "src", "components");
    if (await fs.pathExists(componentsPath)) {
      const components = await fs.readdir(componentsPath);
      structure.components = components.filter((item) =>
        item.endsWith(".tsx") || item.endsWith(".jsx")
      );
    }

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(structure, null, 2),
        },
      ],
    };
  }

  async buildFileTree(dir, rootDir) {
    const files = await fs.readdir(dir);
    const tree = {};

    for (const file of files) {
      const fullPath = path.join(dir, file);
      const stat = await fs.stat(fullPath);

      if (stat.isDirectory()) {
        tree[file] = await this.buildFileTree(fullPath, rootDir);
      } else {
        const relativePath = path.relative(rootDir, fullPath);
        tree[file] = { size: stat.size, path: relativePath };
      }
    }

    return tree;
  }

  async runRnDoctor(projectPath) {
    return new Promise((resolve) => {
      exec(
        "npx react-native doctor",
        { cwd: projectPath, maxBuffer: 1024 * 1024 * 5 },
        (error, stdout, stderr) => {
          resolve({
            content: [
              {
                type: "text",
                text: `Doctor output:\n${stdout}\n\nErrors:\n${stderr}`,
              },
            ],
            isError: !!error,
          });
        }
      );
    });
  }

  async generateNavigationScreen(args) {
    const { projectPath, screenName, screenType } = args;
    const screensPath = path.join(projectPath, "src", "screens");

    // Read existing screen patterns
    let template = `import React from 'react';
import { View, Text, StyleSheet } from 'react-native';

const ${screenName}Screen = () => {
  return (
    <View style={styles.container}>
      <Text style={styles.title}>${screenName}</Text>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
  },
});

export default ${screenName}Screen;
`;

    // Check if project uses TypeScript
    const tsConfigPath = path.join(projectPath, "tsconfig.json");
    const useTypeScript = await fs.pathExists(tsConfigPath);
    if (useTypeScript) {
      template = `import React from 'react';
import { View, Text, StyleSheet } from 'react-native';

const ${screenName}Screen: React.FC = () => {
  return (
    <View style={styles.container}>
      <Text style={styles.title}>${screenName}</Text>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
  },
});

export default ${screenName}Screen;
`;
    }

    // Write the file
    await fs.ensureDir(screensPath);
    const filePath = path.join(screensPath, `${screenName}Screen.${useTypeScript ? "tsx" : "jsx"}`);
    await fs.writeFile(filePath, template);

    // Update navigation file if it exists
    //
    // Heads up: this regex-based mutation is intentionally simple, and it is
    // brittle. It assumes AppNavigator.tsx contains `import ... from '...screens...';`
    // and a `<Stack.Screen ...>` element, and it only edits the first match of
    // each. Different formatting, a non-stack navigator, or a renamed import
    // will silently fail to register the screen. For production tooling,
    // parse the file with an AST library like ts-morph instead:
    //
    //   import { Project } from "ts-morph";
    //   const project = new Project();
    //   const source = project.addSourceFileAtPath(navPath);
    //   source.addImportDeclaration({
    //     moduleSpecifier: `../screens/${screenName}Screen`,
    //     defaultImport: `${screenName}Screen`,
    //   });
    //   // ...then locate the JSX element for the stack and add the screen node
    //
    // The simple regex version is fine for personal scripts; AST edits are the
    // robust option for anything shared with a team.
    const navPath = path.join(projectPath, "src", "navigation", "AppNavigator.tsx");
    if (await fs.pathExists(navPath)) {
      let navContent = await fs.readFile(navPath, "utf-8");
      // Add import
      const importStatement = `import ${screenName}Screen from '../screens/${screenName}Screen';\n`;
      if (!navContent.includes(importStatement)) {
        navContent = navContent.replace(
          /(import.*from.*screens.*;\n)/,
          `$1${importStatement}`
        );
      }
      // Add screen to navigator
      if (screenType === "stack") {
        navContent = navContent.replace(
          /(<Stack\.Screen\s+name=.*)/,
          `$1\n        <Stack.Screen name="${screenName}" component={${screenName}Screen} />`
        );
      }
      await fs.writeFile(navPath, navContent);
    }

    return {
      content: [
        {
          type: "text",
          text: `Generated ${screenName}Screen at ${filePath}${(await fs.pathExists(navPath)) ? " (navigation file updated via regex edit — verify the result)" : ""}`,
        },
      ],
    };
  }

  async analyzeComponents(projectPath) {
    const componentsPath = path.join(projectPath, "src", "components");
    const report = {
      totalComponents: 0,
      componentTypes: { functional: 0, class: 0 },
      hooksUsed: {},
      commonPatterns: [],
    };

    if (!(await fs.pathExists(componentsPath))) {
      return {
        content: [{ type: "text", text: "No components directory found" }],
      };
    }

    const files = await fs.readdir(componentsPath);
    const tsxFiles = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".jsx"));

    for (const file of tsxFiles) {
      const content = await fs.readFile(path.join(componentsPath, file), "utf-8");
      report.totalComponents++;

      // Detect functional vs class components
      if (/const\s+\w+\s*=\s*\(/g.test(content) || /function\s+\w+\s*\(/g.test(content)) {
        report.componentTypes.functional++;
      } else if (/class\s+\w+\s+extends/g.test(content)) {
        report.componentTypes.class++;
      }

      // Detect hooks
      const hooks = ["useState", "useEffect", "useContext", "useCallback", "useMemo", "useRef"];
      hooks.forEach((hook) => {
        if (content.includes(hook)) {
          report.hooksUsed[hook] = (report.hooksUsed[hook] || 0) + 1;
        }
      });
    }

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(report, null, 2),
        },
      ],
    };
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error("React Native MCP Server running on stdio");
  }
}

const server = new ReactNativeMcpServer();
server.run();

Step 3: Configure Claude Code

The easiest way is the claude mcp add command:

Copy

claude mcp add react-native -- node /absolute/path/to/mcp-react-native-server/index.js

By default this registers the server in local scope (private to you, for the current project, stored in ~/.claude.json). To share it with your team, use project scope, which writes a .mcp.json at the project root you can commit to git:

Copy

// .mcp.json (project root)
{
  "mcpServers": {
    "react-native": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-react-native-server/index.js"]
    }
  }
}

Use claude mcp add --scope user react-native -- ... if you want it available across all your projects.

Step 4: Use with Claude Code

Start Claude Code in your React Native project:

Copy

cd /path/to/your/react-native-project
claude

Ask Claude:

Copy

Use the MCP server to:
1. Analyze my project structure
2. Run doctor to check my environment
3. Generate a new "Settings" screen as a stack screen
4. Report what hooks patterns my components use

Claude Code will call your MCP tools and report back.

Step 5: Expo Integration

For Expo projects, add Expo-specific tools:

Copy

// Add to your tool handlers
{
  name: "expoStart",
  description: "Start Expo development server",
  inputSchema: {
    type: "object",
    properties: {
      projectPath: { type: "string" },
      platform: {
        type: "string",
        enum: ["ios", "android", "web"],
        default: "ios"
      },
    },
    required: ["projectPath"],
  },
}

Implementation:

Copy

async expoStart(args) {
  const { projectPath, platform } = args;
  return new Promise((resolve) => {
    exec(
      `npx expo start --${platform}`,
      { cwd: projectPath },
      (error, stdout, stderr) => {
        resolve({
          content: [{ type: "text", text: stdout }],
        });
      }
    );
  });
}

Real-World Use Cases

1. Onboarding New Developers

Copy

Ask Claude: "Explain the navigation architecture and show me how screens are registered"

The MCP server reads AppNavigator.tsx and src/screens/, and Claude explains the flow.

2. Pre-Commit Checks

Copy

Ask Claude: "Run doctor and fix any issues, then generate missing unit tests for new screens"

3. Dependency Updates

Copy

Ask Claude: "Check for outdated packages and suggest updates, especially around React Navigation and Expo SDK"

MCP reads package.json, Claude suggests upgrade paths.

Troubleshooting

MCP Server Not Starting

Copy

# Check Node version (needs 18+)
node --version

# Install dependencies
cd mcp-react-native-server
npm install

# Test directly
node index.js

Claude Code Integration Issues

Verify config is loaded:

Copy

# Check Claude Code sees the MCP server
claude mcp list

If missing, re-add it with claude mcp add (Step 3) and check the JSON syntax in your .mcp.json (project scope) or ~/.claude.json (local/user scope).

Security Considerations

File System Access: The server can read/write files. Only use with trusted projects.

Command Execution: exec() calls are dangerous. Validate inputs:

Copy

if (!projectPath.startsWith("/safe/root/dir")) {
  throw new Error("Invalid project path");
}

Authentication: For team deployments, add API keys or OAuth.

Conclusion

Adding MCP to your React Native workflow transforms AI assistance from “chatting about code” to “understanding and modifying your project.” Whether it’s generating screens that match your navigation patterns, running health checks, or analyzing component architecture, MCP bridges the gap between AI and your mobile development environment.

Start with the basic server, then extend it with tools for your specific stack (Expo, bare React Native, React Navigation vs. React Native Navigation, state management patterns like Redux vs. Zustand). The investment in setup pays off in autonomous code generation that actually fits your project.

FAQ

What is an MCP server for React Native development?

An MCP (Model Context Protocol) server is a Node.js or TypeScript program that gives AI assistants like Claude Code structured access to your React Native project. It can read package.json and metro.config.js, analyze your src and components directories, run react-native doctor, generate navigation screens matching your patterns, and control Expo commands like expo start.

How do I add an MCP server to Claude Code for React Native?

Run claude mcp add with a server name and the command that launches it, for example node followed by the absolute path to your server’s index.js. This registers the server in local scope by default. For a team-shared configuration, use project scope, which creates a .mcp.json file in the project root that can be committed to git.

Do MCP servers work with Expo projects?

Yes. You can add Expo-specific tools to your MCP server, such as one that runs npx expo start with a platform argument, letting Claude Code launch or manage the Expo development server on demand. The MCP server itself is just a Node process speaking the protocol over stdio, so it works identically for Expo and bare React Native workflows.

Is it safe to let an AI assistant run commands through an MCP server?

Only with proper guardrails. MCP servers can read and write files and execute shell commands, so validate inputs — for example, reject project paths outside a trusted root directory before passing them to exec — and only run servers from sources you trust. For team deployments, add API keys or OAuth to control who can invoke the server’s tools.

Add an MCP Server to Your Flutter/Dart Tooling

mihirpipermitwala.com — Tue, 06 Oct 2026 00:00:00 GMT

Model Context Protocol (MCP) lets AI tools like Claude Code plug into your local development environment. In this guide, I’ll walk you through building a small MCP server in Dart and wiring it into Claude Code, so it can read your project structure, run tests, and even generate code that matches your team’s patterns.

I’ve been using MCP with Flutter for 3 months now. It’s transformed how I write boilerplate, refactor widgets, and debug platform-specific issues. Here’s how to set it up.

What is MCP?

MCP is an open protocol that standardizes how AI applications connect to data sources and tools. Think of it as a USB-C port for AI: instead of every AI tool building custom integrations, they all plug into MCP servers that expose your data safely.

For Flutter/Dart, an MCP server can:

Read your pubspec.yaml to understand dependencies
Analyze your lib/ directory structure
Run flutter analyze and report issues
Generate code that follows your existing patterns
Execute dart test and report failures

Prerequisites

Flutter SDK installed
Claude Code CLI installed (npm install -g @anthropic-ai/claude-code)
Basic Dart/Flutter knowledge

Step 1: Create a Dart MCP Server

Create a new Dart package for your MCP server:

Copy

dart create -t package mcp_flutter_server
cd mcp_flutter_server

Add the MCP SDK dependency (mcp_dart is the community Dart SDK port of the official TypeScript MCP SDK — check pub.dev for the current version):

Copy

# pubspec.yaml
dependencies:
  mcp_dart: ^2.4.0
  path: ^1.9.0

Note: the code below is a reference implementation I’ve adapted from the SDK’s docs. The mcp_dart API is evolving quickly between minor versions, so if a name doesn’t compile against your installed version, check the package’s getting-started guide on pub.dev — the concepts (server, tools, schemas, stdio transport) are stable even when method signatures shift.

Step 2: Implement the MCP Server

Create bin/mcp_server.dart:

Copy

import 'package:mcp_dart/mcp_dart.dart';
import 'dart:io';
import 'dart:convert';
import 'package:path/path.dart' as path;

void main() async {
  final server = McpServer(
    const Implementation(name: 'flutter-mcp-server', version: '1.0.0'),
  );

  // Tool: List Flutter project structure
  server.addTool(
    name: 'getProjectStructure',
    description: 'Get the structure of a Flutter project',
    inputSchema: ToolInputSchema(
      type: 'object',
      properties: {
        'projectPath': {
          'type': 'string',
          'description': 'Path to the Flutter project',
        },
      },
      required: ['projectPath'],
    ),
    callback: (args, extra) async {
      final projectPath = args['projectPath'] as String;
      final structure = <String, dynamic>{};

      // Read pubspec.yaml
      final pubspecFile = File(path.join(projectPath, 'pubspec.yaml'));
      if (await pubspecFile.exists()) {
        structure['pubspec'] = await pubspecFile.readAsString();
      }

      // List lib directory
      final libDir = Directory(path.join(projectPath, 'lib'));
      if (await libDir.exists()) {
        final files = <String>[];
        await for (final entity in libDir.list(recursive: true)) {
          if (entity is File) {
            files.add(path.relative(entity.path, from: projectPath));
          }
        }
        structure['libFiles'] = files;
      }

      return CallToolResult(
        content: [TextContent(text: jsonEncode(structure))],
      );
    },
  );

  // Tool: Run Flutter analyze
  server.addTool(
    name: 'runFlutterAnalyze',
    description: 'Run flutter analyze on a project',
    inputSchema: ToolInputSchema(
      type: 'object',
      properties: {
        'projectPath': {
          'type': 'string',
          'description': 'Path to the Flutter project',
        },
      },
      required: ['projectPath'],
    ),
    callback: (args, extra) async {
      final projectPath = args['projectPath'] as String;
      final result = await Process.run(
        'flutter',
        ['analyze'],
        workingDirectory: projectPath,
        runInShell: true,
      );

      return CallToolResult(
        content: [
          TextContent(text: 'Exit code: ${result.exitCode}'),
          TextContent(text: result.stdout.toString()),
          if (result.stderr.isNotEmpty) TextContent(text: result.stderr.toString()),
        ],
        isError: result.exitCode != 0,
      );
    },
  );

  // Tool: Run Dart tests
  server.addTool(
    name: 'runDartTest',
    description: 'Run dart test on a specific test file',
    inputSchema: ToolInputSchema(
      type: 'object',
      properties: {
        'projectPath': {'type': 'string'},
        'testFile': {'type': 'string'},
      },
      required: ['projectPath', 'testFile'],
    ),
    callback: (args, extra) async {
      final projectPath = args['projectPath'] as String;
      final testFile = args['testFile'] as String;
      
      final result = await Process.run(
        'dart',
        ['test', testFile],
        workingDirectory: projectPath,
      );

      return CallToolResult(
        content: [
          TextContent(text: result.stdout.toString()),
          if (result.stderr.isNotEmpty) TextContent(text: result.stderr.toString()),
        ],
        isError: result.exitCode != 0,
      );
    },
  );

  // Start the server over stdio
  final transport = StdioServerTransport();
  await server.connect(transport);
}

Step 3: Configure Claude Code to Use Your MCP Server

The easiest way is the claude mcp add command:

Copy

claude mcp add flutter-dart -- dart /absolute/path/to/mcp_flutter_server/bin/mcp_server.dart

Copy

// .mcp.json (project root)
{
  "mcpServers": {
    "flutter-dart": {
      "command": "dart",
      "args": ["/absolute/path/to/mcp_flutter_server/bin/mcp_server.dart"]
    }
  }
}

Use claude mcp add --scope user flutter-dart -- ... if you want the server available across all your projects.

Step 4: Use the MCP Server in Claude Code

Now when you start Claude Code in a Flutter project, it can use your MCP tools:

Copy

cd /path/to/your/flutter/project
claude

Inside Claude Code, ask:

Copy

Use the MCP server to analyze my Flutter project structure and tell me:
1. What dependencies I have
2. What files exist in lib/
3. Any analyzer errors

Claude Code will call getProjectStructure and runFlutterAnalyze through your MCP server and report back.

Step 5: Advanced Usage - Auto-Generate Boilerplate

Add a tool to generate BLoC boilerplate:

Copy

server.addTool(
  name: 'generateBloc',
  description: 'Generate BLoC pattern files for a feature',
  inputSchema: ToolInputSchema(
    type: 'object',
    properties: {
      'featureName': {'type': 'string'},
      'projectPath': {'type': 'string'},
    },
    required: ['featureName', 'projectPath'],
  ),
  callback: (args, extra) async {
    final featureName = args['featureName'] as String;
    final projectPath = args['projectPath'] as String;
    final featurePath = path.join(projectPath, 'lib', 'features', featureName);

    // Create directories
    await Directory(path.join(featurePath, 'bloc')).create(recursive: true);
    await Directory(path.join(featurePath, 'ui')).create(recursive: true);

    // Generate BLoC file
    final blocFile = File(path.join(featurePath, 'bloc', '${featureName}_bloc.dart'));
    await blocFile.writeAsString('''
import 'package:flutter_bloc/flutter_bloc.dart';

abstract class ${featureName}Event {}

abstract class ${featureName}State {}

class ${featureName}Initial extends ${featureName}State {}

class ${featureName}Bloc extends Bloc<${featureName}Event, ${featureName}State> {
  ${featureName}Bloc() : super(${featureName}Initial()) {
    on<${featureName}Event>((event, emit) {
      // TODO: implement
    });
  }
}
''');

    return CallToolResult(
      content: [TextContent(text: 'Generated BLoC for $featureName')],
    );
  },
);

Real-World Use Cases

1. Onboarding New Team Members

Copy

Ask Claude: "Explain the BLoC pattern used in the auth feature"

The MCP server reads lib/features/auth/bloc/ and Claude explains the existing implementation.

2. Pre-Commit Hook Validation

Copy

Ask Claude: "Run flutter analyze and fix any issues"

MCP runs analysis, Claude suggests fixes, you review before committing.

3. Documentation Generation

Copy

Ask Claude: "Generate API documentation for the UserRepository class"

MCP reads the file, Claude generates markdown docs.

Security Considerations

File System Access: MCP servers can read/write files. Only run servers from trusted sources.
Command Execution: The runFlutterAnalyze tool executes shell commands. Validate inputs to prevent injection.
Authentication: For web-based MCP servers, add authentication headers.

Troubleshooting

MCP Server Not Starting

Check logs:

Copy

dart /path/to/mcp_server.dart 2>&1

Common issues:

Dart not in PATH
Missing mcp_dart dependency (run dart pub get)
A version mismatch between the code and your installed mcp_dart (the SDK evolves fast — see the note in Step 2)

Claude Code Not Detecting MCP

Verify the server is registered:

Copy

claude mcp list

If it’s missing, re-add it with claude mcp add (Step 3), and ensure the command and args match your Dart executable and server path. You can also test the server in isolation by speaking raw MCP over stdio — or simply running the script and checking it doesn’t crash:

Copy

dart /path/to/mcp_server.dart 2>&1

Conclusion

Adding an MCP server to your Flutter/Dart tooling bridges AI assistance with your local dev environment. Instead of copying code snippets into chat windows, Claude Code can now understand your project structure, run analysis, and generate code that fits your existing architecture.

The ecosystem is young (MCP was announced in late 2024), but tooling is maturing fast. For Flutter developers, this is a game-changer for productivity.

FAQ

What is an MCP server for Flutter development?

An MCP (Model Context Protocol) server is a small Dart program that exposes your Flutter project’s data and tools to AI assistants like Claude Code over a standardized protocol. It can read pubspec.yaml and your lib directory, run flutter analyze, execute dart test, and generate code matching your project’s patterns, so the assistant works from real context instead of guesses.

How do I connect an MCP server to Claude Code?

Run claude mcp add with a server name followed by the command that starts your server, such as dart plus the path to your server script. By default this registers in local scope for the current project. To share the setup with a team, use project scope, which writes a .mcp.json at the project root you can commit to git.

Is it safe to run an MCP server on my machine?

It depends on the server’s source. MCP servers can read and write files on your disk and execute shell commands, so only run servers from sources you trust, and review any tool that runs commands like flutter analyze for input validation to prevent injection. For team or web-based deployments, add authentication before exposing the server beyond your local machine.

What can Claude Code do with a Flutter MCP server that it cannot do otherwise?

Without MCP, Claude Code only sees files you paste or that its built-in tools read. With an MCP server, it can call purpose-built tools: verify your dependency list from pubspec.yaml, run flutter analyze and report real analyzer output, execute specific dart test files, and generate BLoC or screen boilerplate that matches your existing directory structure and conventions.

React Native On-Device LLM: Run Gemma & Llama Locally

mihirpipermitwala.com — Mon, 05 Oct 2026 00:00:00 GMT

On-device LLMs have arrived for React Native. Using optimized quantization and native modules, you can run Gemma 2B or Llama 3.2 1B directly on user devices — no API keys, no cloud costs, complete privacy. I integrated this into a health app; here’s everything I learned.

A note on libraries: this space moves fast and the code below is illustrative rather than a drop-in snippet. llama.rn is real and actively maintained; MediaPipe’s LLM Inference API is real too, but there is no official @react-native-community wrapper — you’ll use a community bridge (e.g. react-native-llm-mediapipe) or write a small native module. Always check the linked repos for the current API before committing to one.

Why On-Device for React Native?

Zero API costs: No per-user LLM fees
True offline: Works in airplane mode
Privacy GDPR-friendly: Data never transits to servers
Latency: <500ms responses vs 1-3s cloud round-trips

Option 1: llama.rn (Llama Models)

The most mature React Native on-device LLM library.

Installation

Copy

npm install llama.rn
cd ios && pod install # iOS

Usage

Copy

import { initLlama } from 'llama.rn';

class LlamaService {
  constructor() {
    this.context = null;
  }

  async initialize() {
    // Model file should be in the app bundle (iOS) or app-private storage
    // (Android). RNFS.MainBundlePath is iOS-only; for Android resolve a
    // documents-directory path like the download example below.
    const modelPath = `${RNFS.MainBundlePath}/models/llama-3.2-1b-instruct-q4_k_m.gguf`;

    this.context = await initLlama({
      model: modelPath,
      use_mlock: true,
      n_ctx: 2048,
      n_gpu_layers: 99, // Use GPU on iOS/Android
    });
  }

  async generate(prompt) {
    if (!this.context) await this.initialize();
    
    return this.context.completion({
      prompt,
      n_predict: 512,
      temperature: 0.7,
    });
  }

  release() {
    this.context?.release();
  }
}

Downloading Models Programmatically

Copy

import RNFS from 'react-native-fs';

async downloadModel(url, filename, onProgress) {
  const modelPath = `${RNFS.DocumentDirectoryPath}/${filename}`;
  
  const exists = await RNFS.exists(modelPath);
  if (exists) return modelPath;

  const download = RNFS.downloadFile({
    fromUrl: url,
    toFile: modelPath,
    progressDivider: 10,
    begin: (res) => console.log('Download started', res.contentLength),
    progress: (res) => onProgress(res.bytesWritten / res.contentLength),
  });

  const result = await download.promise;
  if (result.statusCode === 200) return modelPath;
  throw new Error('Download failed');
}

Option 2: MediaPipe LLM Inference (Gemma)

Google’s MediaPipe (via Google AI Edge) supports Gemma models with GPU acceleration on both Android and iOS. There is no official React Native package, so you have two realistic paths:

Community bridge: packages like react-native-llm-mediapipe wrap MediaPipe’s LLM Inference task for RN. APIs vary between packages, so treat them as starting points and read the repo before adopting.
Your own native module: a thin Kotlin/Swift wrapper over the MediaPipe LLM Inference API (native dependency: MediaPipeTasksGenAI). It’s a day of work and removes a dependency on unmaintained bridges.

Gemma licensing: Gemma weights are not open source in the Apache/MIT sense. They ship under Google’s Gemma Terms of Use, which impose redistribution conditions — your app’s model distribution must comply with the use restrictions, you must not remove the terms, and Google can revoke the license. Read the terms before you bundle or rehost Gemma weights, especially if you serve model downloads from your own CDN.

Implementation sketch

Copy

// Pseudocode — the exact API depends on the bridge you choose.
// This mirrors the MediaPipe LlmInference options surface.
class GemmaService {
  async initialize() {
    this.llm = await createLlmInference({
      modelPath: `${RNFS.DocumentDirectoryPath}/gemma-2b-it-gpu-int4.task`,
      maxTokens: 1024,
      temperature: 0.8,
      topK: 40,
    });
  }

  async generate(prompt) {
    if (!this.llm) await this.initialize();
    return this.llm.generateResponse(prompt);
  }
}

How Do You Build a Full Chat Interface?

Copy

import React, { useState, useEffect } from 'react';
import { View, Text, TextInput, Button, FlatList, KeyboardAvoidingView, Platform } from 'react-native';
import { LlamaService } from './services/LlamaService';

const ChatScreen = () => {
  const [messages, setMessages] = useState([]);
  const [inputText, setInputText] = useState('');
  const [isLoading, setIsLoading] = useState(false);
  const [modelLoaded, setModelLoaded] = useState(false);
  const llamaService = new LlamaService();

  useEffect(() => {
    const init = async () => {
      try {
        await llamaService.initialize();
        setModelLoaded(true);
      } catch (e) {
        console.error('Failed to load model:', e);
      }
    };
    init();
    
    return () => llamaService.release();
  }, []);

  const sendMessage = async () => {
    if (!inputText.trim() || !modelLoaded) return;

    const userMessage = { id: Date.now(), text: inputText, sender: 'user' };
    setMessages(prev => [...prev, userMessage]);
    setInputText('');
    setIsLoading(true);

    try {
      // Build context from recent messages
      const context = messages.slice(-6).map(m => 
        `${m.sender === 'user' ? 'User' : 'Assistant'}: ${m.text}`
      ).join('\n');
      
      const prompt = `${context}\nUser: ${inputText}\nAssistant:`;
      const response = await llamaService.generate(prompt);
      
      setMessages(prev => [...prev, {
        id: Date.now() + 1,
        text: response.text?.trim() || 'No response',
        sender: 'assistant'
      }]);
    } catch (error) {
      console.error('Generation error:', error);
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <KeyboardAvoidingView style={{ flex: 1 }} behavior={Platform.OS === 'ios' ? 'padding' : 'height'}>
      <FlatList
        data={messages}
        keyExtractor={(item) => item.id.toString()}
        renderItem={({ item }) => (
          <View style={[styles.message, item.sender === 'user' ? styles.user : styles.ai]}>
            <Text style={styles.text}>{item.text}</Text>
          </View>
        )}
      />
      <View style={styles.inputContainer}>
        <TextInput
          style={styles.input}
          value={inputText}
          onChangeText={setInputText}
          placeholder={modelLoaded ? "Type message..." : "Loading model..."}
          editable={modelLoaded && !isLoading}
        />
        <Button title={isLoading ? "..." : "Send"} onPress={sendMessage} disabled={!modelLoaded} />
      </View>
    </KeyboardAvoidingView>
  );
};

// Styles...

How Do You Optimize Models for Mobile?

1. Use GGUF Format (Llama)

Convert models with llama.cpp:

Copy

python convert.py --outtype f16 --outfile llama-3.2-1b-instruct-f16.gguf /path/to/model
./quantize llama-3.2-1b-instruct-f16.gguf llama-3.2-1b-instruct-q4_k_m.gguf Q4_K_M

2. Progressive Loading

Download small model first, larger on demand:

Copy

const MODELS = {
  small: 'llama-3.2-1b-instruct-q2_k.gguf', // 600 MB
  medium: 'llama-3.2-1b-instruct-q4_k_m.gguf', // 900 MB
};

async function ensureModel(type) {
  const path = getPath(MODELS[type]);
  if (!(await RNFS.exists(path))) {
    await downloadModel(`https://your-cdn/models/${MODELS[type]}`, MODELS[type], console.log);
  }
  return path;
}

Performance Expectations

I don’t have rigorously controlled benchmarks for every device class, so take these community-reported figures as ballpark expectations rather than guarantees — measure on your own target hardware before making promises in your app:

Model	Approx. download size	Approx. RAM in use	Typical speed (flagship phone)	Use Case
Llama 3.2 1B (Q4)	~800 MB	~2 GB	~15-25 t/s	Quick chat
Gemma 2B (int4)	~1.3 GB	~3 GB	~10-15 t/s	Quality responses
Llama 3.2 3B (Q4)	~2 GB	~4-5 GB	~8-12 t/s	Complex tasks

Realistic minimum specs (community consensus, not official):

Android: flagship or near-flagship SoC (Snapdragon 8-series / Tensor G3 class), 8 GB RAM
iOS: iPhone 13 or newer (A15 Bionic)

Budget and older devices will struggle with anything above the 1B models, and low-RAM devices may get killed by the OS during inference.

How Do You Integrate On-Device LLMs With Expo?

Both llama.rn and MediaPipe bridges contain native code, so they don’t work with Expo Go. Use a development build:

Copy

npx expo prebuild
npx expo run:ios   # or run:android

llama.rn ships an Expo config plugin (check its README for current setup details) — enable it in app.json:

Copy

{
  "plugins": ["llama.rn"]
}

If you write your own MediaPipe native module, you’ll register it via the config-plugin mechanism yourself (or add the pods/gradle deps in the ios/ and android/ folders that prebuild generates).

What Should You Consider Before Shipping to Production?

Battery Impact

Run inference in background threads with InteractionManager:

Copy

import { InteractionManager } from 'react-native';

const generate = () => {
  return new Promise((resolve) => {
    InteractionManager.runAfterInteractions(async () => {
      const result = await llamaService.generate(prompt);
      resolve(result);
    });
  });
};

App Store Compliance

Keep app binary < 4 GB by offering downloadable models
Add “AI features not available offline” disclaimer

Conclusion

On-device LLMs in React Native are viable today. Start with llama.rn for maximum compatibility, use MediaPipe (Google AI Edge) for Gemma-specific optimizations, and always download models post-install to meet app store size limits. If you need to run other TFLite models alongside your LLM, react-native-fast-tflite is a solid companion library. The privacy and cost benefits are real — I’ve had zero API bills and 100% offline functionality.

Resources:

FAQ

Can React Native apps run LLMs locally on the device?

Yes. Libraries like llama.rn, which wraps llama.cpp, run quantized Llama models directly on iOS and Android, and MediaPipe-based community bridges run Google’s Gemma models with GPU acceleration. Everything happens on the device: no API keys, no server costs, full offline operation, and complete privacy since user data never leaves the phone.

Which is better for React Native: llama.rn or MediaPipe?

llama.rn is the most mature option and works with any GGUF-quantized model, including Llama 3.2, making it the safer default for broad compatibility. The MediaPipe route suits Gemma-specific optimizations and GPU acceleration on both platforms, but there is no official React Native wrapper — you rely on community bridges or write your own small native module.

What phones can run on-device LLMs in React Native?

Community consensus points to flagship or near-flagship hardware: a Snapdragon 8-series or Tensor G3 class Android phone with 8 GB RAM, or an iPhone 13 or newer. A Llama 3.2 1B model at 4-bit quantization needs roughly 800 MB of storage and 2 GB of RAM and reaches about 15-25 tokens per second; larger 2B-3B models need more of both.

Do on-device LLM libraries work with Expo?

Not in Expo Go, because llama.rn and MediaPipe bridges contain native code. You need an Expo development build: run expo prebuild, then expo run:ios or run:android to compile the native modules. llama.rn ships an Expo config plugin you enable in app.json, while a custom MediaPipe native module registers through the config-plugin mechanism or by editing the generated native folders.

Flutter On-Device LLM: Run Gemma & Llama Locally (2026)

mihirpipermitwala.com — Thu, 24 Sep 2026 00:00:00 GMT

Running large language models on-device is no longer science fiction. With Gemma and optimized quantization, Flutter apps can now offer AI features — summarization, chat, code explanation — without sending data to the cloud. I integrated flutter_gemma into a Flutter app and tested the full flow — model install, offline inference, and streaming responses — on real devices. Here’s the complete guide.

Why On-Device LLMs?

Privacy: Data never leaves the device
Cost: No API fees per user
Offline: Works without internet
Latency: No network round-trip on the inference path

The trade-off: model size and quality. You’ll use compact models (Gemma 3, Gemma 3n, Phi-4 Mini, Qwen, Llama-family variants) that fit in mobile RAM.

What Do You Need Before You Start?

Flutter 3.22+
A physical device for testing (emulators lack GPU/NPU acceleration)
8 GB+ device RAM recommended for 2B+ parameter models
Android: minSdkVersion 24+
iOS: iOS 15.0+ (16.0+ if you use the MediaPipe engine package, which requires MediaPipe GenAI)

The Package: flutter_gemma

The package you’ll actually use is flutter_gemma — a well-maintained Flutter plugin (436+ likes on pub.dev) that runs Gemma, Qwen, Phi, DeepSeek, SmolLM and other open models on-device. Under the hood it wraps Google’s MediaPipe LLM Inference API and LiteRT-LM.

Note: The plugin family is being renamed — new releases now ship as flutter_edge_ai with the same API. Everything in this guide applies to both names.

Setup

Add the core package plus at least one engine package to pubspec.yaml. The core has no engine on its own — you register the engine that matches your model format:

Copy

dependencies:
  flutter:
    sdk: flutter
  flutter_gemma: ^1.8.2            # Core — always required
  flutter_gemma_mediapipe: any     # .task / .bin models (Gemma 3, Gemma 3n, Qwen 2.5, Phi-4)
  # flutter_gemma_litertlm: any    # .litertlm models (Gemma 4, Qwen3) + desktop support

Download a Model

The fastest path is installing a model from Hugging Face with one call (some google/ and litert-community/ repos are gated and need a token):

Copy

await FlutterGemma.installModel(
  modelType: ModelType.gemmaIt,        // Gemma 3 / Gemma 3n
  fileType: ModelFileType.litertlm,
).fromNetwork(
  'https://huggingface.co/litert-community/Gemma3-1B-IT/resolve/main/Gemma3-1B-IT_multi-prefill-seq_q4_ekv4096.litertlm',
  token: 'your_hf_token', // only for gated repos
).withProgress((progress) {
  print('Downloading: $progress%');
}).install();

For small models you can also bundle the file in assets/ and install it offline-first:

Copy

flutter:
  assets:
    - assets/models/gemma3-270m-it-q8.litertlm

Copy

await FlutterGemma.installModel(
  modelType: ModelType.gemmaIt,
  fileType: ModelFileType.litertlm,
).fromAsset('assets/models/gemma3-270m-it-q8.litertlm').install();

Bundling works well for ~300 MB models (Gemma 3 270M, SmolLM 135M). Larger models noticeably bloat your app size — host them on your own CDN or Hugging Face and use fromNetwork instead.

Platform Setup (Do This First)

The plugin needs platform-specific setup before inference works:

Android — for the GPU backend, declare OpenCL native libraries in AndroidManifest.xml (above </application>):

Copy

<uses-native-library android:name="libOpenCL.so" android:required="false" />
<uses-native-library android:name="libOpenCL-car.so" android:required="false" />
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false" />

iOS — set the minimum deployment target (15.0, or 16.0 with the MediaPipe engine), enable file sharing in Info.plist, and for large models add memory entitlements to Runner.entitlements:

Copy

<key>UIFileSharingEnabled</key>
<true/>

Copy

<key>com.apple.developer.kernel.increased-memory-limit</key>
<true/>

Implementation

Initialize the plugin once in main() and register the engine package you depend on:

Copy

import 'package:flutter/widgets.dart';
import 'package:flutter_gemma/flutter_gemma.dart';
import 'package:flutter_gemma_mediapipe/flutter_gemma_mediapipe.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await FlutterGemma.initialize(
    inferenceEngines: const [MediaPipeEngine()],
  );

  runApp(const ChatApp());
}

Then wrap the model lifecycle in a small service class:

Copy

import 'package:flutter_gemma/flutter_gemma.dart';

class LlmService {
  InferenceModel? _model;
  Chat? _chat;

  /// One-time model install. Skipped if the model is already on disk.
  Future<void> ensureModelInstalled() async {
    final installed = await FlutterGemma.isModelInstalled('Gemma3-1B-IT_multi-prefill-seq_q4_ekv4096.litertlm');
    if (installed) return;

    await FlutterGemma.installModel(
      modelType: ModelType.gemmaIt,
      fileType: ModelFileType.litertlm,
    ).fromNetwork(
      'https://huggingface.co/litert-community/Gemma3-1B-IT/resolve/main/Gemma3-1B-IT_multi-prefill-seq_q4_ekv4096.litertlm',
    ).install();
  }

  /// Loads the model weights and opens a chat session.
  Future<void> initialize() async {
    if (_chat != null) return;
    await ensureModelInstalled();

    // maxTokens is the CONTEXT WINDOW (input + output combined),
    // not the reply length. .litertlm models need at least 1024.
    _model = await FlutterGemma.getActiveModel(
      maxTokens: 2048,
      preferredBackend: PreferredBackend.gpu,
    );
    _chat = await _model!.createChat(
      systemInstruction: 'You are a helpful offline assistant. Answer concisely.',
    );
  }

  Future<String> generateResponse(String prompt) async {
    await initialize();
    // Message.isUser defaults to false — always pass isUser: true,
    // or the model returns an empty response.
    await _chat!.addQueryChunk(Message.text(text: prompt, isUser: true));
    final response = await _chat!.generateChatResponse();
    return response is TextResponse ? response.token : '';
  }

  Stream<String> generateStreamingResponse(String prompt) async* {
    await initialize();
    await _chat!.addQueryChunk(Message.text(text: prompt, isUser: true));
    await for (final response in _chat!.generateChatResponseAsync()) {
      if (response is TextResponse) yield response.token;
    }
  }

  Future<void> close() async {
    await _model?.close();
    _model = null;
    _chat = null;
  }
}

A few things that trip people up:

maxTokens is the context window (KV-cache budget shared by prompt and reply), not the reply length. To cap the reply, pass maxOutputTokens to createChat.
Message.isUser defaults to false. Forgetting isUser: true is the #1 cause of empty responses.
The chat session keeps conversation history for you — don’t manually prepend past messages to the prompt.

Copy

import 'package:flutter/material.dart';

class ChatScreen extends StatefulWidget {
  const ChatScreen({super.key});

  @override
  State<ChatScreen> createState() => _ChatScreenState();
}

class _ChatScreenState extends State<ChatScreen> {
  final LlmService _llmService = LlmService();
  final TextEditingController _controller = TextEditingController();
  final List<String> _messages = [];
  bool _isLoading = false;

  Future<void> _sendMessage() async {
    if (_controller.text.isEmpty) return;

    final userMessage = _controller.text;
    setState(() {
      _messages.add('You: $userMessage');
      _isLoading = true;
    });

    try {
      final response = await _llmService.generateResponse(userMessage);
      setState(() {
        _messages.add('AI: $response');
      });
    } catch (e) {
      setState(() {
        _messages.add('Error: $e');
      });
    } finally {
      setState(() => _isLoading = false);
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('On-Device AI')),
      body: Column(
        children: [
          Expanded(
            child: ListView.builder(
              itemCount: _messages.length,
              itemBuilder: (context, index) {
                return ListTile(title: Text(_messages[index]));
              },
            ),
          ),
          if (_isLoading) const CircularProgressIndicator(),
          Padding(
            padding: const EdgeInsets.all(8.0),
            child: Row(
              children: [
                Expanded(
                  child: TextField(
                    controller: _controller,
                    decoration: const InputDecoration(
                      hintText: 'Ask offline AI...',
                    ),
                  ),
                ),
                IconButton(
                  icon: const Icon(Icons.send),
                  onPressed: _sendMessage,
                ),
              ],
            ),
          ),
        ],
      ),
    );
  }
}

How Do You Ship Model Downloads in Production?

For production apps, don’t embed large models in your assets — host them on your own CDN or Hugging Face and let flutter_gemma handle the download. The plugin already gives you progress tracking, retry with exponential backoff, a cancel token, and an optional Android foreground service for multi-GB downloads:

Copy

import 'package:flutter_gemma/core/model_management/cancel_token.dart';

final cancelToken = CancelToken();

final downloadFuture = FlutterGemma.installModel(
  modelType: ModelType.gemmaIt,
  fileType: ModelFileType.litertlm,
).fromNetwork(
  'https://yourcdn.com/models/gemma3-1b-it.litertlm',
).withProgress((progress) {
  setState(() => _downloadProgress = progress); // int 0-100
}).withCancelToken(cancelToken).install();

// Let the user cancel from your UI:
cancelToken.cancel('User cancelled download');

try {
  await downloadFuture;
} catch (e) {
  if (CancelToken.isCancel(e)) {
    // download was cancelled by the user
  } else {
    rethrow;
  }
}

Download failures are typed: catch DownloadException and switch on its sealed DownloadError (UnauthorizedError, NotFoundError, RateLimitedError, …) instead of parsing error strings.

Performance Benchmarks

I verified the setup runs offline end-to-end on device; treat the figures below as vendor-reported / community-reported ballparks, not my measurements — they will vary with quantization, backend (GPU vs CPU), and device.

Model	Size	First Token	Speed (tokens/sec)
Gemma 3 1B (int4, litertlm)	~0.5 GB	~400-900ms	~10-20
Gemma 3n E2B (int4, .task)	~3.1 GB	~1s	~8-15
Phi-4 Mini (3.8B)	~3.9 GB	~1-2s	~5-12

Sources: MediaPipe LLM Inference docs, flutter_gemma on pub.dev, LiteRT community models on Hugging Face.

Device minimums:

Android: Pixel 7 / Samsung S23 class for 2B+ models; 1B models run on mid-range devices
iOS: iPhone 12+ (A14 Bionic)

How Can You Optimize On-Device Inference Performance?

1. Quantization

Use pre-quantized int4/int8 builds:

Gemma models ship quantized in the litert-community Hugging Face repos
Use llama.cpp to quantize Llama models yourself

2. Memory Management

Copy

@override
void dispose() {
  _llmService.close();
  super.dispose();
}

On iOS, large models need the memory entitlements described in the platform setup section. If you hit memory pressure, reduce maxTokens or drop to a smaller model (1B-2B parameters).

3. GPU vs CPU

Use GPU for interactive chat, CPU for background tasks (GPU is unavailable or slower in some scenarios, and on web it’s the only backend):

Copy

final model = await FlutterGemma.getActiveModel(
  maxTokens: 2048,
  preferredBackend: isUserInteractive ? PreferredBackend.gpu : PreferredBackend.cpu,
);

Note that switching the backend reloads the model weights — don’t flip it per request.

What Can You Build With On-Device LLMs?

Document Summarizer (Offline)

Copy

Future<String> summarizeDocument(String text) async {
  final clipped = text.length > 2000 ? text.substring(0, 2000) : text;
  final prompt = 'Summarize this in 3 sentences:\n\n$clipped';
  return await _llmService.generateResponse(prompt);
}

Code Explanation Assistant

Copy

Future<String> explainCode(String code) async {
  final prompt = 'Explain this Dart code:\n```\n$code\n```';
  return await _llmService.generateResponse(prompt);
}

Private Journaling with AI

No network needed — all sentiment analysis runs locally.

What Are the Limitations of On-Device LLMs?

Model size: Can’t fit 70B parameter models on phones.
Quality: Sub-3B models are weaker than cloud APIs.
Battery: Continuous use drains battery quickly.
App Store: Apple may reject apps over 4 GB; use downloadable models.
Architecture support: the FFI/LiteRT-LM engine is arm64-only on Android — add ndk { abiFilters 'arm64-v8a' } so the Play Store doesn’t offer broken APKs to other ABIs.

Conclusion

On-device LLMs are ready for specific use cases today. Start with flutter_gemma + a 1B Gemma model for chat, measure performance on your own target devices before committing to any numbers, and add downloadable larger models for power users. The privacy and offline benefits are compelling — this isn’t a gimmick, it’s a new category of app features.

Next steps:

Try Gemini Nano on Android for system-level integration (flutter_gemma’s flutter_gemma_builtin_ai package also exposes it)
Explore LLaMA 3.2 1B for sub-GB models
Check the MediaPipe GenAI docs for the latest updates

Questions? Comment below or check the GitHub repo with full source code.

FAQ

Can I run an LLM offline in a Flutter app?

Yes. The flutter_gemma plugin wraps Google’s MediaPipe LLM Inference API and LiteRT-LM so models like Gemma 3, Gemma 3n, Qwen, and Phi run entirely on the device with no API keys, no internet connection, and no per-request cost. Data never leaves the phone, making it suitable for privacy-sensitive features like journaling or offline summarization.

What devices can run on-device LLMs in Flutter?

A 1B-parameter model such as Gemma 3 1B runs on mid-range Android phones and iPhone 12 or newer, while 2B+ models want flagship-class hardware like a Pixel 7 or Samsung S23 with 8 GB of RAM. Emulators lack GPU and NPU acceleration, so test on physical devices. Community-reported speeds range from roughly 10-20 tokens per second for 1B models.

Should I bundle the LLM model in my Flutter app assets or download it?

Bundle only small models of roughly 300 MB, such as Gemma 3 270M, because they inflate app size and Apple may reject binaries over 4 GB. For larger models, host the file on Hugging Face or your own CDN and download it after install — flutter_gemma provides download progress tracking, cancellation, retry, and typed error handling for this flow.

Why does my flutter_gemma chat return empty responses?

The most common cause is forgetting isUser: true when adding a message. Message.isUser defaults to false, and queries sent as non-user messages produce empty replies. Two related gotchas: maxTokens sets the total context window shared by prompt and reply, not the reply length, and the chat session already tracks history, so never prepend past messages manually.

Alphabet Rhombus in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 18 Sep 2026 00:00:00 GMT

The Alphabet Rhombus pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

Implementation

Copy

void alphabetRhombus(int n) {
  for (int i = 1; i <= n; i++) {
    String seq = '';
    for (int j = 0; j < i; j++) seq += String.fromCharCode(65 + j);
    print(' ' * (n - i) + seq);
  }
  for (int i = n - 1; i >= 1; i--) {
    String seq = '';
    for (int j = 0; j < i; j++) seq += String.fromCharCode(65 + j);
    print(' ' * (n - i) + seq);
  }
}

void main() {
  alphabetRhombus(5);
}

Output

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

How It Works

Each row prints the first i letters, padded on the left so the block leans into a rhombus. The top half grows to the full alphabet, then the bottom half shrinks back down.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rhombus pattern in Dart?

Use nested loops: the outer loop walks through the rows while the inner loop prints the characters or values for each row. The complete Dart implementation with expected output is shown in the sections above.

What is the time complexity of the Alphabet Rhombus pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rhombus in Go — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 18 Sep 2026 00:00:00 GMT

The Alphabet Rhombus pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

Implementation

Copy

package main

import ("fmt"; "strings")

func alphabetRhombus(n int) {
	for i := 1; i <= n; i++ {
		seq := ""
		for j := 0; j < i; j++ {
			seq += string(rune(65 + j))
		}
		fmt.Println(strings.Repeat(" ", n-i) + seq)
	}
	for i := n - 1; i >= 1; i-- {
		seq := ""
		for j := 0; j < i; j++ {
			seq += string(rune(65 + j))
		}
		fmt.Println(strings.Repeat(" ", n-i) + seq)
	}
}

func main() {
	alphabetRhombus(5)
}

Output

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

How It Works

Each row prints the first i letters, padded on the left so the block leans into a rhombus. The top half grows to the full alphabet, then the bottom half shrinks back down.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rhombus pattern in Go?

Use nested loops: the outer loop walks through the rows while the inner loop prints the characters or values for each row. The complete Go implementation with expected output is shown in the sections above.

What is the time complexity of the Alphabet Rhombus pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rhombus in Python — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 18 Sep 2026 00:00:00 GMT

The Alphabet Rhombus pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

Implementation

Copy

def alphabet_rhombus(n):
    for i in range(1, n + 1):
        seq = "".join(chr(65 + j) for j in range(i))
        print(" " * (n - i) + seq)
    for i in range(n - 1, 0, -1):
        seq = "".join(chr(65 + j) for j in range(i))
        print(" " * (n - i) + seq)

alphabet_rhombus(5)

Output

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

How It Works

Each row prints the first i letters, padded on the left so the block leans into a rhombus. The top half grows to the full alphabet, then the bottom half shrinks back down.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rhombus pattern in Python?

Use nested loops: the outer loop walks through the rows while the inner loop prints the characters or values for each row. The complete Python implementation with expected output is shown in the sections above.

What is the time complexity of the Alphabet Rhombus pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rhombus in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 18 Sep 2026 00:00:00 GMT

The Alphabet Rhombus pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

Implementation

Copy

func alphabetRhombus(_ n: Int) {
    for i in 1...n {
        var seq = ""
        for j in 0..<i { seq += String(UnicodeScalar(65 + j)!) }
        print(String(repeating: " ", count: n - i) + seq)
    }
    for i in stride(from: n - 1, through: 1, by: -1) {
        var seq = ""
        for j in 0..<i { seq += String(UnicodeScalar(65 + j)!) }
        print(String(repeating: " ", count: n - i) + seq)
    }
}
alphabetRhombus(5)

Output

Copy

    A
   AB
  ABC
 ABCD
ABCDE
 ABCD
  ABC
   AB
    A

How It Works

Each row prints the first i letters, padded on the left so the block leans into a rhombus. The top half grows to the full alphabet, then the bottom half shrinks back down.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rhombus pattern in Swift?

Use nested loops: the outer loop walks through the rows while the inner loop prints the characters or values for each row. The complete Swift implementation with expected output is shown in the sections above.

What is the time complexity of the Alphabet Rhombus pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Best Time to Buy and Sell Stock in Dart — DP Explained

mihirpipermitwala.com — Sat, 12 Sep 2026 00:00:00 GMT

Best Time to Buy and Sell Stock (LeetCode #121) is a classic dynamic programming problem: given daily stock prices, find the maximum profit from one buy-sell transaction.

Problem Statement

Given an array prices where prices[i] is the price of a stock on day i, find the maximum profit you can achieve. You can only complete one transaction (buy once, sell once). Note you cannot sell before buying.

Examples:

Copy

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price=1) and sell on day 5 (price=6), profit = 6-1 = 5.

Input: prices = [7,6,4,3,1]
Output: 0
Explanation: No profit possible since prices always decrease.

Approach 1: Brute Force (O(n²))

Try every buy-sell pair where buy comes before sell.

Copy

int maxProfitBrute(List<int> prices) {
  int maxProfit = 0;
  int n = prices.length;

  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      int profit = prices[j] - prices[i];
      if (profit > maxProfit) {
        maxProfit = profit;
      }
    }
  }

  return maxProfit;
}

void main() {
  print(maxProfitBrute([7,1,5,3,6,4])); // 5
  print(maxProfitBrute([7,6,4,3,1])); // 0
}

Time: O(n²) — too slow for interviews
Space: O(1)

Approach 2: Single Pass (Optimal)

Track the minimum price seen so far, and update max profit at each step.

Copy

int maxProfit(List<int> prices) {
  if (prices.isEmpty) return 0;

  int minPrice = prices[0];
  int maxProfit = 0;

  for (int i = 1; i < prices.length; i++) {
    // Update minimum price seen so far
    if (prices[i] < minPrice) {
      minPrice = prices[i];
    }
    // Update max profit if selling today gives better profit
    else if (prices[i] - minPrice > maxProfit) {
      maxProfit = prices[i] - minPrice;
    }
  }

  return maxProfit;
}

void main() {
  print(maxProfit([7,1,5,3,6,4])); // 5
  print(maxProfit([7,6,4,3,1])); // 0
  print(maxProfit([2,4,1])); // 2
}

Time: O(n) — single pass
Space: O(1)

How it works:

Track lowest price to buy at (minPrice)
Calculate profit if selling at current price (prices[i] - minPrice)
Update max profit if current profit is higher

Approach 3: Dynamic Programming (Educational)

For conceptual understanding, define DP state:

dp[i] = maximum profit achievable by day i

Copy

import 'dart:math';

int maxProfitDP(List<int> prices) {
  if (prices.isEmpty) return 0;

  int n = prices.length;
  List<int> dp = List.filled(n, 0);
  int minPrice = prices[0];

  for (int i = 1; i < n; i++) {
    minPrice = min(minPrice, prices[i]);
    dp[i] = max(dp[i - 1], prices[i] - minPrice);
  }

  return dp[n - 1];
}

void main() {
  print(maxProfitDP([7,1,5,3,6,4])); // 5
}

Time: O(n)
Space: O(n) for DP array — can be optimized to O(1) by tracking only the previous day.

Dart-Specific Tips

List.filled(n, 0) creates a fixed-size list
min(a, b) and max(a, b) from dart:math return minimum/maximum of two values (remember to import 'dart:math';)
Use isEmpty and isNotEmpty instead of length == 0
Dart lists are 0-indexed like Python/Java

Complexity Comparison

Approach	Time	Space	Notes
Brute Force	O(n²)	O(1)	Rarely accepted in interviews
Single Pass	O(n)	O(1)	✅ Best for production code
Dynamic Programming	O(n)	O(n)	Educational, can be optimized to O(1)

Follow-Up Problems

Best Time to Buy and Sell Stock II (#122) — unlimited transactions (accumulate all positive slopes)
Best Time with Cooldown (#309) — after sell, must skip one day
Best Time with Fee (#714) — subtract fee per transaction

Master #121 first — it’s the building block for all harder variants.

FAQ

What is the best approach to solve Best Time to Buy and Sell Stock in Dart?

The recommended approach is the optimal approach, which runs in O(n²) time with O(1) space. The full Dart implementation is shown above.

What is the time complexity of Best Time to Buy and Sell Stock in Dart?

Using the optimal approach, the time complexity is O(n²) and the space complexity is O(1).

Best Time to Buy and Sell Stock in Go — Optimal Solution & More

mihirpipermitwala.com — Sat, 12 Sep 2026 00:00:00 GMT

Best Time to Buy and Sell Stock (#121 — Easy): Given an array prices where prices[i] is the price of a stock on day i, choose one day to buy and a different later day to sell to maximize profit. Return that maximum profit, or 0 when no profitable trade exists.

Problem Statement

Given an array prices where prices[i] is the price of a stock on day i, choose one day to buy and a different later day to sell to maximize profit. Return that maximum profit, or 0 when no profitable trade exists.

Example:

Copy

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1), sell on day 5 (price = 6), profit = 6 − 1 = 5.

Approach: One-Pass Min Tracking (Optimal)

Time: O(n) | Space: O(1)

Walk the prices once while remembering the cheapest price seen so far. At each day the best possible trade selling today is today’s price minus that minimum, so update the answer on the fly.

Copy

package main

import ("fmt")

func maxProfit(prices []int) int {
	minPrice := prices[0]
	best := 0
	for _, price := range prices[1:] {
		if price < minPrice {
			minPrice = price
		} else if price-minPrice > best {
			best = price - minPrice
		}
	}
	return best
}

func main() {
	fmt.Println(maxProfit([]int{7, 1, 5, 3, 6, 4}))
}

Approach: Brute Force

Time: O(n²) | Space: O(1)

Try every buy-day/sell-day pair, keep the largest positive difference, and return it. Straightforward but quadratic, which fails on large inputs.

Copy

package main

import ("fmt")

func maxProfitBrute(prices []int) int {
	best := 0
	for i := 0; i < len(prices); i++ {
		for j := i + 1; j < len(prices); j++ {
			if prices[j]-prices[i] > best {
				best = prices[j] - prices[i]
			}
		}
	}
	return best
}

func main() {
	fmt.Println(maxProfitBrute([]int{7, 1, 5, 3, 6, 4}))
}

Key Takeaways

Start with the brute-force approach to understand the problem
One-Pass Min Tracking (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Best Time to Buy and Sell Stock in Go?

The recommended approach is One-Pass Min Tracking (Optimal), which runs in O(n) time with O(1) space. The full Go implementation is shown above.

What is the time complexity of Best Time to Buy and Sell Stock in Go?

Using One-Pass Min Tracking (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Best Time to Buy and Sell Stock in Python

mihirpipermitwala.com — Sat, 12 Sep 2026 00:00:00 GMT

Problem Statement

Example:

Copy

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1), sell on day 5 (price = 6), profit = 6 − 1 = 5.

Approach: One-Pass Min Tracking (Optimal)

Time: O(n) | Space: O(1)

Walk the prices once while remembering the cheapest price seen so far. At each day the best possible trade selling today is today’s price minus that minimum, so update the answer on the fly.

Copy

def max_profit(prices):
    min_price = prices[0]
    best = 0
    for price in prices[1:]:
        if price < min_price:
            min_price = price
        elif price - min_price > best:
            best = price - min_price
    return best

print(max_profit([7, 1, 5, 3, 6, 4]))

Approach: Brute Force

Time: O(n²) | Space: O(1)

Try every buy-day/sell-day pair, keep the largest positive difference, and return it. Straightforward but quadratic, which fails on large inputs.

Copy

def max_profit_brute(prices):
    best = 0
    for i in range(len(prices)):
        for j in range(i + 1, len(prices)):
            if prices[j] - prices[i] > best:
                best = prices[j] - prices[i]
    return best

print(max_profit_brute([7, 1, 5, 3, 6, 4]))

Key Takeaways

Start with the brute-force approach to understand the problem
One-Pass Min Tracking (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Best Time to Buy and Sell Stock in Python?

The recommended approach is One-Pass Min Tracking (Optimal), which runs in O(n) time with O(1) space. The full Python implementation is shown above.

What is the time complexity of Best Time to Buy and Sell Stock in Python?

Using One-Pass Min Tracking (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Best Time to Buy and Sell Stock in Swift — Solution & Explanation

mihirpipermitwala.com — Sat, 12 Sep 2026 00:00:00 GMT

Problem Statement

Example:

Copy

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1), sell on day 5 (price = 6), profit = 6 − 1 = 5.

Approach: One-Pass Min Tracking (Optimal)

Time: O(n) | Space: O(1)

Walk the prices once while remembering the cheapest price seen so far. At each day the best possible trade selling today is today’s price minus that minimum, so update the answer on the fly.

Copy

func maxProfit(_ prices: [Int]) -> Int {
    var minPrice = prices[0]
    var best = 0
    for price in prices.dropFirst() {
        if price < minPrice {
            minPrice = price
        } else if price - minPrice > best {
            best = price - minPrice
        }
    }
    return best
}

print(maxProfit([7, 1, 5, 3, 6, 4]))

Approach: Brute Force

Time: O(n²) | Space: O(1)

Try every buy-day/sell-day pair, keep the largest positive difference, and return it. Straightforward but quadratic, which fails on large inputs.

Copy

func maxProfitBrute(_ prices: [Int]) -> Int {
    var best = 0
    for i in 0..<prices.count {
        for j in (i + 1)..<prices.count {
            if prices[j] - prices[i] > best { best = prices[j] - prices[i] }
        }
    }
    return best
}

print(maxProfitBrute([7, 1, 5, 3, 6, 4]))

Key Takeaways

Start with the brute-force approach to understand the problem
One-Pass Min Tracking (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Best Time to Buy and Sell Stock in Swift?

The recommended approach is One-Pass Min Tracking (Optimal), which runs in O(n) time with O(1) space. The full Swift implementation is shown above.

What is the time complexity of Best Time to Buy and Sell Stock in Swift?

Using One-Pass Min Tracking (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

10 Creative Pattern Programs in Dart — Spiral, ZigZag & More

mihirpipermitwala.com — Fri, 04 Sep 2026 00:00:00 GMT

In this tutorial, we’ll explore 10 creative pattern programs in Dart that are useful for interviews and understanding loop mechanics. These go beyond basic shapes and introduce algorithmic thinking.

1. Spiral Square Pattern

Print a square spiral of numbers.

Copy

1  2  3  4  5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Copy

void spiralSquare(int n) {
  List<List<int>> matrix = List.generate(n, (_) => List.filled(n, 0));
  int num = 1;
  int top = 0, bottom = n - 1, left = 0, right = n - 1;

  while (top <= bottom && left <= right) {
    for (int i = left; i <= right; i++) matrix[top][i] = num++;
    top++;
    for (int i = top; i <= bottom; i++) matrix[i][right] = num++;
    right--;
    for (int i = right; i >= left; i--) matrix[bottom][i] = num++;
    bottom--;
    for (int i = bottom; i >= top; i--) matrix[i][left] = num++;
    left++;
  }

  for (var row in matrix) {
    print(row.map((e) => e.toString().padLeft(2)).join(" "));
  }
}

void main() => spiralSquare(5);

2. K-Shape Pattern

Print a K shape using asterisks.

Copy

* *
*  *
*   *
*    *
*   *
*  *
* *

Copy

void kShape(int n) {
  // Upper part
  for (int i = 1; i <= n; i++) {
    print("*" + " " * i + "*");
  }
  // Lower part
  for (int i = n - 1; i >= 1; i--) {
    print("*" + " " * i + "*");
  }
}

void main() => kShape(4);

3. Wave Pattern

Print a sine wave pattern.

Copy

*               *
* *           * *
*  *         *  *
*   *       *   *
*    *     *    *
*     *   *     *
*      * *      *
*       *       *
*      * *      *
*     *   *     *

Copy

void wavePattern(int n) {
  int width = 4 * n - 3; // 17 for n = 5
  int peak = 2 * n - 2;  // inner apex row

  for (int r = 1; r <= 2 * n; r++) {
    List<String> cells = List.filled(width, " ");
    cells[0] = "*";
    cells[width - 1] = "*";
    if (r > 1) {
      int inner = r <= peak ? r : 2 * peak - r;
      cells[inner] = "*";
      cells[width - 1 - inner] = "*";
    }
    print(cells.join());
  }
}

void main() => wavePattern(5);

4. Concentric Square Pattern

Print nested squares (like a target).

Copy

* * * * * * *
*           *
*   * * *   *
*   *   *   *
*   * * *   *
*           *
* * * * * * *

Copy

void concentricSquare(int n) {
  for (int i = 1; i <= n; i++) {
    String row = "";
    for (int j = 1; j <= n; j++) {
      int min = [i, j, n - i + 1, n - j + 1].reduce((a, b) => a < b ? a : b);
      if (min % 2 == 1) {
        row += "* ";
      } else {
        row += "  ";
      }
    }
    print(row);
  }
}

void main() => concentricSquare(7);

5. Checkerboard Pattern

Print a checkerboard (alternating black and white squares).

Copy

* * * * *
 * * * * *
* * * * *
 * * * * *
* * * * *

Copy

void checkerboard(int n) {
  for (int i = 0; i < n; i++) {
    String row = "";
    for (int j = 0; j < n; j++) {
      row += ((i + j) % 2 == 0) ? "* " : "  ";
    }
    print(row);
  }
}

void main() => checkerboard(5);

6. Fibonacci Triangle Pattern

Print Fibonacci numbers in triangle shape.

Copy

0
1 1
2 3 5
8 13 21 34
55 89 144 233 377

Copy

void fibonacciTriangle(int n) {
  List<int> fib = [0, 1];
  while (fib.length < n * (n + 1) ~/ 2) {
    fib.add(fib[fib.length - 1] + fib[fib.length - 2]);
  }

  int index = 0;
  for (int i = 1; i <= n; i++) {
    String row = "";
    for (int j = 1; j <= i; j++) {
      row += "${fib[index++]} ";
    }
    print(row);
  }
}

void main() => fibonacciTriangle(5);

7. Hollow Cross Pattern

Print a hollow cross/plus symbol.

Copy

  *
  *
*****
  *
  *

Copy

void hollowCross(int n) {
  int mid = n ~/ 2;
  for (int i = 0; i < n; i++) {
    String row = "";
    for (int j = 0; j < n; j++) {
      if (i == mid || j == mid) {
        row += "*";
      } else {
        row += " ";
      }
    }
    print(row);
  }
}

void main() => hollowCross(5);

8. Arrow Pattern

Print a right-pointing arrow.

Copy

*
**
***
****
*****
****
***
**
*

Copy

void arrowPattern(int n) {
  // Top half
  for (int i = 1; i <= n; i++) {
    print("*" * i);
  }
  // Bottom half
  for (int i = n - 1; i >= 1; i--) {
    print("*" * i);
  }
}

void main() => arrowPattern(5);

9. Heart Pattern

Print a heart shape.

Copy

 **   **
**** ****
*********
 *******
  *****
   ***
    *

Copy

void heartPattern(int n) {
  // Top lobes: two bumps separated by a gap
  for (int i = n ~/ 2 - 1; i <= n - 2; i += 2) {
    int pad = (n - i - 2) ~/ 2;
    print(" " * pad + "*" * i + " " * (n - i - 1) + "*" * i);
  }
  // Bottom point: shrinking triangle ending in a single star
  for (int i = n; i >= 2; i--) {
    print(" " * (n - i) + "*" * (2 * i - (n ~/ 2)));
  }
}

void main() => heartPattern(6);

10. Diamond with Letters

Print a diamond using consecutive letters.

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

Copy

import 'dart:io';

void diamondLetters(int n) {
  String letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  // Upper half
  for (int i = 0; i < n; i++) {
    stdout.write(" " * (n - i - 1));
    for (int j = 0; j <= i; j++) stdout.write(letters[j]);
    for (int j = i - 1; j >= 0; j--) stdout.write(letters[j]);
    stdout.writeln();
  }

  // Lower half
  for (int i = n - 2; i >= 0; i--) {
    stdout.write(" " * (n - i - 1));
    for (int j = 0; j <= i; j++) stdout.write(letters[j]);
    for (int j = i - 1; j >= 0; j--) stdout.write(letters[j]);
    stdout.writeln();
  }
}

void main() => diamondLetters(5);

Conclusion

These Dart patterns are perfect for Flutter developers looking to strengthen their algorithmic thinking. They cover everything from mathematical sequences (Fibonacci) to spatial reasoning (Spiral, Concentric) and ASCII art (Heart, K-Shape).

Try integrating these into your DartPad or Flutter console apps!

Happy coding!

Claude Code vs Copilot Agent vs Cursor: 3 Months of Real Work

mihirpipermitwala.com — Wed, 19 Aug 2026 00:00:00 GMT

Three months ago I stopped asking “which AI coding tool is best?” and started asking “which one actually ships my work?” I’ve used Claude Code, GitHub Copilot Agent, and Cursor daily on real projects — Flutter apps, React Native prototypes, and backend APIs. This isn’t a feature checklist comparison. This is what happened when I tried to get actual work done with each tool.

How Did I Set Up the 3-Month Test?

I gave each tool the same tasks:

Refactor a 2000-line Flutter BLoC into smaller components
Add offline-first sync to a Node.js API with PostgreSQL
Debug a React Native navigation memory leak
Write comprehensive tests for a payment integration

I tracked time, tokens (where visible), and — most importantly — whether the output needed heavy editing or was shippable.

Claude Code: The CLI Powerhouse

Cost: $150-250/month for team usage (Pro plan, heavy usage)

What It Does Well

Claude Code operates in your terminal, not an IDE. It reads your entire project context, runs commands, and iterates autonomously. When I asked it to refactor the Flutter BLoC, it:

Ran flutter analyze to see every warning
Read the existing file
Generated a refactored version
Ran tests automatically
Fixed the failures it introduced

The MCP integration I wrote about in my Flutter MCP post transforms it. It can actually do things, not just suggest.

Where It Falls Short

Context switching: Leaving VS Code to use a terminal for AI help breaks flow. I caught myself avoiding asking Claude because I didn’t want to switch contexts.
Latency: Large refactors take 30 seconds to 2 minutes. Not interactive.
Cost: At $150+/month, solo developers will flinch.

Real Numbers

Task	Time to Complete	Quality (1-10)	Edits Needed
BLoC refactor	4 min	8/10	Minor (null safety)
Offline sync	12 min	7/10	Some logic errors
RN memory leak	25 min	9/10	Correct root cause

GitHub Copilot Agent: The Quiet Workhorse

Cost: $10/month (Individual), $19/user/month (Business)

What It Does Well

Copilot Agent is unobtrusive. It sits in VS Code, watches your code, and completes lines before you think of them. The agent mode (Ctrl+Shift+I) can:

Implement entire functions
Fix errors automatically
Run tests in the background

I was skeptical about the $10 price point, but the ROI is undeniable. For boilerplate — model classes, form validations, simple CRUD — Copilot writes 80% of the code.

Where It Falls Short

Shallow context: It sees the current file, maybe the tabbed files. It doesn’t understand architectural decisions.
No autonomy: You drive. It suggests. For complex refactors, you’re guiding every step.
Flutter gaps: Good at generic Dart, weak at Flutter-specific patterns (BLoC, Riverpod, widget lifecycle).

Real Numbers

Task	Time to Complete	Quality (1-10)	Integration
BLoC refactor	45 min (guided)	6/10	VS Code native
Offline sync	90 min (guided)	5/10	Needed manual fixes
RN memory leak	3 hrs	4/10	Missed navigation issue

Cursor: The AI-Native IDE

Cost: $20/month (Pro), $40/user/month (Business)

What It Does Well

Cursor is VS Code rebuilt for AI. The “Composer” feature edits multiple files simultaneously. The “Chat” understands your entire codebase (with indexing). When I asked it to add offline sync, it:

Indexed my project
Asked clarifying questions about conflict resolution strategy
Generated the code, tests, and migration scripts
Showed diffs for review before applying

It’s like pair programming with a senior engineer who never sleeps.

Where It Falls Short

IDE lock-in: Your team must use Cursor. VS Code extensions don’t transfer cleanly (settings sync is manual).
Heavier resource usage: Cursor takes 2-3 GB RAM vs VS Code’s 500 MB.
Over-eager: Sometimes “helps” when you didn’t ask. I disabled some auto-features.

Real Numbers

Task	Time to Complete	Quality (1-10)	Notes
BLoC refactor	8 min	9/10	Perfect null safety
Offline sync	15 min	8/10	Caught edge cases I missed
RN memory leak	10 min	9/10	Identified useEffect cleanup issue

Which Commands Do I Actually Use Every Day?

Here’s the concrete setup behind the hybrid stack, so you can reproduce it.

Claude Code — launch it in your project root and let it read the whole tree:

Copy

# Install once
npm install -g @anthropic-ai/claude-code

# Run inside a repo; it picks up context automatically
cd ~/projects/my-flutter-app
claude

# One-shot refactor with a specific instruction
claude "Refactor lib/bloc/cart_bloc.dart into smaller components and run flutter analyze"

Cursor — enable codebase indexing and set the model in Settings > Features:

Copy

// .cursor/settings.json
{
  "codebaseIndexing": true,
  "model": "claude-sonnet",
  "composer.enabled": true,
  "autoApplyEdits": false
}

GitHub Copilot — turn on agent mode and inline suggestions in VS Code:

Copy

// settings.json
{
  "github.copilot.enable": { "*": true },
  "github.copilot.chat.agent.enabled": true,
  "editor.inlineSuggest.enabled": true
}

The single highest-leverage addition was wiring an MCP server into Claude Code so it can run flutter analyze and the test suite itself — that’s covered in my Flutter MCP post.

Which AI Coding Tool Wins Head-to-Head?

Feature	Claude Code	Copilot Agent	Cursor
Cost	$$$	$	$$
Autonomy	High	Low	Medium
Context Awareness	Excellent	Poor	Excellent
IDE Integration	None (CLI)	Native	Native (is IDE)
Learning Curve	Medium	Low	Low
Team-friendly	Hard to enforce	Easy	Medium
MCP Support	Yes	No	Yes

What Is My Verdict After 3 Months?

After 3 months, I landed on a hybrid approach:

Claude Code for:

Large refactors
Architecture discussions
Complex debugging (the memory leak analysis was worth the price)
Anything requiring MCP (Flutter tooling, React Native analysis)

Cursor for:

Rapid prototyping
Multi-file edits (adding a feature across model, UI, and tests)
When I want AI-native UX

Copilot for:

Boilerplate generation
Writing simple functions
Pairing when teaching (junior devs appreciate the inline suggestions)

Cost-Driven Recommendations

Solo developer on budget: Cursor ($20). It covers 80% of use cases with the best UX.

Team wanting consistency: Copilot Business ($19/user). Minimal disruption, proven ROI.

Power user shipping complex features: Claude Code ($200). The autonomy pays for itself in saved time.

Enterprise with security constraints: Azure-hosted Copilot or self-hosted Claude via Bedrock.

What Are the Honest Limitations of Each Tool?

None of these tools replace understanding:

Claude Code generates code that works but may violate your team’s patterns without MCP guidance.
Copilot suggests outdated Flutter widgets (pre-Material 3 patterns).
Cursor hallucinates APIs when indexed documentation is stale.

You still need senior engineers to catch these. AI makes juniors 3x faster, mids 2x faster, and seniors 1.5x faster (less typing, more reviewing). The last part is crucial — reviewing AI output is a skill. These tools accelerate anyone who can recognize why generated code is wrong.

What’s Next

The gap between these tools is closing. Cursor added agent mode, Claude Code got IDE extensions, Copilot went agentic. By mid-2027, we’ll likely see one clear winner. For now, my advice:

Start with Cursor for a month.
Add Claude Code for complex refactors.
Keep Copilot for lightweight work.
Invest in MCP custom servers for your stack.

Your mileage will vary, but I shipped 40% more features in Q2 than Q1 with this stack. The tools are real. The hype, however, undersells how much correction they still need.

FAQ

Which is better: Claude Code, Copilot Agent, or Cursor?

It depends on the work. Claude Code wins for large autonomous refactors and complex debugging, Cursor for multi-file edits and rapid prototyping with the best AI-native UX, and Copilot for cheap boilerplate and inline suggestions. After three months of daily use on production projects, a hybrid of all three beat any single tool.

How much do Claude Code, Cursor, and Copilot cost?

Copilot is cheapest at $10/month for individuals ($19/user for Business), Cursor Pro is $20/month, and heavy Claude Code usage runs roughly $150–250/month at team level. For most solo developers, Cursor covers the most use cases per dollar, while Claude Code’s autonomy pays off only when complex refactors and debugging dominate your workload.

Is Claude Code worth the cost compared to Copilot?

For power users shipping complex features, yes — in a three-month comparison it finished a Flutter BLoC refactor in 4 minutes versus 45 guided minutes with Copilot, and solved a navigation memory leak Copilot missed entirely. At $150+ per month it is hard to justify for boilerplate work, but its autonomy on hard tasks pays for itself.

Can I use Claude Code, Cursor, and Copilot together?

Yes, and that hybrid approach works best. Use Claude Code in the terminal for big refactors and MCP-driven tasks, Cursor as the AI-native IDE for multi-file prototyping, and Copilot inline in VS Code for boilerplate and teaching juniors. One developer reported shipping 40% more features in a quarter with this combined stack.

Spiral Number Matrix in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 20 Jul 2026 00:00:00 GMT

The Spiral Number Matrix pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

Implementation

Copy

void main() {
  int n = 5;
  List<List<int>> matrix = List.generate(n, (_) => List.filled(n, 0));
  int num = 1, top = 0, bottom = n - 1, left = 0, right = n - 1;
  while (top <= bottom && left <= right) {
    for (int i = left; i <= right; i++) { matrix[top][i] = num++; }
    top++;
    for (int i = top; i <= bottom; i++) { matrix[i][right] = num++; }
    right--;
    if (top <= bottom) {
      for (int i = right; i >= left; i--) { matrix[bottom][i] = num++; }
      bottom--;
    }
    if (left <= right) {
      for (int i = bottom; i >= top; i--) { matrix[i][left] = num++; }
      left++;
    }
  }
  for (var row in matrix) {
    print(row.map((e) => e.toString().padLeft(3)).join(' '));
  }
}

Output

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

How It Works

Layer-by-layer approach: walk the outer ring clockwise (top → right → bottom → left), then shrink the boundaries and repeat for the inner rings.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Number Matrix pattern in Dart?

What is the time complexity of the Spiral Number Matrix pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Spiral Number Matrix in Go — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 20 Jul 2026 00:00:00 GMT

The Spiral Number Matrix pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

Implementation

Copy

package main

import "fmt"

func main() {
	n := 5
	matrix := make([][]int, n)
	for i := range matrix { matrix[i] = make([]int, n) }
	num, top, bottom, left, right := 1, 0, n-1, 0, n-1
	for top <= bottom && left <= right {
		for i := left; i <= right; i++ { matrix[top][i] = num; num++ }
		top++
		for i := top; i <= bottom; i++ { matrix[i][right] = num; num++ }
		right--
		if top <= bottom {
			for i := right; i >= left; i-- { matrix[bottom][i] = num; num++ }
			bottom--
		}
		if left <= right {
			for i := bottom; i >= top; i-- { matrix[i][left] = num; num++ }
			left++
		}
	}
	for _, row := range matrix {
		for _, v := range row { fmt.Printf("%3d ", v) }
		fmt.Println()
	}
}

Output

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

How It Works

Layer-by-layer approach: walk the outer ring clockwise (top → right → bottom → left), then shrink the boundaries and repeat for the inner rings.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Number Matrix pattern in Go?

What is the time complexity of the Spiral Number Matrix pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Spiral Number Matrix in Python — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 20 Jul 2026 00:00:00 GMT

The Spiral Number Matrix pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

Implementation

Copy

def spiral_matrix(n):
    matrix = [[0]*n for _ in range(n)]
    num = 1
    top, bottom, left, right = 0, n-1, 0, n-1
    while top <= bottom and left <= right:
        for i in range(left, right+1):
            matrix[top][i] = num; num += 1
        top += 1
        for i in range(top, bottom+1):
            matrix[i][right] = num; num += 1
        right -= 1
        if top <= bottom:
            for i in range(right, left-1, -1):
                matrix[bottom][i] = num; num += 1
            bottom -= 1
        if left <= right:
            for i in range(bottom, top-1, -1):
                matrix[i][left] = num; num += 1
            left += 1
    for row in matrix:
        print(' '.join(f'{x:3d}' for x in row))

spiral_matrix(5)

Output

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

How It Works

Layer-by-layer approach: walk the outer ring clockwise (top → right → bottom → left), then shrink the boundaries and repeat for the inner rings.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Number Matrix pattern in Python?

What is the time complexity of the Spiral Number Matrix pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Spiral Number Matrix in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 20 Jul 2026 00:00:00 GMT

The Spiral Number Matrix pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

Implementation

Copy

func spiralMatrix(_ n: Int) {
    var matrix = Array(repeating: Array(repeating: 0, count: n), count: n)
    var num = 1, top = 0, bottom = n - 1, left = 0, right = n - 1
    while top <= bottom && left <= right {
        for i in left...right { matrix[top][i] = num; num += 1 }
        top += 1
        for i in top...bottom { matrix[i][right] = num; num += 1 }
        right -= 1
        if top <= bottom {
            for i in stride(from: right, through: left, by: -1) { matrix[bottom][i] = num; num += 1 }
            bottom -= 1
        }
        if left <= right {
            for i in stride(from: bottom, through: top, by: -1) { matrix[i][left] = num; num += 1 }
            left += 1
        }
    }
    for row in matrix {
        print(row.map { String(format: "%3d", $0) }.joined(separator: " "))
    }
}
spiralMatrix(5)

Output

Copy

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

How It Works

Layer-by-layer approach: walk the outer ring clockwise (top → right → bottom → left), then shrink the boundaries and repeat for the inner rings.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Number Matrix pattern in Swift?

What is the time complexity of the Spiral Number Matrix pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Antigravity vs Claude Code vs Codex: Honest 2026 Test

mihirpipermitwala.com — Sat, 04 Jul 2026 00:00:00 GMT

The Antigravity vs Claude Code vs Codex question got harder to answer this year. Codex hit 5 million weekly active users in June 2026, up from 600,000 in January. That’s 8x growth in five months (OpenAI, June 2026). A growth curve that steep demands a real answer: is the tool actually better, or just better distributed? I ran all three major agentic coding tools on one concrete production task to find out. The task: scaffold a production REST API endpoint with JWT authentication, input validation, and unit tests. Same requirements, no pre-loaded context, first-run results only. I’ve used all three for six months. This test confirmed some assumptions and overturned a few.

If you’re already building an AI-assisted workflow, this pairs well with my breakdown of 5 ways to transform your workflow using GitHub Copilot and MCP.

Claude Code produced the cleanest TypeScript with 100% test coverage in ~3 minutes, but real-world team cost runs $150-250/dev/month (finout.io, June 2026)

Codex added HMAC state protection without being asked and keeps running async in the background while you review output

Antigravity finished in ~2 minutes with parallel agents and opened a live browser preview instantly, but its free tier dropped from 250 to 20 requests/day (Augment Code, June 2026)

The Same-Task Test
Feature Matrix at a Glance
What Is Antigravity, Really?
Does Claude Code Justify Its Price Tag?
Why Is Codex Growing So Fast?
What Does Each Tool Actually Cost?
Which One Is Right for You?
Can You Use All Three Together?
FAQ

Antigravity vs Claude Code vs Codex: The Same-Task Test

One prompt. Three tools. One hour. I measured test coverage, time to first compile, and any behavior that wasn’t explicitly asked for. No cherry-picked runs. Claude Opus 4.8’s 88.6% SWE-bench Verified score (MorphLLM SWE-bench Pro, July 2026) set the quality baseline before I started. These are first-run numbers, run sequentially on identical task input.

Metric	Antigravity	Claude Code	Codex
Files generated	5 (parallel)	5	7
Wall-clock time	~2 min	~3 min	~4 min
TypeScript coverage	37%	100%	Not measured
First-run compile	Yes	Near (1 import fix)	Yes
Security standout	None	None	HMAC state protection
Browser preview	Yes (immediate)	No	No

The 37% TypeScript coverage from Antigravity isn’t a minor gap. For auth scaffolding, partial typing is technical debt you pay the moment you write a test. Claude Code’s 100% coverage reflects what a model trained specifically for agentic coding tasks actually produces under real conditions.

Codex’s HMAC state protection appeared in the auth middleware without being prompted. It was correctly implemented, not left as a stub. That’s the kind of security-first default that changes how you think about what “code quality” means across these tools.

Reproduce the Test

Here’s the exact setup, so you can run the same comparison yourself:

Copy

# Install the two CLIs
npm install -g @anthropic-ai/claude-code
npm install -g @openai/codex

# Same prompt, run fresh in an empty directory for each tool
claude "Scaffold a production Express REST API endpoint with JWT auth,
input validation via zod, and unit tests. Use TypeScript."

codex "Scaffold a production Express REST API endpoint with JWT auth,
input validation via zod, and unit tests. Use TypeScript."

For Antigravity, paste the identical prompt into a new Agent Manager session. Measure with npx jest --coverage and time from prompt to first successful compile.

Citation Capsule: Claude Opus 4.8 scores 88.6% on SWE-bench Verified as of July 2026, the highest of any generally-available model, per the MorphLLM SWE-bench Pro leaderboard. This benchmark measures resolution of real GitHub issues, making it the most direct proxy for production code generation quality currently available.

Feature Matrix at a Glance

Claude Code leads GitHub stars at 131,985, ahead of Gemini CLI’s 105,189 and Codex CLI’s 90,644 as of June 2026 (gradually.ai, June 2026). Stars track ecosystem momentum: available integrations, community plugins, how fast bugs surface. The matrix below covers features that affect daily developer workflow, not features that sound impressive in announcements.

Feature	Antigravity	Claude Code	Codex
Model	Gemini 3.5 Flash	Claude Opus 4.8	GPT-5.5
Setup	Standalone IDE	`npm -g` CLI	`npm -g` CLI
Parallel agents	Up to 5	Sequential	Async background
Browser testing	Native (built-in)	Via MCP plugin	No
Code quality	Good (37% TS coverage)	Best (100% TS)	Strong (HMAC security)
Enterprise (SOC2)	No	Yes	Partial
Mobile handoff	No	No	Yes (Codex Remote)
Google ecosystem	Deep	No	No
GitHub stars	105K (Gemini CLI)	131K	90K

Benchmark Performance Comparison

What Is Antigravity, Really?

Antigravity is Google’s standalone agent-first IDE, built on a VS Code base from the Windsurf team Google acquired in November 2025. Version 2.0 launched at Google I/O on May 19, 2026. Gemini 3.5 Flash generates approximately 289 tokens per second, described by Google as 4x faster than competing frontier models (Google I/O 2026 blog, May 19, 2026). The speed shows in the parallel agent execution.

The native Chromium sub-agent is the feature no other tool in this comparison has. After scaffolding the JWT endpoint, Antigravity immediately opened a browser preview of the running service. I didn’t prompt for it. For front-end and full-stack work where visual verification matters, this saves a real context switch. The multi-agent system, up to five parallel Gemini agents, also lets you run a test suite while writing additional features simultaneously.

Pricing trajectory is the real risk. Antigravity’s free tier dropped from 250 requests per day to 20 requests per day between December 2025 and February 2026, a 97% reduction in under two months (Augment Code competitive analysis, June 2026). There’s no SOC 2 certification, no SAML, and no team pricing yet. These aren’t minor footnotes for a team evaluating production tooling.

Citation Capsule: Antigravity’s free tier was cut from 250 requests/day to 20 requests/day between December 2025 and February 2026, a 97% reduction in under eight weeks, per Augment Code’s competitive analysis (June 2026). Teams building workflows around the free tier should treat it as a temporary subsidy, not a stable pricing commitment.

Does Claude Code Justify Its Price Tag?

Real-world team cost for Claude Code runs $150-250 per developer per month before optimization (finout.io, June 2026). That’s not the $20 Pro plan listed on the pricing page. It’s what engineering teams actually pay when developers use it as a primary coding tool across an eight-hour workday. Whether the quality justifies that cost depends on what you’re building.

The code quality makes the argument clearly. The 100% TypeScript coverage on the JWT scaffold, with one minor import path correction needed before first compile, reflects a model trained specifically for agentic tasks. Claude Opus 4.8’s 88.6% SWE-bench Verified score (MorphLLM, July 2026) is the highest of any generally-available model. That number translates directly to fewer correction cycles in practice.

The approval-gate model is the unlock, not the bottleneck. Because Claude Code asks before executing shell commands, you naturally review architecture decisions before they’re committed to disk. You catch a wrong directory structure or a missing middleware pattern before it propagates. No other tool in this comparison forces that discipline. After six months of use, it’s changed how I think about code review as a step in the generation loop.

Citation Capsule: Claude Code carries SOC 2 Type II and ISO 27001 certification, making it the only tool in this comparison with enterprise-grade compliance credentials. Combined with an 88.6% SWE-bench Verified score (MorphLLM, July 2026) and 131,985 GitHub stars (gradually.ai, June 2026), it’s the strongest option for regulated engineering environments.

Why Is Codex Growing So Fast?

Codex reached 5 million weekly active users in June 2026, up from 600,000 in January (OpenAI, June 2026). That’s 8x growth in five months. Distribution explains it: Codex is bundled into ChatGPT subscriptions that developers already pay for. Zero additional billing friction, zero new account creation. That distribution advantage explains a significant portion of the growth curve.

GPT-5.5 leads Terminal-Bench 2.0 at 82.7% (Kommunicate hands-on comparison, June 2026), the benchmark specifically designed for command-line and scripting tasks. If your team writes shell automation, cron jobs, or data pipeline scripts, that number is more relevant to your workflow than SWE-bench. Codex Remote went GA on June 25, 2026 (OpenAI Codex changelog, June 2026), adding mobile handoff via ChatGPT iOS and Android. You can start a background refactoring task on your laptop and approve the diff from your phone. No other tool does this.

Sandbox isolation is the limitation. Codex runs in isolated cloud environments. If your stack is fully cloud-native, this is transparent. If you rely on local Docker services, private databases, or VPN-gated infrastructure, the isolation becomes a real blocker with no current workaround.

Citation Capsule: Codex reached 5 million weekly active users by June 2026, up from 600,000 in January, representing 8x growth in five months, per OpenAI (openai.com/index/codex-for-knowledge-work, June 2, 2026). The bundled ChatGPT subscription model removes the barrier to first use that competing tools require, which partly explains the adoption velocity.

What Does Each Tool Actually Cost?

Claude Code’s typical team cost runs $150-250 per developer per month before optimization (finout.io, June 2026). That’s the number that drives budget conversations, not the sticker price on the plans page. Here’s the full picture across all three tools:

Tier	Claude Code	Codex	Antigravity
Free	None	Yes (local)	20 req/day
Entry	$20/mo Pro	$20/mo (ChatGPT Plus)	$20/mo Pro
Mid	$100/mo Max 5x	$100/mo Pro 5x	—
Heavy	$200/mo Max 20x	$200/mo Pro 20x	$249.99/mo Ultra
Team	$100/seat/mo	Business (PAYG)	Not yet
Real cost	$150-250/dev/mo	$100-200/dev/mo	Free in preview*

*Antigravity pricing reliability: free tier cut 97% once already.

Codex at $100-200 per developer per month offers the clearest value if your team already pays for ChatGPT Max. The bundled billing means no separate line item, which simplifies approval in most organizations. Claude Code’s Max 5x plan at $100 per month covers moderate daily use, but heavy users with large codebases hit the ceiling fast. Antigravity is genuinely free during the preview period. Whether that holds is the open question.

Citation Capsule: A hybrid Claude Code plus Antigravity CLI approach delivered a 27-64% cost reduction compared to running Claude solo on a large build task, per an analysis by Yuting Lin in the Google Cloud Community on Medium (June 2026). The savings come from routing lower-complexity tasks to the Antigravity CLI while reserving Claude’s full context for architecture and auth work.

Claude Code vs Codex vs Antigravity: Which One Is Right for You?

Adoption numbers don’t answer this question. Codex reached 5 million weekly active users in June 2026 (OpenAI, June 2026), but active users and the right tool for your specific workflow are different measurements. Here are three clear verdicts based on the test results and real-world cost data above.

Use Claude Code if you need the highest code quality available, your organization has SOC 2 or ISO 27001 requirements, and budget is approved for $150-250 per developer per month. The approval-gate model is a genuine workflow advantage for teams that review code seriously. The 100% TypeScript coverage from the test wasn’t a coincidence.

Use Codex if your team already pays for ChatGPT, you write significant shell automation or async pipelines, or you need mobile-accessible background task execution via Codex Remote. Terminal-Bench 2.0 leadership at 82.7% also makes it the right pick for scripting-heavy data engineering work.

Use Antigravity if you’re doing front-end or full-stack work where visual browser verification saves real time, you’re on Firebase or Google Cloud, and you can accept early-access risk. The parallel agent execution and native browser preview are genuinely useful. Don’t build team workflows around the free tier.

Can You Use All Three Together?

A hybrid Claude Code and Antigravity CLI approach delivered a 27-64% cost reduction compared to Claude solo on a large build task (Yuting Lin, Google Cloud Community on Medium, June 2026). The pattern extends naturally to all three tools. Use Claude Code for architecture decisions and auth logic where type correctness matters most. Route long-running async jobs, like large refactors or bulk test generation, to Codex background tasks. Use Antigravity for parallel front-end feature work and browser verification of API outputs.

What makes this work is treating the tools as a pipeline, not as competitors. Claude Code’s approval-gate rhythm pairs directly with Codex’s async execution model: you review Claude’s architecture plan, kick off a Codex background refactor, then open Antigravity to run browser verification while both tasks run in parallel. That’s three separate AI workstreams running simultaneously while you review diffs. The cost reduction isn’t just about cheaper tokens. It’s about using each model’s strength at exactly the right stage of the build cycle.

FAQ

Is Claude Code worth $150-250 per month for a solo developer?

It depends on your output volume. If you’re shipping production features daily and your TypeScript correctness matters, the code quality reduction in rework time can cover that cost quickly. We’ve found the approval-gate workflow alone catches enough early errors to justify it on large codebases. For side projects or light use, the $20 Pro plan covers more than it looks like on paper.

Is Antigravity ready for production team use?

Not yet, based on the current state. No SOC 2, no SAML, no team pricing tier, and a 97% free-tier cut in two months (Augment Code, June 2026) signal a tool still finding its business model. The Chromium browser agent and parallel execution are genuinely ahead of competitors. Check back when enterprise compliance and stable pricing land. Solo developers and Firebase-native teams can use it now with low risk.

Does Codex’s cloud sandbox create real limitations?

Yes, for specific infrastructure patterns. If you run local databases, private APIs, or VPN-gated services, Codex Remote can’t reach them from its isolated cloud environment. GPT-5.5’s Terminal-Bench 2.0 score of 82.7% shows strong capability on pure command-line tasks. The sandbox is a hard constraint, not a soft limitation. OpenAI has not announced local environment bridging support as of July 2026.

Which tool works best for a TypeScript and Node.js stack?

Claude Code. The test result is direct: 100% TypeScript coverage versus Antigravity’s 37%. Claude Opus 4.8’s 88.6% SWE-bench Verified score (MorphLLM, July 2026) translates to correct types, accurate import paths, and auth middleware that doesn’t need a second pass. For Node.js API work specifically, the gap between Claude Code and the other two tools is larger than the benchmark numbers suggest.

Spiral Maze Path in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 02 Jul 2026 00:00:00 GMT

The Spiral Maze Path pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

Implementation

Copy

void main() {
  int n = 10;
  List<List<String>> maze = List.generate(n, (_) => List.filled(n, ' '));
  int top = 0, bottom = n - 1, left = 0, right = n - 1;
  while (top <= bottom && left <= right) {
    for (int i = left; i <= right; i++) { maze[top][i] = '#'; }
    top += 2;
    for (int i = top; i <= bottom; i++) { maze[i][right] = '#'; }
    right -= 2;
    if (top <= bottom) {
      for (int i = right; i >= left; i--) { maze[bottom][i] = '#'; }
      bottom -= 2;
    }
    if (left <= right) {
      for (int i = bottom; i >= top; i--) { maze[i][left] = '#'; }
      left += 2;
    }
  }
  for (var row in maze) {
    print(row.join());
  }
}

Output

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

How It Works

A spiral path drawn with walls: each pass adds a rectangular ring, then jumps 2 cells inward to start the next ring. Produces a clean maze-like spiral.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Maze Path pattern in Dart?

What is the time complexity of the Spiral Maze Path pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Spiral Maze Path in Go — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 02 Jul 2026 00:00:00 GMT

The Spiral Maze Path pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

Implementation

Copy

package main

import "fmt"

func main() {
	n := 10
	maze := make([][]rune, n)
	for i := range maze {
		maze[i] = make([]rune, n)
		for j := range maze[i] { maze[i][j] = ' ' }
	}
	top, bottom, left, right := 0, n-1, 0, n-1
	for top <= bottom && left <= right {
		for i := left; i <= right; i++ { maze[top][i] = '#' }
		top += 2
		for i := top; i <= bottom; i++ { maze[i][right] = '#' }
		right -= 2
		if top <= bottom {
			for i := right; i >= left; i-- { maze[bottom][i] = '#' }
			bottom -= 2
		}
		if left <= right {
			for i := bottom; i >= top; i-- { maze[i][left] = '#' }
			left += 2
		}
	}
	for _, row := range maze { fmt.Println(string(row)) }
}

Output

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

How It Works

A spiral path drawn with walls: each pass adds a rectangular ring, then jumps 2 cells inward to start the next ring. Produces a clean maze-like spiral.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Maze Path pattern in Go?

What is the time complexity of the Spiral Maze Path pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Spiral Maze Path in Python — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 02 Jul 2026 00:00:00 GMT

The Spiral Maze Path pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

Implementation

Copy

def spiral_maze(n):
    maze = [[' ']*n for _ in range(n)]
    top, bottom, left, right = 0, n-1, 0, n-1
    while top <= bottom and left <= right:
        for i in range(left, right+1): maze[top][i] = '#'
        top += 2
        for i in range(top, bottom+1): maze[i][right] = '#'
        right -= 2
        if top <= bottom:
            for i in range(right, left-1, -1): maze[bottom][i] = '#'
            bottom -= 2
        if left <= right:
            for i in range(bottom, top-1, -1): maze[i][left] = '#'
            left += 2
    for row in maze:
        print(''.join(row))

spiral_maze(10)

Output

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

How It Works

A spiral path drawn with walls: each pass adds a rectangular ring, then jumps 2 cells inward to start the next ring. Produces a clean maze-like spiral.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Maze Path pattern in Python?

What is the time complexity of the Spiral Maze Path pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Spiral Maze Path in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 02 Jul 2026 00:00:00 GMT

The Spiral Maze Path pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

Implementation

Copy

func spiralMaze(_ n: Int) {
    var maze = Array(repeating: Array(repeating: " ", count: n), count: n)
    var top = 0, bottom = n - 1, left = 0, right = n - 1
    while top <= bottom && left <= right {
        for i in left...right { maze[top][i] = "#" }
        top += 2
        if top > bottom { break }
        for i in top...bottom { maze[i][right] = "#" }
        right -= 2
        if left > right { break }
        if top <= bottom {
            for i in stride(from: right, through: left, by: -1) { maze[bottom][i] = "#" }
            bottom -= 2
        }
        if left <= right {
            for i in stride(from: bottom, through: top, by: -1) { maze[i][left] = "#" }
            left += 2
        }
    }
    for row in maze { print(row.joined()) }
}
spiralMaze(10)

Output

Copy

##########
#        #
# ###### #
# #    # #
# # ## # #
# # ## # #
# #    # #
# ###### #
#        #
##########

How It Works

A spiral path drawn with walls: each pass adds a rectangular ring, then jumps 2 cells inward to start the next ring. Produces a clean maze-like spiral.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Spiral Maze Path pattern in Swift?

What is the time complexity of the Spiral Maze Path pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Snake Matrix in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 04 Jun 2026 00:00:00 GMT

The Snake Matrix pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

Implementation

Copy

void main() {
  int n = 5, num = 1;
  for (int i = 0; i < n; i++) {
    List<int> row = List.generate(n, (j) => num + j);
    if (i % 2 == 1) row = row.reversed.toList();
    print(row.map((e) => e.toString().padLeft(3)).join(' '));
    num += n;
  }
}

Output

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

How It Works

Fill rows sequentially left-to-right, but reverse every odd row. The result zigzags like a snake.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Snake Matrix pattern in Dart?

What is the time complexity of the Snake Matrix pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Snake Matrix in Go — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 04 Jun 2026 00:00:00 GMT

The Snake Matrix pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

Implementation

Copy

package main

import "fmt"

func main() {
	n, num := 5, 1
	for i := 0; i < n; i++ {
		row := make([]int, n)
		for j := 0; j < n; j++ { row[j] = num + j }
		if i%2 == 1 {
			for l, r := 0, len(row)-1; l < r; l, r = l+1, r-1 { row[l], row[r] = row[r], row[l] }
		}
		for _, v := range row { fmt.Printf("%3d ", v) }
		fmt.Println()
		num += n
	}
}

Output

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

How It Works

Fill rows sequentially left-to-right, but reverse every odd row. The result zigzags like a snake.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Snake Matrix pattern in Go?

What is the time complexity of the Snake Matrix pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Snake Matrix in Python — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 04 Jun 2026 00:00:00 GMT

The Snake Matrix pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

Implementation

Copy

def snake_matrix(n):
    num = 1
    for i in range(n):
        row = list(range(num, num + n))
        if i % 2 == 1: row.reverse()
        print(' '.join(f'{x:3d}' for x in row))
        num += n

snake_matrix(5)

Output

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

How It Works

Fill rows sequentially left-to-right, but reverse every odd row. The result zigzags like a snake.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Snake Matrix pattern in Python?

What is the time complexity of the Snake Matrix pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Snake Matrix in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 04 Jun 2026 00:00:00 GMT

The Snake Matrix pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

Implementation

Copy

func snakeMatrix(_ n: Int) {
    var num = 1
    for i in 0..<n {
        var row = (0..<n).map { num + $0 }
        if i % 2 == 1 { row.reverse() }
        print(row.map { String(format: "%3d", $0) }.joined(separator: " "))
        num += n
    }
}
snakeMatrix(5)

Output

Copy

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
21 22 23 24 25

How It Works

Fill rows sequentially left-to-right, but reverse every odd row. The result zigzags like a snake.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Snake Matrix pattern in Swift?

What is the time complexity of the Snake Matrix pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right Pascal Star in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 03 May 2026 00:00:00 GMT

The Right Pascal Star pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

Implementation

Copy

void main() {
  int n = 5;
  // Top half
  for (int i = 1; i <= n; i++) {
    print(' ' * (n - i) + '*' * i);
  }
  // Bottom half
  for (int i = n - 1; i >= 1; i--) {
    print(' ' * (n - i) + '*' * i);
  }
}

Output

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

How It Works

Two loops: the first builds rows from 1 to n stars (right-aligned), the second mirrors it back down from n-1 to 1. Result is a sideways diamond.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right Pascal Star pattern in Dart?

What is the time complexity of the Right Pascal Star pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right Pascal Star in Go — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 03 May 2026 00:00:00 GMT

The Right Pascal Star pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ {
		fmt.Println(strings.Repeat(" ", n-i) + strings.Repeat("*", i))
	}
	for i := n - 1; i >= 1; i-- {
		fmt.Println(strings.Repeat(" ", n-i) + strings.Repeat("*", i))
	}
}

Output

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

How It Works

Two loops: the first builds rows from 1 to n stars (right-aligned), the second mirrors it back down from n-1 to 1. Result is a sideways diamond.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right Pascal Star pattern in Go?

What is the time complexity of the Right Pascal Star pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right Pascal Star in Python — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 03 May 2026 00:00:00 GMT

The Right Pascal Star pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

Implementation

Copy

def right_pascal(n):
    # Top half (including middle)
    for i in range(1, n + 1):
        print(" " * (n - i) + "*" * i)
    # Bottom half
    for i in range(n - 1, 0, -1):
        print(" " * (n - i) + "*" * i)

right_pascal(5)

Output

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

How It Works

Two loops: the first builds rows from 1 to n stars (right-aligned), the second mirrors it back down from n-1 to 1. Result is a sideways diamond.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right Pascal Star pattern in Python?

What is the time complexity of the Right Pascal Star pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right Pascal Star in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 03 May 2026 00:00:00 GMT

The Right Pascal Star pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

Implementation

Copy

func rightPascal(_ n: Int) {
    for i in 1...n {
        print(String(repeating: " ", count: n - i) + String(repeating: "*", count: i))
    }
    for i in stride(from: n - 1, through: 1, by: -1) {
        print(String(repeating: " ", count: n - i) + String(repeating: "*", count: i))
    }
}
rightPascal(5)

Output

Copy

    *
   **
  ***
 ****
*****
 ****
  ***
   **
    *

How It Works

Two loops: the first builds rows from 1 to n stars (right-aligned), the second mirrors it back down from n-1 to 1. Result is a sideways diamond.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right Pascal Star pattern in Swift?

What is the time complexity of the Right Pascal Star pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Reverse Linked List in Dart — Iterative (Optimal) & More

mihirpipermitwala.com — Thu, 09 Apr 2026 00:00:00 GMT

Reverse Linked List (#206 — Easy): Given the head of a singly linked list, reverse the list, and return the reversed list.

Problem Statement

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example:

Copy

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Approach: Iterative (Optimal)

Time: O(n) | Space: O(1)

Three pointers dance: save next, flip current’s pointer backward, advance both. The head becomes the tail and prev ends up as the new head.

Copy

ListNode? reverseList(ListNode? head) {
  ListNode? prev, curr = head;
  while (curr != null) {
    var nxt = curr.next;
    curr.next = prev;
    prev = curr;
    curr = nxt;
  }
  return prev;
}

Approach: Recursive

Time: O(n) | Space: O(n) (call stack)

Recursively reverse the rest of the list, then fix the current node. Elegant but uses stack space proportional to list length.

Copy

ListNode? reverseListRecursive(ListNode? head) {
  if (head == null || head.next == null) return head;
  var newHead = reverseListRecursive(head.next);
  head.next!.next = head;
  head.next = null;
  return newHead;
}

Key Takeaways

Start with the brute-force approach to understand the problem
Iterative (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Reverse Linked List in Dart?

The recommended approach is Iterative (Optimal), which runs in O(n) time with O(1) space. The full Dart implementation is shown above.

What is the time complexity of Reverse Linked List in Dart?

Using Iterative (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Reverse Linked List in Go — Iterative (Optimal) & More

mihirpipermitwala.com — Thu, 09 Apr 2026 00:00:00 GMT

Reverse Linked List (#206 — Easy): Given the head of a singly linked list, reverse the list, and return the reversed list.

Problem Statement

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example:

Copy

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Approach: Iterative (Optimal)

Time: O(n) | Space: O(1)

Three pointers dance: save next, flip current’s pointer backward, advance both. The head becomes the tail and prev ends up as the new head.

Copy

func reverseList(head *ListNode) *ListNode {
	var prev *ListNode
	curr := head
	for curr != nil {
		nxt := curr.Next
		curr.Next = prev
		prev = curr
		curr = nxt
	}
	return prev
}

Approach: Recursive

Time: O(n) | Space: O(n) (call stack)

Recursively reverse the rest of the list, then fix the current node. Elegant but uses stack space proportional to list length.

Copy

func reverseListRecursive(head *ListNode) *ListNode {
	if head == nil || head.Next == nil { return head }
	newHead := reverseListRecursive(head.Next)
	head.Next.Next = head
	head.Next = nil
	return newHead
}

Key Takeaways

Start with the brute-force approach to understand the problem
Iterative (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Reverse Linked List in Go?

The recommended approach is Iterative (Optimal), which runs in O(n) time with O(1) space. The full Go implementation is shown above.

What is the time complexity of Reverse Linked List in Go?

Using Iterative (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Reverse Linked List in Python — Iterative (Optimal) & More

mihirpipermitwala.com — Thu, 09 Apr 2026 00:00:00 GMT

Reverse Linked List (#206 — Easy): Given the head of a singly linked list, reverse the list, and return the reversed list.

Problem Statement

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example:

Copy

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Approach: Iterative (Optimal)

Time: O(n) | Space: O(1)

Three pointers dance: save next, flip current’s pointer backward, advance both. The head becomes the tail and prev ends up as the new head.

Copy

def reverse_list(head):
    prev = None
    curr = head
    while curr:
        nxt = curr.next
        curr.next = prev
        prev = curr
        curr = nxt
    return prev

Approach: Recursive

Time: O(n) | Space: O(n) (call stack)

Recursively reverse the rest of the list, then fix the current node. Elegant but uses stack space proportional to list length.

Copy

def reverse_list_recursive(head):
    if not head or not head.next:
        return head
    new_head = reverse_list_recursive(head.next)
    head.next.next = head
    head.next = None
    return new_head

Key Takeaways

Start with the brute-force approach to understand the problem
Iterative (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Reverse Linked List in Python?

The recommended approach is Iterative (Optimal), which runs in O(n) time with O(1) space. The full Python implementation is shown above.

What is the time complexity of Reverse Linked List in Python?

Using Iterative (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Reverse Linked List in Swift — Iterative (Optimal) & More

mihirpipermitwala.com — Thu, 09 Apr 2026 00:00:00 GMT

Reverse Linked List (#206 — Easy): Given the head of a singly linked list, reverse the list, and return the reversed list.

Problem Statement

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example:

Copy

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Approach: Iterative (Optimal)

Time: O(n) | Space: O(1)

Three pointers dance: save next, flip current’s pointer backward, advance both. The head becomes the tail and prev ends up as the new head.

Copy

func reverseList(_ head: ListNode?) -> ListNode? {
    var prev: ListNode? = nil
    var curr = head
    while let node = curr {
        let nxt = node.next
        node.next = prev
        prev = node
        curr = nxt
    }
    return prev
}

Approach: Recursive

Time: O(n) | Space: O(n) (call stack)

Recursively reverse the rest of the list, then fix the current node. Elegant but uses stack space proportional to list length.

Copy

func reverseListRecursive(_ head: ListNode?) -> ListNode? {
    guard let head = head, let next = head.next else { return head }
    let newHead = reverseListRecursive(next)
    next.next = head
    head.next = nil
    return newHead
}

Key Takeaways

Start with the brute-force approach to understand the problem
Iterative (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Reverse Linked List in Swift?

The recommended approach is Iterative (Optimal), which runs in O(n) time with O(1) space. The full Swift implementation is shown above.

What is the time complexity of Reverse Linked List in Swift?

Using Iterative (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Repeated Letter Rows in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 12 Mar 2026 00:00:00 GMT

The Repeated Letter Rows pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

A
BB
CCC
DDDD
EEEEE

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) { print(String.fromCharCode(64 + i) * i); }
}

Output

Copy

A
BB
CCC
DDDD
EEEEE

How It Works

Row i prints the i-th letter of the alphabet repeated i times.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Repeated Letter Rows pattern in Dart?

What is the time complexity of the Repeated Letter Rows pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Repeated Letter Rows in Go — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 12 Mar 2026 00:00:00 GMT

The Repeated Letter Rows pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

A
BB
CCC
DDDD
EEEEE

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ { fmt.Println(strings.Repeat(string(64+i), i)) }
}

Output

Copy

A
BB
CCC
DDDD
EEEEE

How It Works

Row i prints the i-th letter of the alphabet repeated i times.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Repeated Letter Rows pattern in Go?

What is the time complexity of the Repeated Letter Rows pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Repeated Letter Rows in Python — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 12 Mar 2026 00:00:00 GMT

The Repeated Letter Rows pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

A
BB
CCC
DDDD
EEEEE

Implementation

Copy

def repeated_letter(n):
    for i in range(1, n + 1):
        print(chr(64 + i) * i)

repeated_letter(5)

Output

Copy

A
BB
CCC
DDDD
EEEEE

How It Works

Row i prints the i-th letter of the alphabet repeated i times.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Repeated Letter Rows pattern in Python?

What is the time complexity of the Repeated Letter Rows pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Repeated Letter Rows in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 12 Mar 2026 00:00:00 GMT

The Repeated Letter Rows pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

A
BB
CCC
DDDD
EEEEE

Implementation

Copy

func repeatedLetter(_ n: Int) {
    for i in 1...n { print(String(repeating: String(UnicodeScalar(64 + i)!), count: i)) }
}
repeatedLetter(5)

Output

Copy

A
BB
CCC
DDDD
EEEEE

How It Works

Row i prints the i-th letter of the alphabet repeated i times.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Repeated Letter Rows pattern in Swift?

What is the time complexity of the Repeated Letter Rows pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

PugCalc - Calculator

mihirpipermitwala.com — Thu, 05 Mar 2026 00:00:00 GMT

PugCalc is an all-in-one smart calculator app for Android, combining standard and specialized utility calculation features into an intuitive, lightweight mobile experience.

What Makes PugCalc Different From the Built-In Android Calculator?

Stock calculator apps handle everyday arithmetic well, but they stop there. PugCalc bundles the specialized modes people usually install separate apps for — percentage calculations, unit-style conversions, and multi-step expressions — into a single lightweight package. The entire app is built with Flutter, which keeps the install size small while delivering a smooth 60fps interface on everything from budget phones to flagships.

What Features Does PugCalc Include?

Standard calculations — addition, subtraction, multiplication, division with full expression support
Percentage tools — quick percentage-of, increase/decrease, and discount math
Advanced functions — the specialized calculations needed for finance and day-to-day problem solving
Clean history — review and reuse previous calculations without leaving the flow
Ad-light interface — a focused UI that stays out of the way of the math

Who Is PugCalc For?

PugCalc is designed for anyone who reaches for a calculator more than once a day: students checking homework, shoppers comparing discounts, freelancers quoting percentages, and professionals doing quick on-the-go math. Because every mode lives in one app, it replaces the clutter of three or four single-purpose utilities.

How Is PugCalc Built?

The app is developed in Dart with Flutter, following the same clean-architecture principles I write about on this blog — separation of UI and logic, testable calculation engines, and platform-aware state management. You can read more about those practices in the Flutter clean code guide.

How Do You Get PugCalc?

PugCalc is available as a free download on Google Play for Android devices. Install it, grant nothing beyond what a calculator needs, and start calculating.

Tester Legion - 20 Testers for Closed Testing

mihirpipermitwala.com — Sun, 01 Mar 2026 00:00:00 GMT

Tester Legion is an Android developer platform that solves Google Play’s 20-tester, 14-day closed testing requirement. It connects indie developers through a reciprocal community testing system with automated tracking and community-backed feedback.

What Is Google Play’s 20-Tester Requirement?

Since late 2023, Google requires every new personal developer account to run a closed test with at least 20 testers for 14 consecutive days before the app can move to production on Google Play. For solo developers with no audience, this single requirement blocks thousands of launches — and that is exactly the problem Tester Legion was built to solve.

How Does Tester Legion Work?

Tester Legion is a reciprocal community: you test other developers’ apps, and they test yours. The platform coordinates the exchange, tracks participation, and makes sure your tester count stays above the 20-tester threshold across the full 14-day window. Automated tracking means you can see exactly where you stand against the requirement at any moment, instead of chasing testers by hand in Discord servers and Reddit threads.

Who Should Use Tester Legion?

Indie Android developers publishing their first app under a personal Google Play account
Solo founders who need to clear the closed-testing gate without an existing user base
Small teams that want a predictable, dependable tester pool for every release

What Do You Get as a Member?

A reliable pool of 20+ active testers for your closed testing track
Automated day-by-day tracking of your 14-day requirement
Community-backed feedback from real Android users, not bots
Reciprocal credit — testing others keeps your own app eligible

How Do You Get Started?

Install the Tester Legion app from Google Play, register your app’s closed testing track, and start testing other members’ builds to earn credits for your own. Most developers clear the 14-day requirement without any manual coordination.

Pascal's Triangle in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 21 Jan 2026 00:00:00 GMT

The Pascal’s Triangle pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 0; i < n; i++) {
    int num = 1;
    String row = ' ' * (n - i);
    for (int j = 0; j <= i; j++) { row += num.toString() + ' '; num = num * (i - j) ~/ (j + 1); }
    print(row);
  }
}

Output

Copy

How It Works

Each element is computed with the multiplicative formula: value = previous * (row - col) / (col + 1).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Pascal’s Triangle pattern in Dart?

What is the time complexity of the Pascal’s Triangle pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Pascal's Triangle in Go — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 21 Jan 2026 00:00:00 GMT

The Pascal’s Triangle pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

Implementation

Copy

package main

import "fmt"

func main() {
	n := 5
	for i := 0; i < n; i++ {
		num := 1
		for s := 0; s < n-i; s++ { fmt.Print(" ") }
		for j := 0; j <= i; j++ { fmt.Printf("%d ", num); num = num * (i - j) / (j + 1) }
		fmt.Println()
	}
}

Output

Copy

How It Works

Each element is computed with the multiplicative formula: value = previous * (row - col) / (col + 1).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Pascal’s Triangle pattern in Go?

What is the time complexity of the Pascal’s Triangle pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Pascal's Triangle in Python — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 21 Jan 2026 00:00:00 GMT

The Pascal’s Triangle pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

Implementation

Copy

def pascal_triangle(n):
    for i in range(n):
        num = 1
        print(' ' * (n - i), end='')
        for j in range(i + 1):
            print(num, end=' ')
            num = num * (i - j) // (j + 1)
        print()

pascal_triangle(5)

Output

Copy

How It Works

Each element is computed with the multiplicative formula: value = previous * (row - col) / (col + 1).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Pascal’s Triangle pattern in Python?

What is the time complexity of the Pascal’s Triangle pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Pascal's Triangle in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 21 Jan 2026 00:00:00 GMT

The Pascal’s Triangle pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

Implementation

Copy

func pascalTriangle(_ n: Int) {
    for i in 0..<n {
        var num = 1
        var row = String(repeating: " ", count: n - i)
        for j in 0...i { row += "(num) "; num = num * (i - j) / (j + 1) }
        print(row)
    }
}
pascalTriangle(5)

Output

Copy

How It Works

Each element is computed with the multiplicative formula: value = previous * (row - col) / (col + 1).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Pascal’s Triangle pattern in Swift?

What is the time complexity of the Pascal’s Triangle pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

10 Advanced Pattern Programs in Python — Floyd's & More

mihirpipermitwala.com — Sat, 03 Jan 2026 00:00:00 GMT

In this tutorial, we’ll explore 10 advanced pattern programs in Python that go beyond basic triangles. These patterns are frequently asked in technical interviews and are excellent for mastering nested loops and 2D arrays.

1. Floyd’s Triangle

Print Floyd’s triangle (consecutive numbers in rows).

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

Copy

def floyds_triangle(n):
    num = 1
    for i in range(1, n + 1):
        for j in range(i):
            print(num, end=" ")
            num += 1
        print()

floyds_triangle(5)

2. Pascal’s Triangle

Print Pascal’s triangle (binomial coefficients).

Copy

Copy

def pascals_triangle(n):
    for i in range(n):
        # Print leading spaces
        print(" " * (n - i - 1), end="")
        
        num = 1
        for j in range(i + 1):
            print(num, end=" ")
            num = num * (i - j) // (j + 1)
        print()

pascals_triangle(5)

3. Butterfly Pattern

Print a butterfly shape.

Copy

*        *
**      **
***    ***
****  ****
**********
****  ****
***    ***
**      **
*        *

Copy

def butterfly(n):
    # Upper half
    for i in range(1, n + 1):
        print("*" * i + " " * (2 * (n - i)) + "*" * i)
    
    # Lower half
    for i in range(n, 0, -1):
        print("*" * i + " " * (2 * (n - i)) + "*" * i)

butterfly(5)

4. Spiral Matrix Pattern

Fill a matrix in spiral order and print it.

Copy

1  2  3  4  5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Copy

def spiral_matrix(n):
    matrix = [[0] * n for _ in range(n)]
    num = 1
    top, bottom, left, right = 0, n - 1, 0, n - 1
    
    while top <= bottom and left <= right:
        for i in range(left, right + 1):
            matrix[top][i] = num
            num += 1
        top += 1
        
        for i in range(top, bottom + 1):
            matrix[i][right] = num
            num += 1
        right -= 1
        
        for i in range(right, left - 1, -1):
            matrix[bottom][i] = num
            num += 1
        bottom -= 1
        
        for i in range(bottom, top - 1, -1):
            matrix[i][left] = num
            num += 1
        left += 1
    
    for row in matrix:
        print(" ".join(f"{x:2}" for x in row))

spiral_matrix(5)

5. ZigZag Pattern

Print a zigzag wave of numbers.

Copy

1       5       9
  2   4   6   8
    3       7

Copy

def zigzag(n, rows=3):
    cols = 2 * n - 1
    grid = [[" " for _ in range(cols)] for _ in range(rows)]
    r, c = 0, 0
    direction = 1  # moving down
    for num in range(1, n + 1):
        grid[r][c] = str(num)
        if r == rows - 1:
            direction = -1
        elif r == 0:
            direction = 1
        r += direction
        c += 2
    for row in grid:
        print(" ".join(row).rstrip())

zigzag(9, 3)

6. Sandglass Pattern

Print a sandglass (hourglass) shape with numbers.

Copy

1 2 3 4 5 6 7 8 9
  2 3 4 5 6 7 8
    3 4 5 6 7
      4 5 6
        5
      4 5 6
    3 4 5 6 7
  2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9

Copy

def sandglass(n):
    # Upper half
    for i in range(1, n + 1):
        print("  " * (i - 1), end="")
        for j in range(i, 2 * n - i + 1):
            print(j, end=" ")
        print()
    
    # Lower half
    for i in range(n - 1, 0, -1):
        print("  " * (i - 1), end="")
        for j in range(i, 2 * n - i + 1):
            print(j, end=" ")
        print()

sandglass(5)

7. Wave Pattern

Print a sine wave using asterisks.

Copy

*               *
* *           * *
*  *         *  *
*   *       *   *
*    *     *    *
*     *   *     *
*      * *      *
*       *       *

Copy

def wave(n):
    width = 2 * n + 1
    for i in range(1, n + 1):
        if i == n:
            # Bottom row: peak points merged into a solid line
            print("*" * (n + 1))
        else:
            line = [" "] * width
            line[0] = "*"            # left edge
            line[2 * n] = "*"        # right edge
            if i > 1:
                line[i] = "*"        # descending diagonal
                if (2 * n - i) != i:
                    line[2 * n - i] = "*"  # ascending diagonal
            print("".join(line).rstrip())

wave(8)

8. Hollow Diamond Pattern

Print a hollow diamond (only edges).

Copy

    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

Copy

def hollow_diamond(n):
    # Upper half
    for i in range(1, n + 1):
        print(" " * (n - i), end="")
        for j in range(1, 2 * i):
            if j == 1 or j == 2 * i - 1:
                print("*", end="")
            else:
                print(" ", end="")
        print()
    
    # Lower half
    for i in range(n - 1, 0, -1):
        print(" " * (n - i), end="")
        for j in range(1, 2 * i):
            if j == 1 or j == 2 * i - 1:
                print("*", end="")
            else:
                print(" ", end="")
        print()

hollow_diamond(5)

9. Christmas Tree Pattern

Print a Christmas tree with trunk.

Copy

      *
     ***
    *****
   *******
  *********
 ***********
*************
     |||
     |||
     |||

Copy

def christmas_tree(n):
    # Tree layers
    for i in range(1, n + 1):
        print(" " * (n - i) + "*" * (2 * i - 1))
    
    # Trunk
    trunk_width = 3
    trunk_height = 3
    for _ in range(trunk_height):
        print(" " * (n - 2) + "|" * trunk_width)

christmas_tree(7)

10. Number Snake Pattern

Print numbers in a snake-like sequence.

Copy

Copy

def number_snake(n):
    for i in range(1, n + 1):
        for j in range(i, i + n):
            print(j, end=" ")
        print()

number_snake(5)

Conclusion

These advanced patterns will help you master Python loops and 2D arrays. Try combining them or creating your own variations. Each pattern teaches different algorithmic thinking - from mathematical sequences (Floyd’s, Pascal’s) to spatial reasoning (Spiral, ZigZag).

Happy coding!

Palindromic Number Pyramid in Dart — Code, Output & Explanation

mihirpipermitwala.com — Thu, 18 Dec 2025 00:00:00 GMT

The Palindromic Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) {
    String row = ' ' * (n - i);
    for (int j = 1; j <= i; j++) { row += j.toString(); }
    for (int j = i - 1; j >= 1; j--) { row += j.toString(); }
    print(row);
  }
}

Output

Copy

How It Works

Print ascending 1..i then descending i-1..1 on each row, right-aligned with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Palindromic Number Pyramid pattern in Dart?

What is the time complexity of the Palindromic Number Pyramid pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Palindromic Number Pyramid in Go — Code, Output & Explanation

mihirpipermitwala.com — Thu, 18 Dec 2025 00:00:00 GMT

The Palindromic Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ {
		fmt.Print(strings.Repeat(" ", n-i))
		for j := 1; j <= i; j++ { fmt.Print(j) }
		for j := i - 1; j >= 1; j-- { fmt.Print(j) }
		fmt.Println()
	}
}

Output

Copy

How It Works

Print ascending 1..i then descending i-1..1 on each row, right-aligned with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Palindromic Number Pyramid pattern in Go?

What is the time complexity of the Palindromic Number Pyramid pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Palindromic Number Pyramid in Python — Code, Output & Explanation

mihirpipermitwala.com — Thu, 18 Dec 2025 00:00:00 GMT

The Palindromic Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

Implementation

Copy

def palindromic_pyramid(n):
    for i in range(1, n + 1):
        print(' ' * (n - i), end='')
        for j in range(1, i + 1): print(j, end='')
        for j in range(i - 1, 0, -1): print(j, end='')
        print()

palindromic_pyramid(5)

Output

Copy

How It Works

Print ascending 1..i then descending i-1..1 on each row, right-aligned with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Palindromic Number Pyramid pattern in Python?

What is the time complexity of the Palindromic Number Pyramid pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Palindromic Number Pyramid in Swift — Code, Output & Explanation

mihirpipermitwala.com — Thu, 18 Dec 2025 00:00:00 GMT

The Palindromic Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

Implementation

Copy

func palindromicPyramid(_ n: Int) {
    for i in 1...n {
        var row = String(repeating: " ", count: n - i)
        for j in 1...i { row += "(j)" }
        for j in stride(from: i - 1, through: 1, by: -1) { row += "(j)" }
        print(row)
    }
}
palindromicPyramid(5)

Output

Copy

How It Works

Print ascending 1..i then descending i-1..1 on each row, right-aligned with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Palindromic Number Pyramid pattern in Swift?

What is the time complexity of the Palindromic Number Pyramid pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Number Pyramid in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 16 Nov 2025 00:00:00 GMT

The Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) { print(' ' * (n - i) + (i.toString() + ' ') * i); }
}

Output

Copy

How It Works

Row i repeats the digit i exactly i times, centered with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Number Pyramid pattern in Dart?

What is the time complexity of the Number Pyramid pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Number Pyramid in Go — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 16 Nov 2025 00:00:00 GMT

The Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

Implementation

Copy

package main

import ("fmt"; "strings"; "strconv")

func main() {
	n := 5
	for i := 1; i <= n; i++ { fmt.Println(strings.Repeat(" ", n-i) + strings.Repeat(strconv.Itoa(i)+" ", i)) }
}

Output

Copy

How It Works

Row i repeats the digit i exactly i times, centered with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Number Pyramid pattern in Go?

What is the time complexity of the Number Pyramid pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Number Pyramid in Python — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 16 Nov 2025 00:00:00 GMT

The Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

Implementation

Copy

def number_pyramid(n):
    for i in range(1, n + 1):
        print(' ' * (n - i) + (str(i) + ' ') * i)

number_pyramid(5)

Output

Copy

How It Works

Row i repeats the digit i exactly i times, centered with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Number Pyramid pattern in Python?

What is the time complexity of the Number Pyramid pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Number Pyramid in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Sun, 16 Nov 2025 00:00:00 GMT

The Number Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

Implementation

Copy

func numberPyramid(_ n: Int) {
    for i in 1...n { print(String(repeating: " ", count: n - i) + String(repeating: "(i) ", count: i)) }
}
numberPyramid(5)

Output

Copy

How It Works

Row i repeats the digit i exactly i times, centered with leading spaces.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Number Pyramid pattern in Swift?

What is the time complexity of the Number Pyramid pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Maximum Subarray in Dart — Kadane's Algorithm (Optimal) & More

mihirpipermitwala.com — Thu, 23 Oct 2025 00:00:00 GMT

Maximum Subarray (#53 — Medium): Given an integer array nums, find the subarray with the largest sum, and return its sum.

Problem Statement

Given an integer array nums, find the subarray with the largest sum, and return its sum.

Example:

Copy

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The subarray [4,-1,2,1] has the sum 6.

Approach: Kadane’s Algorithm (Optimal)

Time: O(n) | Space: O(1)

Kadane’s tracks the best sum ending at each index: either start fresh at current element, or extend the previous sum. The answer is the maximum of all these local bests.

Copy

int maxSubArray(List<int> nums) {
  if (nums.isEmpty) return 0;
  int maxSum = nums[0], current = nums[0];
  for (int i = 1; i < nums.length; i++) {
    current = nums[i] > current + nums[i] ? nums[i] : current + nums[i];
    maxSum = maxSum > current ? maxSum : current;
  }
  return maxSum;
}

void main() {
  print(maxSubArray([-2,1,-3,4,-1,2,1,-5,4]));  // 6
}

Approach: Brute Force

Time: O(n²) | Space: O(1)

Try every starting point and extend it to all possible endings. Too slow for large inputs but simple to verify correctness.

Copy

int maxSubArrayBrute(List<int> nums) {
  int maxSum = nums[0];
  for (int i = 0; i < nums.length; i++) {
    int current = 0;
    for (int j = i; j < nums.length; j++) {
      current += nums[j];
      if (current > maxSum) maxSum = current;
    }
  }
  return maxSum;
}

Key Takeaways

Start with the brute-force approach to understand the problem
Kadane’s Algorithm (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Maximum Subarray in Dart?

The recommended approach is Kadane’s Algorithm (Optimal), which runs in O(n) time with O(1) space. The full Dart implementation is shown above.

What is the time complexity of Maximum Subarray in Dart?

Using Kadane’s Algorithm (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Maximum Subarray in Go — Kadane's Algorithm (Optimal) & More

mihirpipermitwala.com — Thu, 23 Oct 2025 00:00:00 GMT

Maximum Subarray (#53 — Medium): Given an integer array nums, find the subarray with the largest sum, and return its sum.

Problem Statement

Given an integer array nums, find the subarray with the largest sum, and return its sum.

Example:

Copy

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The subarray [4,-1,2,1] has the sum 6.

Approach: Kadane’s Algorithm (Optimal)

Time: O(n) | Space: O(1)

Kadane’s tracks the best sum ending at each index: either start fresh at current element, or extend the previous sum. The answer is the maximum of all these local bests.

Copy

func maxSubArray(nums []int) int {
	if len(nums) == 0 { return 0 }
	maxSum, current := nums[0], nums[0]
	for _, num := range nums[1:] {
		if num > current+num { current = num } else { current = current + num }
		if current > maxSum { maxSum = current }
	}
	return maxSum
}

func main() {
	fmt.Println(maxSubArray([]int{-2,1,-3,4,-1,2,1,-5,4}))  // 6
}

Approach: Brute Force

Time: O(n²) | Space: O(1)

Try every starting point and extend it to all possible endings. Too slow for large inputs but simple to verify correctness.

Copy

func maxSubArrayBrute(nums []int) int {
	maxSum := nums[0]
	for i := 0; i < len(nums); i++ {
		current := 0
		for j := i; j < len(nums); j++ {
			current += nums[j]
			if current > maxSum { maxSum = current }
		}
	}
	return maxSum
}

Key Takeaways

Start with the brute-force approach to understand the problem
Kadane’s Algorithm (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Maximum Subarray in Go?

The recommended approach is Kadane’s Algorithm (Optimal), which runs in O(n) time with O(1) space. The full Go implementation is shown above.

What is the time complexity of Maximum Subarray in Go?

Using Kadane’s Algorithm (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Maximum Subarray in Python — Kadane's Algorithm (Optimal) & More

mihirpipermitwala.com — Thu, 23 Oct 2025 00:00:00 GMT

Maximum Subarray (#53 — Medium): Given an integer array nums, find the contiguous subarray with the largest sum and return its sum. Kadane’s algorithm solves it in O(n) time — a classic dynamic programming interview question every Python developer should know.

Problem Statement

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Examples:

Copy

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The subarray [4,-1,2,1] has the sum 6.

Input: nums = [1]
Output: 1

Input: nums = [5,4,-1,7,8]
Output: 23

Approach: Kadane’s Algorithm (Optimal)

Time: O(n) | Space: O(1)

Track the best sum ending at each index. For position i, the best sum ending there is either:

nums[i] (start a new subarray), OR
nums[i] + best_sum_at_i-1 (extend the previous subarray)

Copy

def max_subarray_kadane(nums):
    if not nums:
        return 0

    max_so_far = nums[0]   # global max
    max_ending_here = nums[0]  # best sum ending at current position

    for num in nums[1:]:
        # Either start a new subarray OR extend the existing one
        max_ending_here = max(num, max_ending_here + num)
        # Update the global max
        max_so_far = max(max_so_far, max_ending_here)

    return max_so_far

# Test
print(max_subarray_kadane([-2,1,-3,4,-1,2,1,-5,4]))  # 6
print(max_subarray_kadane([5,4,-1,7,8]))              # 23
print(max_subarray_kadane([-1]))                       # -1

This is the interview-standard answer.

Walkthrough of Kadane’s Algorithm

For nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]:

Index	Value	`max_ending_here`	`max_so_far`	Decision
0	-2	-2	-2	start new
1	1	1	1	new is better than -2+1
2	-3	-2	1	extend: 1 + (-3) = -2
3	4	4	4	new: -2+4=2, better to start at 4
4	-1	3	4	extend: 4 - 1 = 3
5	2	5	5	extend: 3 + 2 = 5
6	1	6	6	extend: 5 + 1 = 6 (best so far)
7	-5	1	6	extend: 6 - 5 = 1
8	4	5	6	extend: 1 + 4 = 5

Final answer: 6 (from subarray [4, -1, 2, 1])

Approach: Brute Force

Time: O(n²) | Space: O(1)

Generate every possible subarray and track the maximum sum. Too slow for interviews, but useful to validate correctness on small inputs.

Copy

def max_subarray_brute(nums):
    max_sum = float('-inf')
    for i in range(len(nums)):
        current_sum = 0
        for j in range(i, len(nums)):
            current_sum += nums[j]
            if current_sum > max_sum:
                max_sum = current_sum
    return max_sum

# Test
print(max_subarray_brute([-2,1,-3,4,-1,2,1,-5,4]))  # 6

Approach: Divide & Conquer

Time: O(n log n) | Space: O(log n)

Split the array in half. The answer is either:

Entirely in the left half
Entirely in the right half
Crossing the middle (left suffix + right prefix)

Copy

def max_subarray_dc(nums):
    def max_crossing_sum(arr, left, mid, right):
        # Left part: from mid to left
        left_sum = float('-inf')
        current_sum = 0
        for i in range(mid, left - 1, -1):
            current_sum += arr[i]
            if current_sum > left_sum:
                left_sum = current_sum

        # Right part: from mid+1 to right
        right_sum = float('-inf')
        current_sum = 0
        for i in range(mid + 1, right + 1):
            current_sum += arr[i]
            if current_sum > right_sum:
                right_sum = current_sum

        return left_sum + right_sum

    def max_subarray_recursive(arr, left, right):
        if left == right:
            return arr[left]

        mid = (left + right) // 2
        left_max = max_subarray_recursive(arr, left, mid)
        right_max = max_subarray_recursive(arr, mid + 1, right)
        cross_max = max_crossing_sum(arr, left, mid, right)

        return max(left_max, right_max, cross_max)

    if not nums:
        return 0
    return max_subarray_recursive(nums, 0, len(nums) - 1)

Good to know if asked, but usually overkill since Kadane’s is simpler.

Approach: Kadane’s with Index Tracking

Time: O(n) | Space: O(1)

Return the subarray indices along with the sum — a common interview follow-up:

Copy

def max_subarray_with_indices(nums):
    if not nums:
        return 0, -1, -1

    max_sum = nums[0]
    current_sum = nums[0]
    start = 0
    end = 0
    current_start = 0

    for i in range(1, len(nums)):
        if current_sum + nums[i] < nums[i]:
            current_sum = nums[i]
            current_start = i
        else:
            current_sum += nums[i]

        if current_sum > max_sum:
            max_sum = current_sum
            start = current_start
            end = i

    return max_sum, start, end

# Test
nums = [-2,1,-3,4,-1,2,1,-5,4]
result, start, end = max_subarray_with_indices(nums)
print(f"Max sum: {result}")       # 6
print(f"Indices: {start} to {end}") # 3 to 6
print(f"Subarray: {nums[start:end+1]}") # [4, -1, 2, 1]

Complexity Comparison

Approach	Time	Space	Interview Use
Brute Force	O(n²)	O(1)	Rarely
Kadane’s Algorithm	O(n)	O(1)	✅ Always use
Divide & Conquer	O(n log n)	O(log n)	✅ If asked
Index Tracking	O(n)	O(1)	⭐ For follow-ups

Common Mistakes to Avoid

Initializing with 0 instead of nums[0] — breaks when all numbers are negative
Forgetting -inf — using -999 doesn’t work for edge cases
Misunderstanding “contiguous” — the subarray must have consecutive elements
Trying to return indices with original Kadane — leads to off-by-one errors

Practice Exercises

Modify Kadane to handle all-negative arrays correctly
Write the max-product variant (take the max of current, previous_max * num, previous_min * num)
Write a version that returns the actual subarray as a slice
Implement the circular-array version where the array connects to itself

Key Takeaways

Start with the brute-force approach to understand the problem
Kadane’s Algorithm gives the optimal O(n) solution with O(1) space
The core idea — best sum ending here is max(num, best + num) — is a reusable dynamic programming pattern that appears frequently in coding interviews

FAQ

What is the best approach to solve Maximum Subarray in Python?

The recommended approach is Kadane’s Algorithm (Optimal), which runs in O(n) time with O(1) space. The full Python implementation is shown above.

What is the time complexity of Maximum Subarray in Python?

Using Kadane’s Algorithm (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Maximum Subarray in Swift — Kadane's Algorithm (Optimal) & More

mihirpipermitwala.com — Thu, 23 Oct 2025 00:00:00 GMT

Maximum Subarray (#53 — Medium): Given an integer array nums, find the subarray with the largest sum, and return its sum.

Problem Statement

Given an integer array nums, find the subarray with the largest sum, and return its sum.

Example:

Copy

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The subarray [4,-1,2,1] has the sum 6.

Approach: Kadane’s Algorithm (Optimal)

Time: O(n) | Space: O(1)

Kadane’s tracks the best sum ending at each index: either start fresh at current element, or extend the previous sum. The answer is the maximum of all these local bests.

Copy

func maxSubArray(_ nums: [Int]) -> Int {
    guard let first = nums.first else { return 0 }
    var maxSum = first, current = first
    for num in nums.dropFirst() {
        current = max(num, current + num)
        maxSum = max(maxSum, current)
    }
    return maxSum
}
print(maxSubArray([-2,1,-3,4,-1,2,1,-5,4]))  // 6

Approach: Brute Force

Time: O(n²) | Space: O(1)

Try every starting point and extend it to all possible endings. Too slow for large inputs but simple to verify correctness.

Copy

func maxSubArrayBrute(_ nums: [Int]) -> Int {
    var maxSum = nums[0]
    for i in 0..<nums.count {
        var current = 0
        for j in i..<nums.count {
            current += nums[j]
            maxSum = max(maxSum, current)
        }
    }
    return maxSum
}

Key Takeaways

Start with the brute-force approach to understand the problem
Kadane’s Algorithm (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Maximum Subarray in Swift?

The recommended approach is Kadane’s Algorithm (Optimal), which runs in O(n) time with O(1) space. The full Swift implementation is shown above.

What is the time complexity of Maximum Subarray in Swift?

Using Kadane’s Algorithm (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Letter Diamond in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 01 Sep 2025 00:00:00 GMT

The Letter Diamond pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) {
    String letters = '';
    for (int j = 1; j <= i; j++) { letters += String.fromCharCode(64 + j); }
    print(' ' * (n - i) + letters + letters.split('').reversed.skip(1).join());
  }
  for (int i = n - 1; i >= 1; i--) {
    String letters = '';
    for (int j = 1; j <= i; j++) { letters += String.fromCharCode(64 + j); }
    print(' ' * (n - i) + letters + letters.split('').reversed.skip(1).join());
  }
}

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

How It Works

The alphabet pyramid mirrored vertically: top half grows, bottom half shrinks back to A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Letter Diamond pattern in Dart?

What is the time complexity of the Letter Diamond pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Letter Diamond in Go — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 01 Sep 2025 00:00:00 GMT

The Letter Diamond pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ {
		var b strings.Builder
		for j := 1; j <= i; j++ { b.WriteByte(byte(64 + j)) }
		s := b.String()
		rev := ""
		for k := len(s) - 2; k >= 0; k-- { rev += string(s[k]) }
		fmt.Println(strings.Repeat(" ", n-i) + s + rev)
	}
	for i := n - 1; i >= 1; i-- {
		var b strings.Builder
		for j := 1; j <= i; j++ { b.WriteByte(byte(64 + j)) }
		s := b.String()
		rev := ""
		for k := len(s) - 2; k >= 0; k-- { rev += string(s[k]) }
		fmt.Println(strings.Repeat(" ", n-i) + s + rev)
	}
}

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

How It Works

The alphabet pyramid mirrored vertically: top half grows, bottom half shrinks back to A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Letter Diamond pattern in Go?

What is the time complexity of the Letter Diamond pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Letter Diamond in Python — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 01 Sep 2025 00:00:00 GMT

The Letter Diamond pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

Implementation

Copy

def letter_diamond(n):
    for i in range(1, n + 1):
        letters = ''.join(chr(64 + j) for j in range(1, i + 1))
        print(' ' * (n - i) + letters + letters[-2::-1])
    for i in range(n - 1, 0, -1):
        letters = ''.join(chr(64 + j) for j in range(1, i + 1))
        print(' ' * (n - i) + letters + letters[-2::-1])

letter_diamond(5)

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

How It Works

The alphabet pyramid mirrored vertically: top half grows, bottom half shrinks back to A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Letter Diamond pattern in Python?

What is the time complexity of the Letter Diamond pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Letter Diamond in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 01 Sep 2025 00:00:00 GMT

The Letter Diamond pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

Implementation

Copy

func letterDiamond(_ n: Int) {
    for i in 1...n {
        var letters = ""
        for j in 1...i { letters += String(UnicodeScalar(64 + j)!) }
        print(String(repeating: " ", count: n - i) + letters + String(letters.dropLast().reversed()))
    }
    for i in stride(from: n - 1, through: 1, by: -1) {
        var letters = ""
        for j in 1...i { letters += String(UnicodeScalar(64 + j)!) }
        print(String(repeating: " ", count: n - i) + letters + String(letters.dropLast().reversed()))
    }
}
letterDiamond(5)

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA
 ABCDCBA
  ABCBA
   ABA
    A

How It Works

The alphabet pyramid mirrored vertically: top half grows, bottom half shrinks back to A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Letter Diamond pattern in Swift?

What is the time complexity of the Letter Diamond pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

How GitHub reduced testing time for iOS apps with new runner features

mihirpipermitwala.com — Thu, 07 Aug 2025 00:00:00 GMT

Learn how GitHub used macOS and Apple Silicon runners for GitHub Actions to build, test, and deploy our iOS app faster.

5 ways to transform your workflow using GitHub Copilot and MCP

mihirpipermitwala.com — Fri, 01 Aug 2025 00:00:00 GMT

Learn how to streamline your development workflow with five different MCP use cases.

Hollow Square Star in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 31 Jul 2025 00:00:00 GMT

The Hollow Square Star pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

*****
*   *
*   *
*   *
*****

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 0; i < n; i++) {
    if (i == 0 || i == n - 1) { print('*' * n); } else { print('*' + ' ' * (n - 2) + '*'); }
  }
}

Output

Copy

*****
*   *
*   *
*   *
*****

How It Works

Print solid stars on the first and last rows, and only edge stars with spaces inside for all middle rows.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Square Star pattern in Dart?

What is the time complexity of the Hollow Square Star pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Square Star in Go — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 31 Jul 2025 00:00:00 GMT

The Hollow Square Star pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

*****
*   *
*   *
*   *
*****

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 0; i < n; i++ {
		if i == 0 || i == n-1 { fmt.Println(strings.Repeat("*", n)) } else { fmt.Println("*" + strings.Repeat(" ", n-2) + "*") }
	}
}

Output

Copy

*****
*   *
*   *
*   *
*****

How It Works

Print solid stars on the first and last rows, and only edge stars with spaces inside for all middle rows.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Square Star pattern in Go?

What is the time complexity of the Hollow Square Star pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Square Star in Python — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 31 Jul 2025 00:00:00 GMT

The Hollow Square Star pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

*****
*   *
*   *
*   *
*****

Implementation

Copy

def hollow_square(n):
    for i in range(n):
        if i == 0 or i == n - 1:
            print('*' * n)
        else:
            print('*' + ' ' * (n - 2) + '*')

hollow_square(5)

Output

Copy

*****
*   *
*   *
*   *
*****

How It Works

Print solid stars on the first and last rows, and only edge stars with spaces inside for all middle rows.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Square Star pattern in Python?

What is the time complexity of the Hollow Square Star pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Square Star in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 31 Jul 2025 00:00:00 GMT

The Hollow Square Star pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

*****
*   *
*   *
*   *
*****

Implementation

Copy

func hollowSquare(_ n: Int) {
    for i in 0..<n {
        if i == 0 || i == n - 1 { print(String(repeating: "*", count: n)) } else { print("*" + String(repeating: " ", count: n - 2) + "*") }
    }
}
hollowSquare(5)

Output

Copy

*****
*   *
*   *
*   *
*****

How It Works

Print solid stars on the first and last rows, and only edge stars with spaces inside for all middle rows.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Square Star pattern in Swift?

What is the time complexity of the Hollow Square Star pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Cross Plus in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 03 Jul 2025 00:00:00 GMT

The Hollow Cross Plus pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

*   *
*   *
*****
*   *
*   *

Implementation

Copy

void main() {
  int n = 5, mid = n ~/ 2;
  for (int i = 0; i < n; i++) {
    String row = '';
    for (int j = 0; j < n; j++) { row += (i == mid || j == 0 || j == n - 1) ? '*' : ' '; }
    print(row);
  }
}

Output

Copy

*   *
*   *
*****
*   *
*   *

How It Works

Middle row solid, sides are vertical bars with hollow interior.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Cross Plus pattern in Dart?

What is the time complexity of the Hollow Cross Plus pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Cross Plus in Go — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 03 Jul 2025 00:00:00 GMT

The Hollow Cross Plus pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

*   *
*   *
*****
*   *
*   *

Implementation

Copy

package main

import "fmt"

func main() {
	n, mid := 5, 2
	for i := 0; i < n; i++ {
		row := ""
		for j := 0; j < n; j++ { if i == mid || j == 0 || j == n-1 { row += "*" } else { row += " " } }
		fmt.Println(row)
	}
}

Output

Copy

*   *
*   *
*****
*   *
*   *

How It Works

Middle row solid, sides are vertical bars with hollow interior.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Cross Plus pattern in Go?

What is the time complexity of the Hollow Cross Plus pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Cross Plus in Python — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 03 Jul 2025 00:00:00 GMT

The Hollow Cross Plus pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

*   *
*   *
*****
*   *
*   *

Implementation

Copy

def hollow_cross(n):
    mid = n // 2
    for i in range(n):
        for j in range(n):
            if i == mid or j == 0 or j == n - 1: print('*', end='')
            else: print(' ', end='')
        print()

hollow_cross(5)

Output

Copy

*   *
*   *
*****
*   *
*   *

How It Works

Middle row solid, sides are vertical bars with hollow interior.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Cross Plus pattern in Python?

What is the time complexity of the Hollow Cross Plus pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Hollow Cross Plus in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Thu, 03 Jul 2025 00:00:00 GMT

The Hollow Cross Plus pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

*   *
*   *
*****
*   *
*   *

Implementation

Copy

func hollowCross(_ n: Int) {
    let mid = n / 2
    for i in 0..<n {
        var row = ""
        for j in 0..<n { row += (i == mid || j == 0 || j == n - 1) ? "*" : " " }
        print(row)
    }
}
hollowCross(5)

Output

Copy

*   *
*   *
*****
*   *
*   *

How It Works

Middle row solid, sides are vertical bars with hollow interior.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Hollow Cross Plus pattern in Swift?

What is the time complexity of the Hollow Cross Plus pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Floyd's Triangle in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 09 Jun 2025 00:00:00 GMT

Floyd’s Triangle is a right-angled triangle of consecutive natural numbers. The first row has 1 number, the second has 2, and so on — but the numbers keep incrementing across rows instead of resetting. It’s a classic loop exercise for mastering state that persists across iterations.

Pattern to Print

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

Implementation

Copy

void main() {
  int n = 5;
  int counter = 1;

  for (int i = 1; i <= n; i++) {
    List<String> row = [];
    for (int j = 0; j < i; j++) {
      row.add(counter.toString());
      counter++;
    }
    print(row.join(" "));
  }
}

Output

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

How It Works

A single counter increments with every printed number, and row i contains exactly i numbers. The key insight: the counter lives outside the inner loop, so it persists across rows. That’s what makes Floyd’s Triangle different from patterns where each row resets to 1 2 3....

Variation: Right-Aligned Floyd’s

Pad each number to a fixed column width so the triangle’s right edge lines up:

Copy

void main() {
  int n = 5;
  int counter = 1;
  int maxNum = n * (n + 1) ~/ 2;          // last number printed
  int width = maxNum.toString().length;    // column width for alignment

  for (int i = 1; i <= n; i++) {
    List<String> row = [];
    for (int j = 0; j < i; j++) {
      row.add(counter.toString().padLeft(width));
      counter++;
    }
    print(row.join(" "));
  }
}

Output

Copy

 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15

n * (n + 1) ~/ 2 is the closed-form for the last number (sum of 1..n), used to compute the padding width.

Variation: Reverse Floyd’s Triangle

Count downward, starting each row from where the previous row would have ended:

Copy

void main() {
  int n = 5;
  int total = n * (n + 1) ~/ 2;

  for (int i = 1; i <= n; i++) {
    List<String> row = [];
    int start = total - i + 1;
    for (int j = 0; j < i; j++) {
      row.add((start + j).toString());
    }
    print(row.join(" "));
    total -= i;
  }
}

Output

Copy

Practice Variations

Fibonacci Floyd’s: fill the rows with Fibonacci numbers instead of consecutive integers
Even-only Floyd’s: print 2, 4, 6, 8… in triangle form
Pyramid Floyd’s: center the numbers like a pyramid instead of left-aligning
Modify the code to accept the triangle size as user input

Each variation exercises the same skill: tracking state across loop iterations. Master this and the harder pattern problems become straightforward.

Complexity

Time: O(n²) — prints n(n+1)/2 numbers
Space: O(n) — one row buffer at a time

FAQ

How do you print the Floyd’s Triangle pattern in Dart?

What is the time complexity of the Floyd’s Triangle pattern in Dart?

The time complexity is O(n²) and the space complexity is O(n), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Floyd's Triangle in Go — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 09 Jun 2025 00:00:00 GMT

The Floyd’s Triangle pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

Implementation

Copy

package main

import "fmt"

func main() {
	n, num := 5, 1
	for i := 1; i <= n; i++ {
		for j := 0; j < i; j++ { fmt.Printf("%d ", num); num++ }
		fmt.Println()
	}
}

Output

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

How It Works

A single counter increments with every printed number. Row i contains i numbers.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Floyd’s Triangle pattern in Go?

What is the time complexity of the Floyd’s Triangle pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Floyd's Triangle in Python — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 09 Jun 2025 00:00:00 GMT

Floyd’s Triangle is a right-angled triangle filled with consecutive natural numbers — 1 on the first row, 2 3 on the second, and so on. It’s a classic exercise for learning how to maintain state across nested loop iterations.

Pattern to Print

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

Each row contains the next consecutive integers — the counter never resets between rows.

Implementation

Copy

def floyds_triangle(n):
    num = 1
    for i in range(1, n + 1):     # row number
        for j in range(i):          # column count grows with row
            print(num, end=" ")
            num += 1
        print()                     # newline after each row

floyds_triangle(5)

Output

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

How It Works

A single counter increments with every printed number, and row i contains exactly i numbers. The key insight: num lives outside the inner loop, so it persists across rows. That’s what makes Floyd’s Triangle different from patterns where each row resets to 1 2 3....

Variation: Using `str.join()`

Building each row as a list avoids trailing spaces:

Copy

def floyds_triangle_v2(n):
    num = 1
    for i in range(1, n + 1):
        row_values = []
        for j in range(i):
            row_values.append(str(num))
            num += 1
        print(" ".join(row_values))

floyds_triangle_v2(5)

Variation: With `itertools.count`

An infinite counter removes the manual increment:

Copy

from itertools import count

def floyds_triangle_v3(n):
    counter = count(1)
    for i in range(1, n + 1):
        row = [str(next(counter)) for _ in range(i)]
        print(" ".join(row))

floyds_triangle_v3(5)

Variation: Right-Aligned Floyd’s

Pad each number to a fixed column width so the triangle’s right edge lines up:

Copy

def floyds_triangle_right(n):
    num = 1
    max_num = n * (n + 1) // 2
    max_width = len(str(max_num))

    for i in range(1, n + 1):
        row = []
        for j in range(i):
            row.append(str(num).rjust(max_width))
            num += 1
        print(" ".join(row))

floyds_triangle_right(5)

Output

Copy

 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15

n * (n + 1) // 2 is the closed-form for the last number (sum of 1..n), used to compute the padding width.

Variation: Inverted Floyd’s Triangle

Rows shrink instead of grow, while the numbers keep counting up:

Copy

def floyds_triangle_inverted(n):
    num = 1

    for i in range(n, 0, -1):
        row = []
        for j in range(i):
            row.append(str(num))
            num += 1
        print(" ".join(row))

floyds_triangle_inverted(5)

Output

Copy

Testing the Triangle

Capture stdout and assert the exact expected rows:

Copy

import io
import sys

def floyds_triangle(n):
    num = 1
    for i in range(1, n + 1):
        for j in range(i):
            print(num, end=" ")
            num += 1
        print()

def test_floyds_triangle():
    old_stdout = sys.stdout
    sys.stdout = io.StringIO()

    floyds_triangle(4)

    raw = sys.stdout.getvalue()
    sys.stdout = old_stdout

    output = [line.rstrip() for line in raw.strip().split("\n")]
    expected = ["1", "2 3", "4 5 6", "7 8 9 10"]
    assert output == expected, f"Expected {expected}, got {output}"
    print("Test passed!")

test_floyds_triangle()

Common Beginner Mistakes

Resetting the counter each row — the numbers should continue across rows, never restart
Using print(num, end="") without a space — results in 123456... glued on one line
Missing newline between rows — you need a bare print() after the inner loop
Off-by-one in the inner loop — row i needs range(i), not range(i + 1)

Practice Variations

Floyd’s Triangle with Characters: A B C D... instead of numbers
Floyd’s Triangle of Squares: print the square of each number
Floyd’s Triangle of Primes: use an is_prime() helper to print only primes
Floyd’s Triangle of Even Numbers: start at 2, skip odd numbers
Modify the code to accept the triangle size as user input

Complexity

Metric	Value	Note
Time	O(n²)	Total iterations = n(n+1)/2
Space	O(1)	Only one counter variable

For n = 5: total iterations = 5 × 6 / 2 = 15, printing values 1 to 15.

Floyd’s Triangle is a stepping stone to Pascal’s Triangle, which adds combinatorial logic to the same structure.

FAQ

How do you print the Floyd’s Triangle pattern in Python?

What is the time complexity of the Floyd’s Triangle pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Floyd's Triangle in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Mon, 09 Jun 2025 00:00:00 GMT

The Floyd’s Triangle pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

Implementation

Copy

func floydsTriangle(_ n: Int) {
    var num = 1
    for i in 1...n {
        var row = ""
        for _ in 0..<i { row += "(num) "; num += 1 }
        print(row)
    }
}
floydsTriangle(5)

Output

Copy

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15

How It Works

A single counter increments with every printed number. Row i contains i numbers.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Floyd’s Triangle pattern in Swift?

What is the time complexity of the Floyd’s Triangle pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Cross/Plus Sign Star in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 14 May 2025 00:00:00 GMT

The Cross/Plus Sign Star pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

  *
  *
*****
  *
  *

Implementation

Copy

void main() {
  int n = 5, mid = n ~/ 2;
  for (int i = 0; i < n; i++) {
    String row = '';
    for (int j = 0; j < n; j++) { row += (i == mid || j == mid) ? '*' : ' '; }
    print(row);
  }
}

Output

Copy

  *
  *
*****
  *
  *

How It Works

Print a star wherever the row equals the middle index OR the column equals the middle index.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Cross/Plus Sign Star pattern in Dart?

What is the time complexity of the Cross/Plus Sign Star pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Cross/Plus Sign Star in Go — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 14 May 2025 00:00:00 GMT

The Cross/Plus Sign Star pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

  *
  *
*****
  *
  *

Implementation

Copy

package main

import "fmt"

func main() {
	n, mid := 5, 2
	for i := 0; i < n; i++ {
		row := ""
		for j := 0; j < n; j++ { if i == mid || j == mid { row += "*" } else { row += " " } }
		fmt.Println(row)
	}
}

Output

Copy

  *
  *
*****
  *
  *

How It Works

Print a star wherever the row equals the middle index OR the column equals the middle index.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Cross/Plus Sign Star pattern in Go?

What is the time complexity of the Cross/Plus Sign Star pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Cross/Plus Sign Star in Python — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 14 May 2025 00:00:00 GMT

The Cross/Plus Sign Star pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

  *
  *
*****
  *
  *

Implementation

Copy

def cross(n):
    mid = n // 2
    for i in range(n):
        for j in range(n):
            print('*' if i == mid or j == mid else ' ', end='')
        print()

cross(5)

Output

Copy

  *
  *
*****
  *
  *

How It Works

Print a star wherever the row equals the middle index OR the column equals the middle index.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Cross/Plus Sign Star pattern in Python?

What is the time complexity of the Cross/Plus Sign Star pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Cross/Plus Sign Star in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 14 May 2025 00:00:00 GMT

The Cross/Plus Sign Star pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

  *
  *
*****
  *
  *

Implementation

Copy

func cross(_ n: Int) {
    let mid = n / 2
    for i in 0..<n {
        var row = ""
        for j in 0..<n { row += (i == mid || j == mid) ? "*" : " " }
        print(row)
    }
}
cross(5)

Output

Copy

  *
  *
*****
  *
  *

How It Works

Print a star wherever the row equals the middle index OR the column equals the middle index.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Cross/Plus Sign Star pattern in Swift?

What is the time complexity of the Cross/Plus Sign Star pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Christmas Tree Star in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Mar 2025 00:00:00 GMT

The Christmas Tree Star pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

Implementation

Copy

void main() {
  int n = 4;
  for (int section = 0; section < 2; section++) {
    for (int i = 1; i <= n; i++) { print(' ' * (n - i) + '*' * (2 * i - 1)); }
  }
  print(' ' * (n - 1) + '###');
}

Output

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

How It Works

Stack two pyramid sections of increasing height, then finish with a trunk of hash symbols.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Christmas Tree Star pattern in Dart?

What is the time complexity of the Christmas Tree Star pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Christmas Tree Star in Go — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Mar 2025 00:00:00 GMT

The Christmas Tree Star pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 4
	for section := 0; section < 2; section++ {
		for i := 1; i <= n; i++ { fmt.Println(strings.Repeat(" ", n-i) + strings.Repeat("*", 2*i-1)) }
	}
	fmt.Println(strings.Repeat(" ", n-1) + "###")
}

Output

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

How It Works

Stack two pyramid sections of increasing height, then finish with a trunk of hash symbols.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Christmas Tree Star pattern in Go?

What is the time complexity of the Christmas Tree Star pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Christmas Tree Star in Python — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Mar 2025 00:00:00 GMT

The Christmas Tree Star pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

Implementation

Copy

def christmas_tree(n):
    for section in range(2):
        for i in range(1, n + 1):
            print(' ' * (n - i) + '*' * (2 * i - 1))
    print(' ' * (n - 1) + '###')

christmas_tree(4)

Output

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

How It Works

Stack two pyramid sections of increasing height, then finish with a trunk of hash symbols.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Christmas Tree Star pattern in Python?

What is the time complexity of the Christmas Tree Star pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Christmas Tree Star in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Mar 2025 00:00:00 GMT

The Christmas Tree Star pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

Implementation

Copy

func christmasTree(_ n: Int) {
    for _ in 0..<2 {
        for i in 1...n { print(String(repeating: " ", count: n - i) + String(repeating: "*", count: 2 * i - 1)) }
    }
    print(String(repeating: " ", count: n - 1) + "###")
}
christmasTree(4)

Output

Copy

    *
   ***
  *****
    *
   ***
  *****
 *******
*********
   ###

How It Works

Stack two pyramid sections of increasing height, then finish with a trunk of hash symbols.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Christmas Tree Star pattern in Swift?

What is the time complexity of the Christmas Tree Star pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Checkerboard in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Feb 2025 00:00:00 GMT

The Checkerboard pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

Implementation

Copy

void main() {
  int n = 8;
  for (int i = 0; i < n; i++) {
    String row = '';
    for (int j = 0; j < n; j++) {
      row += (i + j) % 2 == 0 ? '*' : ' ';
    }
    print(row);
  }
}

Output

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

How It Works

The classic (row + col) % 2 == 0 test: if the sum is even, print a star; if odd, print a space. Alternating rows produce the checkerboard.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Checkerboard pattern in Dart?

What is the time complexity of the Checkerboard pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Checkerboard in Go — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Feb 2025 00:00:00 GMT

The Checkerboard pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

Implementation

Copy

package main

import "fmt"

func main() {
	n := 8
	for i := 0; i < n; i++ {
		row := ""
		for j := 0; j < n; j++ {
			if (i+j)%2 == 0 {
				row += "*"
			} else {
				row += " "
			}
		}
		fmt.Println(row)
	}
}

Output

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

How It Works

The classic (row + col) % 2 == 0 test: if the sum is even, print a star; if odd, print a space. Alternating rows produce the checkerboard.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Checkerboard pattern in Go?

What is the time complexity of the Checkerboard pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Checkerboard in Python — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Feb 2025 00:00:00 GMT

The Checkerboard pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

Implementation

Copy

def checkerboard(n):
    for i in range(n):
        row = ''
        for j in range(n):
            row += '*' if (i + j) % 2 == 0 else ' '
        print(row)

checkerboard(8)

Output

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

How It Works

The classic (row + col) % 2 == 0 test: if the sum is even, print a star; if odd, print a space. Alternating rows produce the checkerboard.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Checkerboard pattern in Python?

What is the time complexity of the Checkerboard pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Checkerboard in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 25 Feb 2025 00:00:00 GMT

The Checkerboard pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

Implementation

Copy

func checkerboard(_ n: Int) {
    for i in 0..<n {
        var row = ""
        for j in 0..<n {
            row += (i + j) % 2 == 0 ? "*" : " "
        }
        print(row)
    }
}
checkerboard(8)

Output

Copy

* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *
* * * *
 * * * *

How It Works

The classic (row + col) % 2 == 0 test: if the sum is even, print a star; if odd, print a space. Alternating rows produce the checkerboard.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Checkerboard pattern in Swift?

What is the time complexity of the Checkerboard pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right-Facing Arrowhead in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 24 Jan 2025 00:00:00 GMT

The Right-Facing Arrowhead pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

*
**
***
****
*****
****
***
**
*

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) { print('*' * i); }
  for (int i = n - 1; i >= 1; i--) { print('*' * i); }
}

Output

Copy

*
**
***
****
*****
****
***
**
*

How It Works

Left-aligned right triangle followed by its mirror. The shape points right like an arrow tip.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right-Facing Arrowhead pattern in Dart?

What is the time complexity of the Right-Facing Arrowhead pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right-Facing Arrowhead in Go — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 24 Jan 2025 00:00:00 GMT

The Right-Facing Arrowhead pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

*
**
***
****
*****
****
***
**
*

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ { fmt.Println(strings.Repeat("*", i)) }
	for i := n - 1; i >= 1; i-- { fmt.Println(strings.Repeat("*", i)) }
}

Output

Copy

*
**
***
****
*****
****
***
**
*

How It Works

Left-aligned right triangle followed by its mirror. The shape points right like an arrow tip.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right-Facing Arrowhead pattern in Go?

What is the time complexity of the Right-Facing Arrowhead pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right-Facing Arrowhead in Python — Code, Output & Explanation

mihirpipermitwala.com — Fri, 24 Jan 2025 00:00:00 GMT

The Right-Facing Arrowhead pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

*
**
***
****
*****
****
***
**
*

Implementation

Copy

def arrowhead(n):
    for i in range(1, n + 1): print('*' * i)
    for i in range(n - 1, 0, -1): print('*' * i)

arrowhead(5)

Output

Copy

*
**
***
****
*****
****
***
**
*

How It Works

Left-aligned right triangle followed by its mirror. The shape points right like an arrow tip.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right-Facing Arrowhead pattern in Python?

What is the time complexity of the Right-Facing Arrowhead pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right-Facing Arrowhead in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Fri, 24 Jan 2025 00:00:00 GMT

The Right-Facing Arrowhead pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

*
**
***
****
*****
****
***
**
*

Implementation

Copy

func arrowhead(_ n: Int) {
    for i in 1...n { print(String(repeating: "*", count: i)) }
    for i in stride(from: n - 1, through: 1, by: -1) { print(String(repeating: "*", count: i)) }
}
arrowhead(5)

Output

Copy

*
**
***
****
*****
****
***
**
*

How It Works

Left-aligned right triangle followed by its mirror. The shape points right like an arrow tip.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Right-Facing Arrowhead pattern in Swift?

What is the time complexity of the Right-Facing Arrowhead pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Pyramid in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 31 Dec 2024 00:00:00 GMT

The Alphabet Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) {
    String letters = '';
    for (int j = 1; j <= i; j++) {
      letters += String.fromCharCode(64 + j);
    }
    String rev = letters.split('').reversed.skip(1).join();
    print(' ' * (n - i) + letters + rev);
  }
}

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

How It Works

Each row prints ascending letters A..X followed by descending X-1..A, centered with spaces. Uses ASCII arithmetic (A = 65).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Pyramid pattern in Dart?

What is the time complexity of the Alphabet Pyramid pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Pyramid in Go — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 31 Dec 2024 00:00:00 GMT

The Alphabet Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ {
		var letters strings.Builder
		for j := 1; j <= i; j++ {
			letters.WriteByte(byte(64 + j))
		}
		s := letters.String()
		rev := ""
		for k := len(s) - 2; k >= 0; k-- {
			rev += string(s[k])
		}
		fmt.Println(strings.Repeat(" ", n-i) + s + rev)
	}
}

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

How It Works

Each row prints ascending letters A..X followed by descending X-1..A, centered with spaces. Uses ASCII arithmetic (A = 65).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Pyramid pattern in Go?

What is the time complexity of the Alphabet Pyramid pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Pyramid in Python — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 31 Dec 2024 00:00:00 GMT

The Alphabet Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Implementation

Copy

def alphabet_pyramid(n):
    for i in range(1, n + 1):
        letters = ''.join(chr(64 + j) for j in range(1, i + 1))
        print(" " * (n - i) + letters + letters[-2::-1])

alphabet_pyramid(5)

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

How It Works

Each row prints ascending letters A..X followed by descending X-1..A, centered with spaces. Uses ASCII arithmetic (A = 65).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Pyramid pattern in Python?

What is the time complexity of the Alphabet Pyramid pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Pyramid in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Tue, 31 Dec 2024 00:00:00 GMT

The Alphabet Pyramid pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Implementation

Copy

func alphabetPyramid(_ n: Int) {
    for i in 1...n {
        var letters = ""
        for j in 1...i {
            letters += String(UnicodeScalar(64 + j)!)
        }
        let rev = String(letters.dropLast().reversed())
        print(String(repeating: " ", count: n - i) + letters + rev)
    }
}
alphabetPyramid(5)

Output

Copy

    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

How It Works

Each row prints ascending letters A..X followed by descending X-1..A, centered with spaces. Uses ASCII arithmetic (A = 65).

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Pyramid pattern in Swift?

What is the time complexity of the Alphabet Pyramid pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Hollow Diamond in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 27 Nov 2024 00:00:00 GMT

The Alphabet Hollow Diamond pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 1; i <= n; i++) {
    String ch = String.fromCharCode(64 + i);
    if (i == 1) { print(' ' * (n - i) + ch); } else { print(' ' * (n - i) + ch + ' ' * (2 * i - 3) + ch); }
  }
  for (int i = n - 1; i >= 1; i--) {
    String ch = String.fromCharCode(64 + i);
    if (i == 1) { print(' ' * (n - i) + ch); } else { print(' ' * (n - i) + ch + ' ' * (2 * i - 3) + ch); }
  }
}

Output

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

How It Works

Print only the border letters of a diamond. Row i uses the i-th letter.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Hollow Diamond pattern in Dart?

What is the time complexity of the Alphabet Hollow Diamond pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Hollow Diamond in Go — With Code, Output & Explanation

mihirpipermitwala.com — Wed, 27 Nov 2024 00:00:00 GMT

The Alphabet Hollow Diamond pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

Implementation

Copy

package main

import ("fmt"; "strings")

func main() {
	n := 5
	for i := 1; i <= n; i++ {
		ch := string(64 + i)
		if i == 1 { fmt.Println(strings.Repeat(" ", n-i) + ch) } else { fmt.Println(strings.Repeat(" ", n-i) + ch + strings.Repeat(" ", 2*i-3) + ch) }
	}
	for i := n - 1; i >= 1; i-- {
		ch := string(64 + i)
		if i == 1 { fmt.Println(strings.Repeat(" ", n-i) + ch) } else { fmt.Println(strings.Repeat(" ", n-i) + ch + strings.Repeat(" ", 2*i-3) + ch) }
	}
}

Output

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

How It Works

Print only the border letters of a diamond. Row i uses the i-th letter.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Hollow Diamond pattern in Go?

What is the time complexity of the Alphabet Hollow Diamond pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Hollow Diamond in Python — Code, Output & Explanation

mihirpipermitwala.com — Wed, 27 Nov 2024 00:00:00 GMT

The Alphabet Hollow Diamond pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

Implementation

Copy

def hollow_diamond(n):
    for i in range(1, n + 1):
        ch = chr(64 + i)
        if i == 1: print(' ' * (n - i) + ch)
        else: print(' ' * (n - i) + ch + ' ' * (2 * i - 3) + ch)
    for i in range(n - 1, 0, -1):
        ch = chr(64 + i)
        if i == 1: print(' ' * (n - i) + ch)
        else: print(' ' * (n - i) + ch + ' ' * (2 * i - 3) + ch)

hollow_diamond(5)

Output

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

How It Works

Print only the border letters of a diamond. Row i uses the i-th letter.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Hollow Diamond pattern in Python?

What is the time complexity of the Alphabet Hollow Diamond pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Hollow Diamond in Swift — Code, Output & Explanation

mihirpipermitwala.com — Wed, 27 Nov 2024 00:00:00 GMT

The Alphabet Hollow Diamond pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

Implementation

Copy

func hollowDiamond(_ n: Int) {
    for i in 1...n {
        let ch = String(UnicodeScalar(64 + i)!)
        if i == 1 { print(String(repeating: " ", count: n - i) + ch) } else { print(String(repeating: " ", count: n - i) + ch + String(repeating: " ", count: 2 * i - 3) + ch) }
    }
    for i in stride(from: n - 1, through: 1, by: -1) {
        let ch = String(UnicodeScalar(64 + i)!)
        if i == 1 { print(String(repeating: " ", count: n - i) + ch) } else { print(String(repeating: " ", count: n - i) + ch + String(repeating: " ", count: 2 * i - 3) + ch) }
    }
}
hollowDiamond(5)

Output

Copy

    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A

How It Works

Print only the border letters of a diamond. Row i uses the i-th letter.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Hollow Diamond pattern in Swift?

What is the time complexity of the Alphabet Hollow Diamond pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rectangle in Dart — With Code, Output & Explanation

mihirpipermitwala.com — Sat, 09 Nov 2024 00:00:00 GMT

The Alphabet Rectangle pattern is a classic loop exercise. Here’s the complete implementation in Dart with working code and output.

Pattern to Print

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

Implementation

Copy

void main() {
  int rows = 5, cols = 5;
  for (int i = 0; i < rows; i++) {
    String row = '';
    for (int j = 0; j < cols; j++) { row += String.fromCharCode(65 + j); }
    print(row);
  }
}

Output

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

How It Works

Print an n×m grid where each row spells out the alphabet starting from A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rectangle pattern in Dart?

What is the time complexity of the Alphabet Rectangle pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rectangle in Go — With Code, Output & Explanation

mihirpipermitwala.com — Sat, 09 Nov 2024 00:00:00 GMT

The Alphabet Rectangle pattern is a classic loop exercise. Here’s the complete implementation in Go with working code and output.

Pattern to Print

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

Implementation

Copy

package main

import "fmt"

func main() {
	rows, cols := 5, 5
	for i := 0; i < rows; i++ {
		row := ""
		for j := 0; j < cols; j++ { row += string(65 + j) }
		fmt.Println(row)
	}
}

Output

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

How It Works

Print an n×m grid where each row spells out the alphabet starting from A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rectangle pattern in Go?

What is the time complexity of the Alphabet Rectangle pattern in Go?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rectangle in Python — With Code, Output & Explanation

mihirpipermitwala.com — Sat, 09 Nov 2024 00:00:00 GMT

The Alphabet Rectangle pattern is a classic loop exercise. Here’s the complete implementation in Python with working code and output.

Pattern to Print

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

Implementation

Copy

def alpha_rectangle(rows, cols):
    for _ in range(rows):
        print(''.join(chr(65 + j) for j in range(cols)))

alpha_rectangle(5, 5)

Output

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

How It Works

Print an n×m grid where each row spells out the alphabet starting from A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rectangle pattern in Python?

What is the time complexity of the Alphabet Rectangle pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Alphabet Rectangle in Swift — With Code, Output & Explanation

mihirpipermitwala.com — Sat, 09 Nov 2024 00:00:00 GMT

The Alphabet Rectangle pattern is a classic loop exercise. Here’s the complete implementation in Swift with working code and output.

Pattern to Print

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

Implementation

Copy

func alphaRectangle(_ rows: Int, _ cols: Int) {
    for _ in 0..<rows {
        var row = ""
        for j in 0..<cols { row += String(UnicodeScalar(65 + j)!) }
        print(row)
    }
}
alphaRectangle(5, 5)

Output

Copy

ABCDE
ABCDE
ABCDE
ABCDE
ABCDE

How It Works

Print an n×m grid where each row spells out the alphabet starting from A.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a more complex shape

Complexity

Time: O(n²) — the grid or line count grows quadratically
Space: O(1) — only loop counters are needed

FAQ

How do you print the Alphabet Rectangle pattern in Swift?

What is the time complexity of the Alphabet Rectangle pattern in Swift?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Solid Square Star Pattern in Dart — Code, Output & Variations

mihirpipermitwala.com — Tue, 08 Oct 2024 00:00:00 GMT

The Solid Square Star pattern is a fundamental loop exercise for Dart beginners. Here’s the complete implementation with working code and output.

Pattern to Print

Copy

*****
*****
*****
*****
*****

Implementation

Copy

void main() {
  int n = 5;
  for (int i = 0; i < n; i++) {
    print("* " * n);
  }
}

Output

Copy

*****
*****
*****
*****
*****

How It Works

n rows, each containing n stars. The simplest nested-loop pattern — the foundation for all grid patterns.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a diamond or hourglass

Complexity

Time: O(n²) — total characters printed grows quadratically
Space: O(n) — longest row is O(n) characters

FAQ

How do you print the Solid Square Star pattern in Dart?

What is the time complexity of the Solid Square Star pattern in Dart?

The time complexity is O(n²) and the space complexity is O(n), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Solid Square Star Pattern in Go — With Code, Output & Variations

mihirpipermitwala.com — Tue, 08 Oct 2024 00:00:00 GMT

The Solid Square Star pattern is a fundamental loop exercise for Go beginners. Here’s the complete implementation with working code and output.

Pattern to Print

Copy

*****
*****
*****
*****
*****

Implementation

Copy

package main
import ("fmt"; "strings")
func main() {
    n := 5
    for i := 0; i < n; i++ {
        fmt.Println(strings.Repeat("*", n))
    }
}

Output

Copy

*****
*****
*****
*****
*****

How It Works

n rows, each containing n stars. The simplest nested-loop pattern — the foundation for all grid patterns.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a diamond or hourglass

Complexity

Time: O(n²) — total characters printed grows quadratically
Space: O(n) — longest row is O(n) characters

FAQ

How do you print the Solid Square Star pattern in Go?

What is the time complexity of the Solid Square Star pattern in Go?

The time complexity is O(n²) and the space complexity is O(n), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Solid Square Star Pattern in Python: Simple Grid Tutorial

mihirpipermitwala.com — Tue, 08 Oct 2024 00:00:00 GMT

The solid square star pattern is the simplest nested loop pattern: every row has exactly n stars and there are n rows. It’s the perfect exercise to understand how outer and inner loops interact.

What We’ll Build

Copy

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

A 5×5 grid of stars — simple but the foundation of every other pattern.

Approach 1: Nested For Loops

Copy

def solid_square(n):
    for i in range(n):         # outer loop: rows
        for j in range(n):      # inner loop: stars per row
            print("*", end=" ")
        print()                 # new line after each row

solid_square(5)

Output

Copy

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

Approach 2: String Multiplication (Pythonic)

Copy

def solid_square_v2(n):
    for i in range(n):
        print("* " * n)

solid_square_v2(5)

Output

Copy

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

Approach 3: One-Liner

Copy

def solid_square_oneliner(n):
    print(("\n".join(["* " * n] * n)))

solid_square_oneliner(5)

Output

Copy

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

Approach 4: With Numbers (Debug Friendly)

Copy

def solid_square_numbers(n):
    for i in range(1, n + 1):
        print(" ".join(str(j) for j in range(1, n + 1)))

solid_square_numbers(5)

Output

Copy

Approach 5: Hollow Square (Border Only)

Copy

def hollow_square(n):
    for i in range(n):
        if i == 0 or i == n - 1:
            print("* " * n)
        else:
            print("* " + "  " * (n - 2) + "*")

hollow_square(5)

Output

Copy

* * * * *
*       *
*       *
*       *
* * * * *

Complexity Comparison

Approach	Time	Space	Recommended
Nested Loops	O(n²)	O(1)	✅ Interview default
String Multiplication	O(n * n) = O(n²)	O(n) per row	✅ Cleaner code
One-liner	O(n²)	O(n²)	✅ Quick prototyping
With Numbers	O(n²)	O(1)	✅ Testing/debugging
Hollow Square	O(n²)	O(1)	★ Follow-up exercise

Practice Variations

Hollow square — only print stars on the border
Checkerboard — alternate * and # characters
Diagonal square — stars only on the main diagonal
Frame within frame — nested hollow squares

Why Start Here?

The solid square teaches you:

How nested loops iterate (outer = rows, inner = columns)
The end="" trick to avoid default newline after each star
Conditionals for hollow/shaped versions
How to estimate time complexity O(n²)

Once you master this, the right triangle and pyramid follow naturally — they are simply squares with a conditional inside the inner loop.

Next pattern: Right Triangle Star Pattern in Python

FAQ

How do you print the Solid Square Star pattern in Python?

What is the time complexity of the Solid Square Star pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Solid Square Star Pattern in Swift — Code, Output & Variations

mihirpipermitwala.com — Tue, 08 Oct 2024 00:00:00 GMT

The Solid Square Star pattern is a fundamental loop exercise for Swift beginners. Here’s the complete implementation with working code and output.

Pattern to Print

Copy

*****
*****
*****
*****
*****

Implementation

Copy

func solidSquare(_ n: Int) {
    for _ in 1...n {
        print(String(repeating: "*", count: n))
    }
}
solidSquare(5)

Output

Copy

*****
*****
*****
*****
*****

How It Works

n rows, each containing n stars. The simplest nested-loop pattern — the foundation for all grid patterns.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a diamond or hourglass

Complexity

Time: O(n²) — total characters printed grows quadratically
Space: O(n) — longest row is O(n) characters

FAQ

How do you print the Solid Square Star pattern in Swift?

What is the time complexity of the Solid Square Star pattern in Swift?

The time complexity is O(n²) and the space complexity is O(n), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right Triangle Star Pattern in Dart — Beginner Guide

mihirpipermitwala.com — Tue, 10 Sep 2024 00:00:00 GMT

The right triangle star pattern is the “Hello World” of loop exercises in any language. Here’s how to build it in Dart, with nested loops and clean console output.

What We’ll Build

Copy

*
* *
* * *
* * * *
* * * * *

Each row shows i stars in row i, starting from row 1.

Basic Approach: Nested For Loops

Copy

void main() {
  int n = 5;

  for (int i = 1; i <= n; i++) {
    // Inner loop prints stars
    for (int j = 1; j <= i; j++) {
      print("*");
    }
    print(""); // Newline after each row
  }
}

Output

Copy

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

Wait — this is wrong! It’s printing one star per line. You need a horizontal space between stars.

Fixed Approach: String Buffer

Use StringBuffer (Dart’s efficient string builder) or the end parameter isn’t available in Dart’s print():

Copy

void main() {
  int n = 5;

  for (int i = 1; i <= n; i++) {
    StringBuffer row = StringBuffer();
    for (int j = 1; j <= i; j++) {
      row.write("* ");
    }
    print(row.toString().trimRight());
  }
}

Output

Copy

*
* *
* * *
* * * *
* * * * *

Approach 2: Using List.filled

For cleaner functional style:

Copy

void main() {
  int n = 5;

  for (int i = 1; i <= n; i++) {
    print(List.filled(i, "*").join(" "));
  }
}

Output

Copy

*
* *
* * *
* * * *
* * * * *

Approach 3: With Numbers Instead of Stars

Copy

void main() {
  int n = 5;

  for (int i = 1; i <= n; i++) {
    List<String> row = [];
    for (int j = 1; j <= i; j++) {
      row.add(j.toString());
    }
    print(row.join(" "));
  }
}

Output

Copy

Approach 4: Right-Aligned (Left Triangle)

Copy

void main() {
  int n = 5;

  for (int i = 1; i <= n; i++) {
    String spaces = " " * (n - i);
    String stars = List.filled(i, "*").join(" ");
    print(spaces + stars);
  }
}

Output

Copy

    *
   * *
  * * *
 * * * *
* * * * *

Dart-Specific Tips

StringBuffer is more efficient than String += in loops
print() always adds a newline — no end parameter like Python
List.filled(count, value) creates repeated elements quickly
Use String * int for repetition: "*" * 5 → "*****"

Complexity Analysis

Metric	Reason
Time	O(n²) — total iterations = n(n+1)/2
Space	O(n) — each row is a temporary string

Practice Variations

Inverted triangle: start with n stars, end with 1
Number triangle: 1, 2 2, 3 3 3
Character triangle: A, B B, C C C
Hourglass: right triangle followed by inverted triangle

Running the Code

Copy

dart run main.dart

Or paste into DartPad — Dart’s online editor.

Next pattern: Inverted Right Triangle Star in Dart

FAQ

How do you print the Right Triangle Star pattern in Dart?

What is the time complexity of the Right Triangle Star pattern in Dart?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Right Triangle Star Pattern in Go — Code, Output & Variations

mihirpipermitwala.com — Tue, 10 Sep 2024 00:00:00 GMT

The Right Triangle Star pattern is a fundamental loop exercise for Go beginners. Here’s the complete implementation with working code and output.

Pattern to Print

Copy

*
**
***
****
*****

Implementation

Copy

package main
import ("fmt"; "strings")
func main() {
    for i := 1; i <= 5; i++ {
        fmt.Println(strings.Repeat("*", i))
    }
}

Output

Copy

*
**
***
****
*****

How It Works

Row i contains i stars — the outer loop tracks the row, the star count equals the row number.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a diamond or hourglass

Complexity

Time: O(n²) — total characters printed grows quadratically
Space: O(n) — longest row is O(n) characters

FAQ

How do you print the Right Triangle Star pattern in Go?

What is the time complexity of the Right Triangle Star pattern in Go?

The time complexity is O(n²) and the space complexity is O(n), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

Right Triangle Star Pattern in Python — Beginner Guide

mihirpipermitwala.com — Tue, 10 Sep 2024 00:00:00 GMT

The right triangle star pattern is the most common first pattern in programming tutorials. It teaches you nested loops, printing without newline, and how to control row-by-row output.

What We’ll Build

Copy

*
* *
* * *
* * * *
* * * * *

Basic Approach: Nested For Loops

The outer loop controls the row, inner loop controls how many stars per row.

Copy

def right_triangle(n):
    for i in range(1, n + 1):  # rows
        for j in range(i):      # stars per row
            print("*", end=" ")
        print()                 # new line after each row

# Test with 5 rows
right_triangle(5)

Output

Copy

* 
* * 
* * * 
* * * * 
* * * * *

Variation 1: Using `end` and `sep`

Python 3 lets you control line endings directly.

Copy

def right_triangle_v2(n):
    for i in range(1, n + 1):
        print("* " * i, end="")
        print()  # newline

right_triangle_v2(5)

Output

Copy

*
* *
* * *
* * * *
* * * * *

Variation 2: Using `str.join()`

Copy

def right_triangle_v3(n):
    for i in range(1, n + 1):
        print(" ".join(["*"] * i))

right_triangle_v3(5)

Output

Copy

*
* *
* * *
* * * *
* * * * *

Variation 3: With Numbers Instead of Stars

Copy

def right_triangle_numbers(n):
    for i in range(1, n + 1):
        print(" ".join(str(j) for j in range(1, i + 1)))

right_triangle_numbers(5)

Output

Copy

Variation 4: Right-Aligned (Left Triangle)

Copy

def left_triangle(n):
    for i in range(1, n + 1):
        print(" " * (n - i) + "* " * i, end="")
        print()

left_triangle(5)

Output

Copy

    * 
   * * 
  * * * 
 * * * * 
* * * * *

Common Beginner Errors

Forgetting end="" → every star prints on its own line
Off-by-one in range → Python’s range(1, n+1) is exclusive, so you get exactly n rows
Mixing tabs and spaces → inconsistent alignment

Time & Space Complexity

Metric	Value
Time	O(n²)
Space	O(1) (no extra storage)

Practice Exercises

Change the star count formula: try print("* " * (2*i - 1)) to get odd columns
Print row numbers instead of stars: 1, 2 2, 3 3 3…
Print reversed rows: 5 4 3 2 1, 4 3 2 1, etc.

Try these variations in your own Python REPL or script. Next up: Inverted Right Triangle Pattern in Python

FAQ

How do you print the Right Triangle Star pattern in Python?

What is the time complexity of the Right Triangle Star pattern in Python?

The time complexity is O(n²) and the space complexity is O(1), since the pattern is built with a fixed number of loop counters and printed row by row.

Right Triangle Star Pattern in Swift — Code, Output & Variations

mihirpipermitwala.com — Tue, 10 Sep 2024 00:00:00 GMT

The Right Triangle Star pattern is a fundamental loop exercise for Swift beginners. Here’s the complete implementation with working code and output.

Pattern to Print

Copy

*
**
***
****
*****

Implementation

Copy

func rightTriangle(_ n: Int) {
    for i in 1...n {
        print(String(repeating: "*", count: i))
    }
}
rightTriangle(5)

Output

Copy

*
**
***
****
*****

How It Works

Row i contains i stars — the outer loop tracks the row, the star count equals the row number.

Practice Variations

Try printing the pattern with a different character (e.g., # or +)
Modify the code to accept the pattern size as user input
Combine this pattern with its inverse to create a diamond or hourglass

Complexity

Time: O(n²) — total characters printed grows quadratically
Space: O(n) — longest row is O(n) characters

FAQ

How do you print the Right Triangle Star pattern in Swift?

What is the time complexity of the Right Triangle Star pattern in Swift?

The time complexity is O(n²) and the space complexity is O(n), since the pattern is built with a fixed number of loop counters and printed row by row.

Happy coding!

One weird trick for powerful Git aliases

mihirpipermitwala.com — Sun, 01 Sep 2024 00:00:00 GMT

Advanced Git Aliases

Remove Duplicates from Sorted Array in Dart — Two Pointers & More

mihirpipermitwala.com — Thu, 29 Aug 2024 00:00:00 GMT

Remove Duplicates from Sorted Array (#26 — Easy): Given a sorted integer array nums, remove duplicates in-place such that each unique element appears only once. Return the number of unique elements.

Problem Statement

Given a sorted integer array nums, remove duplicates in-place such that each unique element appears only once. Return the number of unique elements.

Example:

Copy

Input: nums = [1,1,2]
Output: 2, nums = [1,2,_]

Approach: Two Pointers (Optimal)

Time: O(n) | Space: O(1)

One read pointer scans all elements; one write pointer only advances when it finds a new unique value. Since the array is sorted, duplicates are always adjacent.

Copy

int removeDuplicates(List<int> nums) {
  if (nums.isEmpty) return 0;
  int write = 1;
  for (int read = 1; read < nums.length; read++) {
    if (nums[read] != nums[read - 1]) {
      nums[write] = nums[read];
      write++;
    }
  }
  return write;
}

void main() {
  var nums = [1,1,2,2,3];
  int k = removeDuplicates(nums);
  print(k);
  print(nums.sublist(0, k));
}

Key Takeaways

Start with the brute-force approach to understand the problem
Two Pointers (Optimal) gives the optimal O(n) solution
Practice this pattern — it appears frequently in coding interviews

FAQ

What is the best approach to solve Remove Duplicates from Sorted Array in Dart?

The recommended approach is Two Pointers (Optimal), which runs in O(n) time with O(1) space. The full Dart implementation is shown above.

What is the time complexity of Remove Duplicates from Sorted Array in Dart?

Using Two Pointers (Optimal), the time complexity is O(n) and the space complexity is O(1).

Happy coding!

Mihir Blog Site's RSS Feed

10 More Pattern Programs in Go — Spiral, Diamond & More

1. Spiral Matrix

Output

2. Hollow Diamond

Output

3. Letter Triangle

Output

4. Number Stair

Output

5. Fibonacci Triangle

Output

6. Binary Triangle

Output

7. Plus Sign

Output

8. Hollow Pyramid

Output

9. X-Shape

Output

10. Sandglass

Output

Conclusion

10 More Pattern Programs in Dart — Spiral, Diamond & More

1. Spiral Matrix Pattern

Output

2. Hollow Diamond Star

Output

3. Letter Triangle

Output

4. Number Stair

Output

5. Fibonacci Triangle

Output

6. Binary Triangle

Output

7. Wave Pattern

Output

8. Double Hill

Output

9. Hollow Pyramid

Output

10. X-Shape

Output

Conclusion

Add an MCP Server to Your React Native Tooling

What is MCP for React Native?

Prerequisites

Step 1: Create a Node.js/TypeScript MCP Server

Step 2: Implement the MCP Server

Step 3: Configure Claude Code

Step 4: Use with Claude Code

Step 5: Expo Integration

Real-World Use Cases

1. Onboarding New Developers

2. Pre-Commit Checks

3. Dependency Updates

Troubleshooting

MCP Server Not Starting

Claude Code Integration Issues

Security Considerations

Conclusion

Related Posts

FAQ

What is an MCP server for React Native development?

How do I add an MCP server to Claude Code for React Native?

Do MCP servers work with Expo projects?

Is it safe to let an AI assistant run commands through an MCP server?

Add an MCP Server to Your Flutter/Dart Tooling

What is MCP?

Prerequisites

Step 1: Create a Dart MCP Server

Step 2: Implement the MCP Server

Step 3: Configure Claude Code to Use Your MCP Server

Step 4: Use the MCP Server in Claude Code

Step 5: Advanced Usage - Auto-Generate Boilerplate

Real-World Use Cases

1. Onboarding New Team Members

2. Pre-Commit Hook Validation

3. Documentation Generation