Cifre la array dada en un solo dígito usando el triángulo de Pascal invertido

Dada una array arr[] de longitud N (N > 1) que contiene números enteros positivos, la tarea es cifrar los números de la array en un solo dígito usando el triángulo de Pascal invertido de la siguiente manera.

• Desde el comienzo de la array, encuentre la suma de dos elementos adyacentes.
• Reemplace la suma con solo el dígito en la posición de la unidad de la suma.
• Reemplace todos los elementos de la array con los valores formados de esta manera y continúe hasta que solo queden dos elementos.
• Los dos últimos elementos se concatenan entre sí.

Ejemplos:

Entrada: arr[] = {4, 5, 6, 7}
Salida: 04
Explicación:

Cifrado de Pascal de [4, 5, 6, 7]

Entrada: arr[] = {1, 2, 3}
Salida: 35
Explicación:

Cifrado de Pascal de [1, 2, 3]

Entrada: arr[] = {14, 5}
Salida: 145
Explicación: Como había dos elementos, se agregan juntos

Enfoque: Este problema se puede resolver usando la recursividad basada en la siguiente idea:

Calcule la suma de todo i ^th con (i-1)th elemento y mod por 10 para obtener el dígito menos significativo para la próxima operación hasta que todo el contenedor tenga una longitud de 2 .

Siga los pasos para resolver el problema:

• Utilice una función recursiva y haga lo siguiente:
  • Traverse números para calcular la suma de elementos adyacentes y mod con 10 para obtener el dígito menos significativo como números[i]=(números[i]+números[i+1])%10
  • Elimine el último elemento de la array, ya que se reducirá un elemento después de cada operación.
  • Continúe este procedimiento hasta que solo queden 2 elementos.

A continuación se muestra la implementación del enfoque anterior:

// C++ code for the above approach:
 
#include <bits/stdc++.h>
using namespace std;
 
// Recursive function to find the encryption
string digitEncrypt(vector<int>& numbers)
{
    int N = numbers.size();
    string ans;
 
    // If the value of N is 2
    if (N == 2) {
        if (numbers[0] == 0 && numbers[1] == 0)
            return "00";
        else if (numbers[0] == 0)
            return "0" + to_string(numbers[1]);
        return to_string(numbers[0])
               + to_string(numbers[1]);
    }
 
    for (int i = 0; i < N - 1; i++)
        numbers[i] = (numbers[i]
                      + numbers[i + 1])
                     % 10;
 
    numbers.pop_back();
 
    return digitEncrypt(numbers);
}
 
// Drivers code
int main()
{
    vector<int> numbers = { 4, 5, 6, 7 };
 
    // Function call
    cout << digitEncrypt(numbers);
    return 0;
}

// Java code for the above approach:
import java.io.*;
import java.util.*;
 
class GFG
{
 
  // Recursive function to find the encryption
  public static String
    digitEncrypt(ArrayList<Integer> numbers)
  {
    int N = numbers.size();
 
    // If the value of N is 2
    if (N == 2) {
      if (numbers.get(0) == 0 && numbers.get(1) == 0)
        return "00";
      else if (numbers.get(0) == 0)
        return "0"
        + Integer.toString(numbers.get(1));
      else
        return Integer.toString(numbers.get(0))
        + Integer.toString(numbers.get(1));
    }
 
    for (int i = 0; i < N - 1; i++)
      numbers.set(
      i, ((numbers.get(i) + numbers.get(i + 1))
          % 10));
 
    numbers.remove(numbers.size() - 1);
 
    return digitEncrypt(numbers);
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    ArrayList<Integer> numbers = new ArrayList<Integer>(
      Arrays.asList(4, 5, 6, 7));
 
    // Function call
    System.out.print(digitEncrypt(numbers));
  }
}
 
// This code is contributed by Rohit Pradhan

# python3 code to implement the approach
 
# Recursive function to find the encryption
def digitEncrypt(numbers) :
    N = len(numbers)
     
    # If the value of N is 2
    if N == 2 :
        if numbers[0] == 0 and numbers[1] == 0 :
            return "00"
        elif numbers[0] == 0:
            return "0" + str((numbers[1]))
        return str(numbers[0])+ str(numbers[1])
     
    for i in range(0,N-1) :
        numbers[i] = (numbers[i]+ numbers[i + 1])% 10
  
    numbers.pop()
  
    return digitEncrypt(numbers)
 
# Driver code
if __name__ == "__main__":
 
    numbers = [ 4, 5, 6, 7 ]
 
    # Function call
    print(digitEncrypt(numbers))
 
# This code is contributed by jana_sayantan.

// C# code for the above approach:
 
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Recursive function to find the encryption
    public static string digitEncrypt(List<int> numbers)
    {
        int N = numbers.Count;
 
        // If the value of N is 2
        if (N == 2) {
            if (numbers[0] == 0 && numbers[1] == 0)
                return "00";
            else if (numbers[0] == 0)
                return "0" + Convert.ToString(numbers[1]);
            else
                return Convert.ToString(numbers[0])
                    + Convert.ToString(numbers[1]);
        }
 
        for (int i = 0; i < N - 1; i++)
            numbers[i] = (numbers[i] + numbers[i + 1]) % 10;
 
        numbers.RemoveAt(numbers.Count - 1);
 
        return digitEncrypt(numbers);
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        List<int> numbers
            = new List<int>(new int[] { 4, 5, 6, 7 });
 
        // Function call
        Console.Write(digitEncrypt(numbers));
    }
}
 
// This code is contributed by phasing17

<script>
// JavaScript code for the above approach:
 
// Recursive function to find the encryption
function digitEncrypt(numbers)
{
    var N = numbers.length;
    var ans;
 
    // If the value of N is 2
    if (N == 2) {
        if (numbers[0] == 0 && numbers[1] == 0)
            return "00";
        else if (numbers[0] == 0)
            return "0" + (numbers[1]);
        return to_string(numbers[0])
               + to_string(numbers[1]);
    }
 
    for (var i = 0; i < N - 1; i++)
        numbers[i] = (numbers[i]
                      + numbers[i + 1])
                     % 10;
 
    numbers.pop();
 
    return digitEncrypt(numbers);
}
 
// Drivers code
var numbers = [ 4, 5, 6, 7 ];
 
// Function call
document.write(digitEncrypt(numbers));
 
// This code is contributed by phasing17.
 
</script>

04

Complejidad de Tiempo: O(N ² )
Espacio Auxiliar: O(N)