在矩阵中形成线圈

给定一个正整数 n，它表示一个 4n x 4n 矩阵的维数，其值从 1 到 n 从左到右、从上到下填充。从矩阵中形成两个线圈并打印线圈。

例子：

Input  : n = 1;
Output : Coil 1 : 10 6 2 3 4 8 12 16 
         Coil 2 : 7 11 15 14 13 9 5 1
Explanation : Matrix is 
1  2  3  4 
5  6  7  8 
9  10 11 12 
13 14 15 16

Input  : n = 2;
Output : Coil 1 : 36 28 20 21 22 30 38 46 54 
                  53 52 51 50 42 34 26 18 10 
                  2 3 4 5 6 7 8 16 24 32 40 
                  48 56 64 
        Coil 2 : 29 37 45 44 43 35 27 19 11 12 
                 13 14 15 23 31 39 47 55 63 62 
                 61 60 59 58 57 49 41 33 25 17
                 9 1 

矩阵中的总元素是 16n ² 。所有元件都分为两个线圈。每个线圈有 8n ^{2 个}元素。我们制作了两个这种大小的数组。我们首先通过按给定顺序遍历它们来填充线圈 1 中的元素。一旦我们在线圈 1 中填充了元素，我们就可以使用公式线圈 2[i] = 16*n*n + 1 -coil1[i] 来获取其他线圈 2 的元素。

C++

// C++ program to print 2 coils of a
// 4n x 4n matrix.
#include
using namespace std;
 
// Print coils in a matrix of size 4n x 4n
void printCoils(int n)
{
    // Number of elements in each coil
    int m = 8*n*n;
 
    // Let us fill elements in coil 1.
    int coil1[m];
 
    // First element of coil1
    // 4*n*2*n + 2*n;
    coil1[0] = 8*n*n + 2*n;
    int curr = coil1[0];
 
    int nflg = 1, step = 2;
 
    // Fill remaining m-1 elements in coil1[]
    int index = 1;
    while (index < m)
    {
        // Fill elements of current step from
        // down to up
        for (int i=0; i= m)
                break;
        }
        if (index >= m)
            break;
 
        // Fill elements of current step from
        // up to down.
        for (int i=0; i= m)
                break;
        }
        nflg = nflg*(-1);
        step += 2;
    }
 
    /* get coil2 from coil1 */
    int coil2[m];
    for (int i=0; i<8*n*n; i++)
        coil2[i] = 16*n*n + 1 -coil1[i];
 
    // Print both coils
    cout << "Coil 1 : ";
    for(int i=0; i<8*n*n; i++)
        cout << coil1[i] << " ";
    cout << "\nCoil 2 : ";
    for (int i=0; i<8*n*n; i++)
        cout << coil2[i] << " ";
}
 
// Driver code
int main()
{
    int n = 1;
    printCoils(n);
    return 0;
}

Java

// Java program to print 2 coils
// of a 4n x 4n matrix.
 
class GFG {
     
    // Print coils in a matrix of size 4n x 4n
    static void printCoils(int n)
    {
        // Number of elements in each coil
        int m = 8 * n * n;
     
        // Let us fill elements in coil 1.
        int coil1[] = new int[m];
     
        // First element of coil1
        // 4*n*2*n + 2*n;
        coil1[0] = 8 * n * n + 2 * n;
        int curr = coil1[0];
     
        int nflg = 1, step = 2;
     
        // Fill remaining m-1 elements in coil1[]
        int index = 1;
        while (index < m)
        {
            // Fill elements of current step from
            // down to up
            for (int i = 0; i < step; i++)
                {
                    // Next element from current element
                    curr = coil1[index++] = (curr - 4 * n * nflg);
                    if (index >= m)
                    break;
                }
            if (index >= m)
                break;
         
            // Fill elements of current step from
            // up to down.
            for (int i = 0; i < step; i++)
            {
                curr = coil1[index++] = curr + nflg;
                if (index >= m)
                break;
            }
             
            nflg = nflg * (-1);
            step += 2;
        }
     
        /* get coil2 from coil1 */
        int coil2[] = new int[m];
        for (int i = 0; i < 8 * n * n; i++)
            coil2[i] = 16 * n * n + 1 - coil1[i];
     
        // Print both coils
        System.out.print("Coil 1 : ");
         
        for (int i = 0; i < 8 * n * n; i++)
            System.out.print(coil1[i] + " ");
         
        System.out.print("\nCoil 2 : ");
         
        for (int i = 0; i < 8 * n * n; i++)
            System.out.print(coil2[i] + " ");
    }
     
    // Driver code
    public static void main(String[] args)
    {
        int n = 1;
        printCoils(n);
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python3 program to print 2 coils of a
# 4n x 4n matrix.
 
# Print coils in a matrix of size 4n x 4n
def printCoils(n):
     
    # Number of elements in each coil
    m = 8*n*n
     
    # Let us fill elements in coil 1.
    coil1 = [0]*m
     
    # First element of coil1
    # 4*n*2*n + 2*n
    coil1[0] = 8*n*n + 2*n
     
    curr = coil1[0]
     
    nflg = 1
    step = 2
     
    # Fill remaining m-1 elements in coil1[]
    index = 1
    while (index < m):
         
        # Fill elements of current step from
        # down to up
        for i in range(step):
             
            # Next element from current element
            curr = coil1[index] = (curr - 4*n*nflg)
            index += 1
            if (index >= m):
                break
        if (index >= m):
            break
         
        # Fill elements of current step from
        # up to down.
        for i in range(step):
             
            curr = coil1[index] = curr + nflg
            index += 1
            if (index >= m):
                break
        nflg = nflg*(-1)
        step += 2
     
    #get coil2 from coil1 */
     
    coil2 = [0]*m
    i = 0
    while(i < 8*n*n):
        coil2[i] = 16*n*n + 1 -coil1[i]
        i += 1
    # Print both coils
    print("Coil 1 :", end = " ")
    i = 0
    while(i < 8*n*n):
        print(coil1[i], end = " ")
        i += 1
    print("\nCoil 2 :", end = " ")
    i = 0
    while(i < 8*n*n):
        print(coil2[i], end = " ")
        i += 1
 
# Driver code
 
n = 1
printCoils(n)
 
# This code is contributed by shubhamsingh10

C#

// C# program to print 2 coils
// of a 4n x 4n matrix.
using System;
 
class GFG {
     
    // Print coils in a matrix of
    // size 4n x 4n
    static void printCoils(int n)
    {
         
        // Number of elements in
        // each coil
        int m = 8 * n * n;
     
        // Let us fill elements in
        // coil 1.
        int [] coil1 = new int[m];
     
        // First element of coil1
        // 4*n*2*n + 2*n;
        coil1[0] = 8 * n * n + 2 * n;
        int curr = coil1[0];
     
        int nflg = 1, step = 2;
     
        // Fill remaining m-1 elements
        // in coil1[]
        int index = 1;
        while (index < m)
        {
             
            // Fill elements of current
            // step from down to up
            for (int i = 0; i < step; i++)
                {
                    // Next element from
                    // current element
                    curr = coil1[index++]
                    = (curr - 4 * n * nflg);
                     
                    if (index >= m)
                        break;
                }
                 
            if (index >= m)
                break;
         
            // Fill elements of current step
            // from up to down.
            for (int i = 0; i < step; i++)
            {
                curr = coil1[index++] = curr
                                     + nflg;
                if (index >= m)
                    break;
            }
             
            nflg = nflg * (-1);
            step += 2;
        }
     
        /* get coil2 from coil1 */
        int [] coil2 = new int[m];
         
        for (int i = 0; i < 8 * n * n; i++)
            coil2[i] = 16 * n * n + 1 - coil1[i];
     
        // Print both coils
        Console.Write("Coil 1 : ");
         
        for (int i = 0; i < 8 * n * n; i++)
            Console.Write(coil1[i] + " ");
         
        Console.Write("\nCoil 2 : ");
         
        for (int i = 0; i < 8 * n * n; i++)
            Console.Write(coil2[i] + " ");
    }
     
    // Driver code
    public static void Main()
    {
        int n = 1;
         
        printCoils(n);
    }
}
 
// This code is contributed by KRV.

PHP

= $m)
                break;
        }
        if ($index >= $m)
            break;
 
        // Fill elements of current step from
        // up to down.
        for ( $i=0; $i<$step; $i++)
        {
            $curr = $coil1[$index++] =
                            $curr + $nflg;
            if ($index >= $m)
                break;
        }
        $nflg = $nflg * (-1);
        $step += 2;
    }
 
    /* get coil2 from coil1 */
    $coil2 = array();
     
    for ( $i = 0; $i < 8 * $n * $n; $i++)
        $coil2[$i] = 16 * $n * $n + 1 -$coil1[$i];
 
    // Print both coils
    echo "Coil 1 : ";
    for( $i = 0; $i < 8 * $n * $n; $i++)
    echo $coil1[$i] , " ";
     
    echo "\nCoil 2 : ";
    for ( $i = 0; $i < 8 * $n * $n; $i++)
        echo $coil2[$i] , " ";
}
 
// Driver code
$n = 1;
printCoils($n);
 
// This code is contributed by anuj_67.
?>

Javascript

    // Javascript program to print 2 coils
    // of a 4n x 4n matrix.
     
    // Print coils in a matrix of
    // size 4n x 4n
    function printCoils(n)
    {
           
        // Number of elements in
        // each coil
        let m = 8 * n * n;
       
        // Let us fill elements in
        // coil 1.
        let coil1 = new Array(m);
        coil1.fill(0);
       
        // First element of coil1
        // 4*n*2*n + 2*n;
        coil1[0] = 8 * n * n + 2 * n;
        let curr = coil1[0];
       
        let nflg = 1, step = 2;
       
        // Fill remaining m-1 elements
        // in coil1[]
        let index = 1;
        while (index < m)
        {
               
            // Fill elements of current
            // step from down to up
            for (let i = 0; i < step; i++)
                {
                    // Next element from
                    // current element
                    curr = coil1[index++]
                    = (curr - 4 * n * nflg);
                       
                    if (index >= m)
                        break;
                }
                   
            if (index >= m)
                break;
           
            // Fill elements of current step
            // from up to down.
            for (let i = 0; i < step; i++)
            {
                curr = coil1[index++] = curr
                                     + nflg;
                if (index >= m)
                    break;
            }
               
            nflg = nflg * (-1);
            step += 2;
        }
       
        /* get coil2 from coil1 */
        let coil2 = new Array(m);
        coil2.fill(0);
           
        for (let i = 0; i < 8 * n * n; i++)
            coil2[i] = 16 * n * n + 1 - coil1[i];
       
        // Print both coils
        document.write("Coil 1 : ");
           
        for (let i = 0; i < 8 * n * n; i++)
            document.write(coil1[i] + " ");
           
        document.write("</br>" + "Coil 2 : ");
           
        for (let i = 0; i < 8 * n * n; i++)
            document.write(coil2[i] + " ");
    }
     
    let n = 1;
           
      printCoils(n);
     

输出：

Coil 1 : 10 6 2 3 4 8 12 16 
Coil 2 : 7 11 15 14 13 9 5 1