Encuentra la permutación de n que es divisible por 3 pero no divisible por 6

Dado un número entero  . La tarea es encontrar otro entero que sea una permutación de n, divisible por 3 pero no divisible por 6. Dado que n es divisible por 6. Si tal permutación no es posible, imprima -1.

Ejemplos :  

Input: n = 336
Output: 363

Input: n = 48
Output: -1

Para que un número sea divisible por 6, debe ser divisible por 3 así como por 2, lo que significa que todo número par divisible por 3 es divisible por 6. Entonces, un número entero que es divisible por 3 pero no por 6 es un número impar divisible por 3 Entonces ,
si el número entero n contiene algún número entero impar, entonces existe una permutación que es divisible por 3 pero no por 6, de lo contrario, no existe tal permutación.

Algoritmo :

1. let LEN es la longitud de un entero (es decir, ceil(log10(n))).
2. itere sobre LEN y verifique si n es par o impar.
   • si n es impar devuelve n
   • otra cosa a la derecha: gire n una vez. y continuar
3. si LEN está por encima devuelve -1

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

// C++ program to find permutation of n
// which is divisible by 3 but not
// divisible by 6
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the permutation
int findPermutation(int n)
{
    // length of integer
    int len = ceil(log10(n));
 
    for (int i = 0; i < len; i++) {
        // if integer is even
        if (n % 2 != 0) {
            // return odd integer
            return n;
        }
        else {
            // rotate integer
            n = (n / 10) + (n % 10) * pow(10, len - i - 1);
            continue;
        }
    }
 
    // return -1 in case no required
    // permutation exists
    return -1;
}
 
// Driver Code
int main()
{
    int n = 132;
 
    cout << findPermutation(n);
 
    return 0;
}

// Java program to find permutation
// of n which is divisible by 3
// but not divisible by 6
import java.lang.*;
import java.util.*;
 
class GFG
{
// Function to find the permutation
static int findPermutation(int n)
{
    // length of integer
    int len = (int)Math.ceil(Math.log10(n));
 
    for (int i = 0; i < len; i++)
    {
        // if integer is even
        if (n % 2 != 0)
        {
            // return odd integer
            return n;
        }
        else
        {
            // rotate integer
            n = (n / 10) + (n % 10) *
                (int)Math.pow(10, len - i - 1);
            continue;
        }
    }
 
    // return -1 in case no required
    // permutation exists
    return -1;
}
 
// Driver Code
public static void main(String args[])
{
    int n = 132;
 
    System.out.println(findPermutation(n));
}
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)

# Python3 program to find permutation
# of n which is divisible by 3 but
# not divisible by 6
from math import log10, ceil, pow
 
# Function to find the permutation
def findPermutation(n):
     
    # length of integer
    len = ceil(log10(n))
 
    for i in range(0, len, 1):
         
        # if integer is even
        if n % 2 != 0:
             
            # return odd integer
            return n
        else:
             
            # rotate integer
            n = ((n / 10) + (n % 10) *
                  pow(10, len - i - 1))
            continue
         
    # return -1 in case no required
    # permutation exists
    return -1
 
# Driver Code
if __name__ == '__main__':
    n = 132
 
    print(int(findPermutation(n)))
 
# This code is contributed
# by Surendra_Gangwar

// C# program to find permutation
// of n which is divisible by 3
// but not divisible by 6
using System;
 
class GFG
{
// Function to find the permutation
static int findPermutation(int n)
{
    // length of integer
    int len = (int)Math.Ceiling(Math.Log10(n));
 
    for (int i = 0; i < len; i++)
    {
        // if integer is even
        if (n % 2 != 0)
        {
            // return odd integer
            return n;
        }
        else
        {
            // rotate integer
            n = (n / 10) + (n % 10) *
                (int)Math.Pow(10, len - i - 1);
            continue;
        }
    }
 
    // return -1 in case no required
    // permutation exists
    return -1;
}
 
// Driver Code
public static void Main()
{
    int n = 132;
 
    Console.WriteLine(findPermutation(n));
}
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)

<?php
// PHP program to find permutation
// of n which is divisible by 3 but
// not divisible by 6
 
// Function to find the permutation
function findPermutation($n)
{
    // length of integer
    $len = ceil(log10($n));
 
    for ($i = 0; $i < $len; $i++)
    {
        // if integer is even
        if ($n % 2 != 0)
        {
            // return odd integer
            return (int)$n;
        }
        else
        {
            // rotate integer
            $n = ($n / 10) + ($n % 10) *
                  pow(10, $len - $i - 1);
            continue;
        }
    }
 
    // return -1 in case no required
    // permutation exists
    return -1;
}
 
// Driver Code
$n = 132;
 
echo findPermutation($n);
 
// This code is contributed by mits
?>

<script>
// java script  program to find permutation
// of n which is divisible by 3 but
// not divisible by 6
 
// Function to find the permutation
function findPermutation(n)
{
 
    // length of integer
    let len = Math.ceil(Math.log10(n));
 
    for (let i = 0; i < len; i++)
    {
     
        // if integer is even
        if (n % 2 != 0)
        {
         
            // return odd integer
            return parseInt(n);
        }
        else
        {
         
            // rotate integer
            n = (n / 10) + (n % 10) *
                Math.pow(10, len - i - 1);
            continue;
        }
    }
     
    // return -1 in case no required
    // permutation exists
    return -1;
}
 
// Driver Code
let n = 132;
 
document.write( findPermutation(n));
 
// This code is contributed by sravan kumar (vignan)
</script>

213