# Transform one string to another using minimum number of operation

Here given code implementation process.

``````/*
C program for
Transform one string to another using minimum number of operation
*/
#include <stdio.h>
#include <string.h>

void countMinOperation(char *str1, char *str2)
{
int a = strlen(str1);
int b = strlen(str2);
int result = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
int frequency;
// Set initial frequency in possible characters
for (int i = 0; i < 256; ++i)
{
frequency[i] = 0;
}
// Count character frequency of  str1
for (int i = 0; i < a; ++i)
{
frequency[str1[i]]++;
}
// Reduce character frequency of str2
for (int i = 0; i < b; ++i)
{
frequency[str2[i]]--;
}
// Check the different characters
for (int i = 0; i < 256 && result != -1; ++i)
{
if (frequency[i] != 0)
{
result = -1;
}
}
int i = a - 1;
int j = i;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (i >= 0 && result != -1)
{
while (i >= 0 && str1[i] != str2[j])
{
// Need to changes
result++;
i--;
}
if (i >= 0)
{
j--;
i--;
}
}
}
printf("\n %s  %s", str1, str2);
if (result == -1)
{
printf("\n No solution \n");
}
else
{
printf("\n Number of operations required is : %d", result);
}
}
int main(int argc, char const *argv[])
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)

acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race

Result = 2

*/
countMinOperation("care", "race");
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)

tabsen <- Get e and insert at beginning

etabsn  (➁ operation)

etabsn <- Get n and insert at beginning

netabs  (➂ operation)

netabs <- Get a and insert at beginning

anetbs  (➃ operation)

anetbs <- Get b and insert at beginning

banets  (➄ operation)

--------------------
absent is transform into a banets

Result = 5

*/
countMinOperation("absent", "banets");
// Similar to above approach
countMinOperation("LISTEN", "SILENT");
countMinOperation("abc", "abc");
countMinOperation("abc", "axc");
return 0;
}``````

#### Output

`````` care  race
Number of operations required is : 2
absent  banets
Number of operations required is : 5
LISTEN  SILENT
Number of operations required is : 5
abc  abc
Number of operations required is : 0
abc  axc
No solution``````
``````// Include header file
#include <iostream>
#include <string>

using namespace std;
// C++ program for
//  Transform one string to another using minimum number of operation
class Transformation
{
public: void countMinOperation(string str1, string str2)
{
int a = str1.length();
int b = str2.length();
int result = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
int frequency;
// Set initial frequency in possible characters
for (int i = 0; i < 256; ++i)
{
frequency[i] = 0;
}
// Count character frequency of  str1
for (int i = 0; i < a; ++i)
{
frequency[str1[i]]++;
}
// Reduce character frequency of str2
for (int i = 0; i < b; ++i)
{
frequency[str2[i]]--;
}
// Check the different characters
for (int i = 0; i < 256 && result != -1; ++i)
{
if (frequency[i] != 0)
{
result = -1;
}
}
int i = a - 1;
int j = i;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (i >= 0 && result != -1)
{
while (i >= 0 && str1[i] != str2[j])
{
// Need to changes
result++;
i--;
}
if (i >= 0)
{
j--;
i--;
}
}
}
cout << "\n " << str1 << " " << str2;
if (result == -1)
{
cout << "\n No solution \n";
}
else
{
cout << "\n Number of operations required is : " << result;
}
}
};
int main()
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)

acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race

Result = 2

*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)

tabsen <- Get e and insert at beginning

etabsn  (➁ operation)

etabsn <- Get n and insert at beginning

netabs  (➂ operation)

netabs <- Get a and insert at beginning

anetbs  (➃ operation)

anetbs <- Get b and insert at beginning

banets  (➄ operation)

--------------------
absent is transform into a banets

Result = 5

*/
// Similar to above approach
return 0;
}``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````// Java program for
//  Transform one string to another using minimum number of operation
public class Transformation
{
public void countMinOperation(String str1, String str2)
{
int a = str1.length();
int b = str2.length();
int result = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
int[] frequency = new int;
// Set initial frequency in possible characters
for (int i = 0; i < 256; ++i)
{
frequency[i] = 0;
}
// Count character frequency of  str1
for (int i = 0; i < a; ++i)
{
frequency[str1.charAt(i)]++;
}
// Reduce character frequency of str2
for (int i = 0; i < b; ++i)
{
frequency[str2.charAt(i)]--;
}
// Check the different characters
for (int i = 0; i < 256 && result != -1; ++i)
{
if (frequency[i] != 0)
{
result = -1;
}
}
int k = a - 1;
int j = k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (k >= 0 && result != -1)
{
while (k >= 0 && str1.charAt(k) != str2.charAt(j))
{
// Need to changes
result++;
k--;
}
if (k >= 0)
{
j--;
k--;
}
}
}
System.out.print("\n " + str1 + " " + str2);
if (result == -1)
{
System.out.print("\n No solution \n");
}
else
{
System.out.print("\n Number of operations required is : " + result);
}
}
public static void main(String[] args)
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)

acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race

Result = 2

*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)

tabsen <- Get e and insert at beginning

etabsn  (➁ operation)

etabsn <- Get n and insert at beginning

netabs  (➂ operation)

netabs <- Get a and insert at beginning

anetbs  (➃ operation)

anetbs <- Get b and insert at beginning

banets  (➄ operation)

--------------------
absent is transform into a banets

Result = 5

*/
// Similar to above approach
}
}``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````// Include namespace system
using System;
// Csharp program for
//  Transform one string to another using minimum number of operation
public class Transformation
{
public void countMinOperation(String str1, String str2)
{
int a = str1.Length;
int b = str2.Length;
int result = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
int[] frequency = new int;
// Set initial frequency in possible characters
for (int i = 0; i < 256; ++i)
{
frequency[i] = 0;
}
// Count character frequency of  str1
for (int i = 0; i < a; ++i)
{
frequency[str1[i]]++;
}
// Reduce character frequency of str2
for (int i = 0; i < b; ++i)
{
frequency[str2[i]]--;
}
// Check the different characters
for (int i = 0; i < 256 && result != -1; ++i)
{
if (frequency[i] != 0)
{
result = -1;
}
}
int k = a - 1;
int j = k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (k >= 0 && result != -1)
{
while (k >= 0 && str1[k] != str2[j])
{
// Need to changes
result++;
k--;
}
if (k >= 0)
{
j--;
k--;
}
}
}
Console.Write("\n " + str1 + " " + str2);
if (result == -1)
{
Console.Write("\n No solution \n");
}
else
{
Console.Write("\n Number of operations required is : " + result);
}
}
public static void Main(String[] args)
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
// Similar to above approach
}
}``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````package main

import "fmt"
// Go program for
// Transform one string to another using minimum number of operation

func countMinOperation(str1, str2 string) {
var a int = len(str1)
var b int = len(str2)
var result int = 0
if a != b {
// Not possible to transform two different length string
result = -1
} else {
// Set initial frequency in possible characters
var frequency = make([] int, 256)
// Count character frequency of  str1
for i := 0 ; i < a ; i++ {
frequency[str1[i]]++
}
// Reduce character frequency of str2
for i := 0 ; i < b ; i++ {
frequency[str2[i]]--
}
// Check the different characters
for i := 0 ; i < 256 && result != -1 ; i++ {
if frequency[i] != 0 {
result = -1
}
}
var k int = a - 1
var j int = k
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
for (k >= 0 && result != -1) {
for (k >= 0 && str1[k] != str2[j]) {
// Need to changes
result++
k--
}
if k >= 0 {
j--
k--
}
}
}
fmt.Print("\n ", str1, " ", str2)
if result == -1 {
fmt.Print("\n No solution \n")
} else {
fmt.Print("\n Number of operations required is : ", result)
}
}
func main() {

// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
countMinOperation("care", "race")
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
countMinOperation("absent", "banets")
// Similar to above approach
countMinOperation("LISTEN", "SILENT")
countMinOperation("abc", "abc")
countMinOperation("abc", "axc")
}``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````<?php
// Php program for
// Transform one string to another using minimum number of operation
class Transformation
{
public	function countMinOperation(\$str1, \$str2)
{
\$a = strlen(\$str1);
\$b = strlen(\$str2);
\$result = 0;
if (\$a != \$b)
{
// Not possible to transform two different length string
\$result = -1;
}
else
{
\$frequency = array_fill(0, 256, 0);
// Set initial frequency in possible characters
for (\$i = 0; \$i < 256; ++\$i)
{
\$frequency[\$i] = 0;
}
// Count character frequency of  str1
for (\$i = 0; \$i < \$a; ++\$i)
{
\$frequency[ord(\$str1[\$i])]++;
}
// Reduce character frequency of str2
for (\$i = 0; \$i < \$b; ++\$i)
{
\$frequency[ord(\$str2[\$i])]--;
}
// Check the different characters
for (\$i = 0; \$i < 256 && \$result != -1; ++\$i)
{
if (\$frequency[\$i] != 0)
{
\$result = -1;
}
}
\$k = \$a - 1;
\$j = \$k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (\$k >= 0 && \$result != -1)
{
while (\$k >= 0 && \$str1[\$k] != \$str2[\$j])
{
// Need to changes
\$result++;
\$k--;
}
if (\$k >= 0)
{
\$j--;
\$k--;
}
}
}
echo("\n ".\$str1." ".\$str2);
if (\$result == -1)
{
echo("\n No solution \n");
}
else
{
echo("\n Number of operations required is : ".\$result);
}
}
}

function main()
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
// Similar to above approach
}
main();``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````// Node JS program for
//  Transform one string to another using minimum number of operation
class Transformation
{
countMinOperation(str1, str2)
{
var a = str1.length;
var b = str2.length;
var result = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
// Set initial frequency in possible characters
var frequency = Array(256).fill(0);
// Count character frequency of  str1
for (var i = 0; i < a; ++i)
{
frequency[str1.charCodeAt(i)]++;
}
// Reduce character frequency of str2
for (var i = 0; i < b; ++i)
{
frequency[str2.charCodeAt(i)]--;
}
// Check the different characters
for (var i = 0; i < 256 && result != -1; ++i)
{
if (frequency[i] != 0)
{
result = -1;
}
}
var k = a - 1;
var j = k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (k >= 0 && result != -1)
{
while (k >= 0 && str1.charAt(k) != str2.charAt(j))
{
// Need to changes
result++;
k--;
}
if (k >= 0)
{
j--;
k--;
}
}
}
process.stdout.write("\n " + str1 + " " + str2);
if (result == -1)
{
process.stdout.write("\n No solution \n");
}
else
{
process.stdout.write("\n Number of operations required is : " + result);
}
}
}

function main()
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
// Similar to above approach
}
main();``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````#  Python 3 program for
#   Transform one string to another using minimum number of operation
class Transformation :
def countMinOperation(self, str1, str2) :
a = len(str1)
b = len(str2)
result = 0
if (a != b) :
#  Not possible to transform two different length string
result = -1
else :
#  Set initial frequency in possible characters
frequency =  * (256)
i = 0
#  Count character frequency of  str1
while (i < a) :
frequency[ord(str1[i])] += 1
i += 1

i = 0
#  Reduce character frequency of str2
while (i < b) :
frequency[ord(str2[i])] -= 1
i += 1

i = 0
#  Check the different characters
while (i < 256 and result != -1) :
if (frequency[i] != 0) :
result = -1

i += 1

k = a - 1
j = k
#  When result is not -1 and value of [i] is
#  greater than or equal to zero.
#  Count resultant operation
while (k >= 0 and result != -1) :
while (k >= 0 and str1[k] != str2[j]) :
#  Need to changes
result += 1
k -= 1

if (k >= 0) :
j -= 1
k -= 1

print("\n ", str1 ," ", str2, end = "")
if (result == -1) :
print("\n No solution ")
else :
print("\n Number of operations required is : ", result, end = "")

def main() :
#  Test
#    care  race
#    -----------
#    care <- Get a and insert at beginning
#    acre  (➀ operation)
#    acre <- Get r and insert at beginning
#    race  (➁ operation)
#    --------------------
#    care is transform into race
#    Result = 2
#    absent  banets
#    --------------
#    absent <- Get t and insert at beginning
#    tabsen  (➀ operation)
#    tabsen <- Get e and insert at beginning
#    etabsn  (➁ operation)
#    etabsn <- Get n and insert at beginning
#    netabs  (➂ operation)
#    netabs <- Get a and insert at beginning
#    anetbs  (➃ operation)
#    anetbs <- Get b and insert at beginning
#    banets  (➄ operation)
#    --------------------
#    absent is transform into a banets
#    Result = 5
#  Similar to above approach

if __name__ == "__main__": main()``````

#### Output

``````  care   race
Number of operations required is :  2
absent   banets
Number of operations required is :  5
LISTEN   SILENT
Number of operations required is :  5
abc   abc
Number of operations required is :  0
abc   axc
No solution``````
``````#  Ruby program for
#   Transform one string to another using minimum number of operation
class Transformation
def countMinOperation(str1, str2)
a = str1.length
b = str2.length
result = 0
if (a != b)
#  Not possible to transform two different length string
result = -1
else

#  Set initial frequency in possible characters
frequency = Array.new(256) {0}
i = 0
#  Count character frequency of  str1
while (i < a)
frequency[str1[i].ord] += 1
i += 1
end

i = 0
#  Reduce character frequency of str2
while (i < b)
frequency[str2[i].ord] -= 1
i += 1
end

i = 0
#  Check the different characters
while (i < 256 && result != -1)
if (frequency[i] != 0)
result = -1
end

i += 1
end

k = a - 1
j = k
#  When result is not -1 and value of [i] is
#  greater than or equal to zero.
#  Count resultant operation
while (k >= 0 && result != -1)
while (k >= 0 && str1[k] != str2[j])
#  Need to changes
result += 1
k -= 1
end

if (k >= 0)
j -= 1
k -= 1
end

end

end

print("\n ", str1 ," ", str2)
if (result == -1)
print("\n No solution \n")
else

print("\n Number of operations required is : ", result)
end

end

end

def main()
#  Test
#    care  race
#    -----------
#    care <- Get a and insert at beginning
#    acre  (➀ operation)
#    acre <- Get r and insert at beginning
#    race  (➁ operation)
#    --------------------
#    care is transform into race
#    Result = 2
#    absent  banets
#    --------------
#    absent <- Get t and insert at beginning
#    tabsen  (➀ operation)
#    tabsen <- Get e and insert at beginning
#    etabsn  (➁ operation)
#    etabsn <- Get n and insert at beginning
#    netabs  (➂ operation)
#    netabs <- Get a and insert at beginning
#    anetbs  (➃ operation)
#    anetbs <- Get b and insert at beginning
#    banets  (➄ operation)
#    --------------------
#    absent is transform into a banets
#    Result = 5
#  Similar to above approach
end

main()``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution
``````
``````// Scala program for
//  Transform one string to another using minimum number of operation
class Transformation()
{
def countMinOperation(str1: String, str2: String): Unit = {
var a: Int = str1.length();
var b: Int = str2.length();
var result: Int = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
// Set initial frequency in possible characters
var frequency: Array[Int] = Array.fill[Int](256)(0);
var i: Int = 0;
// Count character frequency of  str1
while (i < a)
{
frequency(str1.charAt(i)) += 1;
i += 1;
}
i = 0;
// Reduce character frequency of str2
while (i < b)
{
frequency(str2.charAt(i)) -= 1;
i += 1;
}
i = 0;
// Check the different characters
while (i < 256 && result != -1)
{
if (frequency(i) != 0)
{
result = -1;
}
i += 1;
}
var k: Int = a - 1;
var j: Int = k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (k >= 0 && result != -1)
{
while (k >= 0 && str1.charAt(k) != str2.charAt(j))
{
// Need to changes
result += 1;
k -= 1;
}
if (k >= 0)
{
j -= 1;
k -= 1;
}
}
}
print("\n " + str1 + " " + str2);
if (result == -1)
{
print("\n No solution \n");
}
else
{
print("\n Number of operations required is : " + result);
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Transformation = new Transformation();
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
// Similar to above approach
}
}``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````
``````import Foundation;
// Swift 4 program for
//  Transform one string to another using minimum number of operation
class Transformation
{
func countMinOperation(_ text1: String, _ text2: String)
{
let str1 = Array(text1);
let str2 = Array(text2);
let a: Int = str1.count;
let b: Int = str2.count;
var result: Int = 0;
if (a  != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
// Set initial frequency in possible characters
var frequency: [Int] = Array(repeating: 0, count: 256);
var i: Int = 0;
// Count character frequency of  str1
while (i < a)
{
frequency[Int(UnicodeScalar(String(str1[i]))!.value)] += 1;
i += 1;
}
i = 0;
// Reduce character frequency of str2
while (i < b)
{
frequency[Int(UnicodeScalar(String(str2[i]))!.value)] -= 1;
i += 1;
}
i = 0;
// Check the different characters
while (i < 256 && result  != -1)
{
if (frequency[i]  != 0)
{
result = -1;
}
i += 1;
}
var k: Int = a - 1;
var j: Int = k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (k >= 0 && result  != -1)
{
while (k >= 0 && str1[k]  != str2[j])
{
// Need to changes
result += 1;
k -= 1;
}
if (k >= 0)
{
j -= 1;
k -= 1;
}
}
}
print("\n ", text1 ," ", text2, terminator: "");
if (result == -1)
{
print("\n No solution ");
}
else
{
print("\n Number of operations required is : ",
result, terminator: "");
}
}
}
func main()
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
// Similar to above approach
}
main();``````

#### Output

``````  care   race
Number of operations required is :  2
absent   banets
Number of operations required is :  5
LISTEN   SILENT
Number of operations required is :  5
abc   abc
Number of operations required is :  0
abc   axc
No solution``````
``````// Kotlin program for
//  Transform one string to another using minimum number of operation
class Transformation
{
fun countMinOperation(str1: String, str2: String): Unit
{
val a: Int = str1.length;
val b: Int = str2.length;
var result: Int = 0;
if (a != b)
{
// Not possible to transform two different length string
result = -1;
}
else
{
// Set initial frequency in possible characters
val frequency: Array < Int > = Array(256)
{
0
};
var i: Int = 0;
// Count character frequency of  str1
while (i < a)
{
frequency[str1.get(i).toInt()] += 1;
i += 1;
}
i = 0;
// Reduce character frequency of str2
while (i < b)
{
frequency[str2.get(i).toInt()] -= 1;
i += 1;
}
i = 0;
// Check the different characters
while (i < 256 && result != -1)
{
if (frequency[i] != 0)
{
result = -1;
}
i += 1;
}
var k: Int = a - 1;
var j: Int = k;
// When result is not -1 and value of [i] is
// greater than or equal to zero.
// Count resultant operation
while (k >= 0 && result != -1)
{
while (k >= 0 && str1.get(k) != str2.get(j))
{
// Need to changes
result += 1;
k -= 1;
}
if (k >= 0)
{
j -= 1;
k -= 1;
}
}
}
print("\n " + str1 + " " + str2);
if (result == -1)
{
print("\n No solution \n");
}
else
{
print("\n Number of operations required is : " + result);
}
}
}
fun main(args: Array < String > ): Unit
{
// Test
/*
care  race
-----------
care <- Get a and insert at beginning

acre  (➀ operation)
acre <- Get r and insert at beginning

race  (➁ operation)
--------------------
care is transform into race
Result = 2
*/
/*
absent  banets
--------------
absent <- Get t and insert at beginning

tabsen  (➀ operation)
tabsen <- Get e and insert at beginning

etabsn  (➁ operation)
etabsn <- Get n and insert at beginning

netabs  (➂ operation)
netabs <- Get a and insert at beginning

anetbs  (➃ operation)
anetbs <- Get b and insert at beginning

banets  (➄ operation)
--------------------
absent is transform into a banets
Result = 5
*/
// Similar to above approach
}``````

#### Output

`````` care race
Number of operations required is : 2
absent banets
Number of operations required is : 5
LISTEN SILENT
Number of operations required is : 5
abc abc
Number of operations required is : 0
abc axc
No solution``````

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

### New Comment 