API tools faq
paste
Advertisement
Guest User

Ihatemyprofessor

a guest
Oct 19th, 2014
249
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 13.02 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. this program requires either zero or one command line argument
  3. java filename OUTPUT: program generates a password
  4. java filename [string] OUTPUT: program evaluates whether [string] is a valid password
  5. java filename [string] [string] ... OUTPUT: program shows user manual page to aid in program usage
  6. */
  7.  
  8. public class AllAboutPasswords{
  9. import java.util.scanner;
  10. import static java.lang.System.*;
  11. /*********** NOTE ***********/
  12. /* YOU DO NOT NEED TO EDIT THE MAIN METHOD */
  13.  public static void main( String[] args )
  14.  {
  15.        
  16.         if (args.length == 0) // Generate password
  17.         {
  18.                    
  19.         System.out.println("Your new password is: " + generateValidPassword());
  20.  
  21.         }
  22.         else if (args.length == 1) // Test password
  23.         {          
  24.             System.out.print("The password you entered, " + args[0]);
  25.            
  26.             if (isValidPassword(args[0]))
  27.             {
  28.                 System.out.println(" is a valid password");
  29.             }
  30.             else
  31.             {
  32.                 System.out.println(" is NOT a valid password");
  33.             }    
  34.         }
  35.         else // To many command line arguments, educate user
  36.         {
  37.        
  38.             System.out.println();
  39.             System.out.println("This program takes either zero or one parameter.");
  40.             System.out.println("When run with zero parameters it will generate a password.");
  41.             System.out.print("When run with one parameter it will test whether");
  42.             System.out.println(" the parameter is a valid password.");
  43.             System.out.println();
  44.             System.out.println("A valid password has the following four properties:");
  45.             System.out.println("1. A valid password contains between 8 and 14 characters, inclusive.");
  46.             System.out.println("2. A valid password contains two or more uppercase letters [A-Z].");
  47.             System.out.println("3. A valid password contains two or more lowercase letters [a-z]");
  48.             System.out.println("4. A valid password contains two or more numbers [0-9]");
  49.             System.out.println();
  50.             System.out.println();
  51.         }
  52.    }
  53.  
  54.  // Evaluate a password input as a string
  55.  static private boolean isValidPassword(String testPassword)
  56.  {
  57.     boolean returnValue = false;
  58.      
  59.     if (testPassword.length() > 8 && testPassword.length() < 14)
  60.     {
  61.         boolean t1 = false, t2 = false, t3 = false, t4 = false, t5 = false, t6 = false;
  62.         while (t1 = false && t2 = false && t3 = false && t4 = false && t5 = false && t6 = false)
  63.         {
  64.             boolean flip = true;
  65.             while(flip)
  66.             {
  67.                 n = charAt(testPassword.length() - 1);
  68.                 flip = false;
  69.             }
  70.             while (n > -1)
  71.             {
  72.                 int times = 0;
  73.                 if (CharacterIsNumber(testPassword.charAt(n)))
  74.                 {
  75.                     times += 1;
  76.                     n -= 1;
  77.                 }
  78.                
  79.                 else if (CharacterIsCapitalLetter(testPassword.charAt(n)))
  80.                 {
  81.                     times += 1;
  82.                     n -= 1;
  83.                 }
  84.                
  85.                 else if (CharacterIsLowercaseLetter(testPassword.charAt(n)
  86.                 {
  87.                     times += 1;
  88.                     n -= 1;
  89.                 }
  90.                
  91.             }
  92.            
  93.             if (times >= 6)
  94.             {
  95.                 t1 = true;
  96.                 t2 = true;
  97.                 t3 = true;
  98.                 t4 = true;
  99.                 t5 = true;
  100.                 t6 = true;
  101.             }
  102.            
  103.             else
  104.             {
  105.                 out.println("Test 1: " + t1);
  106.                 out.println("Test 2: " + t2);
  107.                 out.println("Test 3: " + t3);
  108.                 out.println("Test 4: " + t4);
  109.                 out.println("Test 5: " + t5);
  110.                 out.println("Test 6: " + t6);
  111.                 break;
  112.             }
  113.            
  114.             returnValue = true;
  115.         }
  116.     }
  117.    
  118.     else
  119.     {
  120.     }
  121.      // Write your code here, use Helper Methods, SEE EXAMPLES BELOW.
  122.      // HINT 1: you get CharacterIsNumber(char testChar) as an example.
  123.      //you will need to write CharacterIsCapitalLetter() and CharacterIsLowercaseLetter()
  124.      
  125.      /*
  126.      //Hint 2: Test Code for CharacterIsNumber method
  127.      System.out.println();
  128.      int testPasswordCounter = 0;
  129.      while(testPasswordCounter < testPassword.length())
  130.      {
  131.         System.out.print(testPassword.charAt(testPasswordCounter)+" is a number? ");
  132.         System.out.println(CharacterIsNumber(testPassword.charAt(testPasswordCounter)));
  133.         testPasswordCounter++;
  134.      }
  135.      */
  136.      
  137.      return returnValue;
  138.  }  
  139.  
  140.  // Generate a password and return it as a string
  141.  static private String generateValidPassword()
  142.  {
  143.     String returnString = "";
  144.    
  145.     // Write your code here, use Helper Methods, SEE EXAMPLES BELOW.
  146.     // HINT 3: you get GenerateNumber() as an example.
  147.     //you will need to write GenerateCapitalLetter() and GenerateLowercaseLetter()
  148.    
  149.         int a, b;
  150.         a = GenerateNumber();
  151.         b = GenerateNumber();
  152.        
  153.         char c, d, e, f;
  154.         c = GenerateCaptialLetter();
  155.         d = GenerateCapitalLetter();
  156.         e = GenerateLowercaseLetter();
  157.         f = GenerateLowercaseLetter();
  158.         g = GenerateNumber();
  159.         h = GenerateNumber();
  160.        
  161.         returnString = a + b + c + d + e + f + g + h;
  162.        
  163. /*  //Hint 4: Test Code for GenerateNumber() method
  164.     int i = 0;
  165.     while(i < 100)
  166.     {
  167.        System.out.println(GenerateNumber());
  168.        i++;
  169.     }
  170. */
  171.     return returnString;
  172.  }  
  173.  
  174.  //Returns an Integer between Min and Max, inclusive.
  175.  static private int randInt(int Min, int Max)
  176.  {
  177.     int randomNum;
  178.    
  179.     randomNum = Min + (int)(Math.random() * ((Max - Min) + 1));
  180.  
  181.     return randomNum;
  182.  }
  183.  
  184.  
  185.  
  186.  // Returns a random number between 0 and 9 as a char
  187.  static private char GenerateNumber()
  188.  {
  189.      char returnChar = ' ';
  190.      switch (randInt(0, 9))
  191.      {
  192.         case 0:
  193.              returnChar = '0';
  194.             break;    
  195.         case 1:
  196.             returnChar = '1';
  197.             break;
  198.         case 2:
  199.             returnChar = '2';
  200.             break;
  201.         case 3:
  202.             returnChar = '3';
  203.             break;
  204.         case 4:
  205.             returnChar = '4';
  206.             break;
  207.         case 5:
  208.             returnChar = '5';
  209.             break;            
  210.         case 6:
  211.             returnChar = '6';
  212.             break;
  213.         case 7:
  214.             returnChar = '7';
  215.             break;
  216.         case 8:
  217.             returnChar = '8';
  218.             break;
  219.         case 9:
  220.             returnChar = '9';
  221.             break;
  222.         default:
  223.             System.out.println("Error Random int outside expected values");          
  224.      }
  225.      return returnChar;
  226.  }  
  227.  
  228.  
  229.  
  230.  // Tests to see if an input char is a Number
  231.  static private boolean CharacterIsNumber(char testChar)
  232.  {
  233.      boolean returnValue = false;
  234.      switch (testChar)
  235.      {
  236.         case '0':
  237.             returnValue = true;
  238.             break;
  239.         case '1':
  240.             returnValue = true;
  241.             break;
  242.         case '2':
  243.             returnValue = true;
  244.             break;
  245.         case '3':
  246.             returnValue = true;
  247.             break;
  248.         case '4':
  249.             returnValue = true;
  250.             break;
  251.         case '5':
  252.             returnValue = true;
  253.             break;            
  254.         case '6':
  255.             returnValue = true;
  256.             break;
  257.         case '7':
  258.             returnValue = true;
  259.             break;
  260.         case '8':
  261.             returnValue = true;
  262.             break;
  263.         case '9':
  264.             returnValue = true;
  265.             break;          
  266.      }
  267.      return returnValue;
  268.  }
  269.  
  270.  
  271.  
  272.  
  273.  // Returns a random Capital letter as a char
  274.  static private char GenerateCapitalLetter()
  275.  {
  276.    
  277.     switch(randInt(1, 26))
  278.     case 1:
  279.         char returnChar = 'A';
  280.     case 2:
  281.         char returnChar = 'B';
  282.     case 3:
  283.         char returnChar = 'C';
  284.     case 4:
  285.         char returnChar = 'D';
  286.     case 5:
  287.         char returnChar = 'E';
  288.     case 6:
  289.         char returnChar = 'F';
  290.     case 7:
  291.         char returnChar = 'G';
  292.     case 8:
  293.         char returnChar = 'H';
  294.     case 9:
  295.         char returnChar = 'I';
  296.     case 10:
  297.         char returnChar = 'J';
  298.     case 11:
  299.         char returnChar = 'K';
  300.     case 12:
  301.         char returnChar = 'L';
  302.     case 13:
  303.         char returnChar = 'M';
  304.     case 14:
  305.         char returnChar = 'N';
  306.     case 15:
  307.         char returnChar = 'O';
  308.     case 16:
  309.         char returnChar = 'P';
  310.     case 17:
  311.         char returnChar = 'Q';
  312.     case 18:
  313.         char returnChar = 'R';
  314.     case 19:
  315.         char returnChar = 'S';
  316.     case 20:
  317.         char returnChar = 'T';
  318.     case 21:
  319.         char returnChar = 'U';
  320.     case 22:
  321.         char returnChar = 'V';
  322.     case 23:
  323.         char returnChar = 'W';
  324.     case 24:
  325.         char returnChar = 'X';
  326.     case 25:
  327.         char returnChar = 'Y';
  328.     case 26:
  329.         char returnChar = 'Z';
  330.    
  331.     // Write your code here
  332.     // HINT: look at the GenerateNumber() method
  333.     // HINT: think of how to modify GenerateNumber() to generate a Capital letter
  334.      
  335.        
  336.     return returnChar;
  337.  }
  338.  
  339.  
  340.  // Returns a random Lowercase letter as a char
  341. static private char GenerateLowercaseLetter()
  342. {    
  343.     switch(randInt(1, 26))
  344.     case 1:
  345.         char returnChar = 'a';
  346.     case 2:
  347.         char returnChar = 'b';
  348.     case 3:
  349.         char returnChar = 'c';
  350.     case 4:
  351.         char returnChar = 'd';
  352.     case 5:
  353.         char returnChar = 'e';
  354.     case 6:
  355.         char returnChar = 'f';
  356.     case 7:
  357.         char returnChar = 'g';
  358.     case 8:
  359.         char returnChar = 'h';
  360.     case 9:
  361.         char returnChar = 'i';
  362.     case 10:
  363.         char returnChar = 'j';
  364.     case 11:
  365.         char returnChar = 'k';
  366.     case 12:
  367.         char returnChar = 'l';
  368.     case 13:
  369.         char returnChar = 'm';
  370.     case 14:
  371.         char returnChar = 'n';
  372.     case 15:
  373.         char returnChar = 'o';
  374.     case 16:
  375.         char returnChar = 'p';
  376.     case 17:
  377.         char returnChar = 'q';
  378.     case 18:
  379.         char returnChar = 'r';
  380.     case 19:
  381.         char returnChar = 's';
  382.     case 20:
  383.         char returnChar = 't';
  384.     case 21:
  385.         char returnChar = 'u';
  386.     case 22:
  387.         char returnChar = 'v';
  388.     case 23:
  389.         char returnChar = 'w';
  390.     case 24:
  391.         char returnChar = 'x';
  392.     case 25:
  393.         char returnChar = 'y';
  394.     case 26:
  395.         char returnChar = 'z';
  396.        
  397.     // Write your code here
  398.     // HINT: look at the GenerateNumber() method
  399.     // HINT: think of how to modify GenerateNumber() to generate a lowercase letter
  400.        
  401.     return returnChar;
  402. }
  403.  
  404.  
  405.  // Tests to see if an input char is a Capital letter
  406.  static private boolean CharacterIsCapitalLetter(char testChar)
  407.  {
  408.      boolean returnValue = false;
  409.    
  410.         switch(char testChar)
  411.         {
  412.         case 'A':
  413.             returnValue = true;
  414.             break;
  415.         case 'B':
  416.             returnValue = true;
  417.             break;
  418.         case 'C':
  419.             returnValue = true;
  420.             break;
  421.         case 'D':
  422.             returnValue = true;
  423.             break;
  424.         case 'E':
  425.             returnValue = true;
  426.             break;
  427.         case 'F':
  428.             returnValue = true;
  429.             break;
  430.         case 'G':
  431.             returnValue = true;
  432.             break;
  433.         case 'H':
  434.             returnValue = true;
  435.             break;
  436.         case 'I':
  437.             returnValue = true;
  438.             break;
  439.         case 'J':
  440.             returnValue = true;
  441.             break;
  442.         case 'K':
  443.             returnValue = true;
  444.             break;
  445.         case 'L':
  446.             returnValue = true;
  447.             break;
  448.         case 'M':
  449.             returnValue = true;
  450.             break;
  451.         case 'N':
  452.             returnValue = true;
  453.             break;
  454.         case 'O':
  455.             returnValue = true;
  456.             break;
  457.         case 'P':
  458.             returnValue = true;
  459.             break;
  460.         case 'Q':
  461.             returnValue = true;
  462.             break;
  463.         case 'R':
  464.             returnValue = true;
  465.             break;
  466.         case 'S':
  467.             returnValue = true;
  468.             break;
  469.         case 'T':
  470.             returnValue = true;
  471.             break;
  472.         case 'U':
  473.             returnValue = true;
  474.             break;
  475.         case 'V':
  476.             returnValue = true;
  477.             break;
  478.         case 'W':
  479.             returnValue = true;
  480.             break;
  481.         case 'X':
  482.             returnValue = true;
  483.             break;
  484.         case 'Y':
  485.             returnValue = true;
  486.             break;
  487.         case 'Z':
  488.             returnValue = true;
  489.             break;
  490.         }
  491.  
  492.     // Write your code here
  493.     // HINT: look at the CharacterIsNumber(char testChar)  method
  494.     // HINT: think of how to modify CharacterIsNumber(char testChar) to detect capital letters
  495.    
  496.      return returnValue;
  497.  }
  498.  
  499.  
  500.  // Tests to see if an input char is a lowercase letter
  501.  static private boolean CharacterIsLowercaseLetter(char testChar)
  502.  {
  503.      boolean returnValue = false;
  504.      
  505.      switch(char testChar)
  506.         {
  507.         case 'a':
  508.             returnValue = true;
  509.             break;
  510.         case 'b':
  511.             returnValue = true;
  512.             break;
  513.         case 'c':
  514.             returnValue = true;
  515.             break;
  516.         case 'd':
  517.             returnValue = true;
  518.             break;
  519.         case 'e':
  520.             returnValue = true;
  521.             break;
  522.         case 'f':
  523.             returnValue = true;
  524.             break;
  525.         case 'g':
  526.             returnValue = true;
  527.             break;
  528.         case 'h':
  529.             returnValue = true;
  530.             break;
  531.         case 'i':
  532.             returnValue = true;
  533.             break;
  534.         case 'j':
  535.             returnValue = true;
  536.             break;
  537.         case 'k':
  538.             returnValue = true;
  539.             break;
  540.         case 'l':
  541.             returnValue = true;
  542.             break;
  543.         case 'm':
  544.             returnValue = true;
  545.             break;
  546.         case 'n':
  547.             returnValue = true;
  548.             break;
  549.         case 'o':
  550.             returnValue = true;
  551.             break;
  552.         case 'p':
  553.             returnValue = true;
  554.             break;
  555.         case 'q':
  556.             returnValue = true;
  557.             break;
  558.         case 'r':
  559.             returnValue = true;
  560.             break;
  561.         case 's':
  562.             returnValue = true;
  563.             break;
  564.         case 't':
  565.             returnValue = true;
  566.             break;
  567.         case 'u':
  568.             returnValue = true;
  569.             break;
  570.         case 'v':
  571.             returnValue = true;
  572.             break;
  573.         case 'w':
  574.             returnValue = true;
  575.             break;
  576.         case 'x':
  577.             returnValue = true;
  578.             break;
  579.         case 'y':
  580.             returnValue = true;
  581.             break;
  582.         case 'z':
  583.             returnValue = true;
  584.             break;
  585.         }
  586.          
  587.     // Write your code here
  588.     // HINT: look at the CharacterIsNumber(char testChar)  method
  589.     // HINT: think of how to modify CharacterIsNumber(char testChar) to detect lowercase letters
  590.    
  591.      return returnValue;
  592.     }
  593.  
  594. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!