DEV Community: Shashank Shekhar

Building a Playful File Locker with GoFr

Shashank Shekhar — Fri, 19 Apr 2024 10:38:42 +0000

Forget complex permission schemes, sometimes you just want a quick and dirty way to lock a file. This guide takes you on a fun adventure to create a basic file locker command-line tool using GoFr, specifically focusing on understanding CLI tool development rather than building a production-ready application.

What is GoFr?

GoFr is an opinionated Go framework for accelerated microservice development. It takes an "opinionated" approach, meaning it has a specific way of doing things that streamlines development. This makes Gofr ideal for creating robust and scalable web applications without a lot of boilerplate code.

Gofr is designed to be familiar and user-friendly for developers, even those new to Go. It provides a clear and consistent way to structure your web application, making it easier to understand and maintain.

Building Our Playful File Locker

1. Setting the Stage:

Make sure you have Go installed https://go.dev/.
Create a project directory and initialize a Go module within it using go mod init . Replace with a fun name for your locker tool!
Add gofr package to the project using the following command: go get gofr.dev

2. Directory structure

├── file-locker
│   ├── handlers
│   │   ├── unix
│   │   │   ├── handler.go
│   ├── services
│   │   ├── unix
│   │   │   ├── service.go
│   │   ├── crypt
│   │   │   ├── crypt.go
│   ├── constants
│   │   ├── contants.go
│   ├── main.go
│   ├── go.mod

3. Service Layer

Let's add interface for the service. Add following code to services/interfaces.go:

type FileLocker interface {  
    Init(password string) error  
    Lock() error  
    Unlock(password string) error  
}

type Crypt interface {  
    Encrypt(creds []byte) []byte  
    Decrypt(cred string) ([]byte, error)  
}

Let's add implementation for interfaces. Add following code to services/unix/service.go:

  const (  
     fileName = `private`  
     hiddenFileName = `.private`  
     encryptedDataFileName = `.encrypted-data`  
  )  

  type unix struct {  
     crypt services.Crypt  
  }  

  func New(crypt services.Crypt) services.FileLocker {  
     return &unix{crypt: crypt}  
  }  

  func (m *unix) Init(password string) error {  
     _, err := os.Stat(fileName)  
     if err == nil {  
        return errors.New("file locker already initialized")  
     }  

     err = os.Mkdir(fileName, os.ModePerm)  
     if err != nil {  
        return err  
     }  

     _, err = os.Create(filepath.Join(fileName, ".nomedia"))  
     if err != nil {  
        return err  
     }  

     encryptedPassword := m.crypt.Encrypt([]byte(password))  

     err = os.WriteFile(filepath.Join(fileName, encryptedDataFileName), encryptedPassword, os.ModePerm)  
     if err != nil {  
        return err  
     }  

     return nil  
  }  

  func (m *unix) Lock() error {  
     _, err := os.Stat(fileName)  
     if err != nil {  
        if err == os.ErrNotExist {  
           return errors.New("file locker not initialized or is still locked")  
        }  

        return err  
     }  

     return os.Rename(fileName, hiddenFileName)  
  }  

  func (m *unix) Unlock(password string) error {  
     _, err := os.Stat(hiddenFileName)  
     if err != nil {  
        if err == os.ErrNotExist {  
           return errors.New("file locker not initialized or is still unlocked")  
        }  

        return err  
     }  

     data, err := os.ReadFile(filepath.Join(hiddenFileName, encryptedDataFileName))  
     if err != nil {  
        return err  
     }  

     decryptedData, err := m.crypt.Decrypt(string(data))  
     if err != nil {  
        return err  
     }  

     if password != string(decryptedData) {  
        return errors.New("unauthorized")  
     }  

     return os.Rename(hiddenFileName, fileName)  
  }

- Struct `unix` implements `FileLocker` interface.
- `New` is the factory function that returns a `FileLocker` instance
- `Init` method will create a directory named `private` in the current directory and will store the encrypted password in file named `.encrypted-data`. If `private` directory is already present or there occurs some error while creating it then `Init` method will return error otherwise will return nil.
- `Lock` method will hide the `private` directory by renaming it to `.private`. If the `private` directory is not present in the current directory then it means that either `file-locker` has not been initialised or it is already in locked state.
- `Unlock` method will read the password from `.private/.encrypted-data` file and compare with the password received in the parameter. If it matches, then it will unhide the `private` file otherwise return `unauthorized` error.

Add the following code to services/crypt/crypt.go:

  const secret = `qwertyuiopasdfghjklzxcvb`  

  type crypt struct {  
     block cipher.Block  
  }  

  func New() (services.Crypt, error) {  
     block, err := aes.NewCipher([]byte(secret))  
     if err != nil {  
        return nil, err  
     }  

     return &crypt{block: block}, nil  
  }  

  func (c *crypt) Encrypt(data []byte) []byte {  
     ciphertext := make([]byte, aes.BlockSize+len(data))  
     iv := ciphertext[:aes.BlockSize]  

     cfb := cipher.NewCFBEncrypter(c.block, iv)  
     cipherText := make([]byte, len(data))  
     cfb.XORKeyStream(cipherText, data)  

     dst := make([]byte, base64.StdEncoding.EncodedLen(len(cipherText)))  

     base64.StdEncoding.Encode(dst, cipherText)  

     return dst  
  }  

  func (c *crypt) Decrypt(data string) ([]byte, error) {  
     ciphertext := make([]byte, aes.BlockSize+len(data))  

     iv := ciphertext[:aes.BlockSize]  
     cfb := cipher.NewCFBDecrypter(c.block, iv)  

     cipherText, err := base64.StdEncoding.DecodeString(data)  
     if err != nil {  
        return []byte{}, err  
     }  

     plainText := make([]byte, len(cipherText))  
     cfb.XORKeyStream(plainText, cipherText)  

     return plainText, nil  
  }

- `Encrypt` method will encrypt the data given in the parameter and will return the encrypted string.
- `Decrypt` method will decrypt the string given in the parameter and will return the decrypted string.
- `secret` is a constant that has random string that will be used to encrypt and decrypt the data. You are free to update the value of secret but keeping a strong secret is advisable.

4. Handler layer

Add the following code in handlers/handler.go:

  type Handler interface {  
     Init(ctx *gofr.Context) (interface{}, error)  
     Lock(ctx *gofr.Context) (interface{}, error)  
     Unlock(ctx *gofr.Context) (interface{}, error)  
     Help(_ *gofr.Context) (interface{}, error)  
  }  

  type handler struct {  
     service services.FileLocker  
  }  

  func New(service services.FileLocker) Handler {  
     return &handler{service: service}  
  }  

  func (h *handler) Init(ctx *gofr.Context) (interface{}, error) {  
     password := ctx.Param("password")  
     if password == "" {  
        return nil, errors.New("password is required")  
     }  

     err := h.service.Init(password)  
     if err != nil {  
        return nil, err  
     }  

     return "file locker initialized", nil  
  }  

  func (h *handler) Lock(_ *gofr.Context) (interface{}, error) {  
     err := h.service.Lock()  
     if err != nil {  
        return nil, err  
     }  

     return "file locked", nil  
  }  

  func (h *handler) Unlock(ctx *gofr.Context) (interface{}, error) {  
     password := ctx.Param("password")  
     if password == "" {  
        return nil, errors.New("password is required")  
     }  

     err := h.service.Unlock(password)  
     if err != nil {  
        return nil, err  
     }  

     return "file unlocked", nil  
  }  

  func (h *handler) Help(_ *gofr.Context) (interface{}, error) {  
     return `File Locker CLI Tool  

  Usage:  
   file-locker [command]  
  Available Commands:  
   init      Create a directory named private and initialize the file locker lock      Hide the private directory unlock    Unhides the private directory`, nil  
  }

- `handler` is the struct that implements `Handler` interface.
- `Init` is the handler for `init` command. It takes `password` as the flag. The value for this flag will be used in unlocking.
- `Lock` method is the handler for `lock` command.
- `Unlock` method is the handler for `unlock` command. It takes `password` flag for password to unlock.
- `Help` method is the handler for `help` command. It returns the help string for the app.

5. Main

Add the following code in main.go

  func main() {  
     var service services.FileLocker  

    app := gofr.NewCMD()  

     crypt, err := cryptPkg.New()  
     if err != nil {  
        app.Logger().Fatalf("Error occurred: %v", err)  
     }  

     switch runtime.GOOS {  
     case constants.Darwin, constants.Linux:  
        service = unix.New(crypt)  
     default:  
        app.Logger().Fatalf("Unsupported architecture: %v", runtime.GOOS)  
     }  

     handler := handlers.New(service)  

     app.SubCommand("init", handler.Init)  
     app.SubCommand("unlock", handler.Unlock)  
     app.SubCommand("lock", handler.Lock)  
     app.SubCommand("help", handler.Help)  

     app.Run()  
  }

- `NewCMD()` function creates a command line application
- Depending upon the architecture of the underlying OS, we are creating service. This service will be injected in the handler. Currently, we have only implemented service layer for Unix based OS hence in the switch statement we only have case for `Darwin` (for MacOS) and `Linux`.
- `SubCommand` method adds a sub-command to the CLI application. Here, we have added four sub-commands, viz. `init`, `unlock`, `lock`, `help`. The second argument in the `SubCommand` method is the handler that will be called for execution when that particular sub-command is given.
- `Run()` method will run the application.

Add constants in constants/constants.go and our application is ready for use.

const (  
   Darwin = `darwin`  
   Linux = `linux`  
)

Compiling and Having Fun!

Compile the program using go build -o file-locker .
Run the program with the desired action (sub-command):
```
./file-locker <sub-command> [flags]
```
- To create a private directory use:
```
  ./file-locker init -password=<password>
```
Replace with your desired password. This will create a directory named private in the current directory. You can put all your files that you require to lock in this directory.
- To lock (hide) the private directory, use:
```
  ./file-locker lock
```
- To unlock (unhide) the private directory, use:
```
  ./file-locker unlock -password=<password>
```

Conclusion

Congratulations! You've built a basic file locker command-line tool in Go. It may not be production-ready, but it demonstrates some key concepts of file operations and CLI development using GoFr. While we focused on a playful implementation here, this knowledge can be applied to create more robust tools in the future.

Want to see the complete code and experiment further? The entire codebase for this playful file locker is available at file-locker. Feel free to clone it, explore the implementation, and make it your own!

Note: Currently, this implementation is designed for Unix-based systems. If you're adventurous, try extending it to support Windows by adding platform-specific logic for hiding and unhiding directories.

Go Generics: Unleashing Reusability and Type Safety

Shashank Shekhar — Wed, 03 Apr 2024 13:30:34 +0000

Go 1.18 introduced generics, a game-changer for Go developers. Generics empower you to write code that transcends specific data types, promoting reusability and type safety – hallmarks of clean and maintainable code. So now, we don't have to write the same code over and over again.

What are Generics?

Generics allow you to write flexible and reusable functions and data structures. Say goodbye to repetitive code and hello to generic solutions that adapt to various types.

Generics introduce the concept of type parameters, acting as placeholders for various data types within your functions and data structures. This eliminates the need to create multiple copies of the same logic for different types, leading to several benefits:

Reusability: Write code once and apply it to various data types, reducing code duplication and maintenance overhead.
Type Safety: Generics enforce type checks at compile time, preventing runtime errors caused by incorrect type usage.
Readability: Code becomes more expressive by capturing generic behaviour in a single definition, improving code clarity.

Generics in Action

func Min[T any](x, y T) T {
  if x < y {
    return x
  }

  return y
}

// Leverage Min with multiple types
minString := Min("apple", "banana")
minInt := Min(1, 2)

In this example, the Min function is generic with a type parameter T. It can determine the type of x and y from the function call using type inference. This allows Min to operate on both strings and integers, finding the minimum value in each case.

How to use Generics?

There are some key things to remember when using generics in Go. First, ensure you're using Go version 1.18 or later to take advantage of this feature. Generics extend beyond functions; you can also create generic structs, providing a flexible way to structure your data. It's important to note that generics cannot be used with unnamed types within methods. When defining constraints for your generics, you have two options:

Using type sets: Type sets allow you to restrict the generic to a specific set of types
Using interface: Interfaces offer a more flexible approach by requiring the type to implement a particular set of behaviors.

Understanding these concepts will help us leverage generics effectively in your Go projects.

Using Type Sets

Go generics offer a powerful way to define functions and data structures that work with various types. However, you might want to restrict a generic to a specific set of compatible types. This is where type sets come into play.

Type sets allow you to define a collection of types that can be used with a generic type parameter. This adds an extra layer of control and type safety to your code.

type MyStruct[T int|string] struct {
    Data T
}

func main() {
    intObj := MyStruct[int]{Data: 10}
    fmt.Println("Integer instance:", intObj)

    stringObj := MyStruct[string]{Data: "Hello"}
    fmt.Println("String instance:", stringObj)
}

This code demonstrates a generic struct named MyStruct in Go. Generics allow us to define a structure that can hold different data types. In this example, MyStruct uses a type parameter T which can be either int or string (restricted by the int|string syntax).

The struct itself has a single field named Data with the type T. This allows us to create instances of MyStruct that hold either integer or string data.

The main function showcases this concept:

We create an instance of MyStruct with int as the type for T (MyStruct[int]). We assign the value 10 to the Data field.

Another instance is created with string as the type for T (MyStruct[string]). This time, the Data field holds the string "Hello".

Using Interface

While type sets offer a way to restrict generics to a specific set of types, Go also allows you to use interfaces as constraints. This provides a more flexible approach when defining the required behaviuor for your generic code.

type Stringer interface {
    string() string
}

func PrintString[T Stringer](value T) {
    fmt.Println(value.string())
}

func main() {
    name := "Go Developer"
    PrintString(name) // Works with strings

    // Wouldn't work without implementing Stringer
    // number := 10 
    // PrintString(number)
}

In this example, we define an interface Stringer that requires a single method string() string. This interface acts as the constraint for the generic type parameter T in the PrintString function. The function simply prints the output of the string() method on the provided value.

Here's the key point: PrintString can work with any type that implements the Stringer interface. This could be strings, custom data structures, or even other generic types that implement Stringer. This flexibility allows for wider applicability of the generic function while still enforcing type safety through the interface constraint.

Type Inference

Type inference feature allows the compiler to automatically deduce the types of arguments you pass to generic functions in many scenarios.

Type Inference in Action

Imagine a generic function Min that finds the minimum value of two arguments:

func Min[T any](x, y T) T {
    if x < y {
        return x
    }
    return y
}

Here, the type parameter T can be any type. When you call Min, type inference kicks in:

minString := Min("apple", "banana")  // T is inferred as string
minInt := Min(1, 2)                    // T is inferred as int

In these cases, the compiler can automatically determine the type T based on the values you provide. This eliminates the need to explicitly specify types, making your code cleaner and more concise.

When Inference Needs a Nudge

While type inference is convenient, there are situations where the compiler might need a little help. This is where the tilde (~) operator comes into play.

Consider a generic function that operates on numeric types:

func Abs[T constraints.Number](x T) T {
    return math.Abs(float64(x)) // Might cause data loss
}

Here, the constraint constraints.Number ensures T is a numeric type. However, the math.Abs function expects a float64. This could lead to data loss if T is an integer type.

To address this, we can use the tilde operator:

func Abs[T constraints.Number](x T) T ~float64 {
    return math.Abs(float64(x))
}

The tilde operator tells the compiler to infer the underlying type of x as well. In this case, it ensures x is converted to float64 before calling math.Abs, preventing potential data loss.

Pros & Cons

While generics offer undeniable advantages, it's important to acknowledge the potential drawbacks and how to navigate them effectively.

Advantages:

Code Reusability: Generics empower you to write code that works with various types, eliminating the need for repetitive implementations for each specific type. This reduces code duplication and improves maintainability.
Type Safety: Generics enforce type checks at compile time. This helps prevent runtime errors caused by incorrect type usage, leading to more robust and reliable applications.
Readability: By capturing generic behavior in a single definition, code becomes more expressive and easier to understand. This improves code clarity and reduces the mental overhead for developers.

Disadvantages:

Learning Curve: Generics introduce new concepts and syntax that require developers to adapt their understanding of Go. There's a learning curve involved in effectively utilizing generics in your projects.
Potential for Complexity: While generics promote code reuse, over-reliance on complex generic abstractions can sometimes make code less readable and harder to maintain. Strive for a balance between generality and clarity.
Backward Compatibility: Existing code bases might require adjustments to accommodate generics. Careful consideration during migration is crucial to ensure compatibility and avoid breaking changes.

Finding the Right Balance

Generics are a powerful tool in your Go development arsenal. By understanding their advantages and potential drawbacks, you can leverage them effectively to write cleaner, more maintainable, and type-safe code. Here are some tips:

Start Simple: Begin by introducing generics gradually in your projects, focusing on areas where they provide clear benefits in terms of code reuse and type safety.
Prioritize Readability: Don't sacrifice code clarity for excessive generality. Strive to write generic code that is easy to understand and maintain.
Test Thoroughly: As with any code change, ensure your generic implementations are well-tested to catch potential issues before they impact production.

By embracing generics thoughtfully, you can unlock their full potential to enhance the quality and efficiency of your Go projects.

Intersection of Two Arrays II || Leetcode Problem Solution

Shashank Shekhar — Sat, 21 Jan 2023 16:20:15 +0000

Problem Statement

Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.

Sample Input

nums1 = [1,2,2,1], nums2 = [2,2]

Sample Output

[2,2]

Link to question: https://leetcode.com/problems/intersection-of-two-arrays-ii/description/

Solution

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;
        int i, j, n1, n2;

        n1=nums1.size();
        n2=nums2.size();
        i=0;
        j=0;

        sort(nums1.begin(), nums1.end());
        sort(nums2.begin(), nums2.end());

        while(i<n1 && j<n2) {
            if(nums1[i]==nums2[j]) {
                result.push_back(nums1[i]);
                i++;
                j++;
            }
            else if(nums1[i]>nums2[j])
                j++;
            else
                i++;
        }

        return result;
    }
};

Explanation

It is given in the problem statement that we can give the result in any order. And this had made our task easy. Now we can simply sort both the arrays and traverse through them to get our desired result.

We can use two different variables (i and j in this case) to traverse both the arrays. Using the condition i<n1 && j<n2 in while loop, eliminates the need of an extra statement to find the array of the shorter length. Now, among i and j reaches the end of the array, will make the condition to evaluate to false and the loop will terminate.

Inside the loop, we can check if the element at ith position and jth position of the num1 and num2 respectively are equal or not. If they are equal, then we get the element for our resultant array. If they are not equal, then there can be two cases:

The ith element of num1 is lesser than the jth element of num2 : In this case, we will increment the value of i by 1 till and go for next iteration.
The ith element of num1 is greater than the jth element of num2 : In this case, we will increment the value of j by 1 till and go for next iteration.

In both the cases, we are trying to reach to such position where both the elements are equal so that we can get our next element for the resultant array.

After some iterations, the shorter array will be full traversed. And if any of the array is fully traversed then we can't get more intersecting elements.

Add Two Numbers II | Leetcode Problem Solution With Explanation

Shashank Shekhar — Fri, 15 Jul 2022 17:06:24 +0000

Problem Statement

You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Sample Input
l1 = [7,2,4,3], l2 = [5,6,4]

Sample Output
[7,8,0,7]

Link to question: https://leetcode.com/problems/add-two-numbers-ii/

Solution (Java)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int> n1, n2, sum;
        ListNode *res=new ListNode();
        ListNode *cur=res;
        ListNode *prev;
        int carry=0;
        while(l1!=nullptr) {
            n1.push(l1->val);
            l1=l1->next;
        }
        while(l2!=nullptr) {
            n2.push(l2->val);
            l2=l2->next;
        }
        while(!(n1.empty() && n2.empty())) {
            if(n1.empty()) {
                sum.push((n2.top()+carry)%10);
                carry=(n2.top()+carry)/10;
                n2.pop();
            } 
            else if(n2.empty()) {
                sum.push((n1.top()+carry)%10);
                carry=(n1.top()+carry)/10;
                n1.pop();
            } 
            else {
                sum.push((n2.top()+n1.top()+carry)%10);
                carry=(n1.top()+n2.top()+carry)/10;
                n1.pop();
                n2.pop();
            } 
        }
        if(carry!=0)
            sum.push(carry);
        while(!sum.empty()) {
            cur->val=sum.top();
            cur->next=new ListNode();
            prev=cur;
            cur=cur->next;
            sum.pop();
        }
        prev->next=nullptr;
        return res;
    }
};

Explanation

Firstly, push the numbers from both the linked lists into two separate stacks. This will store the linked list in reverse order and will also help in doing the addition operation. Now pop the elements from the stacks and add them and push the modulo 10 of the sum in the third stack and store the quotient 10 of sum in the carry (simple mathematical addition, just as we used to do in kindergarten). Lastly popped the elements from the third stack and inserted into the third linked list and that will the resultant linked list.

Rings and Rods | Leetcode Problem Solution Using Bit Manipulation

Shashank Shekhar — Fri, 03 Jun 2022 07:19:58 +0000

Problem Statement

There are n rings and each ring is either red, green, or blue. The rings are distributed across ten rods labeled from 0 to 9.

You are given a string rings of length 2n that describes the n rings that are placed onto the rods. Every two characters in rings forms a color-position pair that is used to describe each ring where:

The first character of the ith pair denotes the ith ring's color ('R', 'G', 'B').
The second character of the ith pair denotes the rod that the ith ring is placed on ('0' to '9').

For example, "R3G2B1" describes n == 3 rings: a red ring placed onto the rod labeled 3, a green ring placed onto the rod labeled 2, and a blue ring placed onto the rod labeled 1.

Return the number of rods that have all three colors of rings on them.

Sample Input
B0B6G0R6R0R6G9

Sample Output
1

Explanation

The rod labeled 0 holds 3 rings with all colors: red, green, and blue.
The rod labeled 6 holds 3 rings, but it only has red and blue.
The rod labeled 9 holds only a green ring. Thus, the number of rods with all three colors is 1.

Link to question: https://leetcode.com/problems/rings-and-rods/

Solution (C++)

class Solution {
    public int countPoints(String rings) {
        int count, n=rings.length();
        int rods[]=new int[10];
        Arrays.fill(rods, 0);
        for(int i=0; i<n; i+=2) {
            char color=rings.charAt(i);
            int rod=rings.charAt(i+1)-48;
            switch(color) {
                case 'R':
                    rods[rod]=rods[rod] | 1;
                    break;
                case 'G':
                    rods[rod]=rods[rod] | 2;
                    break;
                case 'B':
                    rods[rod]=rods[rod] | 4;
                    break;
            }
        }
        count=0;
        for(int item: rods)
            count+=item==7?1:0;
        return count;
    }
};

Strange Counter | Hackerrank Problem Solution With Explanation

Shashank Shekhar — Sun, 29 May 2022 12:04:35 +0000

Problem Statement

There is a strange counter. At the first second, it displays the number . Each second, the number displayed by decrements by 1 until it reaches 1. In next second, the timer resets to 2 x the initial number of the prior cycle and continues counting down. The diagram below shows the counter values for each time t in the first three cycles:

Find and print the value displayed by the counter at time t.

Input Format
A single integer, the value of t.

Sample Input
4

Sample Output
6

Link to question: https://www.hackerrank.com/challenges/strange-code/problem

Solution (Python3)



def strangeCounter(t):

    # Write your code here

    n = math.log(((t + 3) / 3), 2)

    if math.floor(n) == math.ceil(n):

        return 1

    n = int(math.ceil(n))

    term = 3 * (math.pow(2, n) - 1)

    return int(term - t + 1)

Explanation

From the given problem statement, we can clearly see that:

Time taken to complete 1st cycle: 3s
Time taken to complete 2nd cycle: 6s
Time taken to complete 3rd cycle: 12s

And so on.

If we observe a little bit then we will find that time taken by cycles is forming a series and that series is in G.P. (Geometric Progression) with common ratio as 2.

It is clear that the time at which is any cycle ends, is the cumulative sum of all the time taken to complete the cycle till that cycle. Viz.

Time at which 1st cycle ends: 3
Time at which cycle ends: Time taken to complete 1st cycle + Time taken to complete 2nd cycle = 3 + 6 = 9

And so on.

If this series is in G.P. then the cumulative sum, i.e. the end time for any cycle, can be calculated using the below formula:

S = a(rⁿ-1)/(r-1),

where S is the sum of the series, a is the first term of the series, r is the common ratio and n is the number of terms in the series.

Here, in the problem, we are given the sum of the series (i.e. t in this case), we know the first term and the common ratio (i.e. 3 and 2). So, we have to calculate n. Using the above formula, we can deduce:

n=log₂((S+3)/3)

If we get a whole number as n then given t is the end time of the cycle. But if we get a floating number, then t is the time between the end times of previous cycle and next cycle. In this case, using the ceil value of t and the formula of the Sum of G.P. we can calculate the end time for the current cycle, say terms. And the difference between the terms and the t is our answer.

The Captain's Room | Hackerrank Problem Solution With Explanation

Shashank Shekhar — Sat, 30 Apr 2022 18:43:50 +0000

Problem Statement

Mr. Anant Asankhya is the manager at the INFINITE hotel. The hotel has an infinite amount of rooms.

One fine day, a finite number of tourists come to stay at the hotel.
The tourists consist of:
→ A Captain.
→ An unknown group of families consisting of members per group where K ≠ 1.

The Captain was given a separate room, and the rest were given one room per group.

Mr. Anant has an unordered list of randomly arranged room entries. The list consists of the room numbers for all of the tourists. The room numbers will appear K times per group except for the Captain's room.

Mr. Anant needs you to help him find the Captain's room number.
The total number of tourists or the total number of groups of families is not known to you.
You only know the value of K and the room number list.

Input Format
The first line consists of an integer, K, the size of each group.
The second line contains the unordered elements of the room number list.

Output Format
Output the Captain's room number.

Sample Input
5
1 2 3 6 5 4 4 2 5 3 6 1 6 5 3 2 4 1 2 5 1 4 3 6 8 4 3 1 5 6 2

Sample Output
8

Link to question: https://www.hackerrank.com/challenges/py-the-captains-room/problem

Solution (Python3)

if __name__ == '__main__':
    k = int(input())
    rooms = list(map(int, input().split()))
    roomSet = set(rooms)
    roomSum = sum(rooms)
    roomSetSum = sum(roomSet) * k
    captiansRoom = (roomSetSum - roomSum) // (k - 1)
    print(captiansRoom)

Explanation

The logic behind this is simple mathematics. If all the unique elements were present in the array K times then their sum would have been sum of unique elements mutliplied K times. But there is one unique element that is present only one time. So the roomSetSum variable's value will be more than the actual sum of elements of the given array, let's say it x.

If we see it from a different angle then we will find that our desired element, let's say it z is present only one time but is missing k-1 times from the array. So we can conclude that x is nothing but z multiplied by k-1. Now all we've to do is to do reverse engineering and just find the x (that is the difference between the sum of all the elements of rooms array if it contained all the unique elements exactly k times and actual sum of all the elements of the rooms array, i.e. the array that contains all the elements k times but a single element only one time) and divide it with k-1 and voila! We got the answer.

Reverse Linked List | Leetcode Problem

Shashank Shekhar — Wed, 12 Jan 2022 17:06:54 +0000

Problem Statement

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

Example:

**Input:** head = [1,2,3,4,5] **Output:** [5,4,3,2,1]
Link to the question: https://leetcode.com/problems/reverse-linked-list/

Solution

class Solution {
public:
    ListNode* reverseList(ListNode *cur, ListNode *next) {
        ListNode *last;
        if(next->next!=nullptr)
            last=reverseList(next, next->next);
        else
            last=next;
        next->next=cur;
        return last;
    }

    ListNode* reverseList(ListNode* head) {
        ListNode *last;
        if(head==nullptr || head->next==nullptr)
            return head;
        if(head->next!=nullptr)
            last=reverseList(head, head->next);
        head->next=nullptr;
        return last;
    }
};

Problem while compiling and executing Java program with JAR file

Shashank Shekhar — Fri, 23 Jul 2021 14:54:10 +0000

One fine day, I was creating a mini project in Java. The concept of the project was to demonstrate the CRUD operation using Swing, i.e. using GUI. As it was to demonstrate CRUD, I used JDBC in the program as well. If you are familiar with JDBC then you must be knowing that it requires a JDBC driver’s JAR file to successfully compile and execute a JDBC program.

I followed all the steps, wrote a clean code and added the JAR file in the root directory of the project. I compiled the program using the following command:

javac -cp “.;relative/path/to/jar/file” filename.java

The compilation was successful. Then I tried to execute the program with the following command:

java -cp “.;relative/path/to/jar/file” classname

But instead of successfully executing, it displayed the following error:

Error: Could not find or load main class classname
Caused by: java.lang.ClassNotFoundException: classname

I googled a lot about the right procedure to compile and execute a JDBC program but either the result contained the same procedure or contained the steps to program on IDE like NetBeans.

After doing a lot of research I went to Stackoverflow, and from the answers there I concluded that I had done a slight mistake in the commands. I was specifying the relative path to the JAR file whereas I was supposed to provide a fully qualified path of the JAR file, i.e. the absolute path for the file. Also, it didn’t require to specify classpath while compiling as the JAR file was in the same directory.

So the new compiling and executing command goes like this:

javac filename.java
java -cp “.:fully/qualified/path/to/jar/file” classname

Another thing to notice here is that I changed the semicolon(;) with a colon(:) in the classpath to separate two different classpaths. Because Linux based OS uses the colon as a separator but Windows uses a semicolon as a separator as the colon is used for drive specification in the Windows system.