DEV Community: Bibin Jaimon

Euclidean algorithm for finding GCD

Bibin Jaimon — Sat, 31 Aug 2024 05:07:20 +0000

function findGCD(num1, num2) {

    if (num1 > 0 && num2 > 0) {
        const val = num1 < num2 ? {
            min: num1,
            max: num2
        } : {
            min: num2,
            max: num1
        }
        return findGCD(val.max - val.min, val.min)
    }

    return num1 != 0 ? num1 : num2
}

How to create a hash for a STRING in Swift

Bibin Jaimon — Sat, 16 Dec 2023 19:10:48 +0000

How to create an identifier for strings having same number of characters?

Use cases:

Group anagram in a dictionary
Check the number of characters in two strings are same

func createHash(_ s: String) -> String {
    var hash = Array(repeating: 0, count: 26)

    Array(s).forEach({ char in
        let index = char.asciiValue! - Character("a").asciiValue!
        hash[Int(index)] += 1
    })

    return hash
        .map({ String($0) })
        .joined(separator: ":")
}

input: abbca
output: a2:b2:c

#5 SOLID - Dependency Inversion Principle | Swift | iOS Development

Bibin Jaimon — Sat, 15 Jul 2023 16:03:14 +0000

High-level modules should not depend on low-level modules. Both should depend on abstractions.

Abstractions should not depend on details. Details should depend on abstractions.

In the example below, the PaymentService is a high-level module that provides payment processing functionality. It depends on the PaymentGateway abstraction rather than specific implementations like PayPal or Stripe. This allows different payment gateways to be easily swapped without modifying the PaymentService.


// High-level module (depends on abstraction)
class PaymentService {
    private let paymentGateway: PaymentGateway

    init(paymentGateway: PaymentGateway) {
        self.paymentGateway = paymentGateway
    }

    func processPayment(amount: Double) {
        // Process payment using the payment gateway
        paymentGateway.processPayment(amount: amount)
    }
}

// Abstraction (does not depend on details)
protocol PaymentGateway {
    func processPayment(amount: Double)
}

// Concrete implementation (depends on abstraction)
class PayPalGateway: PaymentGateway {
    func processPayment(amount: Double) {
        // Process payment using PayPal API
        // Implementation details specific to PayPal
    }
}

// Concrete implementation (depends on abstraction)
class StripeGateway: PaymentGateway {
    func processPayment(amount: Double) {
        // Process payment using Stripe API
        // Implementation details specific to Stripe
    }
}

The PaymentGateway protocol defines the required behavior for a payment gateway, and the concrete implementations (PayPalGateway and StripeGateway) depend on the abstraction. This promotes flexibility and allows for future additions or changes to payment gateway implementations.

By applying the Dependency Inversion Principle, you can design your code in a way that reduces dependencies, increases flexibility, and promotes better code organization and maintainability.

#4 SOLID - Interface Segregation Principle | Swift | iOS Development

Bibin Jaimon — Sun, 09 Jul 2023 05:07:20 +0000

In the following example we have defined a PrinterProtocol which we can use to create multiple type of printers.

We have added every methods in one protocol. So, even if we want to create a simple printer we will have to implement every function in the protocol. We can provide default implimention for the protocols but still it's violates the ISP because the SimplePrinter could call the default implementation as well. That is not expected behaviour. A SimplePrinter doesn't have to call receiveFax() method.

protocol PrinterProtocol {
    func printDocument()
    func scanDocument()
    func sendFax()
    func receiveFax()
}

extension PrinterProtocol {
    func receiveFax() {
        print("Default: Receiving fax...")
    }
}

class SimplePrinter: PrinterProtocol {
    func printDocument() {
        print("Printing document...")
    }

    func scanDocument() {
        print("Scanning document...")
    }

    func sendFax() {
        print("Sending fax...")
    }

    func receiveFax() {
        print("Receiving fax...")
    }
}

Let's check how we can implement as per ISP 🚀

Clients should not be forced to depend on interfaces they don't use.
Larger, general-purpose interfaces should be segregated into smaller, more specific interfaces that are tailored to the needs of individual clients.
The goal is to avoid the situation where a client is required to implement methods that are irrelevant to its use case.
This promotes modularity, maintainability, flexibility, and testability in software systems.


protocol Printer {
    func printDocument()
}

protocol Scanner {
    func scanDocument()
}

protocol FaxMachine {
    func sendFax()
    func receiveFax()
}

class AllInOnePrinter: Printer, Scanner, FaxMachine {
    func printDocument() {
        print("Printing document...")
    }

    func scanDocument() {
        print("Scanning document...")
    }

    func sendFax() {
        print("Sending fax...")
    }

    func receiveFax() {
        print("Receiving fax...")
    }
}

class SimplePrinter: Printer {
    func printDocument() {
        print("Printing document...")
    }
}

#3 SOLID - Liskov Substitution Principle | Swift | iOS Development

Bibin Jaimon — Sat, 08 Jul 2023 07:31:29 +0000

LSP states that objects of a superclass should be replaceable with objects of its subclass without affecting the correctness of the program - Barbara Liskov (1987)

In the below example,

We have a class hierarchy representing different shapes: a superclass Shape and two subclasses, Rectangle and Circle.
The Shape class acts as a superclass defining a common interface with the area() method.
Both Rectangle and Circle subclasses inherit from Shape and provide their own implementation of the area() method.

class Shape {
    func area() -> Double {
        fatalError("Subclasses must override area() method.")
    }
}

class Rectangle: Shape {
    var width: Double
    var height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }

    override func area() -> Double {
        return width * height
    }
}

class Circle: Shape {
    var radius: Double

    init(radius: Double) {
        self.radius = radius
    }

    override func area() -> Double {
        return Double.pi * radius * radius
    }
}

In the printArea() function, we accept an instance of Shape as a parameter.
The area() method will be dynamically dispatched based on the actual type of the object at runtime, and the correct implementation will be executed.
This example demonstrates how the Liskov Substitution Principle allows us to treat objects of different subclasses as interchangeable, as long as they conform to the common superclass interface.

func printArea(shape: Shape) {
    let area = shape.area()
    print("Area: \(area)")
}

let rectangle = Rectangle(width: 4, height: 5)
let circle = Circle(radius: 3)

printArea(shape: rectangle) // Output: Area: 20.0
printArea(shape: circle)    // Output: Area: 28.274333882308138

#2 SOLID - Open Close Principle | Swift | iOS Development

Bibin Jaimon — Thu, 06 Jul 2023 19:20:21 +0000

It states that software entities (classes, modules, functions, etc.)
should be open for extension but closed for modification.

In the below example, the Shape class violates the Open-Closed Principle because it is not closed for modification ❌.
Whenever a new shape is added (e.g., triangle, rectangle), the Shape class needs to be modified to include a new case in the ShapeType enum and update the area() method accordingly.
This violates the principle as the class is not closed for modification.

enum ShapeType {
    case circle
    case square
}

class Shape {
    var type: ShapeType

    init(type: ShapeType) {
        self.type = type
    }

    func area() -> Double {
        switch type {
        case .circle:
            // Calculate circle area
            return 3.14 * 5 * 5
        case .square:
            // Calculate square area
            return 10 * 10
        }
    }
}

let shapes: [Shape] = [Shape(type: .circle), Shape(type: .square)]

In the below example, the Open-Closed Principle is applied correctly ✅.
The Shape protocol defines the contract for shapes, and different shapes (e.g., Circle and Square) implement the Shape protocol and provide their own implementation of the area() method.
Now, if you want to add a new shape (e.g., Triangle), you can simply create a new struct conforming to the Shape protocol without modifying any existing code.
This adheres to the Open-Closed Principle as the code is closed for modification but open for extension.

enum ShapeType {
    case circle
    case square
}

protocol Shape {
    func area() -> Double
}

struct Circle: Shape {
    func area() -> Double {
        // Calculate circle area
        return 3.14 * 5 * 5
    }
}

struct Square: Shape {
    func area() -> Double {
        // Calculate square area
        return 10 * 10
    }
}

let shapes: [Shape] = [Circle(), Square()]

#1 SOLID - Single Responsibility Principle | Swift | iOS Development

Bibin Jaimon — Wed, 05 Jul 2023 14:16:04 +0000

SRP state that a class should have only one reason to change.

Below is an implementation for a Debt calculator.

public class DebtCalculatorOld {

    private var totalDebt: Int = 0

    public init(totalCalories: Int = 0) {
        self.totalDebt = totalCalories
    }

    public func update(_ amount: Int) {
        self.totalDebt += amount

        if self.totalDebt > 500 {
            //Notify user about the change
            print("Limit Reached")
        }
    }
}

Each class should focus on performing a single task.
The below class is for managing debt of a user. If the total debt reaches a certain amount then we should notify the user about it.
Here we have added everything in one class which not recommended as per single responsibility principle.
In future, if we want to change the notification type to be email. Then we will have to change the update function in the DebtCalculator.
There should not be multiple reasons for a class to change.

public class DebtCalculator {

    private var totalDebt: Int = 0
    private var notificationManager: NotificationManager

    public init(totalCalories: Int = 0,
                notificationManager: NotificationManager = NotificationManager()) {
        self.totalDebt = totalCalories
        self.notificationManager = notificationManager
    }

    public func update(_ amount: Int) {
        self.totalDebt += amount

        if self.totalDebt > 500 {
            notificationManager.notify(totalDebt)
        }
    }
}

public class NotificationManager {

    public init() {}

    func notify(_ current: Int) {
        print("Limit Reached - \(current)")
    }
}

Here we have seperate class for Adding debt releated features and Notification releated features.
In future if we want to chagne the Notification type to email we can change it without making changes in DebtCalculator

Is this code thread safe? Swift | iOS Development interview question

Bibin Jaimon — Sun, 18 Jun 2023 18:50:55 +0000

Solution {
    static var names: [Int] = []
}

The names variable is defined as a static property in the Solution class.
Static properties are shared among all instances of the class and can be accessed and modified from multiple threads concurrently.
Since there is no synchronization mechanism in place, concurrent access to the names array can lead to data races and inconsistent results.
If multiple threads attempt to modify the names array simultaneously, it can result in unexpected behaviour, such as incorrect or incomplete modifications, data corruption, or crashes.
To ensure thread safety, concurrent access to the names array should be synchronized using appropriate mechanisms like locks, serial queues, or other synchronization primitives.
Adding synchronization mechanisms will ensure that only one thread can access or modify the names array at a time, preventing data races and ensuring consistent behaviour.

Solution should be like below 🚀

class Solution {
    private static var names: [Int] = []
    private static let queue = DispatchQueue(label: "com.example.solution-queue")

    static func updateNames(_ name: Int) {
        queue.async {
            names.append(name)
        }
    }
}

🚀 LinkedIn
🚀 GitHub

Serial DispatchQueue | sync & async explained | Swift

Bibin Jaimon — Sat, 17 Jun 2023 16:46:52 +0000

Doc: DispatchQueue

The serial queue process a block of object one at a time. There will be an order of execution for serial queues.

Case 1



let serial = DispatchQueue(label: "first")

serial.sync {
    print("1")

    serial.sync {
        print("2")
    }

    print("3")
}

Output: Error
Explanation: When we execute a block of code in serial queue with sync function the queue will be suspended till the block completes execution. Here in between we are trying to add new block with sync function will throw an error.

Case 2



let serial = DispatchQueue(label: "first")

serial.sync { // First block
    print("1")

    serial.async { // Second block
        print("2")
    }

    print("3")
}

Output: 1 3 2
Explanation: The after executing the first block then it will take the second block which prints the number 2. The second block is async function so it will not crash.

Case 3



let serial = DispatchQueue(label: "first")

serial.async {
    print("1")

    serial.sync {
        print("2")
    }

    print("3")
}

Output: 1
Explanation: The reason for this behaviour is a deadlock that occurs due to a circular dependency between the async and sync calls on the same serial queue.

Let's break down the execution step by step:

The async block is dispatched to the serial queue, and "1" is printed.
Inside the async block, there is a sync block dispatched to the same serial queue.
The sync block waits for the async block to complete before executing.
However, the async block cannot complete because it is waiting for the sync block to complete.

This creates a circular dependency, resulting in a deadlock, where both blocks are waiting for each other to finish.

Case 4



let serial = DispatchQueue(label: "first")

serial.async {
    print("1")

    serial.async {
        print("2")
    }

    print("3")
}

Output: 1 3 2
Explanation: Using the async function will not suspend the serial queue from adding new blocks. The will complete execution on the order of inserting it. There will be an order for the code to execute.

How does compression resistance and content hugging is related?

Bibin Jaimon — Tue, 30 May 2023 10:14:09 +0000

Compression resistance and content hugging are two related concepts that work together to determine how a view behaves when its available space is constrained.

Compression resistance: Compression resistance refers to a view's ability to resist being compressed or made smaller when there is limited space available. When a view has a high compression resistance priority, it indicates that it should try to maintain its size and avoid being compressed. This means that if there is not enough space to accommodate all views in a container, the views with higher compression resistance will be less likely to be squeezed or made smaller.

Content hugging: Content hugging, on the other hand, refers to a view's preference for hugging its content tightly. When a view has a high content hugging priority, it means it prefers to be sized to fit its content more closely. Views with high content hugging priority will try to expand to fit their intrinsic content size.

The relationship between compression resistance and content hugging is as follows:

Compression resistance takes effect when there is limited space available and views need to be compressed or made smaller to fit within the container. Views with higher compression resistance priorities will be less likely to be compressed compared to views with lower compression resistance priorities.
Content hugging takes effect when there is excess space available, and views need to expand to fill the container. Views with higher content hugging priorities will be more likely to expand to fit their intrinsic content size compared to views with lower content hugging priorities.

So, in summary, compression resistance determines how views behave when there is limited space, and content hugging determines how views behave when there is excess space.

By adjusting the compression resistance and content hugging priorities of views within a layout, you can control how they respond to changes in available space and ensure a desired layout and appearance.

Array & Hashing: Group Anagrams

Bibin Jaimon — Sat, 01 Apr 2023 16:19:01 +0000

How to group anagrams in same group?

Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

Anagram mean that the words will have same length and same number of character occurrence.

eat can be rearranged to tea, ate

My Recommended Solution

Lets take eat for example.
Count the number of characters in it. That would be e = 1, a = 1, t = 1. So the key for eat would be e1a1t1.
We need to find other words which having same key.
In this case we can store this to a data structure called Hash Map. Then the key of the hash map will be the one which we create with number of characters of the word and value will be an Array.
Once we created a key then we can add it to the hash map. Then the result would like this

{
"e1a1t1": ["eat"]
}

In this case getting the key's character order is a challenging thing. What I'm suggesting is to create an array with 26 size (number alphabets).
Initialize it with zero

[0,0,0,0,0,....0,0,0,0]

We can use this array to create a key. Which should be equal for word with same number of characters.
For Example, if we take eat. Then the array will looks like,

[ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ]

From this we can create a key by stringifying the array '1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0'

How do we know the index in the array to increment the count of a particular character?

Every alphabets has an ASCII value.
a => 97, for e => 101, t => 116

If you closely look at this numbers, We can see a way to get the corresponding array index. Find it.

After looping through every words we will have a hash map with grouped anagrams. The values of all the keys of the hash map is the answer.

Happy Coding,
Bibin Jaimon

#1 iOS Security Tips: UIPasteboard | iOS Development

Bibin Jaimon — Tue, 17 May 2022 17:26:16 +0000

What is UIPasteboard:

This is a method to share data between any other app using cut or copy methods.

How it become a Security concern:

When we copy a sensitive piece of data, It will store in the general paste board of our system which can access by another apps

How to access general paste board programmatically:

UIPasteBoard.general.string

Methods to prevent this security issue:

1. isSecureTextEntry

UITextField has a property called isSecureTextEntry. We can set this to true. Its mainly used for passwords

let passwordTextField = UITextField()
passwordTextField.isSecureTextEntry = true

2. Wipe the content in the paste board in the AppDelegate's applicationWillResignActive method

UIPasteboard.general.items = [[String: Any]()]

3. Create an app specific paste board

The data will not be available to other app if we use custom paste board.
How to create a custom paste board in AppDelegate

extension AppDelegate {
    static let pastboardName = UIPasteboard.Name(rawValue: "CustomPasteBoard")
    static var customPasteBoard: UIPasteboard? = UIPasteboard(name: pastboardName, create: true)
}

How to store data in custom paste board

extension UITextField {
    open override func copy(_ sender: Any?) {
        AppDelegate.customPasteBoard?.string = self.text
    }

    open override func cut(_ sender: Any?) {
        AppDelegate.customPasteBoard?.string = self.text
        self.text = nil
    }

    open override func paste(_ sender: Any?) {
        if let text = AppDelegate.customPasteBoard?.string {
            self.text = text
        }
    }
}

This will store your app's data to custom paste board.

Apple Doc of UIPasteboard
Happy Coding🔥