DEV Community: Foroogh Varmazyar

Leetcode-Remove Element(Top Interview 150) Solution in Kotlin

Foroogh Varmazyar — Fri, 20 Sep 2024 20:01:40 +0000

Given an integer array nums and an integer val, remove all occurrences of val in nums i*n-place*. The order of the elements may be changed. Then return the number of elements in nums which are not equal to val.

Consider the number of elements in nums which are not equal to val be k, to get accepted, you need to do the following things:

Change the array nums such that the first K elements of nums contain the elements which are not equal to val. The remaining elements of nums are not important as well as the size of nums.
Return k.

Custom Judge:

The judge will test your solution with the following code:

int[] nums = [...]; // Input array
int val = ...; // Value to remove
int[] expectedNums = [...]; // The expected answer with correct length.
                            // It is sorted with no values equaling val.

int k = removeElement(nums, val); // Calls your implementation

assert k == expectedNums.length;
sort(nums, 0, k); // Sort the first k elements of nums
for (int i = 0; i < actualLength; i++) {
    assert nums[i] == expectedNums[i];
}

If all assertions pass, then your solution will be accepted.

Example 1:


Input: nums = [3,2,2,3], val = 3
Output: 2, nums = [2,2,_,_]
Explanation: Your function should return k = 2, with the first two elements of nums being 2.
It does not matter what you leave beyond the returned k (hence they are underscores).

Example 2:

Input: nums = [0,1,2,2,3,0,4,2], val = 2
Output: 5, nums = [0,1,4,0,3,_,_,_]
Explanation: Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4.
Note that the five elements can be returned in any order.
It does not matter what you leave beyond the returned k (hence they are underscores).

Constraints:

0 <= nums.length <= 100 0 <= nums[i] <= 50 0 <= val <= 100

The solution :

class Solution {
    fun removeElement(nums: IntArray, `val`: Int): Int {
        var index = 0

        for (i in 0 until nums.size) {
            if (nums[i] != `val`) {
                nums[index++] = nums[i]
            }
        }
        return index
    }
}

Hackerrank-Kangaroo Solution in Kotlin

Foroogh Varmazyar — Fri, 07 Apr 2023 16:57:44 +0000

You are choreographing a circus show with various animals. For one act, you are given two kangaroos on a number line ready to jump in the positive direction (i.e, toward positive infinity).

The first kangaroo starts at location x1 and moves at a rate of v1 meters per jump.
The second kangaroo starts at location x2 and moves at a rate of v2 meters per jump.

You have to figure out a way to get both kangaroos at the same location at the same time as part of the show. If it is possible, return YES, otherwise return NO.

Example
x1=2
v1=1
x2=1
v2=2

After one jump, they are both at x=3,(x1+v1=2+1,x2+v2=1+2)so the answer is YES.

Function Description

Complete the function kangaroo in the editor below.

kangaroo has the following parameter(s):

int x1, int v1: starting position and jump distance for kangaroo 1
int x2, int v2: starting position and jump distance for kangaroo 2

Returns

string: either YES or NO

Input Format

A single line of four space-separated integers denoting the respective values of x1,v1,x2 and v2

Constraints

0<x1<x2<10000
1<v1<10000
1<v2<10000

Sample Input 0

0 3 4 2

Sample Output 0

YES

Explanation 0

The two kangaroos jump through the following sequence of locations:

From the image, it is clear that the kangaroos meet at the same location (number 12 on the number line) after same number of jumps (4 jumps), and we print YES.

Sample Input 1

0 2 5 3

Sample Output 1

NO

The second kangaroo has a starting location that is ahead (further to the right) of the first kangaroo's starting location (i.e., x1>x2) Because the second kangaroo moves at a faster rate (meaning v2>v1)and is already ahead of the first kangaroo, the first kangaroo will never be able to catch up. Thus, we print NO.

Solution :

fun kangaroo(x1: Int, v1: Int, x2: Int, v2: Int): String {
    var start_k1 = x1+v1
    var startt_k2 = x2+v2
    var answer =0

     if(v1!= v2){
         var v = Math.abs(v2-v1)
         answer = (startt_k2-start_k1)%v
     } 

     if (v1<v2 || answer!=0 ||v1==v2){ 
         return "NO"
     }
       else{
          return "YES"
       }
   }

fun main(args: Array<String>) {
    val first_multiple_input = readLine()!!.trimEnd().split(" ")

    val x1 = first_multiple_input[0].toInt()

    val v1 = first_multiple_input[1].toInt()

    val x2 = first_multiple_input[2].toInt()

    val v2 = first_multiple_input[3].toInt()

    val result = kangaroo(x1, v1, x2, v2)

    println(result)
}

Hackerrank-Apple and Orange Solution in Kotlin

Foroogh Varmazyar — Wed, 20 Jul 2022 21:11:01 +0000

Sam's house has an apple tree and an orange tree that yield an abundance of fruit. Using the information given below, determine the number of apples and oranges that land on Sam's house.

In the diagram below:

The red region denotes the house, where s is the start point, and t is the endpoint. The apple tree is to the left of the house, and the orange tree is to its right.
Assume the trees are located on a single point, where the apple tree is at point a, and the orange tree is at point b.
When a fruit falls from its tree, it lands d units of distance from its tree of origin along the x -axis. *A negative value of d means the fruit fell d units to the tree's left, and a positive value of d means it falls d units to the tree's right. *

Given the value of d for m apples and n oranges, determine how many apples and oranges will fall on Sam's house (i.e., in the inclusive range [s,t])?
For example, Sam's house is between s=7 and t=10. The apple tree is located at a=4
and the orange at b=12 There are m=3 _apples and _n=3 oranges. Apples are thrown apples=[2,3,-4] units distance from a, and oranges=[3,-2,-4] units distance. Adding each apple distance to the position of the tree, they land at [4+2,4+3,4+-4]=[6,7,0]. Oranges land at [12+3,12+-2,12+-4] =[15,10,8] One apple and two oranges land in the inclusive range 7-10 so we print

1
2

Function Description

Complete the countApplesAndOranges function in the editor below. It should print the number of apples and oranges that land on Sam's house, each on a separate line.

countApplesAndOranges has the following parameter(s):

s: integer, starting point of Sam's house location.
t: integer, ending location of Sam's house location.
a: integer, location of the Apple tree.
b: integer, location of the Orange tree.
apples: integer array, distances at which each apple falls from the tree.
oranges: integer array, distances at which each orange falls from the tree.

Input Format

The first line contains two space-separated integers denoting the respective values of s and t.
The second line contains two space-separated integers denoting the respective values of a and b.
The third line contains two space-separated integers denoting the respective values of m and n.
The fourth line contains space-separated integers denoting the respective distances that each apple falls from point a.
The fifth line contains n space-separated integers denoting the respective distances that each orange falls from point b.

Constraints

1 < s, t, a, b, m, n < 10
-10 < d < 10
a < s < t < b

Output Format

Print two integers on two different lines:

The first integer: the number of apples that fall on Sam's house.
The second integer: the number of oranges that fall on Sam's house.

Sample Input 0

Sample Output 0

1
1

ANSWER:

 fun countApplesAndOranges(
        s: Int,
        t: Int,
        a: Int,
        b: Int,
        apples: Array<Int>,
        oranges: Array<Int>
    ): Unit {
         var countApple = 0
         var countOrang = 0

         for (i in apples) {
             var appleDistance = a + i
             if (s <= appleDistance && appleDistance <= t)
                 countApple = countApple + 1
         }
         for (i in oranges) {
             var orangeDistance = b + i
             if (s <= orangeDistance && orangeDistance <= t)
                 countOrang = countOrang + 1
         }
         println(countApple)
         println(countOrang)
 }

Hackerrank-Time Conversion Solution in Kotlin

Foroogh Varmazyar — Mon, 04 Jul 2022 09:09:01 +0000

problem

Given a time in 12-hour AM/PM format, convert it to military (24-hour) time.
Note: - 12:00:00AM on a 12-hour clock is 00:00:00 on a 24-hour clock.
-12:00:00PM on a 12-hour clock is 12:00:00 on a 24-hour clock.

Example

s = '12:01:00PM'
Return '12:01:00'.
s= '12:01:00AM'
Return '00:01:00'.

Function Description

Complete the timeConversion function in the editor below. It should return a new string representing the input time in 24 hour format.

timeConversion has the following parameter(s):

string s: a time in 12 hour format

Returns

string: the time in 24 hour format

Input Format

A single string s containing a time in 12 -hour clock format (i.e.: hh:mm:ssAM or hh:mm:ssPM)

Constraints

All input times are valid

Sample Input

07:05:45PM

Sample Output

19:05:45

Answer :


  fun timeConversion(s: String): String {

        val hour = s.substring(0, 2).toInt()
        val minsec = s.substring(2, 8)
        val timeZone = s.substring(8, 10)
        val time = s.substring(0, 8)

        var clock = return when (timeZone) {

            "AM" -> {
                if (hour == 12)
                    "00$minsec"
                else time
            }

            "PM" -> {
                if (hour == 12)
                    time
                else {
                    val sum = hour + 12
                    "$sum$minsec"
                }
            }

            else -> ""
        }
    }

Hackerrank-Grading Students in kotlin

Foroogh Varmazyar — Sun, 03 Jul 2022 19:59:54 +0000

problem
HackerLand University has the following grading policy:

Every student receives a grade in the inclusive range from 0 to 100 .
Any grade less than 40 is a failing grade.

Sam is a professor at the university and likes to round each student’s grade according to these rules:

If the diﬀerence between the grade and the next multiple of 5 is less than 3, round grade up to the next multiple of 5.
If the value of grade is less than 38, no rounding occurs as the result will still be a failing grade.

Examples

grade = 84 round to 85 (85–84 is less than 3)
grade = 29 do not round (result is less than 40)
grade = 57 do not round (60–57 is 3 or higher)

Given the initial value of grade for each of Sam’s n students, write code to automate the rounding process.

Function Description

Complete the function gradingStudents in the editor below.
gradingStudents has the following parameter(s):

int grades[n]: the grades before rounding

Returns

int[n]: the grades after rounding as appropriate

Input Format
The ﬁrst line contains a single integer, n, the number of students. Each line of i the n subsequent lines contains a single integer, grade[i].

Sample Input

Sample Output

Answer :


  fun gradingStudents(grades: Array<Int>): Array<Int> {

        var listOfGrade: MutableList<Int> = ArrayList()

        for (grade in grades) {

            if (grade >= 38 && (grade % 5) > 2) {
                var number = grade + (5 - (grade % 5))
                listOfNumber.add(number)
            } else {
                listOfNumber.add(grade)
            }
        }

        return listOfGrade.toTypedArray()
  }

Android Design Patterns: The Singleton Pattern

Foroogh Varmazyar — Tue, 27 Jul 2021 13:59:40 +0000

Introduction Singleton Design Pattern

Singleton design pattern is categorized under creational design patterns.
The Singleton Pattern guarantees a class has one instance only and a global point of access to it is provided by that class. Anytime multiple classes or clients request for that class, they get the same instance of the class.

The Singleton pattern solves two problems at the same time:

1) Ensure that a class has just a single instance.

Why would anyone want to control how many instances a class has? The most common reason for this is to control access to some shared resource for example, a database or a file.
Here’s how it works: imagine that you created an object, but after a while decided to create a new one. Instead of receiving a fresh object, you’ll get the one you already created.
Note that this behavior is impossible to implement with a regular constructor since a constructor call must always return a new object by design.

2) Provide a global access point to that instance.

Remember those global variables that you used to store some essential objects? While they’re very handy, they’re also very unsafe since any code can potentially overwrite the contents of those variables and crash the app.
Just like a global variable, the Singleton pattern lets you access some object from anywhere in the program. However, it also protects that instance from being overwritten by other code.
There’s another side to this problem: you don’t want the code that solves problem #1 to be scattered all over your program. It’s much better to have it within one class, especially if the rest of your code already depends on it.
Nowadays, the Singleton pattern has become so popular that people may call something a singleton even if it solves just one of the listed problems.

Use case of Singleton design pattern
But before moving into the example, you need to know that there are two common steps in every Singleton implementation.

First step is to make the default constructor private, so it can prevent other objects from using the new operator with the Singleton class.
Then implement a static creation method that acts as a constructor.This method calls the private constructor to create an object and saves it in a static field. So, whenever this method gets called, it will return the object.

Note: The most common use case for applying Singleton design pattern is when dealing with databases.

Example 01: Classic Implementation

It's quite easy to implement this pattern. The following code snippet shows how a Singleton is created.

 public class Singleton  {

    private static Singleton INSTANCE = null;

 // other instance variables can be here

    private Singleton() {};

    public static Singleton getInstance() {
       if (INSTANCE == null) {
           INSTANCE = new Singleton();
       }
       return(INSTANCE);
    }
 }

In the code above, we have a static variable INSTANCE to hold an instance of the class. We also made the constructor private because we want to enforce noninstantiability—the class can only instantiate itself. The method getInstance() guarantees that the class is instantiated, if it has not been, and that it's returned to the caller.

Example 02:Creating a Single Instance of Retrofit

In an Android app, you'll need a single global instance of a Retrofit object so that other parts of an app can use it to execute a network request without the need to create an instance every single time we need it.

 import retrofit2.Retrofit;
 import retrofit2.converter.gson.GsonConverterFactory;

 public class RetrofitClient {

 private static Retrofit retrofit = null;

 private RetrofitClient() {}

 public static Retrofit getClient(String baseUrl) {
   if (retrofit==null) {
      retrofit = new Retrofit.Builder()
      .baseUrl(baseUrl) 
      .addConverterFactory(GsonConverterFactory.create())
      .build();
   }
   return retrofit;
 }
}

So anytime client A calls RetrofitClient.getClient(), it creates the instance if it has not been created already, and then when client B calls this method, it checks if the Retrofit instance already exists. If so, it returns the instance to client B instead of creating a new one.

Note : The main problem with above method is that it is not thread safe.
To solve the problem, it is better to implement the following method

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {
private static volatile Retrofit retrofit = null;
private RetrofitClient() {}   

public static Retrofit getClient(String baseUrl) {
  if (retrofit==null) {
    synchronized (RetrofitClient.class) {
      retrofit = new Retrofit.Builder()
       .baseUrl(baseUrl)
      .addConverterFactory(GsonConverterFactory.create())
       .build();
    }
  }        
  return retrofit;
 }
}

We have declared the retrofit volatile which ensures that multiple threads offer the retrofit variable correctly when it is being initialized to RetrofitClient instance.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Common Design Patterns in Android

Foroogh Varmazyar — Sat, 24 Jul 2021 10:14:08 +0000

A design pattern provides a general reusable solution for the common problems that occur in software design. The pattern typically shows relationships and interactions between classes or objects. The idea is to speed up the development process by providing well tested, proven development/design paradigms. Design patterns are programming language independent strategies for solving a common problem. That means a design pattern represents an idea, not a particular implementation. By using design patterns, you can make your code more flexible, reusable, and maintainable.

Types of Design Patterns

There are mainly three types of design patterns:

Creational patterns: How you create objects.
Structural patterns: How you compose objects.
Behavioral patterns: How you coordinate object interactions.

It’s not mandatory to always implement design patterns in your project. Design patterns are not meant for project development. Design patterns are meant for common problem-solving. Whenever there is a need, you have to implement a suitable pattern to avoid such problems in the future. To find out which pattern to use, you just have to try to understand the design patterns and their purposes. Only by doing that, you will be able to pick the right one.

Creational Patterns :

These design patterns are all about class instantiation or object creation. These patterns can be further categorized into Class-creational patterns and object-creational patterns.

Common Creational design patterns in Android are:
* Builder : Separates object construction from its representation
* Singleton : A class of which only a single instance can exist
* Factory Method : Creates an instance of several derived classes

Structural Patterns :

These design patterns are about organizing different classes and objects to form larger structures and provide new functionality

Common Structural design patterns in Android are:

Adapter : Match interfaces of different classes
Facade : A single class that represents an entire subsystem
Decorator : Add responsibilities to objects dynamically
Composite : A tree structure of simple and composite objects

Behavioral Patterns :

Behavioral patterns are about identifying common communication patterns between objects and realizing these patterns.

Common Behavioral patterns in Android are :

Command : Encapsulate a command request as an object
Observer : A way of notifying change to a number of classes
Strategy : Encapsulates an algorithm inside a class
State : Alter an object's behavior when its state changes