Encuentra el número de pares mágicos de hilo de longitud L

Un par de strings s y r se llaman mágicas si para cada índice i el carácter de s es menor que r , es decir , s[i] < r[i] . La tarea es contar el número de pares de strings posibles de longitud L. Dado que este valor puede ser grande, dé la respuesta módulo 10 ⁹ .

Nota : La string contiene solo alfabetos ingleses en minúsculas.

Ejemplos: 

Entrada: L = 1 
Salida: 325 
Dado que la longitud de las strings requeridas es 1. 
Si s = “a”, entonces r puede ser cualquiera de “b”, “c”, “d”, … “z” (25 Posibilidades ) 
Si s = “b”, entonces r puede ser cualquiera de “c”, “d”, “e”, … “z” (24 Posibilidades) 
…. 
Si s = «y», entonces r solo puede ser «z» (1 Posibilidades) 
s no puede ser «z» ya que es el carácter máximo en minúsculas. 
Por lo tanto, las posibilidades totales son 1 + 2 + 3 + … + 25 = 325

Entrada: L = 2 
Salida: 105625 

Enfoque: Para L = 1 , las posibilidades totales son 325 . Para L = 2 , las posibilidades totales son 325 ² . Las posibilidades totales para cualquier valor de L serán 325 ^L. Dado que este valor puede ser grande, imprima la respuesta módulo 10 ⁹ .

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

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Iterative Function to calculate (x^y)%p in O(log y)
int power(int x, unsigned int y, int p)
{
 
    // Initialize result
    int res = 1;
 
    // Update x if it is >= p
    x = x % p;
 
    while (y > 0) {
 
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res * x) % p;
 
        // Y must be even now
        y = y >> 1; // y = y/2
        x = (x * x) % p;
    }
    return res;
}
 
// Driver Code
int main()
{
 
    int L = 2, P = pow(10, 9);
 
    int ans = power(325, L, P);
 
    cout << ans << "\n";
 
    return 0;
}

// Java implementation of the approach
 
class GFG
{
 
    // Iterative Function to calculate (x^y)%p in O(log y)
    static int power(int x, int y, int p)
    {
 
        // Initialize result
        int res = 1;
 
        // Update x if it is >= p
        x = x % p;
 
        while (y > 0)
        {
 
            // If y is odd, multiply x with result
            if (y % 2 == 1)
            {
                res = (res * x) % p;
            }
 
            // Y must be even now
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }
        return res;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int L = 2;
        int P = (int) Math.pow(10, 9);
 
        int ans = power(325, L, P);
        System.out.println(ans);
    }
}
 
// This code has been contributed by 29AjayKumar

     
# Python implementation of the approach
  
# Iterative Function to calculate (x^y)%p in O(log y)
def power(x, y, p):
  
    # Initialize result
    res = 1;
  
    # Update x if it is >= p
    x = x % p;
  
    while (y > 0):
  
        # If y is odd, multiply x with result
        if (y %2== 1):
            res = (res * x) % p;
  
        # Y must be even now
        y = y >> 1; # y = y/2
        x = (x * x) % p;
    return res;
  
# Driver Code
L = 2; P = pow(10, 9);
ans = power(325, L, P);
print(ans);
 
 
#  This code contributed by Rajput-Ji

// C# implementation of the approach
using System;
 
class GFG
{
 
    // Iterative Function to calculate (x^y)%p in O(log y)
    static int power(int x, int y, int p)
    {
 
        // Initialize result
        int res = 1;
 
        // Update x if it is >= p
        x = x % p;
 
        while (y > 0)
        {
 
            // If y is odd, multiply x with result
            if (y % 2 == 1)
            {
                res = (res * x) % p;
            }
 
            // Y must be even now
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }
        return res;
    }
 
    // Driver Code
    public static void Main()
    {
        int L = 2;
        int P = (int) Math.Pow(10, 9);
 
        int ans = power(325, L, P);
        Console.WriteLine(ans);
    }
}
 
// This code is contributed by AnkitRai01

<?php
// PHP implementation of the approach
 
// Iterative Function to calculate (x^y)%p in O(log y)
function power($x, $y, $p)
{
 
    // Initialize result
    $res = 1;
 
    // Update x if it is >= p
    $x = $x % $p;
 
    while ($y > 0)
    {
 
        // If y is odd, multiply x with result
        if ($y & 1)
            $res = ($res * $x) % $p;
 
        // Y must be even now
        $y = $y >> 1; // y = y/2
        $x = ($x * $x) % $p;
    }
    return $res;
}
 
// Driver Code
 
$L = 2;
$P = pow(10, 9);
 
$ans = power(325, $L, $P);
 
echo $ans , "\n";
 
// This code is contributed by ajit.
?>

<script>
    // Javascript implementation of the approach
     
    // Iterative Function to calculate (x^y)%p in O(log y)
    function power(x, y, p)
    {
   
        // Initialize result
        let res = 1;
   
        // Update x if it is >= p
        x = x % p;
   
        while (y > 0)
        {
   
            // If y is odd, multiply x with result
            if (y % 2 == 1)
            {
                res = (res * x) % p;
            }
   
            // Y must be even now
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }
        return res;
    }
     
    let L = 2;
    let P = Math.pow(10, 9);
 
    let ans = power(325, L, P);
    document.write(ans);
     
</script>

105625

Espacio Auxiliar: O(1)