Untitled

package org.example;


class racional
{
    private int a;
    private int b;
    
   protected racional()
   {
       this.a = 1;
       this.b = 1;
   }
  protected racional(int coc1, int coc2)
   {
       this.a = coc1;
       this.b = coc2;
   }
   protected racional(racional X)
   {
       this.a = X.a;
       this.b = X.b;
   }
   
   void setA(int a)
   {
       try{
           if (a<=0 ) 
               throw new Exception();
           
                  this.a = a;

           
          }
           catch(Exception e){System.out.println("Error general");}
   }
   
   protected boolean equivalencia (racional uno, racional dos)
   {
       if ((uno.a * dos.b) == (uno.b * dos.a)) 
           return true;
       else
           return false;
       
           
       
   }
   protected static int calcularMCD(int a, int b) {
    if (b == 0) {
        return a;
    }
    return calcularMCD(b, a % b);
}

   
       protected static racional simplificado ( racional r1 )
   {
      int a= r1.a / calcularMCD(r1.a, r1.b);
      int b = r1.b /  calcularMCD(r1.a, r1.b);
      
      r1.a = a;
      r1.b = b;
      return r1;
   }
   
   protected racional suma ( racional r1, racional r2)
   {
       racional r3 = new racional();
       r3.a = (r1.a*r2.b) + (r1.b*r2.a);
       r3.b = (r1.b* r2.b);
       return r3;
   }
   
   
      protected racional division ( racional r1, racional r2)
   {
       racional r3 = new racional();
       r3.a = r1.a*r2.b;
       r3.b = (r1.b* r2.a);
       return r3;
   }
      
      
   protected void verdatos()
   {
       System.out.println("LA PARTE SUPERIOR ES " + this.a );
       System.out.println("_________________");
       System.out.println("LA PARTE INFERIOR ES " + this.b);
   }
   
}



public class EXAMEN extends racional
{

    /**
     *
     * @param r1
     * @return
     */

        /*
     Habrá que crear un programa que contenga un método estático validarNSS que validará un
número de la seguridad social. Se le pasará como parámetro (numeroSS) un String y devolverá
un booleano indicando si el código es correcto según el formato correspondiente.
El número de afiliación a la seguridad social consta de cuatro partes:
XX-aa-bbbbbbbb-cc
Los 2 primeros caracteres (XX) son letras cualesquiera del alfabeto.
Los 2 primeros dígitos (a) son un indicaivo de la provincia
Los 8dígitos centrales (b) son el nº del asegurado dentro de cada provincia.
Los 2 dígitos finales (c) son dígitos de control.
Cabe la posibilidad de que el número de la seguridad social se escriba sin guiones.
Examen 1 (Segunda Evaluación) 2
Los dígitos de control (c) se obtienen a partir de las otras dos partes (a) y (b) de la siguiente
forma:
si (b<10000000) entonces d= b + a * 10000000
si no d= valor numérico de (a concatenado con b) // con b sin ceros a la izquierda
c = d % 97 //resto de la división entera
     */
        
        
        
        
    // expresión regular para validar el formato del NSS
public static boolean validarNumeroSeguridadSocial(String ssn) {
  // Verifica si la cadena es nula o no tiene la longitud adecuada
  if (ssn == null || (ssn.length() != 15 && ssn.length() != 11)) {
    return false;
  }
  // Elimina todos los caracteres que no son letras o números
  String cleanedSSN = ssn.replaceAll("[^A-Za-z0-9]", "");
  // Si la cadena limpia no tiene la longitud adecuada, es inválida
  if (cleanedSSN.length() != 15) {
    return false;
  }
  // Extrae las diferentes partes del número de seguridad social
  String aString = cleanedSSN.substring(2, 4); // Los dos primeros dígitos después de las letras iniciales son el indicativo de la provincia
  String bString = cleanedSSN.substring(4, 12); // Los siguientes ocho dígitos son el número del asegurado
  String cString = cleanedSSN.substring(12, 14); // Los dos últimos dígitos son los dígitos de control
  // Verifica que las letras iniciales sean realmente letras, y que las partes numéricas sean en realidad números
 
  // Convierte las partes numéricas en valores enteros
  int a = Integer.parseInt(aString);
  long b = Long.parseLong(bString);
  int c = Integer.parseInt(cString);
  long d;
  // Calcula el número de control (d) de acuerdo con las especificaciones
  if (b < 10000000) {
    d = b + a * 10000000L;
  } else {
    d = Long.parseLong(aString + b);
  }
  // Verifica si el número de control coincide con los dos últimos dígitos del número de seguridad social
  return d % 97 == c;
}
//
public static boolean isValidNSS(String nss) {
    String regEx = "^[A-Z]{2}-[0-9]{2}-[0-9]{8}-[0-9]{2}$";

    //nss = "XX-45-09000000-56"; XX-aa-bbbbbbbb-cc
    //12345723

    if (nss.matches(regEx)) {
        nss = nss.replaceAll("-", "");
        String num1 = nss.substring(0, 2);
        String num2 = nss.substring(2, 4);
        String num3 = nss.substring(4, 12);
        String num4 = nss.substring(12, 14);
        long num4Calc;

        if (Integer.parseInt(num3) < 10000000) {
            num4Calc = Long.parseLong(num3) + Long.parseLong(num2) * 10000000;
        } else {
            System.out.println(num2);
            System.out.println(num3);
            num4Calc = Long.parseLong(num2) + Long.parseLong(num3);
            System.out.println(num4Calc);
        }
        //String strnum4 = String.valueOf(num4 % 97);
        long validacion = num4Calc % 97;
        System.out.print(validacion);
        System.out.println(num4);
        String strnum4 = String.valueOf(validacion);
        //String codigo = num1 + num2 + num3 + strnum4;

        return strnum4.equals(num4);
    }

    return false;
}





      public static boolean esPalindromo(String texto) {
    String textoInvertido = "";
    for (int i = texto.length() - 1; i >= 0; i--) {
        textoInvertido += texto.charAt(i);
    }
    return texto.equalsIgnoreCase(textoInvertido);
      }
      
      
     public static void Calculos_String (String cadena)
  {
      /*
      Calcular un nuevo String que contendrá la cadena de entrada invertida.
        Por ejemplo: Hola → aloH

      */
      String invertida = "";
      int possubcadena = 0;
      String palindromo ="";
      
      
      for (int i = cadena.length()-1; i >= 0; i--) 
      {
       invertida += cadena.charAt(i);
      }
      
      /*
      Calcular las posiciones en las cuales aparecerá una subcadena, leída por teclado en el
método:
Por ejemplo, la subcadena “la” dentro de la cadena
La casa de tía lola → 0,15
      */
      System.out.println("El STRING invertido es " + invertida);
      
      possubcadena += cadena.indexOf("la");
      
      System.out.println("Las posiciones de la subcadena la son : " + possubcadena);
  
      /*
      Si el texto que contien el string es un palíndromo, es decir, e se lee igual de izquierda a
derecha y de derecha a izquierda.
Por ejemplo:
“A cavar a Caravaca” o “1221” serían palíndromos.
      */
      palindromo = cadena.replaceAll(" ", "");
      if ( !palindromo.equalsIgnoreCase(invertida.replaceAll(" ", ""))) {
          System.out.println("No es palindromo");
      }else
          System.out.println("Es palindromo " + cadena + invertida );


  }
     
     

     
     
     
    public static void main(String[] args) {
    
//        racional uno = new racional(24,108);
//        racional dos = new racional(4,10);

        System.out.println(EXAMEN.isValidNSS("XX-45-09000000-74"));
//       Calculos_String("La casa de tía lola ");
    }
}