Programa Javascript para formar bobinas en una array

Dado un entero positivo n que representa las dimensiones de una array de 4n x 4n con valores de 1 a n llenados de izquierda a derecha y de arriba a abajo. Forme dos bobinas a partir de la array e imprima las bobinas.

Ejemplos:  

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 

Los elementos totales en la array son 16n 2 . Todos los elementos se dividen en dos bobinas. Cada bobina tiene 8n 2 elementos. Hacemos dos arreglos de este tamaño. Primero llenamos elementos en la bobina 1 recorriéndolos en el orden dado. Una vez que hemos llenado los elementos en la bobina1, podemos obtener elementos de otra bobina2 usando la fórmula bobina2[i] = 16*n*n + 1 -coil1[i]. 

Javascript

<script>
    // 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);
     
</script>

Producción:  

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

Complejidad de tiempo: O(n 2 ), donde n representa el entero dado.
Espacio auxiliar: O(n 2 ), donde n representa el entero dado.

Consulte el artículo completo sobre bobinas de forma en una array para obtener más detalles.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *