Forem: kittichanr

Two Sum with an Optimized Solution

kittichanr — Sat, 04 Apr 2026 06:58:32 +0000

Coming back from my previous article: two sum problem

I mentioned that I would show another solution to reduce time complexity.

In the previous approach, I used two nested loops to check every possible pair of numbers in the array. This is essentially a brute-force method, where we try all combinations to find two numbers that add up to the target.

In this article, we will use a different approach. Instead of checking every pair, we use a hash map (object in JavaScript) to reduce the number of steps needed to find the solution.

Let’s take a look.

Question

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target.

You may assume that each input has exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example

Input: nums = [2,11,15,7], target = 9
Output: [0,3]
Explanation: Because nums[0] + nums[3] == 9, we return [0, 3].

Solution

function twoSum(nums, target) {
        const obj = {}

    for (let i = 0; i < nums.length ; i++) {
          const num = nums[i]
          const complement = target - num

          if (complement in obj) {
              return [obj[complement], i]
          }

          obj[num] = i
    }
};

const nums = [2, 11, 15, 7]
const target = 9

console.log(twoSum(nums, target)) // Answer: [0, 3]

Explain the solution

Create an object obj to store numbers we have already seen, along with their indices.
Loop through the array nums.
- For each element:
  - Store the current number in a variable num.
  - Calculate its complement using:complement = target - num
- Check if the complement already exists in obj:
  - If it exists, it means we have already seen the number that can pair with the current number to reach the target.
  - Return the indices:[obj[complement], i]
If the complement is not found:
- Store the current number and its index in the object:obj[num] = i
Continue the loop until the solution is found.

Summarize

This solution is more efficient than the previous brute-force approach.

Time Complexity: O(n)
Space Complexity: O(n)

By using a hash map, we avoid nested loops and reduce the number of operations significantly.

There are many ways to solve this problem, so feel free to explore and try other approaches as well.

Thanks for reading, and keep learning!

Reference

https://leetcode.com/problems/two-sum/description/

Two sum problem

kittichanr — Sat, 04 Apr 2026 02:53:44 +0000

Hello! Today I will explain how to solve the Two Sum problem. I believe most developers have seen this problem before—either when they first started practicing coding or when preparing for job interviews.

For those in the software industry who haven’t solved this problem yet, I’ll show you how to approach it step by step.

Let’s get started.

Question

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target.

You may assume that each input has exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example

Input: nums = [2,11,15,7], target = 9
Output: [0,3]
Explanation: Because nums[0] + nums[3] == 9, we return [0, 3].

Solution

function twoSum(nums, target) {
    for (let i = 0; i < nums.length ; i++) {
        for (let j = i + 1; j < nums.length ; j++) {
            if (nums[i] + nums[j] === target) {
                return [i, j]
            }
        }
    }
    return []
};


const nums = [2, 11, 15, 7]
const target = 9

console.log(twoSum(nums, target)) // Answer: [0, 3]

Explain the solution

Create a function that takes two parameters: nums and target.
Use two loops to find two numbers in the array whose sum equals the target:
- The outer loop iterates through each element in the array.
- The inner loop checks the elements after the current outer loop index.
  - For example, with [2, 11, 15, 7]: when the outer loop is at 2, the inner loop checks 11, 15, and 7.
Inside the inner loop, check whether the sum of the two numbers equals the target.
- If it does, return their indices.
If no pair is found after checking all possibilities, return an empty array.
That’s it!

Performance consideration

This solution is easy to understand and works correctly, but it is not efficient. It uses a time complexity of O(n²) because it checks every possible pair.

In the next article, I will show you a more efficient solution that reduces the time complexity—this will be useful for interviews and real-world applications.

Thanks for reading, and keep learning!

Reference

https://leetcode.com/problems/two-sum/description/

Type of changing software

kittichanr — Sat, 20 Sep 2025 00:44:21 +0000

There are 4 main reasons to change software

1.Adding a feature - Introducing new behavior to your software.

Example: adding a company logo to the navigation bar on the left side.

2.Fixing a bug - Correcting unintended or incorrect behavior in existing code.

Example: when a user clicks the button to go to the signup page, but it redirects to the login page instead.

3.Improving the design - Refactoring the codebase to make it easier to read, maintain, and collaborate on, while keeping the behavior the same.

Example: splitting a large class or function into smaller, more manageable pieces, then combining them appropriately.

4.Optimizing resource usage - Refactoring parts of the system to improve performance and efficiency.

Example: creating an index in the database to make queries faster.

Types of Software Changes

Every change to software carries risks, such as breaking user functionality, requiring significant development effort, creating conflicts within the team, or interfering with existing use cases.

To minimize risks, we should ask these three questions before making a change:

What change do we need to make?
How will we know that we've done it correctly?
How will we know that we haven't broken anything else?

If you can confidently answer these three questions, you can make software changes more smoothly and safely. I hope this helps raise awareness whenever you're modifying software.

Credit: Working Effectively with Legacy Code Book by Michael C. Feathers

What is pure function?

kittichanr — Sat, 21 Jun 2025 02:28:39 +0000

Understanding Functional Programming

Functional programming is a programming style or paradigm that focuses on building software by creating and combining functions. Think of it like this: you write small, self-contained pieces of code (functions) that take an input, perform some operations, and then produce an output. A core idea is that for the same input, you will always get the same output, making the code predictable.

Why Use Functional Programming?

Reusable: Functions are designed to be independent, meaning you can easily reuse them across different parts of your code or in various modules, as long as you need their specific output.
Stateless: Functional programs aim to be "stateless." This means a function's output depends solely on its inputs, not on any changeable internal or external state. No matter how many times you run a function with the same input, you'll always get the identical output.
Easier to Test: Because functions are self-contained, predictable, and don't cause side effects (changes outside themselves), they are much simpler to test and debug.
Concurrency Friendly: The stateless and immutable nature of functional programming makes it easier to write code that runs correctly in parallel, reducing common issues found in multi-threaded applications.

Pure Functions

Functional programming relies heavily on a concept called pure functions. So, what exactly makes a function "pure"? A pure function must strictly adhere to these 3 rules:

1.Always returns a single value. A pure function must consistently produce exactly one output value.

Bad Example:

static char getFirstCharacter(String s) {
    return s.charAt(0);
}

This is "bad" because, depending on whether the string s is empty or null, it could either return the first character or throw an error. This means it has multiple possible outcomes for its "return."

Good Example:

static int increment(int x) {
    return x + 1;
}

This is "good" because it predictably returns a single value: the input x plus one.

2.Calculates the return value based only on its arguments (inputs). The output of a pure function should be determined only by the values passed into it as arguments. It must not depend on or be influenced by any external data, variables, or system state that could change.

Bad Example:

static double randomPart(double x){
    return x + Math.random();
}

This is "bad" because Math.random() generates a different random number each time it's called. This makes the function's return value unpredictable even with the same x input. This unpredictable change caused by something outside the function is called a "side effect."

Good Example:

static int add(int a, int b){
    return a + b;
}

This is "good" because for the same inputs a and b, it will always return the same sum.

3.Doesn't change (mutate) any existing values or external state. A pure function must not modify any of the data passed into it, nor should it alter any variables or objects outside of its own scope. It produces new data rather than changing old data.

Bad Example:

public static void addTag(User user, String tag) {
    user.tags.add(tag);
}

While this code works, it's considered "bad" in a pure functional context because it directly modifies the user object that was passed in. If you call this function multiple times with the same user object, the user.tags list will continually change. This modification of an existing object is known as mutating a value (a side effect) and violates rule #3.

Good Example:

public static User addTag(User user, String tag) {
     List<String> newTags = new ArrayList<>(user.tags);
     newTags.add(tag);         
     return new User(newTags);   
 }

This is "good" because the addTag function does not alter the original user object. Instead, it creates a new list (newTags), adds the new tag to that new list, and then returns a new User object that incorporates these changes. The original user object remains completely unchanged, thus avoiding any side effects and adhering to the "no mutation" rule.

Example of a Pure Function:

Here's an example of a function that clearly follows all 3 rules of a pure function:

public static int calculateTotalPrice(int pricePerItem, int quantity, int discountPercent) {
    int total = pricePerItem * quantity;
    int discount = total * discountPercent / 100;
    return total - discount;
}

public static void main(String[] args) {
    int result = calculateTotalPrice(100, 5, 10); // 100 * 5 = 500 - 10% = 450
    System.out.println("Total price after discount: " + result);
}

If a function misses any of these three rules, it becomes an impure function. While impure functions can exist in your code (especially due to the third rule), they might not fully align with the goals of functional programming.

Handling Large Data and Performance

Sometimes, when dealing with large amounts of data, like lists or collections, copying everything to create a new, immutable version can hurt performance. In such cases, you might have to accept making the data mutable to solve the performance issue. This is a trade-off you need to consider. If performance isn't affected, it's always better to keep data immutable.

Some languages (like JavaScript or Scala) have built-in collections that are immutable by default, so you don't need to manually copy them to prevent mutation. but Java need to be copy to a new collection for immutable.

Here's an example of creating a new collection inside a function to prevent mutating the original:

public static List<Integer> doubleAllValues(List<Integer> numbers) {
    List<Integer> result = new ArrayList<>(); // Create a new collection to avoid changing the original
    for (int num : numbers) {
        result.add(num * 2);
    }
    return result;
}

public static void main(String[] args) {
    List<Integer> original = new ArrayList<>();
    original.add(1);
    original.add(2);
    original.add(3);

    List<Integer> doubled = doubleAllValues(original);

    System.out.println("Original list: " + original); // Output: Original list: [1, 2, 3] (Not changed)
    System.out.println("Doubled list: " + doubled);   // Output: Doubled list: [2, 4, 6]
}

Understanding pure functions and their 3 rules is a great starting point for writing functional code. Pure functions are just one piece of the puzzle in functional programming; there are many other concepts to explore! We'll share more about those later.

I hope you enjoy this content. if you have any concern or question you can ask me thank you.

Reference

https://www.amazon.com/Grokking-Functional-Programming-Michal-Plachta/dp/1617291838 In Part 1 Chapter 2 & 3

Golang with google wire

kittichanr — Sat, 14 Jun 2025 06:19:05 +0000

Introduction

Google Wire is a package that helps manage Dependency Injection (DI) in Go, developed by Google. Its main purpose is to generate code that wires together functions with injected values so they can work together.

Dependency Injection (DI) is the practice of providing dependencies from the outside instead of creating them inside the function. The benefits are:

Reduced code coupling (loose coupling)
Easier testing — since the code is decoupled, you can mock dependencies and inject them for testing easily

Example:

package main

import "fmt"

type Animal interface {
    MakeSound()
}

// Dog
type Dog struct{}

func (d *Dog) MakeSound() {
    fmt.Println("Woof!")
}

// Cat
type Cat struct{}

func (c *Cat) MakeSound() {
    fmt.Println("Meow!")
}

type Zoo struct {
    animals []Animal
}

func (z *Zoo) MakeSounds() {
    for _, animal := range z.animals {
        animal.MakeSound()
    }
}

// NewZoo is a constructor function for Zoo with DI
func NewZoo(animals ...Animal) *Zoo {
    return &Zoo{animals: animals}
}

func main() {
    // Injecting dependencies
    dog := &Dog{}
    cat := &Cat{}
    zoo := NewZoo(dog, cat) // dog and cat are injected into NewZoo

    zoo.MakeSounds()
}

Core Concepts

1. Providers
These are functions that return newly created objects, for example:

type Message string

func NewMessage() Message {
    return Message("Hi there!")
}

They can be grouped into what’s called a provider set, like this:

package foobarbaz

import (
    // ...
    "github.com/google/wire"
    "errors"
)

// Foo
type Foo struct {
    X int
}

func ProvideFoo() Foo {
    return Foo{X: 42}
}

// Bar
type Bar struct {
    X int
}

func ProvideBar(foo Foo) Bar {
    return Bar{X: -foo.X}
}

// Baz
type Baz struct {
    X int
}

func ProvideBaz(bar Bar) (Baz, error) {
    if bar.X == 0 {
        return Baz{}, errors.New("cannot provide baz when bar is zero")
    }
    return Baz{X: bar.X}, nil
}

// Group provider 
var SuperSet = wire.NewSet(ProvideFoo, ProvideBar, ProvideBaz)

2. Injectors

These are functions that combine all provider functions together after code generation.

Example:

// +build wireinject
// The build tag ensures this stub is excluded from the final build.

package main

import (
    "context"

    "github.com/google/wire"
    "example.com/foobarbaz"
)

// injector function
func initializeBaz(ctx context.Context) (foobarbaz.Baz, error) {
    wire.Build(foobarbaz.SuperSet)
    return foobarbaz.Baz{}, nil
}

Now that you understand providers and injectors, let’s look at how to set up and use Google Wire in practice.

Set Up and Basic Usage

1.Install the Google Wire package

go install github.com/google/wire/cmd/wire@latest

2.Create your desired provider functions, for example:

// greeter/greeter.go
package greeter

type Message string

// provider function
func NewMessage() Message {
    return Message("Hi there!")
}

type Greeter struct {
    Message Message
}

func (g Greeter) Greet() Message {
    return g.Message
}

// provider function
func NewGreeter(m Message) Greeter {
    return Greeter{Message: m}
}

type Event struct {
     Greeter Greeter
}

func (e Event) Start() {
    msg := e.Greeter.Greet()
    fmt.Println(msg)
}

func NewEvent(g Greeter) Event {
    return Event{Greeter: g}
}

var MainBindingSet = wire.NewSet(NewMessage, NewGreeter, NewEvent)

3.Create an injector function in di/wire.go:

// di/wire.go
//go:build wireinject
// +build wireinject

package di

import (
 "context"

 "github.com/google/wire"
 "github.com/kittichanr/go-wire/greeter"
)

func InitializeApplication(ctx context.Context) (greeter.Event, func(), error) {
 wire.Build(greeter.MainBindingSet)
 return greeter.Event{}, func() {}, nil
}

You must include the go:build and +build comments so that the Wire CLI knows where to generate code.

// go:build wireinject
// +build wireinject

4.In main.go, call the injector function to initialize everything when running your application:

// main.go
package main

import (
 "context"
 "log"

 "github.com/kittichanr/go-wire/di"
)

func main() {
 ctx := context.Background()
 _, cleanUpFn, err := di.InitializeApplication(ctx)
 defer cleanUpFn()

 if err != nil {
  log.Fatal("initial app failed")
  panic(err)
 }
}

5.Run wire ./di in your terminal to generate the code that connects all provider functions. It will produce a file called di/wire_gen.go, which might look like this:

// Code generated by Wire. DO NOT EDIT.

//go:generate go run -mod=mod github.com/google/wire/cmd/wire
//go:build !wireinject
// +build !wireinject

package di

import (
 "context"
 "github.com/kittichanr/go-wire/greeter"
)

// Injectors from wire.go:

func InitializeApplication(ctx context.Context) (greeter.Event, func(), error) {
 message := greeter.NewMessage()
 greeterGreeter := greeter.NewGreeter(message)
 event := greeter.NewEvent(greeterGreeter)
 return event, func() {
 }, nil
}

Note: Do not edit the generated file. Instead, update your provider functions and re-run wire to regenerate the file.

Notice how wire_gen.go wires all provider functions for you — no need to inject them manually. Yay!

Conclusion

Go Wire is a tool that helps generate code for dependency injection, allowing functions with dependencies to work seamlessly together. You don’t need to manually wire every dependency, and you can be confident they will be initialized in the correct order. The example above demonstrates a basic setup — check out the Go Wire GitHub for more advanced usage.

Source code example: https://github.com/kittichanr/go-wire-basic

Forem: kittichanr

Two Sum with an Optimized Solution

Question

Example

Solution

Explain the solution

Summarize

Reference

Two sum problem

Question

Example

Solution

Explain the solution

Performance consideration

Reference

Type of changing software

What is pure function?

Understanding Functional Programming

Why Use Functional Programming?

Pure Functions

Example of a Pure Function:

Handling Large Data and Performance

Reference

Golang with google wire

Introduction

Core Concepts

Set Up and Basic Usage

Conclusion

References