Program For Sine-Wave Pattern

Given a size which is indicate the height of wave. And N is indicate number of sequence of wave. Our goal is to print simple sine wave using of this parameter. Let's first view few examples of this problem.

Sine Wave Pattern Set A

In above example width of sine wave are constant. Only modified that occurring sequence and height. Here given code implementation process.

//C Program
//Program For Sine-Wave Pattern
#include <stdio.h>

void space(int size)
{
  for (int i = 0; i < size; ++i)
  {
    printf(" ");
  }
}
void show_pattern(int size, int n)
{
  if (size <= 2)
  {
    return;
  }
  printf("Size : %d  N : %d\n\n", size, n);
  //First layer of sine wave
  for (int j = 0; j < n; ++j)
  {
    if (j == 0)
    {
      space(7);
    }
    else
    {
      space(9);
    }
    printf("✰ ✰");
  }
  printf("\n");
  // Intermediate layer of sine wave
  for (int i = 0; i < size - 2; ++i)
  {
    for (int j = 0; j < n; ++j)
    {
      space(5);
      printf("✰");
      space(5);
      printf("✰");
    }
    printf("\n");
  }
  //Last layer of sine wave
  for (int j = 0; j <= n; ++j)
  {
    if (j == 0)
    {
      printf(" ✰ ✰");
    }
    else
    {
      space(9);
      printf("✰ ✰");
    }
  }
  printf("\n\n");
}
int main()
{
  //Test Case
  show_pattern(6, 1);
  show_pattern(7, 3);
  show_pattern(3, 4);
  return 0;
}

Output

Size : 6  N : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Size : 7  N : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Size : 3  N : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
/*
  Java Program
  Program For Sine-Wave Pattern
*/
public class MyPattern
{
    // Include space of given size
    public void space(int size)
    {
        for (int i = 0; i < size; ++i)
        {
            System.out.print(" ");
        }
    }
    public void showPattern(int height, int width)
    {
        if (height <= 2)
        {
            return;
        }
        // Display given size
        System.out.print("Height : " + height + 
                         " Width : " + width + "\n\n");
        // First layer of sine wave
        for (int j = 0; j < width; ++j)
        {
            if (j == 0)
            {
                space(7);
            }
            else
            {
                space(9);
            }
            System.out.print("✰ ✰");
        }
        System.out.print("\n");
        // Intermediate layer of sine wave
        for (int i = 0; i < height - 2; ++i)
        {
            for (int j = 0; j < width; ++j)
            {
                space(5);
                System.out.print("✰");
                space(5);
                System.out.print("✰");
            }
            System.out.print("\n");
        }
        // Last layer of sine wave
        for (int j = 0; j <= width; ++j)
        {
            if (j == 0)
            {
                System.out.print(" ✰ ✰");
            }
            else
            {
                space(9);
                System.out.print("✰ ✰");
            }
        }
        System.out.print("\n\n");
    }
    public static void main(String[] args)
    {
        MyPattern obj = new MyPattern();
        // Test A
        // height : 6 
        // width  : 1
        obj.showPattern(6, 1);
        // Test B
        // height : 7 
        // width  : 3
        obj.showPattern(7, 3);
        // Test C
        // height : 3 
        // width  : 4
        obj.showPattern(3, 4);
    }
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Include header file
#include <iostream>
using namespace std;
/*
  C++ Program
  Program For Sine-Wave Pattern
*/
class MyPattern
{
  public:
    // Include space of given size
    void space(int size)
    {
      for (int i = 0; i < size; ++i)
      {
        cout << " ";
      }
    }
  void showPattern(int height, int width)
  {
    if (height <= 2)
    {
      return;
    }
    // Display given size
    cout << "Height : " << height 
             << " Width : " << width << "\n\n";
    // First layer of sine wave
    for (int j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this->space(7);
      }
      else
      {
        this->space(9);
      }
      cout << "✰ ✰";
    }
    cout << "\n";
    // Intermediate layer of sine wave
    for (int i = 0; i < height - 2; ++i)
    {
      for (int j = 0; j < width; ++j)
      {
        this->space(5);
        cout << "✰";
        this->space(5);
        cout << "✰";
      }
      cout << "\n";
    }
    // Last layer of sine wave
    for (int j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        cout << " ✰ ✰";
      }
      else
      {
        this->space(9);
        cout << "✰ ✰";
      }
    }
    cout << "\n\n";
  }
};
int main()
{
  MyPattern *obj = new MyPattern();
  // Test A
  // height : 6 
  // width  : 1
  obj->showPattern(6, 1);
  // Test B
  // height : 7 
  // width  : 3
  obj->showPattern(7, 3);
  // Test C
  // height : 3 
  // width  : 4
  obj->showPattern(3, 4);
  return 0;
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Include namespace system
using System;
/*
  Csharp Program
  Program For Sine-Wave Pattern
*/
public class MyPattern
{
  // Include space of given size
  public void space(int size)
  {
    for (int i = 0; i < size; ++i)
    {
      Console.Write(" ");
    }
  }
  public void showPattern(int height, int width)
  {
    if (height <= 2)
    {
      return;
    }
    // Display given size
    Console.Write("Height : " + height + 
                      " Width : " + width + "\n\n");
    // First layer of sine wave
    for (int j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      Console.Write("✰ ✰");
    }
    Console.Write("\n");
    // Intermediate layer of sine wave
    for (int i = 0; i < height - 2; ++i)
    {
      for (int j = 0; j < width; ++j)
      {
        this.space(5);
        Console.Write("✰");
        this.space(5);
        Console.Write("✰");
      }
      Console.Write("\n");
    }
    // Last layer of sine wave
    for (int j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        Console.Write(" ✰ ✰");
      }
      else
      {
        this.space(9);
        Console.Write("✰ ✰");
      }
    }
    Console.Write("\n\n");
  }
  public static void Main(String[] args)
  {
    MyPattern obj = new MyPattern();
    // Test A
    // height : 6 
    // width  : 1
    obj.showPattern(6, 1);
    // Test B
    // height : 7 
    // width  : 3
    obj.showPattern(7, 3);
    // Test C
    // height : 3 
    // width  : 4
    obj.showPattern(3, 4);
  }
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
<?php
/*
  Php Program
  Program For Sine-Wave Pattern
*/
class MyPattern
{
  // Include space of given size
  public  function space($size)
  {
    for ($i = 0; $i < $size; ++$i)
    {
      echo(" ");
    }
  }
  public  function showPattern($height, $width)
  {
    if ($height <= 2)
    {
      return;
    }
    // Display given size
    echo("Height : ".$height.
      " Width : ".$width.
      "\n\n");
    // First layer of sine wave
    for ($j = 0; $j < $width; ++$j)
    {
      if ($j == 0)
      {
        $this->space(7);
      }
      else
      {
        $this->space(9);
      }
      echo("✰ ✰");
    }
    echo("\n");
    // Intermediate layer of sine wave
    for ($i = 0; $i < $height - 2; ++$i)
    {
      for ($j = 0; $j < $width; ++$j)
      {
        $this->space(5);
        echo("✰");
        $this->space(5);
        echo("✰");
      }
      echo("\n");
    }
    // Last layer of sine wave
    for ($j = 0; $j <= $width; ++$j)
    {
      if ($j == 0)
      {
        echo(" ✰ ✰");
      }
      else
      {
        $this->space(9);
        echo("✰ ✰");
      }
    }
    echo("\n\n");
  }
}

function main()
{
  $obj = new MyPattern();
  // Test A
  // height : 6 
  // width  : 1
  $obj->showPattern(6, 1);
  // Test B
  // height : 7 
  // width  : 3
  $obj->showPattern(7, 3);
  // Test C
  // height : 3 
  // width  : 4
  $obj->showPattern(3, 4);
}
main();

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
/*
  Node JS Program
  Program For Sine-Wave Pattern
*/
class MyPattern
{
  // Include space of given size
  space(size)
  {
    for (var i = 0; i < size; ++i)
    {
      process.stdout.write(" ");
    }
  }
  showPattern(height, width)
  {
    if (height <= 2)
    {
      return;
    }
    // Display given size
    process.stdout.write("Height : " + height + 
                             " Width : " + width + "\n\n");
    // First layer of sine wave
    for (var j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      process.stdout.write("✰ ✰");
    }
    process.stdout.write("\n");
    // Intermediate layer of sine wave
    for (var i = 0; i < height - 2; ++i)
    {
      for (var j = 0; j < width; ++j)
      {
        this.space(5);
        process.stdout.write("✰");
        this.space(5);
        process.stdout.write("✰");
      }
      process.stdout.write("\n");
    }
    // Last layer of sine wave
    for (var j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        process.stdout.write(" ✰ ✰");
      }
      else
      {
        this.space(9);
        process.stdout.write("✰ ✰");
      }
    }
    process.stdout.write("\n\n");
  }
}

function main()
{
  var obj = new MyPattern();
  // Test A
  // height : 6 
  // width  : 1
  obj.showPattern(6, 1);
  // Test B
  // height : 7 
  // width  : 3
  obj.showPattern(7, 3);
  // Test C
  // height : 3 
  // width  : 4
  obj.showPattern(3, 4);
}
main();

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
#  Python 3 Program
#  Program For Sine-Wave Pattern
class MyPattern :
  #  Include space of given size
  def space(self, size) :
    i = 0
    while (i < size) :
      print(" ", end = "")
      i += 1
    
  
  def showPattern(self, height, width) :
    if (height <= 2) :
      return
    
    #  Display given size
    print("Height : ", height ,
              " Width : ", width ,"\n")
    j = 0
    #  First layer of sine wave
    while (j < width) :
      if (j == 0) :
        self.space(7)
      else :
        self.space(9)
      
      print("✰ ✰", end = "")
      j += 1
    
    print(end = "\n")
    i = 0
    #  Intermediate layer of sine wave
    while (i < height - 2) :
      j = 0
      while (j < width) :
        self.space(5)
        print("✰", end = "")
        self.space(5)
        print("✰", end = "")
        j += 1
      
      print(end = "\n")
      i += 1
    
    j = 0
    #  Last layer of sine wave
    while (j <= width) :
      if (j == 0) :
        print(" ✰ ✰", end = "")
      else :
        self.space(9)
        print("✰ ✰", end = "")
      
      j += 1
    
    print("\n")
  

def main() :
  obj = MyPattern()
  #  Test A
  #  height : 6 
  #  width  : 1
  obj.showPattern(6, 1)
  #  Test B
  #  height : 7 
  #  width  : 3
  obj.showPattern(7, 3)
  #  Test C
  #  height : 3 
  #  width  : 4
  obj.showPattern(3, 4)

if __name__ == "__main__": main()

Output

Height :  6  Width :  1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height :  7  Width :  3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height :  3  Width :  4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
#  Ruby Program
#  Program For Sine-Wave Pattern
class MyPattern 
  #  Include space of given size
  def space(size) 
    i = 0
    while (i < size) 
      print(" ")
      i += 1
    end

  end

  def showPattern(height, width) 
    if (height <= 2) 
      return
    end

    #  Display given size
    print("Height : ", height ,
              " Width : ", width ,"\n\n")
    j = 0
    #  First layer of sine wave
    while (j < width) 
      if (j == 0) 
        self.space(7)
      else
 
        self.space(9)
      end

      print("✰ ✰")
      j += 1
    end

    print("\n")
    i = 0
    #  Intermediate layer of sine wave
    while (i < height - 2) 
      j = 0
      while (j < width) 
        self.space(5)
        print("✰")
        self.space(5)
        print("✰")
        j += 1
      end

      print("\n")
      i += 1
    end

    j = 0
    #  Last layer of sine wave
    while (j <= width) 
      if (j == 0) 
        print(" ✰ ✰")
      else
 
        self.space(9)
        print("✰ ✰")
      end

      j += 1
    end

    print("\n\n")
  end

end

def main() 
  obj = MyPattern.new()
  #  Test A
  #  height : 6 
  #  width  : 1
  obj.showPattern(6, 1)
  #  Test B
  #  height : 7 
  #  width  : 3
  obj.showPattern(7, 3)
  #  Test C
  #  height : 3 
  #  width  : 4
  obj.showPattern(3, 4)
end

main()

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

/*
  Scala Program
  Program For Sine-Wave Pattern
*/
class MyPattern()
{
  // Include space of given size
  def space(size: Int): Unit = {
    var i: Int = 0;
    while (i < size)
    {
      print(" ");
      i += 1;
    }
  }
  def showPattern(height: Int, width: Int): Unit = {
    if (height <= 2)
    {
      return;
    }
    // Display given size
    print("Height : " + height + 
             " Width : " + width + "\n\n");
    var j: Int = 0;
    // First layer of sine wave
    while (j < width)
    {
      if (j == 0)
      {
        space(7);
      }
      else
      {
        space(9);
      }
      print("✰ ✰");
      j += 1;
    }
    print("\n");
    var i: Int = 0;
    // Intermediate layer of sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        space(5);
        print("✰");
        space(5);
        print("✰");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    // Last layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰");
      }
      else
      {
        space(9);
        print("✰ ✰");
      }
      j += 1;
    }
    print("\n\n");
  }
}
object Main
{
  def main(args: Array[String]): Unit = {
    var obj: MyPattern = new MyPattern();
    // Test A
    // height : 6 
    // width  : 1
    obj.showPattern(6, 1);
    // Test B
    // height : 7 
    // width  : 3
    obj.showPattern(7, 3);
    // Test C
    // height : 3 
    // width  : 4
    obj.showPattern(3, 4);
  }
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
/*
  Swift 4 Program
  Program For Sine-Wave Pattern
*/
class MyPattern
{
  // Include space of given size
  func space(_ size: Int)
  {
    var i: Int = 0;
    while (i < size)
    {
      print(" ", terminator: "");
      i += 1;
    }
  }
  func showPattern(_ height: Int, _ width: Int)
  {
    if (height <= 2)
    {
      return;
    }
    // Display given size
    print("Height : ", height ,
              " Width : ", width ,"\n");
    var j: Int = 0;
    // First layer of sine wave
    while (j < width)
    {
      if (j == 0)
      {
        self.space(7);
      }
      else
      {
        self.space(9);
      }
      print("✰ ✰", terminator: "");
      j += 1;
    }
    print(terminator: "\n");
    var i: Int = 0;
    // Intermediate layer of sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        self.space(5);
        print("✰", terminator: "");
        self.space(5);
        print("✰", terminator: "");
        j += 1;
      }
      print(terminator: "\n");
      i += 1;
    }
    j = 0;
    // Last layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰", terminator: "");
      }
      else
      {
        self.space(9);
        print("✰ ✰", terminator: "");
      }
      j += 1;
    }
    print("\n");
  }
}
func main()
{
  let obj: MyPattern = MyPattern();
  // Test A
  // height : 6 
  // width  : 1
  obj.showPattern(6, 1);
  // Test B
  // height : 7 
  // width  : 3
  obj.showPattern(7, 3);
  // Test C
  // height : 3 
  // width  : 4
  obj.showPattern(3, 4);
}
main();

Output

Height :  6  Width :  1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height :  7  Width :  3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height :  3  Width :  4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
/*
  Kotlin Program
  Program For Sine-Wave Pattern
*/
class MyPattern
{
  // Include space of given size
  fun space(size: Int): Unit
  {
    var i: Int = 0;
    while (i < size)
    {
      print(" ");
      i += 1;
    }
  }
  fun showPattern(height: Int, width: Int): Unit
  {
    if (height <= 2)
    {
      return;
    }
    // Display given size
    print("Height : " + height + " Width : " + width + "\n\n");
    var j: Int = 0;
    // First layer of sine wave
    while (j < width)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      print("✰ ✰");
      j += 1;
    }
    print("\n");
    var i: Int = 0;
    // Intermediate layer of sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        this.space(5);
        print("✰");
        this.space(5);
        print("✰");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    // Last layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰");
      }
      else
      {
        this.space(9);
        print("✰ ✰");
      }
      j += 1;
    }
    print("\n\n");
  }
}
fun main(args: Array < String > ): Unit
{
  val obj: MyPattern = MyPattern();
  // Test A
  // height : 6 
  // width  : 1
  obj.showPattern(6, 1);
  // Test B
  // height : 7 
  // width  : 3
  obj.showPattern(7, 3);
  // Test C
  // height : 3 
  // width  : 4
  obj.showPattern(3, 4);
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
package main
import "fmt"
/*
  Go Program
  Program For Sine-Wave Pattern
*/
type MyPattern struct {}
func getMyPattern() * MyPattern {
  var me *MyPattern = &MyPattern {}
  return me
}
// Include space of given size
func(this MyPattern) space(size int) {
  for i := 0 ; i < size ; i++ {
    fmt.Print(" ")
  }
}
func(this MyPattern) showPattern(height, width int) {
  if height <= 2 {
    return
  }
  // Display given size
  fmt.Print("Height : ", height, 
              " Width : ", width, "\n\n")
  // First layer of sine wave
  for j := 0 ; j < width ; j++ {
    if j == 0 {
      this.space(7)
    } else {
      this.space(9)
    }
    fmt.Print("✰ ✰")
  }
  fmt.Print("\n")
  // Intermediate layer of sine wave
  for i := 0 ; i < height - 2 ; i++ {
    for j := 0 ; j < width ; j++ {
      this.space(5)
      fmt.Print("✰")
      this.space(5)
      fmt.Print("✰")
    }
    fmt.Print("\n")
  }
  // Last layer of sine wave
  for j := 0 ; j <= width ; j++ {
    if j == 0 {
      fmt.Print(" ✰ ✰")
    } else {
      this.space(9)
      fmt.Print("✰ ✰")
    }
  }
  fmt.Print("\n\n")
}
func main() {
  var obj * MyPattern = getMyPattern()
  // Test A
  // height : 6 
  // width  : 1
  obj.showPattern(6, 1)
  // Test B
  // height : 7 
  // width  : 3
  obj.showPattern(7, 3)
  // Test C
  // height : 3 
  // width  : 4
  obj.showPattern(3, 4)
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Rust Language
// Program For Sine-Wave Pattern
fn main()
{
  //Test Case
  show_pattern(6, 1);
  show_pattern(7, 3);
  show_pattern(3, 4);
}
fn show_pattern(size: i32, n: i32)
{
  if size <= 2
  {
    return;
  }
  print!("Size : {} N : {}\n\n", size, n);
  let mut j: i32 = 0;
  //First layer of sine wave
  while j < n
  {
    if j == 0
    {
      space(7);
    }
    else
    {
      space(9);
    }
    print!("✰ ✰");
    j += 1;
  }
  print!("\n");
  let mut i: i32 = 0;
  let mut j: i32;
  // Intermediate layer of sine wave
  while i < size - 2
  {
    j = 0;
    while j < n
    {
      space(5);
      print!("✰");
      space(5);
      print!("✰");
      j += 1;
    }
    print!("\n");
    i += 1;
  }
  j = 0;
  //Last layer of sine wave
  while j <= n
  {
    if j == 0
    {
      print!(" ✰ ✰");
    }
    else
    {
      space(9);
      print!("✰ ✰");
    }
    j += 1;
  }
  print!("\n\n");
}
fn space(size: i32)
{
  let mut i: i32 = 0;
  while i < size
  {
    print!(" ");
    i += 1;
  }
}

Output

Size : 6 N : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰

Size : 7 N : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

Size : 3 N : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
Sine Wave Pattern Set B
// Java Program
// Program For Sine-Wave Pattern Set-B
class MyPattern
{
    // include space
    public void space(int size)
    {
        for (int i = 0; i < size; ++i)
        {
            System.out.print(" ");
        }
    }
    public void showPattern(int hight, int width)
    {
        if (hight <= 2)
        {
            return;
        }
        // Display given Height Width
        System.out.print("Height : " + hight + 
                         " Width : " + width + "\n\n");
        //First layer of sine wave
        for (int j = 0; j <= width; ++j)
        {
            if (j == 0)
            {
                System.out.print(" * *");
            }
            else
            {
                space(9);
                System.out.print("* *");
            }
        }
        System.out.print("\n");
        // Intermediate layer of sine wave
        for (int i = 0; i < hight - 2; ++i)
        {
            for (int j = 0; j < width; ++j)
            {
                space(5);
                System.out.print("*");
                space(5);
                System.out.print("*");
            }
            System.out.print("\n");
        }
        //Last layer of sine wave
        for (int j = 0; j < width; ++j)
        {
            if (j == 0)
            {
                space(7);
            }
            else
            {
                space(9);
            }
            System.out.print("* *");
        }
        System.out.print("\n\n");
    }
    public static void main(String[] args)
    {
        MyPattern obj = new MyPattern();
        //Test Case
        obj.showPattern(6, 1);
        obj.showPattern(7, 3);
        obj.showPattern(3, 4);
    }
}

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
// Include header file
#include <iostream>
using namespace std;
// C++ Program
// Program For Sine-Wave Pattern Set-B
class MyPattern
{
  public:
    // include space
    void space(int size)
    {
      for (int i = 0; i < size; ++i)
      {
        cout << " ";
      }
    }
  void showPattern(int hight, int width)
  {
    if (hight <= 2)
    {
      return;
    }
    // Display given Height Width
    cout << "Height : " << hight 
             << " Width : " << width << "\n\n";
    //First layer of sine wave
    for (int j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        cout << " * *";
      }
      else
      {
        this->space(9);
        cout << "* *";
      }
    }
    cout << "\n";
    // Intermediate layer of sine wave
    for (int i = 0; i < hight - 2; ++i)
    {
      for (int j = 0; j < width; ++j)
      {
        this->space(5);
        cout << "*";
        this->space(5);
        cout << "*";
      }
      cout << "\n";
    }
    // Last layer of sine wave
    for (int j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this->space(7);
      }
      else
      {
        this->space(9);
      }
      cout << "* *";
    }
    cout << "\n\n";
  }
};
int main()
{
  MyPattern *obj = new MyPattern();
  //Test Case
  obj->showPattern(6, 1);
  obj->showPattern(7, 3);
  obj->showPattern(3, 4);
  return 0;
}

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
// Include namespace system
using System;
// Csharp Program
// Program For Sine-Wave Pattern Set-B
public class MyPattern
{
  // include space
  public void space(int size)
  {
    for (int i = 0; i < size; ++i)
    {
      Console.Write(" ");
    }
  }
  public void showPattern(int hight, int width)
  {
    if (hight <= 2)
    {
      return;
    }
    // Display given Height Width
    Console.Write("Height : " + hight + " Width : " + width + "\n\n");
    //First layer of sine wave
    for (int j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        Console.Write(" * *");
      }
      else
      {
        this.space(9);
        Console.Write("* *");
      }
    }
    Console.Write("\n");
    // Intermediate layer of sine wave
    for (int i = 0; i < hight - 2; ++i)
    {
      for (int j = 0; j < width; ++j)
      {
        this.space(5);
        Console.Write("*");
        this.space(5);
        Console.Write("*");
      }
      Console.Write("\n");
    }
    //Last layer of sine wave
    for (int j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      Console.Write("* *");
    }
    Console.Write("\n\n");
  }
  public static void Main(String[] args)
  {
    MyPattern obj = new MyPattern();
    //Test Case
    obj.showPattern(6, 1);
    obj.showPattern(7, 3);
    obj.showPattern(3, 4);
  }
}

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
<?php
// Php Program
// Program For Sine-Wave Pattern Set-B
class MyPattern
{
  // include space
  public  function space($size)
  {
    for ($i = 0; $i < $size; ++$i)
    {
      echo(" ");
    }
  }
  public  function showPattern($hight, $width)
  {
    if ($hight <= 2)
    {
      return;
    }
    // Display given Height Width
    echo("Height : ".$hight.
      " Width : ".$width.
      "\n\n");
    //First layer of sine wave
    for ($j = 0; $j <= $width; ++$j)
    {
      if ($j == 0)
      {
        echo(" * *");
      }
      else
      {
        $this->space(9);
        echo("* *");
      }
    }
    echo("\n");
    // Intermediate layer of sine wave
    for ($i = 0; $i < $hight - 2; ++$i)
    {
      for ($j = 0; $j < $width; ++$j)
      {
        $this->space(5);
        echo("*");
        $this->space(5);
        echo("*");
      }
      echo("\n");
    }
    //Last layer of sine wave
    for ($j = 0; $j < $width; ++$j)
    {
      if ($j == 0)
      {
        $this->space(7);
      }
      else
      {
        $this->space(9);
      }
      echo("* *");
    }
    echo("\n\n");
  }
}

function main()
{
  $obj = new MyPattern();
  //Test Case
  $obj->showPattern(6, 1);
  $obj->showPattern(7, 3);
  $obj->showPattern(3, 4);
}
main();

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
// Node JS Program
// Program For Sine-Wave Pattern Set-B
class MyPattern
{
  // include space
  space(size)
  {
    for (var i = 0; i < size; ++i)
    {
      process.stdout.write(" ");
    }
  }
  showPattern(hight, width)
  {
    if (hight <= 2)
    {
      return;
    }
    // Display given Height Width
    process.stdout.write("Height : " + hight + 
                             " Width : " + width + "\n\n");
    //First layer of sine wave
    for (var j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        process.stdout.write(" * *");
      }
      else
      {
        this.space(9);
        process.stdout.write("* *");
      }
    }
    process.stdout.write("\n");
    // Intermediate layer of sine wave
    for (var i = 0; i < hight - 2; ++i)
    {
      for (var j = 0; j < width; ++j)
      {
        this.space(5);
        process.stdout.write("*");
        this.space(5);
        process.stdout.write("*");
      }
      process.stdout.write("\n");
    }
    //Last layer of sine wave
    for (var j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      process.stdout.write("* *");
    }
    process.stdout.write("\n\n");
  }
}

function main()
{
  var obj = new MyPattern();
  //Test Case
  obj.showPattern(6, 1);
  obj.showPattern(7, 3);
  obj.showPattern(3, 4);
}
main();

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
#  Python 3 Program
#  Program For Sine-Wave Pattern Set-B
class MyPattern :
  #  include space
  def space(self, size) :
    i = 0
    while (i < size) :
      print(" ", end = "")
      i += 1
    
  
  def showPattern(self, hight, width) :
    if (hight <= 2) :
      return
    
    #  Display given Height Width
    print("Height : ", hight ,
              " Width : ", width ,"\n")
    j = 0
    # First layer of sine wave
    while (j <= width) :
      if (j == 0) :
        print(" * *", end = "")
      else :
        self.space(9)
        print("* *", end = "")
      
      j += 1
    
    print(end = "\n")
    i = 0
    #  Intermediate layer of sine wave
    while (i < hight - 2) :
      j = 0
      while (j < width) :
        self.space(5)
        print("*", end = "")
        self.space(5)
        print("*", end = "")
        j += 1
      
      print(end = "\n")
      i += 1
    
    j = 0
    # Last layer of sine wave
    while (j < width) :
      if (j == 0) :
        self.space(7)
      else :
        self.space(9)
      
      print("* *", end = "")
      j += 1
    
    print("\n")
  

def main() :
  obj = MyPattern()
  # Test Case
  obj.showPattern(6, 1)
  obj.showPattern(7, 3)
  obj.showPattern(3, 4)

if __name__ == "__main__": main()

Output

Height :  6  Width :  1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height :  7  Width :  3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height :  3  Width :  4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
#  Ruby Program
#  Program For Sine-Wave Pattern Set-B
class MyPattern 
  #  include space
  def space(size) 
    i = 0
    while (i < size) 
      print(" ")
      i += 1
    end

  end

  def showPattern(hight, width) 
    if (hight <= 2) 
      return
    end

    #  Display given Height Width
    print("Height : ", hight ,
              " Width : ", width ,"\n\n")
    j = 0
    # First layer of sine wave
    while (j <= width) 
      if (j == 0) 
        print(" * *")
      else
 
        self.space(9)
        print("* *")
      end

      j += 1
    end

    print("\n")
    i = 0
    #  Intermediate layer of sine wave
    while (i < hight - 2) 
      j = 0
      while (j < width) 
        self.space(5)
        print("*")
        self.space(5)
        print("*")
        j += 1
      end

      print("\n")
      i += 1
    end

    j = 0
    # Last layer of sine wave
    while (j < width) 
      if (j == 0) 
        self.space(7)
      else
 
        self.space(9)
      end

      print("* *")
      j += 1
    end

    print("\n\n")
  end

end

def main() 
  obj = MyPattern.new()
  # Test Case
  obj.showPattern(6, 1)
  obj.showPattern(7, 3)
  obj.showPattern(3, 4)
end

main()

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *

// Scala Program
// Program For Sine-Wave Pattern Set-B
class MyPattern()
{
  // include space
  def space(size: Int): Unit = {
    var i: Int = 0;
    while (i < size)
    {
      print(" ");
      i += 1;
    }
  }
  def showPattern(hight: Int, width: Int): Unit = {
    if (hight <= 2)
    {
      return;
    }
    // Display given Height Width
    print("Height : " + hight + " Width : " + width + "\n\n");
    var j: Int = 0;
    //First layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" * *");
      }
      else
      {
        space(9);
        print("* *");
      }
      j += 1;
    }
    print("\n");
    var i: Int = 0;
    // Intermediate layer of sine wave
    while (i < hight - 2)
    {
      j = 0;
      while (j < width)
      {
        space(5);
        print("*");
        space(5);
        print("*");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    // Last layer of sine wave
    while (j < width)
    {
      if (j == 0)
      {
        space(7);
      }
      else
      {
        space(9);
      }
      print("* *");
      j += 1;
    }
    print("\n\n");
  }
}
object Main
{
  def main(args: Array[String]): Unit = {
    var obj: MyPattern = new MyPattern();
    //Test Case
    obj.showPattern(6, 1);
    obj.showPattern(7, 3);
    obj.showPattern(3, 4);
  }
}

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
// Swift 4 Program
// Program For Sine-Wave Pattern Set-B
class MyPattern
{
  // include space
  func space(_ size: Int)
  {
    var i: Int = 0;
    while (i < size)
    {
      print(" ", terminator: "");
      i += 1;
    }
  }
  func showPattern(_ hight: Int, _ width: Int)
  {
    if (hight <= 2)
    {
      return;
    }
    // Display given Height Width
    print("Height : ", hight ,
              " Width : ", width ,"\n");
    var j: Int = 0;
    //First layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" * *", terminator: "");
      }
      else
      {
        self.space(9);
        print("* *", terminator: "");
      }
      j += 1;
    }
    print(terminator: "\n");
    var i: Int = 0;
    // Intermediate layer of sine wave
    while (i < hight - 2)
    {
      j = 0;
      while (j < width)
      {
        self.space(5);
        print("*", terminator: "");
        self.space(5);
        print("*", terminator: "");
        j += 1;
      }
      print(terminator: "\n");
      i += 1;
    }
    j = 0;
    // Last layer of sine wave
    while (j < width)
    {
      if (j == 0)
      {
        self.space(7);
      }
      else
      {
        self.space(9);
      }
      print("* *", terminator: "");
      j += 1;
    }
    print("\n");
  }
}
func main()
{
  let obj: MyPattern = MyPattern();
  //Test Case
  obj.showPattern(6, 1);
  obj.showPattern(7, 3);
  obj.showPattern(3, 4);
}
main();

Output

Height :  6  Width :  1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height :  7  Width :  3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height :  3  Width :  4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
// Kotlin Program
// Program For Sine-Wave Pattern Set-B
class MyPattern
{
  // include space
  fun space(size: Int): Unit
  {
    var i: Int = 0;
    while (i < size)
    {
      print(" ");
      i += 1;
    }
  }
  fun showPattern(hight: Int, width: Int): Unit
  {
    if (hight <= 2)
    {
      return;
    }
    // Display given Height Width
    print("Height : " + hight + " Width : " + width + "\n\n");
    var j: Int = 0;
    //First layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" * *");
      }
      else
      {
        this.space(9);
        print("* *");
      }
      j += 1;
    }
    print("\n");
    var i: Int = 0;
    // Intermediate layer of sine wave
    while (i < hight - 2)
    {
      j = 0;
      while (j < width)
      {
        this.space(5);
        print("*");
        this.space(5);
        print("*");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    //Last layer of sine wave
    while (j < width)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      print("* *");
      j += 1;
    }
    print("\n\n");
  }
}
fun main(args: Array < String > ): Unit
{
  val obj: MyPattern = MyPattern();
  //Test Case
  obj.showPattern(6, 1);
  obj.showPattern(7, 3);
  obj.showPattern(3, 4);
}

Output

Height : 6 Width : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Height : 7 Width : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Height : 3 Width : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
fn main()
{
  //Test Case
  show_pattern(6, 1);
  show_pattern(7, 3);
  show_pattern(3, 4);
}
fn show_pattern(size: i32, n: i32)
{
  if size <= 2
  {
    return;
  }
  print!("Size : {} N : {}\n\n", size, n);
  let mut j: i32 = 0;
  let mut i: i32 = 0;
  //First layer of sine wave
  while j <= n
  {
    if j == 0
    {
      print!(" * *");
    }
    else
    {
      space(9);
      print!("* *");
    }
    j += 1;
  }
  print!("\n");
  // Intermediate layer of sine wave
  while i < size - 2
  {
    j = 0;
    while j < n
    {
      space(5);
      print!("*");
      space(5);
      print!("*");
      j += 1;
    }
    print!("\n");
    i += 1;
  }
  j = 0;
  //Last layer of sine wave
  while j < n
  {
    if j == 0
    {
      space(7);
    }
    else
    {
      space(9);
    }
    print!("* *");
    j += 1;
  }
  print!("\n\n");
}
fn space(size: i32)
{
  let mut i: i32 = 0;
  while i < size
  {
    print!(" ");
    i += 1;
  }
}

Output

Size : 6 N : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Size : 7 N : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Size : 3 N : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
package main
import "fmt"
// Go Program
// Program For Sine-Wave Pattern Set-B
type MyPattern struct {}
func getMyPattern() * MyPattern {
  var me *MyPattern = &MyPattern {}
  return me
}
// include space
func(this MyPattern) space(size int) {
  for i := 0 ; i < size ; i++ {
    fmt.Print(" ")
  }
}
func(this MyPattern) showPattern(hight, width int) {
  if hight <= 2 {
    return
  }
  // Display given Height Width
  fmt.Print("Height : ", hight, 
          " Width : ", width, "\n\n")
  //First layer of sine wave
  for j := 0 ; j <= width ; j++ {
    if j == 0 {
      fmt.Print(" * *")
    } else {
      this.space(9)
      fmt.Print("* *")
    }
  }
  fmt.Print("\n")
  // Intermediate layer of sine wave
  for i := 0 ; i < hight - 2 ; i++ {
    for j := 0 ; j < width ; j++ {
      this.space(5)
      fmt.Print("*")
      this.space(5)
      fmt.Print("*")
    }
    fmt.Print("\n")
  }
  //Last layer of sine wave
  for j := 0 ; j < width ; j++ {
    if j == 0 {
      this.space(7)
    } else {
      this.space(9)
    }
    fmt.Print("* *")
  }
  fmt.Print("\n\n")
}
func main() {
  var obj * MyPattern = getMyPattern()
  //Test Case
  obj.showPattern(6, 1)
  obj.showPattern(7, 3)
  obj.showPattern(3, 4)
}

Output

Size : 6 N : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Size : 7 N : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Size : 3 N : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
//C Program
//Program For Sine-Wave Pattern Set-B
#include <stdio.h>

//include space
void space(int size)
{
  for (int i = 0; i < size; ++i)
  {
    printf(" ");
  }
}
void show_pattern(int size, int n)
{
  if (size <= 2)
  {
    return;
  }
  printf("Size : %d  N : %d\n\n", size, n);
  //First layer of sine wave
  for (int j = 0; j <= n; ++j)
  {
    if (j == 0)
    {
      printf(" * *");
    }
    else
    {
      space(9);
      printf("* *");
    }
  }
  printf("\n");
  // Intermediate layer of sine wave
  for (int i = 0; i < size - 2; ++i)
  {
    for (int j = 0; j < n; ++j)
    {
      space(5);
      printf("*");
      space(5);
      printf("*");
    }
    printf("\n");
  }
  //Last layer of sine wave
  for (int j = 0; j < n; ++j)
  {
    if (j == 0)
    {
      space(7);
    }
    else
    {
      space(9);
    }
    printf("* *");
  }
  printf("\n\n");
}
int main()
{
  //Test Case
  show_pattern(6, 1);
  show_pattern(7, 3);
  show_pattern(3, 4);
  return 0;
}

Output

Size : 6  N : 1

 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Size : 7  N : 3

 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Size : 3  N : 4

 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *
Sine Wave Pattern Set C
//C Program
//Program For Sine-Wave Pattern Set-C
#include <stdio.h>

void space(int size)
{
    for (int i = 0; i < size; ++i)
    {
        printf(" ");
    }
}
void show_pattern(int size, int n)
{
    if (size <= 2)
    {
        return;
    }
    printf("Size : %d  N : %d\n\n", size, n);
    int i = 0;
    int j = 0;
    //First layer of first sine wave
    for (j = 0; j < n; ++j)
    {
        if (j == 0)
        {
            space(7);
        }
        else
        {
            space(9);
        }
        printf("✰ ✰");
    }
    printf("\n");
    // Intermediate layer of first sine wave
    for (i = 0; i < size - 2; ++i)
    {
        for (j = 0; j < n; ++j)
        {
            space(5);
            printf("✰");
            space(5);
            printf("✰");
        }
        printf("\n");
    }
    //Last layer of sine wave
    for (j = 0; j <= n; ++j)
    {
        if (j == 0)
        {
            printf(" ✰ ✰");
        }
        else
        {
            space(9);
            printf("✰ ✰");
        }
    }
    printf("\n");
    //Display bottom layer
    //First layer of second sine wave
    for (j = 0; j <= n; ++j)
    {
        if (j == 0)
        {
            printf(" ✰ ✰");
        }
        else
        {
            space(9);
            printf("✰ ✰");
        }
    }
    printf("\n");
    // Intermediate layer of second sine wave
    for (i = 0; i < size - 2; ++i)
    {
        for (j = 0; j < n; ++j)
        {
            space(5);
            printf("✰");
            space(5);
            printf("✰");
        }
        printf("\n");
    }
    //Last layer of second sine wave
    for (j = 0; j < n; ++j)
    {
        if (j == 0)
        {
            space(7);
        }
        else
        {
            space(9);
        }
        printf("✰ ✰");
    }
    printf("\n\n");
}
int main()
{
    //Test Case
    show_pattern(6, 1);
    show_pattern(7, 3);
    show_pattern(3, 4);
    return 0;
}

Output

Size : 6  N : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Size : 7  N : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Size : 3  N : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Java Program
// Program For Sine-Wave Pattern Set-C
class MyPattern
{
    // include space
    public void space(int size)
    {
        for (int i = 0; i < size; ++i)
        {
            System.out.print(" ");
        }
    }
    public void showPattern(int height, int width)
    {
        if (height <= 2)
        {
            return;
        }
        System.out.print("Height : " + height + 
                         " Width : " + width + "\n\n");
        int i = 0;
        int j = 0;
        //First layer of first sine wave
        for (j = 0; j < width; ++j)
        {
            if (j == 0)
            {
                space(7);
            }
            else
            {
                space(9);
            }
            System.out.print("✰ ✰");
        }
        System.out.print("\n");
        // Intermediate layer of first sine wave
        for (i = 0; i < height - 2; ++i)
        {
            for (j = 0; j < width; ++j)
            {
                space(5);
                System.out.print("✰");
                space(5);
                System.out.print("✰");
            }
            System.out.print("\n");
        }
        //Last layer of sine wave
        for (j = 0; j <= width; ++j)
        {
            if (j == 0)
            {
                System.out.print(" ✰ ✰");
            }
            else
            {
                space(9);
                System.out.print("✰ ✰");
            }
        }
        System.out.print("\n");
        //Display bottom layer
        //First layer of second sine wave
        for (j = 0; j <= width; ++j)
        {
            if (j == 0)
            {
                System.out.print(" ✰ ✰");
            }
            else
            {
                space(9);
                System.out.print("✰ ✰");
            }
        }
        System.out.print("\n");
        // Intermediate layer of second sine wave
        for (i = 0; i < height - 2; ++i)
        {
            for (j = 0; j < width; ++j)
            {
                space(5);
                System.out.print("✰");
                space(5);
                System.out.print("✰");
            }
            System.out.print("\n");
        }
        //Last layer of second sine wave
        for (j = 0; j < width; ++j)
        {
            if (j == 0)
            {
                space(7);
            }
            else
            {
                space(9);
            }
            System.out.print("✰ ✰");
        }
        System.out.print("\n\n");
    }
    public static void main(String[] args)
    {
        MyPattern task = new MyPattern();
        // Test 
        task.showPattern(6, 1);
        task.showPattern(7, 3);
        task.showPattern(3, 4);
    }
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Include header file
#include <iostream>
using namespace std;
// C++ Program
// Program For Sine-Wave Pattern Set-C
class MyPattern
{
  public:
    // include space
    void space(int size)
    {
      for (int i = 0; i < size; ++i)
      {
        cout << " ";
      }
    }
  void showPattern(int height, int width)
  {
    if (height <= 2)
    {
      return;
    }
    cout << "Height : " << height 
       << " Width : " << width << "\n\n";
    int i = 0;
    int j = 0;
    //First layer of first sine wave
    for (j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this->space(7);
      }
      else
      {
        this->space(9);
      }
      cout << "✰ ✰";
    }
    cout << "\n";
    // Intermediate layer of first sine wave
    for (i = 0; i < height - 2; ++i)
    {
      for (j = 0; j < width; ++j)
      {
        this->space(5);
        cout << "✰";
        this->space(5);
        cout << "✰";
      }
      cout << "\n";
    }
    //Last layer of sine wave
    for (j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        cout << " ✰ ✰";
      }
      else
      {
        this->space(9);
        cout << "✰ ✰";
      }
    }
    cout << "\n";
    //Display bottom layer
    //First layer of second sine wave
    for (j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        cout << " ✰ ✰";
      }
      else
      {
        this->space(9);
        cout << "✰ ✰";
      }
    }
    cout << "\n";
    // Intermediate layer of second sine wave
    for (i = 0; i < height - 2; ++i)
    {
      for (j = 0; j < width; ++j)
      {
        this->space(5);
        cout << "✰";
        this->space(5);
        cout << "✰";
      }
      cout << "\n";
    }
    //Last layer of second sine wave
    for (j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this->space(7);
      }
      else
      {
        this->space(9);
      }
      cout << "✰ ✰";
    }
    cout << "\n\n";
  }
};
int main()
{
  MyPattern *task = new MyPattern();
  // Test 
  task->showPattern(6, 1);
  task->showPattern(7, 3);
  task->showPattern(3, 4);
  return 0;
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Include namespace system
using System;
// Csharp Program
// Program For Sine-Wave Pattern Set-C
public class MyPattern
{
  // include space
  public void space(int size)
  {
    for (int i = 0; i < size; ++i)
    {
      Console.Write(" ");
    }
  }
  public void showPattern(int height, int width)
  {
    if (height <= 2)
    {
      return;
    }
    Console.Write("Height : " + height + 
                      " Width : " + width + "\n\n");
    int i = 0;
    int j = 0;
    //First layer of first sine wave
    for (j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      Console.Write("✰ ✰");
    }
    Console.Write("\n");
    // Intermediate layer of first sine wave
    for (i = 0; i < height - 2; ++i)
    {
      for (j = 0; j < width; ++j)
      {
        this.space(5);
        Console.Write("✰");
        this.space(5);
        Console.Write("✰");
      }
      Console.Write("\n");
    }
    //Last layer of sine wave
    for (j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        Console.Write(" ✰ ✰");
      }
      else
      {
        this.space(9);
        Console.Write("✰ ✰");
      }
    }
    Console.Write("\n");
    //Display bottom layer
    //First layer of second sine wave
    for (j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        Console.Write(" ✰ ✰");
      }
      else
      {
        this.space(9);
        Console.Write("✰ ✰");
      }
    }
    Console.Write("\n");
    // Intermediate layer of second sine wave
    for (i = 0; i < height - 2; ++i)
    {
      for (j = 0; j < width; ++j)
      {
        this.space(5);
        Console.Write("✰");
        this.space(5);
        Console.Write("✰");
      }
      Console.Write("\n");
    }
    //Last layer of second sine wave
    for (j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      Console.Write("✰ ✰");
    }
    Console.Write("\n\n");
  }
  public static void Main(String[] args)
  {
    MyPattern task = new MyPattern();
    // Test 
    task.showPattern(6, 1);
    task.showPattern(7, 3);
    task.showPattern(3, 4);
  }
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
<?php
// Php Program
// Program For Sine-Wave Pattern Set-C
class MyPattern
{
  // include space
  public  function space($size)
  {
    for ($i = 0; $i < $size; ++$i)
    {
      echo(" ");
    }
  }
  public  function showPattern($height, $width)
  {
    if ($height <= 2)
    {
      return;
    }
    echo("Height : ".$height.
      " Width : ".$width.
      "\n\n");
    $i = 0;
    $j = 0;
    //First layer of first sine wave
    for ($j = 0; $j < $width; ++$j)
    {
      if ($j == 0)
      {
        $this->space(7);
      }
      else
      {
        $this->space(9);
      }
      echo("✰ ✰");
    }
    echo("\n");
    // Intermediate layer of first sine wave
    for ($i = 0; $i < $height - 2; ++$i)
    {
      for ($j = 0; $j < $width; ++$j)
      {
        $this->space(5);
        echo("✰");
        $this->space(5);
        echo("✰");
      }
      echo("\n");
    }
    //Last layer of sine wave
    for ($j = 0; $j <= $width; ++$j)
    {
      if ($j == 0)
      {
        echo(" ✰ ✰");
      }
      else
      {
        $this->space(9);
        echo("✰ ✰");
      }
    }
    echo("\n");
    //Display bottom layer
    //First layer of second sine wave
    for ($j = 0; $j <= $width; ++$j)
    {
      if ($j == 0)
      {
        echo(" ✰ ✰");
      }
      else
      {
        $this->space(9);
        echo("✰ ✰");
      }
    }
    echo("\n");
    // Intermediate layer of second sine wave
    for ($i = 0; $i < $height - 2; ++$i)
    {
      for ($j = 0; $j < $width; ++$j)
      {
        $this->space(5);
        echo("✰");
        $this->space(5);
        echo("✰");
      }
      echo("\n");
    }
    //Last layer of second sine wave
    for ($j = 0; $j < $width; ++$j)
    {
      if ($j == 0)
      {
        $this->space(7);
      }
      else
      {
        $this->space(9);
      }
      echo("✰ ✰");
    }
    echo("\n\n");
  }
}

function main()
{
  $task = new MyPattern();
  // Test 
  $task->showPattern(6, 1);
  $task->showPattern(7, 3);
  $task->showPattern(3, 4);
}
main();

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Node JS Program
// Program For Sine-Wave Pattern Set-C
class MyPattern
{
  // include space
  space(size)
  {
    for (var i = 0; i < size; ++i)
    {
      process.stdout.write(" ");
    }
  }
  showPattern(height, width)
  {
    if (height <= 2)
    {
      return;
    }
    process.stdout.write("Height : " + height + 
                             " Width : " + width + "\n\n");
    var i = 0;
    var j = 0;
    //First layer of first sine wave
    for (j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      process.stdout.write("✰ ✰");
    }
    process.stdout.write("\n");
    // Intermediate layer of first sine wave
    for (i = 0; i < height - 2; ++i)
    {
      for (j = 0; j < width; ++j)
      {
        this.space(5);
        process.stdout.write("✰");
        this.space(5);
        process.stdout.write("✰");
      }
      process.stdout.write("\n");
    }
    //Last layer of sine wave
    for (j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        process.stdout.write(" ✰ ✰");
      }
      else
      {
        this.space(9);
        process.stdout.write("✰ ✰");
      }
    }
    process.stdout.write("\n");
    //Display bottom layer
    //First layer of second sine wave
    for (j = 0; j <= width; ++j)
    {
      if (j == 0)
      {
        process.stdout.write(" ✰ ✰");
      }
      else
      {
        this.space(9);
        process.stdout.write("✰ ✰");
      }
    }
    process.stdout.write("\n");
    // Intermediate layer of second sine wave
    for (i = 0; i < height - 2; ++i)
    {
      for (j = 0; j < width; ++j)
      {
        this.space(5);
        process.stdout.write("✰");
        this.space(5);
        process.stdout.write("✰");
      }
      process.stdout.write("\n");
    }
    //Last layer of second sine wave
    for (j = 0; j < width; ++j)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      process.stdout.write("✰ ✰");
    }
    process.stdout.write("\n\n");
  }
}

function main()
{
  var task = new MyPattern();
  // Test 
  task.showPattern(6, 1);
  task.showPattern(7, 3);
  task.showPattern(3, 4);
}
main();

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
#  Python 3 Program
#  Program For Sine-Wave Pattern Set-C
class MyPattern :
  #  include space
  def space(self, size) :
    i = 0
    while (i < size) :
      print(" ", end = "")
      i += 1
    
  
  def showPattern(self, height, width) :
    if (height <= 2) :
      return
    
    print("Height : ", height ,
              " Width : ", width ,"\n")
    i = 0
    j = 0
    j = 0
    # First layer of first sine wave
    while (j < width) :
      if (j == 0) :
        self.space(7)
      else :
        self.space(9)
      
      print("✰ ✰", end = "")
      j += 1
    
    print(end = "\n")
    i = 0
    #  Intermediate layer of first sine wave
    while (i < height - 2) :
      j = 0
      while (j < width) :
        self.space(5)
        print("✰", end = "")
        self.space(5)
        print("✰", end = "")
        j += 1
      
      print(end = "\n")
      i += 1
    
    j = 0
    # Last layer of sine wave
    while (j <= width) :
      if (j == 0) :
        print(" ✰ ✰", end = "")
      else :
        self.space(9)
        print("✰ ✰", end = "")
      
      j += 1
    
    print(end = "\n")
    j = 0
    # Display bottom layer
    # First layer of second sine wave
    while (j <= width) :
      if (j == 0) :
        print(" ✰ ✰", end = "")
      else :
        self.space(9)
        print("✰ ✰", end = "")
      
      j += 1
    
    print(end = "\n")
    i = 0
    #  Intermediate layer of second sine wave
    while (i < height - 2) :
      j = 0
      while (j < width) :
        self.space(5)
        print("✰", end = "")
        self.space(5)
        print("✰", end = "")
        j += 1
      
      print(end = "\n")
      i += 1
    
    j = 0
    # Last layer of second sine wave
    while (j < width) :
      if (j == 0) :
        self.space(7)
      else :
        self.space(9)
      
      print("✰ ✰", end = "")
      j += 1
    
    print("\n")
  

def main() :
  task = MyPattern()
  #  Test 
  task.showPattern(6, 1)
  task.showPattern(7, 3)
  task.showPattern(3, 4)

if __name__ == "__main__": main()

Output

Height :  6  Width :  1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height :  7  Width :  3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height :  3  Width :  4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
#  Ruby Program
#  Program For Sine-Wave Pattern Set-C
class MyPattern 
  #  include space
  def space(size) 
    i = 0
    while (i < size) 
      print(" ")
      i += 1
    end

  end

  def showPattern(height, width) 
    if (height <= 2) 
      return
    end

    print("Height : ", height ,
              " Width : ", width ,"\n\n")
    i = 0
    j = 0
    # First layer of first sine wave
    while (j < width) 
      if (j == 0) 
        self.space(7)
      else
 
        self.space(9)
      end

      print("✰ ✰")
      j += 1
    end

    print("\n")
    i = 0
    #  Intermediate layer of first sine wave
    while (i < height - 2) 
      j = 0
      while (j < width) 
        self.space(5)
        print("✰")
        self.space(5)
        print("✰")
        j += 1
      end

      print("\n")
      i += 1
    end

    j = 0
    # Last layer of sine wave
    while (j <= width) 
      if (j == 0) 
        print(" ✰ ✰")
      else
 
        self.space(9)
        print("✰ ✰")
      end

      j += 1
    end

    print("\n")
    j = 0
    # Display bottom layer
    # First layer of second sine wave
    while (j <= width) 
      if (j == 0) 
        print(" ✰ ✰")
      else
 
        self.space(9)
        print("✰ ✰")
      end

      j += 1
    end

    print("\n")
    i = 0
    #  Intermediate layer of second sine wave
    while (i < height - 2) 
      j = 0
      while (j < width) 
        self.space(5)
        print("✰")
        self.space(5)
        print("✰")
        j += 1
      end

      print("\n")
      i += 1
    end

    j = 0
    # Last layer of second sine wave
    while (j < width) 
      if (j == 0) 
        self.space(7)
      else
 
        self.space(9)
      end

      print("✰ ✰")
      j += 1
    end

    print("\n\n")
  end

end

def main() 
  task = MyPattern.new()
  #  Test 
  task.showPattern(6, 1)
  task.showPattern(7, 3)
  task.showPattern(3, 4)
end

main()

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰

// Scala Program
// Program For Sine-Wave Pattern Set-C
class MyPattern()
{
  // include space
  def space(size: Int): Unit = {
    var i: Int = 0;
    while (i < size)
    {
      print(" ");
      i += 1;
    }
  }
  def showPattern(height: Int, width: Int): Unit = {
    if (height <= 2)
    {
      return;
    }
    print("Height : " + height + 
           " Width : " + width + "\n\n");
    var i: Int = 0;
    var j: Int = 0;
    //First layer of first sine wave
    while (j < width)
    {
      if (j == 0)
      {
        space(7);
      }
      else
      {
        space(9);
      }
      print("✰ ✰");
      j += 1;
    }
    print("\n");
    i = 0;
    // Intermediate layer of first sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        space(5);
        print("✰");
        space(5);
        print("✰");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    //Last layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰");
      }
      else
      {
        space(9);
        print("✰ ✰");
      }
      j += 1;
    }
    print("\n");
    j = 0;
    //Display bottom layer
    //First layer of second sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰");
      }
      else
      {
        space(9);
        print("✰ ✰");
      }
      j += 1;
    }
    print("\n");
    i = 0;
    // Intermediate layer of second sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        space(5);
        print("✰");
        space(5);
        print("✰");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    //Last layer of second sine wave
    while (j < width)
    {
      if (j == 0)
      {
        space(7);
      }
      else
      {
        space(9);
      }
      print("✰ ✰");
      j += 1;
    }
    print("\n\n");
  }
}
object Main
{
  def main(args: Array[String]): Unit = {
    var task: MyPattern = new MyPattern();
    // Test 
    task.showPattern(6, 1);
    task.showPattern(7, 3);
    task.showPattern(3, 4);
  }
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Swift 4 Program
// Program For Sine-Wave Pattern Set-C
class MyPattern
{
  // include space
  func space(_ size: Int)
  {
    var i: Int = 0;
    while (i < size)
    {
      print(" ", terminator: "");
      i += 1;
    }
  }
  func showPattern(_ height: Int, _ width: Int)
  {
    if (height <= 2)
    {
      return;
    }
    print("Height : ", height ,
              " Width : ", width ,"\n");
    var i: Int = 0;
    var j: Int = 0;

    //First layer of first sine wave
    while (j < width)
    {
      if (j == 0)
      {
        self.space(7);
      }
      else
      {
        self.space(9);
      }
      print("✰ ✰", terminator: "");
      j += 1;
    }
    print(terminator: "\n");
    i = 0;
    // Intermediate layer of first sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        self.space(5);
        print("✰", terminator: "");
        self.space(5);
        print("✰", terminator: "");
        j += 1;
      }
      print(terminator: "\n");
      i += 1;
    }
    j = 0;
    //Last layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰", terminator: "");
      }
      else
      {
        self.space(9);
        print("✰ ✰", terminator: "");
      }
      j += 1;
    }
    print(terminator: "\n");
    j = 0;
    //Display bottom layer
    //First layer of second sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰", terminator: "");
      }
      else
      {
        self.space(9);
        print("✰ ✰", terminator: "");
      }
      j += 1;
    }
    print(terminator: "\n");
    i = 0;
    // Intermediate layer of second sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        self.space(5);
        print("✰", terminator: "");
        self.space(5);
        print("✰", terminator: "");
        j += 1;
      }
      print(terminator: "\n");
      i += 1;
    }
    j = 0;
    //Last layer of second sine wave
    while (j < width)
    {
      if (j == 0)
      {
        self.space(7);
      }
      else
      {
        self.space(9);
      }
      print("✰ ✰", terminator: "");
      j += 1;
    }
    print("\n");
  }
}
func main()
{
  let task: MyPattern = MyPattern();
  // Test 
  task.showPattern(6, 1);
  task.showPattern(7, 3);
  task.showPattern(3, 4);
}
main();

Output

Height :  6  Width :  1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height :  7  Width :  3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height :  3  Width :  4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
// Kotlin Program
// Program For Sine-Wave Pattern Set-C
class MyPattern
{
  // include space
  fun space(size: Int): Unit
  {
    var i: Int = 0;
    while (i < size)
    {
      print(" ");
      i += 1;
    }
  }
  fun showPattern(height: Int, width: Int): Unit
  {
    if (height <= 2)
    {
      return;
    }
    print("Height : " + height + 
              " Width : " + width + "\n\n");
    var i: Int ;
    var j: Int = 0;
    //First layer of first sine wave
    while (j < width)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      print("✰ ✰");
      j += 1;
    }
    print("\n");
    i = 0;
    // Intermediate layer of first sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        this.space(5);
        print("✰");
        this.space(5);
        print("✰");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    //Last layer of sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰");
      }
      else
      {
        this.space(9);
        print("✰ ✰");
      }
      j += 1;
    }
    print("\n");
    j = 0;
    //Display bottom layer
    //First layer of second sine wave
    while (j <= width)
    {
      if (j == 0)
      {
        print(" ✰ ✰");
      }
      else
      {
        this.space(9);
        print("✰ ✰");
      }
      j += 1;
    }
    print("\n");
    i = 0;
    // Intermediate layer of second sine wave
    while (i < height - 2)
    {
      j = 0;
      while (j < width)
      {
        this.space(5);
        print("✰");
        this.space(5);
        print("✰");
        j += 1;
      }
      print("\n");
      i += 1;
    }
    j = 0;
    //Last layer of second sine wave
    while (j < width)
    {
      if (j == 0)
      {
        this.space(7);
      }
      else
      {
        this.space(9);
      }
      print("✰ ✰");
      j += 1;
    }
    print("\n\n");
  }
}
fun main(args: Array < String > ): Unit
{
  val task: MyPattern = MyPattern();
  // Test 
  task.showPattern(6, 1);
  task.showPattern(7, 3);
  task.showPattern(3, 4);
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
package main
import "fmt"
// Go Program
// Program For Sine-Wave Pattern Set-C
type MyPattern struct {}
func getMyPattern() * MyPattern {
  var me *MyPattern = &MyPattern {}
  return me
}
// include space
func(this MyPattern) space(size int) {
  for i := 0 ; i < size ; i++ {
    fmt.Print(" ")
  }
}
func(this MyPattern) showPattern(height, width int) {
  if height <= 2 {
    return
  }
  fmt.Print("Height : ", height, 
              " Width : ", width, "\n\n")
  var i int = 0
  var j int = 0
  //First layer of first sine wave
  for j = 0 ; j < width ; j++ {
    if j == 0 {
      this.space(7)
    } else {
      this.space(9)
    }
    fmt.Print("✰ ✰")
  }
  fmt.Print("\n")
  // Intermediate layer of first sine wave
  for i = 0 ; i < height - 2 ; i++ {
    for j = 0 ; j < width ; j++ {
      this.space(5)
      fmt.Print("✰")
      this.space(5)
      fmt.Print("✰")
    }
    fmt.Print("\n")
  }
  //Last layer of sine wave
  for j = 0 ; j <= width ; j++ {
    if j == 0 {
      fmt.Print(" ✰ ✰")
    } else {
      this.space(9)
      fmt.Print("✰ ✰")
    }
  }
  fmt.Print("\n")
  //Display bottom layer
  //First layer of second sine wave
  for j = 0 ; j <= width ; j++ {
    if j == 0 {
      fmt.Print(" ✰ ✰")
    } else {
      this.space(9)
      fmt.Print("✰ ✰")
    }
  }
  fmt.Print("\n")
  // Intermediate layer of second sine wave
  for i = 0 ; i < height - 2 ; i++ {
    for j = 0 ; j < width ; j++ {
      this.space(5)
      fmt.Print("✰")
      this.space(5)
      fmt.Print("✰")
    }
    fmt.Print("\n")
  }
  //Last layer of second sine wave
  for j = 0 ; j < width ; j++ {
    if j == 0 {
      this.space(7)
    } else {
      this.space(9)
    }
    fmt.Print("✰ ✰")
  }
  fmt.Print("\n\n")
}
func main() {
  var task * MyPattern = getMyPattern()
  // Test 
  task.showPattern(6, 1)
  task.showPattern(7, 3)
  task.showPattern(3, 4)
}

Output

Height : 6 Width : 1

       ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
 ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
     ✰     ✰
       ✰ ✰

Height : 7 Width : 3

       ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰

Height : 3 Width : 4

       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
 ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
     ✰     ✰     ✰     ✰     ✰     ✰     ✰     ✰
       ✰ ✰         ✰ ✰         ✰ ✰         ✰ ✰
//C Program
//Program For Sine-Wave Pattern Set-C
fn main()
{
  //Test Case
  show_pattern(6, 1);
  show_pattern(7, 3);
  show_pattern(3, 4);
}
fn show_pattern(size: i32, n: i32)
{
  if size <= 2
  {
    return;
  }
  print!("Size : {} N : {}\n\n", size, n);
  let mut i: i32 = 0;
  let mut j: i32 = 0;
  //First layer of first sine wave
  while j < n
  {
    if j == 0
    {
      space(7);
    }
    else
    {
      space(9);
    }
    print!("* *");
    j += 1;
  }
  print!("\n");
  // Intermediate layer of first sine wave
  while i < size - 2
  {
    j = 0;
    while j < n
    {
      space(5);
      print!("*");
      space(5);
      print!("*");
      j += 1;
    }
    print!("\n");
    i += 1;
  }
  j = 0;
  //Last layer of sine wave
  while j <= n
  {
    if j == 0
    {
      print!(" * *");
    }
    else
    {
      space(9);
      print!("* *");
    }
    j += 1;
  }
  print!("\n");
  j = 0;
  //Display bottom layer
  //First layer of second sine wave
  while j <= n
  {
    if j == 0
    {
      print!(" * *");
    }
    else
    {
      space(9);
      print!("* *");
    }
    j += 1;
  }
  print!("\n");
  i = 0;
  // Intermediate layer of second sine wave
  while i < size - 2
  {
    j = 0;
    while j < n
    {
      space(5);
      print!("*");
      space(5);
      print!("*");
      j += 1;
    }
    print!("\n");
    i += 1;
  }
  j = 0;
  //Last layer of second sine wave
  while j < n
  {
    if j == 0
    {
      space(7);
    }
    else
    {
      space(9);
    }
    print!("* *");
    j += 1;
  }
  print!("\n\n");
}
fn space(size: i32)
{
  let mut i: i32 = 0;
  while i < size
  {
    print!(" ");
    i += 1;
  }
}

Output

Size : 6 N : 1

       * *
     *     *
     *     *
     *     *
     *     *
 * *         * *
 * *         * *
     *     *
     *     *
     *     *
     *     *
       * *

Size : 7 N : 3

       * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
 * *         * *         * *         * *
 * *         * *         * *         * *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
     *     *     *     *     *     *
       * *         * *         * *

Size : 3 N : 4

       * *         * *         * *         * *
     *     *     *     *     *     *     *     *
 * *         * *         * *         * *         * *
 * *         * *         * *         * *         * *
     *     *     *     *     *     *     *     *
       * *         * *         * *         * *

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







© 2021, kalkicode.com, All rights reserved