├── README └── java ├── Array-1 ├── sum3.java ├── makePi.java ├── middleWay.java ├── firstLast6.java ├── swapEnds.java ├── no23.java ├── commonEnd.java ├── has23.java ├── sameFirstLast.java ├── sum2.java ├── makeLast.java ├── maxTriple.java ├── maxEnd3.java ├── reverse3.java ├── rotateLeft3.java ├── start1.java ├── double23.java ├── plusTwo.java ├── makeMidde.java ├── frontPiece.java ├── fix23.java ├── midThree.java ├── biggerTwo.java ├── makeEnds.java ├── unlucky1.java ├── front11.java └── make2.java ├── String-1 ├── makeAbba.java ├── helloName.java ├── makeTags.java ├── left2.java ├── extraEnd.java ├── nonStart.java ├── firstHalf.java ├── makeOutWord.java ├── middleTwo.java ├── nTwice.java ├── withoutEnd.java ├── middleThree.java ├── right2.java ├── firstTwo.java ├── theEnd.java ├── withoutEnd2.java ├── seeColor.java ├── atFirst.java ├── twoChar.java ├── lastTwo.java ├── comboString.java ├── lastChars.java ├── extraFront.java ├── frontAgain.java ├── endsLy.java ├── conCat.java ├── hasBad.java ├── without2.java ├── minCat.java ├── deFront.java ├── withoutX2.java ├── startWord.java └── withoutX.java ├── Recursion-1 ├── factorial.java ├── powerN.java ├── sumDigits.java ├── triangle.java ├── bunnyEars.java ├── count7.java ├── fibonacci.java ├── allStar.java ├── array6.java ├── bunnyEars2.java ├── countX.java ├── noX.java ├── array11.java ├── array220.java ├── countHi.java ├── endX.java ├── changeXY.java ├── count8.java ├── count11.java ├── countPairs.java ├── nestParen.java ├── countAbc.java ├── stringClean.java ├── changePi.java ├── pairStar.java ├── parenBit.java ├── strCount.java ├── countHi2.java ├── strCopies.java └── strDist.java ├── Logic-1 ├── nearTen.java ├── sortaSum.java ├── twoAsOne.java ├── teenSum.java ├── maxMod5.java ├── greenTicket.java ├── teaParty.java ├── dateFashion.java ├── answerCell.java ├── inOrderEqual.java ├── cigarParty.java ├── redTicket.java ├── squirrelPlay.java ├── lessBy10.java ├── lastDigit.java ├── love6.java ├── inOrder.java ├── shareDigit.java ├── blueTicket.java ├── alarmClock.java ├── sumLimit.java ├── withoutDoubles.java ├── in1To10.java └── caughtSpeeding.java ├── Warmup-1 ├── backAround.java ├── sumDouble.java ├── hasTeen.java ├── startHi.java ├── intMax.java ├── mixStart.java ├── notString.java ├── diff21.java ├── in1020.java ├── sleepIn.java ├── delDel.java ├── everyNth.java ├── front22.java ├── icyHot.java ├── parrotTrouble.java ├── makes10.java ├── monkeyTrouble.java ├── nearHundred.java ├── front3.java ├── frontBack.java ├── missingChar.java ├── loneTeen.java ├── in3050.java ├── close10.java ├── startOz.java ├── endUp.java ├── lastDigit.java ├── posNeg.java ├── max1020.java └── stringE.java ├── Warmup-2 ├── stringTimes.java ├── array123.java ├── arrayCount9.java ├── stringSplosion.java ├── stringBits.java ├── array667.java ├── noTriples.java ├── altPairs.java ├── stringX.java ├── stringYak.java ├── stringMatch.java ├── frontTimes.java ├── last2.java ├── has271.java └── arrayFront9.java ├── AP-1 ├── wordsFront.java ├── hasOne.java ├── scores100.java ├── sumHeights.java ├── wordsCount.java ├── wordsWithoutList.java ├── bigHeights.java ├── dividesSelf.java ├── scoresIncreasing.java ├── scoreUp.java ├── scoresClump.java ├── copyEvens.java ├── sumHeights2.java ├── matchUp.java ├── scoresSpecial.java ├── commonTwo.java ├── userCompare.java ├── mergeTwo.java ├── scoresAverage.java ├── copyEndy.java └── wordsWithout.java ├── Array-2 ├── countEvens.java ├── lucky13.java ├── only14.java ├── bigDiff.java ├── sum28.java ├── matchUp.java ├── zeroFront.java ├── sameEnds.java ├── sum13.java ├── zeroMax.java ├── has12.java ├── notAlone.java ├── sum67.java ├── has22.java ├── tenRun.java ├── has77.java ├── modThree.java ├── no14.java ├── withoutTen.java ├── more14.java ├── centeredAverage.java ├── shiftLeft.java ├── post4.java ├── tripleUp.java ├── evenOdd.java ├── pre4.java ├── twoTwo.java ├── haveThree.java ├── isEverywhere.java └── either24.java ├── Logic-2 ├── luckySum.java ├── roundSum.java ├── loneSum.java ├── noTeenSum.java ├── evenlySpaced.java ├── makeBricks.java ├── closeFar.java ├── makeChocolate.java └── blackjack.java ├── Array-3 ├── seriesUp.java ├── maxSpan.java ├── canBalance.java ├── countClumps.java ├── squareUp.java ├── linearIn.java ├── maxMirror.java ├── fix34.java └── fix45.java ├── String-2 ├── doubleChar.java ├── repeatFront.java ├── bobThere.java ├── repeatEnd.java ├── countHi.java ├── repeatSeparator.java ├── prefixAgain.java ├── mixString.java ├── countCode.java ├── catDog.java ├── zipZap.java ├── sameStarChar.java ├── wordEnds.java ├── xyBalance.java ├── plusOut.java ├── xyzThere.java ├── xyzMiddle.java ├── endOther.java ├── starOut.java └── getSandwich.java ├── String-3 ├── countTriple.java ├── sumDigits.java ├── sameEnds.java ├── countYZ.java ├── gHappy.java ├── maxBlock.java ├── mirrorEnds.java ├── notReplace.java ├── sumNumbers.java ├── equalIsnot.java └── withoutString.java └── Recursion-2 ├── groupNoAdj.java ├── groupSum.java ├── groupSum6.java ├── splitArray.java ├── splitOdd10.java ├── groupSum5.java ├── groupSumClump.java └── split53.java /README: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /java/Array-1/sum3.java: -------------------------------------------------------------------------------- 1 | public int sum3(int[] nums) { 2 | return nums[0] + nums[1] + nums[2]; 3 | } 4 | -------------------------------------------------------------------------------- /java/String-1/makeAbba.java: -------------------------------------------------------------------------------- 1 | public String makeAbba(String a, String b) { 2 | return a+b+b+a; 3 | } 4 | -------------------------------------------------------------------------------- /java/String-1/helloName.java: -------------------------------------------------------------------------------- 1 | public String helloName(String name) { 2 | return "Hello " + name + "!"; 3 | } 4 | -------------------------------------------------------------------------------- /java/Array-1/makePi.java: -------------------------------------------------------------------------------- 1 | public int[] makePi() { 2 | int[] myArray = new int[] {3,1,4}; 3 | return myArray; 4 | } 5 | -------------------------------------------------------------------------------- /java/Recursion-1/factorial.java: -------------------------------------------------------------------------------- 1 | public int factorial(int n) { 2 | if (n == 0) return 1; 3 | return n * factorial(n-1); 4 | } 5 | -------------------------------------------------------------------------------- /java/String-1/makeTags.java: -------------------------------------------------------------------------------- 1 | public String makeTags(String tag, String word) { 2 | return "<"+tag+">"+word+""; 3 | } 4 | -------------------------------------------------------------------------------- /java/String-1/left2.java: -------------------------------------------------------------------------------- 1 | public String left2(String str) { 2 | return str.substring(2, str.length()) + str.substring(0,2); 3 | } 4 | -------------------------------------------------------------------------------- /java/Recursion-1/powerN.java: -------------------------------------------------------------------------------- 1 | public int powerN(int base, int n) { 2 | if (n == 0) return 1; 3 | return base * powerN(base, n-1); 4 | } 5 | -------------------------------------------------------------------------------- /java/Recursion-1/sumDigits.java: -------------------------------------------------------------------------------- 1 | public int sumDigits(int n) { 2 | if (n < 10) return n; 3 | return (n % 10) + sumDigits(n/10); 4 | } 5 | -------------------------------------------------------------------------------- /java/Recursion-1/triangle.java: -------------------------------------------------------------------------------- 1 | public int triangle(int rows) { 2 | if (rows == 0) return 0; 3 | return rows + triangle(rows-1); 4 | } 5 | -------------------------------------------------------------------------------- /java/Array-1/middleWay.java: -------------------------------------------------------------------------------- 1 | public int[] middleWay(int[] a, int[] b) { 2 | int[] myArray = new int[] {a[1], b[1]}; 3 | return myArray; 4 | } 5 | -------------------------------------------------------------------------------- /java/Recursion-1/bunnyEars.java: -------------------------------------------------------------------------------- 1 | public int bunnyEars(int bunnies) { 2 | if (bunnies == 0) return 0; 3 | return 2 + bunnyEars(bunnies-1); 4 | } 5 | -------------------------------------------------------------------------------- /java/String-1/extraEnd.java: -------------------------------------------------------------------------------- 1 | public String extraEnd(String str) { 2 | String s = str.substring(str.length()-2, str.length()); 3 | return s+s+s; 4 | } -------------------------------------------------------------------------------- /java/String-1/nonStart.java: -------------------------------------------------------------------------------- 1 | public String nonStart(String a, String b) { 2 | return a.substring(1,a.length()) + b.substring(1,b.length()); 3 | } 4 | -------------------------------------------------------------------------------- /java/Logic-1/nearTen.java: -------------------------------------------------------------------------------- 1 | public boolean nearTen(int num) { 2 | if (num % 10 < 3 || num % 10 >=8) 3 | return true; 4 | else return false; 5 | } 6 | -------------------------------------------------------------------------------- /java/String-1/firstHalf.java: -------------------------------------------------------------------------------- 1 | public String firstHalf(String str) { 2 | int half = str.length() / 2; 3 | return str.substring(0, half); 4 | 5 | } 6 | -------------------------------------------------------------------------------- /java/String-1/makeOutWord.java: -------------------------------------------------------------------------------- 1 | public String makeOutWord(String out, String word) { 2 | return out.substring(0,2) + word + out.substring(2,4); 3 | } 4 | -------------------------------------------------------------------------------- /java/String-1/middleTwo.java: -------------------------------------------------------------------------------- 1 | public String middleTwo(String str) { 2 | int half = str.length() / 2; 3 | return str.substring(half-1,half+1); 4 | } 5 | -------------------------------------------------------------------------------- /java/String-1/nTwice.java: -------------------------------------------------------------------------------- 1 | public String nTwice(String str, int n) { 2 | return str.substring(0,n) + str.substring(str.length()- n, str.length()); 3 | } 4 | -------------------------------------------------------------------------------- /java/String-1/withoutEnd.java: -------------------------------------------------------------------------------- 1 | public String withoutEnd(String str) { 2 | int len = str.length(); 3 | 4 | return str.substring(1,len - 1); 5 | } 6 | -------------------------------------------------------------------------------- /java/Warmup-1/backAround.java: -------------------------------------------------------------------------------- 1 | public String backAround(String str) { 2 | char temp = str.charAt(str.length() - 1); 3 | return temp + str + temp; 4 | } 5 | -------------------------------------------------------------------------------- /java/Warmup-1/sumDouble.java: -------------------------------------------------------------------------------- 1 | public int sumDouble(int a, int b) { 2 | if (a == b) 3 | return 2 * (a + b); 4 | else 5 | return a + b; 6 | } 7 | -------------------------------------------------------------------------------- /java/String-1/middleThree.java: -------------------------------------------------------------------------------- 1 | public String middleThree(String str) { 2 | int len = str.length() / 2; 3 | 4 | return str.substring(len-1,len+2); 5 | } 6 | -------------------------------------------------------------------------------- /java/Warmup-1/hasTeen.java: -------------------------------------------------------------------------------- 1 | public boolean hasTeen(int a, int b, int c) { 2 | return ((a >=13 && a <= 19) || (b >=13 && b <= 19)|| (c >=13 && c <= 19)); 3 | } 4 | -------------------------------------------------------------------------------- /java/Warmup-1/startHi.java: -------------------------------------------------------------------------------- 1 | public boolean startHi(String str) { 2 | if (str.startsWith("hi")) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Warmup-1/intMax.java: -------------------------------------------------------------------------------- 1 | public int intMax(int a, int b, int c) { 2 | int temp1 = Math.max(a,b); 3 | int temp2 = Math.max(temp1, c); 4 | return temp2; 5 | } 6 | -------------------------------------------------------------------------------- /java/Warmup-1/mixStart.java: -------------------------------------------------------------------------------- 1 | public boolean mixStart(String str) { 2 | if (str.startsWith("ix", 1)) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Warmup-1/notString.java: -------------------------------------------------------------------------------- 1 | public String notString(String str) { 2 | if (str.startsWith("not")) 3 | return str; 4 | else 5 | return "not " + str; 6 | } -------------------------------------------------------------------------------- /java/Recursion-1/count7.java: -------------------------------------------------------------------------------- 1 | public int count7(int n) { 2 | if (n < 1) return 0; 3 | if (n % 10 == 7) return 1 + count7(n/10); 4 | else return count7(n/10); 5 | } 6 | -------------------------------------------------------------------------------- /java/String-1/right2.java: -------------------------------------------------------------------------------- 1 | public String right2(String str) { 2 | return str.substring(str.length()-2, str.length()) + str.substring(0, 3 | str.length()-2); 4 | } 5 | -------------------------------------------------------------------------------- /java/Array-1/firstLast6.java: -------------------------------------------------------------------------------- 1 | public boolean firstLast6(int[] nums) { 2 | if (nums[0] == 6 || nums[nums.length-1] == 6) 3 | return true; 4 | else return false; 5 | } 6 | -------------------------------------------------------------------------------- /java/Recursion-1/fibonacci.java: -------------------------------------------------------------------------------- 1 | public int fibonacci(int n) { 2 | if (n == 0) return 0; 3 | else if (n == 1) return 1; 4 | return fibonacci(n-1) + fibonacci(n-2); 5 | } 6 | -------------------------------------------------------------------------------- /java/Logic-1/sortaSum.java: -------------------------------------------------------------------------------- 1 | public int sortaSum(int a, int b) { 2 | int sum = a+b; 3 | 4 | if(sum >= 10 && sum <= 19) 5 | return 20; 6 | else 7 | return sum; 8 | } 9 | -------------------------------------------------------------------------------- /java/Warmup-1/diff21.java: -------------------------------------------------------------------------------- 1 | public int diff21(int n) { 2 | int sum = Math.abs(21 - n); 3 | if (n > 21) 4 | return 2 * sum; 5 | else 6 | return sum; 7 | } 8 | -------------------------------------------------------------------------------- /java/Warmup-1/in1020.java: -------------------------------------------------------------------------------- 1 | public boolean in1020(int a, int b) { 2 | if ((a >= 10 && a <= 20) || (b >= 10 && b <= 20)) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/swapEnds.java: -------------------------------------------------------------------------------- 1 | public int[] swapEnds(int[] nums) { 2 | int temp = nums[0]; 3 | nums[0] = nums[nums.length-1]; 4 | nums[nums.length-1] = temp; 5 | return nums; 6 | } 7 | -------------------------------------------------------------------------------- /java/Logic-1/twoAsOne.java: -------------------------------------------------------------------------------- 1 | public boolean twoAsOne(int a, int b, int c) { 2 | if ( a + b == c || c + b == a || c + a == b) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Warmup-2/stringTimes.java: -------------------------------------------------------------------------------- 1 | public String stringTimes(String str, int n) { 2 | String temp = ""; 3 | for (int i = 0; i < n; i++) 4 | temp += str; 5 | return temp; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/no23.java: -------------------------------------------------------------------------------- 1 | public boolean no23(int[] nums) { 2 | if (nums[0] != 2 && nums[0] != 3 && nums[1] != 2 && nums[1] != 3) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/String-1/firstTwo.java: -------------------------------------------------------------------------------- 1 | public String firstTwo(String str) { 2 | int len = str.length(); 3 | if (len < 2) 4 | return str; 5 | else 6 | return str.substring(0,2); 7 | } 8 | -------------------------------------------------------------------------------- /java/Array-1/commonEnd.java: -------------------------------------------------------------------------------- 1 | public boolean commonEnd(int[] a, int[] b) { 2 | if (a[0] == b[0] || a[a.length-1] == b[b.length-1]) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/has23.java: -------------------------------------------------------------------------------- 1 | public boolean has23(int[] nums) { 2 | if (nums[0] == 2 || nums[0] == 3 || nums[1] == 2 || nums[1] == 3) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Logic-1/teenSum.java: -------------------------------------------------------------------------------- 1 | public int teenSum(int a, int b) { 2 | int sum = a+b; 3 | if ((a >= 13 && a <= 19) || (b >= 13 && b <= 19)) 4 | return 19; 5 | else 6 | return sum; 7 | } 8 | -------------------------------------------------------------------------------- /java/Recursion-1/allStar.java: -------------------------------------------------------------------------------- 1 | public String allStar(String str) { 2 | if (str.equals("") || str.length() == 1) return str; 3 | return str.charAt(0) + "*" + allStar(str.substring(1)); 4 | } 5 | -------------------------------------------------------------------------------- /java/String-1/theEnd.java: -------------------------------------------------------------------------------- 1 | public String theEnd(String str, boolean front) { 2 | if (front) 3 | return str.substring(0,1); 4 | else 5 | return str.substring(str.length()-1); 6 | } 7 | -------------------------------------------------------------------------------- /java/Warmup-1/sleepIn.java: -------------------------------------------------------------------------------- 1 | public boolean sleepIn(boolean weekday, boolean vacation) { 2 | if (weekday == true && vacation == false) 3 | return false; 4 | else 5 | return true; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/sameFirstLast.java: -------------------------------------------------------------------------------- 1 | public boolean sameFirstLast(int[] nums) { 2 | if (nums.length >= 1 && nums[0] == nums[nums.length-1]) 3 | return true; 4 | else 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/sum2.java: -------------------------------------------------------------------------------- 1 | public int sum2(int[] nums) { 2 | if (nums.length == 1) 3 | return nums[0]; 4 | if (nums.length == 0) 5 | return 0; 6 | 7 | return nums[0] + nums[1]; 8 | } 9 | -------------------------------------------------------------------------------- /java/Warmup-1/delDel.java: -------------------------------------------------------------------------------- 1 | public String delDel(String str) { 2 | if (str.startsWith("del", 1)) 3 | return str.charAt(0) + str.substring(4, str.length()); 4 | else 5 | return str; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/makeLast.java: -------------------------------------------------------------------------------- 1 | public int[] makeLast(int[] nums) { 2 | int len = nums.length; 3 | int[] myArray = new int[2*len]; 4 | myArray[myArray.length-1] = nums[len-1]; 5 | return myArray; 6 | } 7 | -------------------------------------------------------------------------------- /java/String-1/withoutEnd2.java: -------------------------------------------------------------------------------- 1 | public String withouEnd2(String str) { 2 | int len = str.length(); 3 | if (len < 3) 4 | return ""; 5 | else 6 | return str.substring(1,str.length()-1); 7 | } 8 | -------------------------------------------------------------------------------- /java/Warmup-1/everyNth.java: -------------------------------------------------------------------------------- 1 | public String everyNth(String str, int n) { 2 | String temp = ""; 3 | for (int i = 0; i < str.length();i = i + n) 4 | temp += str.charAt(i); 5 | return temp; 6 | } 7 | -------------------------------------------------------------------------------- /java/Array-1/maxTriple.java: -------------------------------------------------------------------------------- 1 | public int maxTriple(int[] nums) { 2 | int largest = Math.max(nums[0], nums[nums.length / 2]); 3 | largest = Math.max(largest, nums[nums.length-1]); 4 | return largest; 5 | } 6 | -------------------------------------------------------------------------------- /java/Recursion-1/array6.java: -------------------------------------------------------------------------------- 1 | public boolean array6(int[] nums, int index) { 2 | if (index >= nums.length) return false; 3 | if (nums[index] == 6) return true; 4 | else return array6(nums, index+1); 5 | } 6 | -------------------------------------------------------------------------------- /java/AP-1/wordsFront.java: -------------------------------------------------------------------------------- 1 | public String[] wordsFront(String[] words, int n) { 2 | String[] array = new String[n]; 3 | for (int i = 0; i < n; i++) { 4 | array[i] = words[i]; 5 | } 6 | return array; 7 | } 8 | -------------------------------------------------------------------------------- /java/Array-1/maxEnd3.java: -------------------------------------------------------------------------------- 1 | public int[] maxEnd3(int[] nums) { 2 | int larger = Math.max(nums[0], nums[2]); 3 | 4 | nums[0] = larger; 5 | nums[1] = larger; 6 | nums[2] = larger; 7 | return nums; 8 | } 9 | -------------------------------------------------------------------------------- /java/Logic-1/maxMod5.java: -------------------------------------------------------------------------------- 1 | public int maxMod5(int a, int b) { 2 | if (a == b) 3 | return 0; 4 | 5 | if (a % 5 == b % 5) 6 | return Math.min(a,b); 7 | 8 | return Math.max(a,b); 9 | } 10 | -------------------------------------------------------------------------------- /java/String-1/seeColor.java: -------------------------------------------------------------------------------- 1 | public String seeColor(String str) { 2 | if (str.startsWith("red")) 3 | return "red"; 4 | if (str.startsWith("blue")) 5 | return "blue"; 6 | else 7 | return ""; 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-1/reverse3.java: -------------------------------------------------------------------------------- 1 | public int[] reverse3(int[] nums) { 2 | int[] myArray = new int[3]; 3 | 4 | myArray[0] = nums[2]; 5 | myArray[1] = nums[1]; 6 | myArray[2] = nums[0]; 7 | return myArray; 8 | } 9 | -------------------------------------------------------------------------------- /java/Logic-1/greenTicket.java: -------------------------------------------------------------------------------- 1 | public int greenTicket(int a, int b, int c) { 2 | if (a == b && b == c) 3 | return 20; 4 | if (a == b || a == c || b == c) 5 | return 10; 6 | else; 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /java/Recursion-1/bunnyEars2.java: -------------------------------------------------------------------------------- 1 | public int bunnyEars2(int bunnies) { 2 | if (bunnies == 0) return 0; 3 | if (bunnies % 2 == 0) return 3 + bunnyEars2(bunnies-1); 4 | else return 2 + bunnyEars2(bunnies-1); 5 | } 6 | -------------------------------------------------------------------------------- /java/Recursion-1/countX.java: -------------------------------------------------------------------------------- 1 | public int countX(String str) { 2 | if (str.equals("")) return 0; 3 | if (str.charAt(0) == 'x') return 1 + countX(str.substring(1)); 4 | else return countX(str.substring(1)); 5 | } 6 | -------------------------------------------------------------------------------- /java/Warmup-1/front22.java: -------------------------------------------------------------------------------- 1 | public String front22(String str) { 2 | if (str.length() > 2) { 3 | String temp = str.substring(0,2); 4 | return temp + str + temp; 5 | } else 6 | return str + str + str; 7 | } 8 | -------------------------------------------------------------------------------- /java/Warmup-2/array123.java: -------------------------------------------------------------------------------- 1 | public boolean array123(int[] nums) { 2 | for (int i=0; i < (nums.length-2); i++) { 3 | if (nums[i]==1 && nums[i+1]==2 && nums[i+2]==3) return true; 4 | } 5 | return false; 6 | } 7 | -------------------------------------------------------------------------------- /java/AP-1/hasOne.java: -------------------------------------------------------------------------------- 1 | public boolean hasOne(int n) 2 | { 3 | while(n%10!=0||n==10) 4 | { 5 | if(n%10 == 1) 6 | return true; 7 | else 8 | n/=10; 9 | } 10 | 11 | return false; 12 | } -------------------------------------------------------------------------------- /java/Array-1/rotateLeft3.java: -------------------------------------------------------------------------------- 1 | public int[] rotateLeft3(int[] nums) { 2 | int[] myArray = new int[3]; 3 | 4 | myArray[0] = nums[1]; 5 | myArray[1] = nums[2]; 6 | myArray[2] = nums[0]; 7 | return myArray; 8 | } 9 | -------------------------------------------------------------------------------- /java/Logic-1/teaParty.java: -------------------------------------------------------------------------------- 1 | public int teaParty(int tea, int candy) { 2 | if (tea < 5 || candy < 5) 3 | return 0; 4 | if ((tea >= 2 * candy) || (candy >= 2 * tea)) 5 | return 2; 6 | else 7 | return 1; 8 | } 9 | -------------------------------------------------------------------------------- /java/Recursion-1/noX.java: -------------------------------------------------------------------------------- 1 | public String noX(String str) { 2 | if (str.equals("")) return str; 3 | if (str.charAt(0) == 'x') return noX(str.substring(1)); 4 | else return str.charAt(0) + noX(str.substring(1)); 5 | } 6 | -------------------------------------------------------------------------------- /java/String-1/atFirst.java: -------------------------------------------------------------------------------- 1 | public String atFirst(String str) { 2 | if (str.length() >= 2) 3 | return str.substring(0,2); 4 | else if (str.length() == 1) 5 | return str + "@"; 6 | else 7 | return "@@"; 8 | } 9 | -------------------------------------------------------------------------------- /java/String-1/twoChar.java: -------------------------------------------------------------------------------- 1 | public String twoChar(String str, int index) { 2 | if (str.length() <= index + 1 || index < 0) 3 | return str.substring(0,2); 4 | else 5 | return str.substring(index, index + 2); 6 | } 7 | -------------------------------------------------------------------------------- /java/Recursion-1/array11.java: -------------------------------------------------------------------------------- 1 | public int array11(int[] nums, int index) { 2 | if (index >= nums.length) return 0; 3 | if (nums[index] == 11) return 1 + array11(nums,index+1); 4 | else return array11(nums,index+1); 5 | } 6 | -------------------------------------------------------------------------------- /java/Recursion-1/array220.java: -------------------------------------------------------------------------------- 1 | public boolean array220(int[] nums, int index) { 2 | if (index >= nums.length-1) return false; 3 | if (nums[index+1] == nums[index] * 10) return true; 4 | return array220(nums, index+1); 5 | } 6 | -------------------------------------------------------------------------------- /java/Warmup-1/icyHot.java: -------------------------------------------------------------------------------- 1 | public boolean icyHot(int temp1, int temp2) { 2 | if (temp1 > 100 && temp2 < 0) 3 | return true; 4 | else if (temp1 < 0 && temp2 > 100) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/AP-1/scores100.java: -------------------------------------------------------------------------------- 1 | public boolean scores100(int[] scores) { 2 | for (int i = 0; i < scores.length-1; i++) { 3 | if (scores[i] == 100 && scores[i+1] == 100) 4 | return true; 5 | 6 | } 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/AP-1/sumHeights.java: -------------------------------------------------------------------------------- 1 | public int sumHeights(int[] heights, int start, int end) { 2 | int tmp = 0; 3 | for (int i = start; i <= end-1; i++) { 4 | tmp += Math.abs(heights[i] - heights[i+1]); 5 | } 6 | return tmp; 7 | } 8 | -------------------------------------------------------------------------------- /java/Array-1/start1.java: -------------------------------------------------------------------------------- 1 | public int start1(int[] a, int[] b) { 2 | int count = 0; 3 | if (a.length > 0 && a[0] == 1) 4 | count++; 5 | if (b.length > 0 && b[0] ==1) 6 | count++; 7 | return count; 8 | 9 | } 10 | -------------------------------------------------------------------------------- /java/Recursion-1/countHi.java: -------------------------------------------------------------------------------- 1 | public int countHi(String str) { 2 | if (str.length() < 2) return 0; 3 | if (str.substring(0,2).equals("hi")) return 1 + countHi(str.substring(1)); 4 | else return countHi(str.substring(1)); 5 | } 6 | -------------------------------------------------------------------------------- /java/Recursion-1/endX.java: -------------------------------------------------------------------------------- 1 | public String endX(String str) { 2 | if (str.equals("")) return str; 3 | if (str.charAt(0) == 'x') return endX(str.substring(1)) + 'x'; 4 | else return str.charAt(0) + endX(str.substring(1)); 5 | } 6 | -------------------------------------------------------------------------------- /java/String-1/lastTwo.java: -------------------------------------------------------------------------------- 1 | public String lastTwo(String str) { 2 | if (str.length() < 2) 3 | return str; 4 | else 5 | return str.substring(0, str.length()-2) + str.charAt(str.length()-1) + str.charAt(str.length()-2); 6 | } 7 | -------------------------------------------------------------------------------- /java/Warmup-1/parrotTrouble.java: -------------------------------------------------------------------------------- 1 | public boolean parrotTrouble(boolean talking, int hour) { 2 | if (!talking) 3 | return false; 4 | else if (hour > 20 || hour < 7) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/AP-1/wordsCount.java: -------------------------------------------------------------------------------- 1 | public int wordsCount(String[] words, int len) { 2 | int count = 0; 3 | for (int i = 0; i < words.length; i++) { 4 | if (words[i].length() == len) 5 | count++; 6 | } 7 | return count; 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-2/countEvens.java: -------------------------------------------------------------------------------- 1 | public int countEvens(int[] nums) { 2 | int count = 0; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | if (nums[i] % 2 == 0) 6 | count++; 7 | } 8 | 9 | return count; 10 | } 11 | -------------------------------------------------------------------------------- /java/Logic-1/dateFashion.java: -------------------------------------------------------------------------------- 1 | public int dateFashion(int you, int date) { 2 | if ((you >= 8 && date > 2) || (date >= 8 && you > 2)) 3 | return 2; 4 | if (you <= 2 || date <= 2) 5 | return 0; 6 | else 7 | return 1; 8 | } 9 | -------------------------------------------------------------------------------- /java/Recursion-1/changeXY.java: -------------------------------------------------------------------------------- 1 | public String changeXY(String str) { 2 | if (str.equals("")) return str; 3 | if (str.charAt(0) == 'x') return "y" + changeXY(str.substring(1)); 4 | return str.charAt(0) + changeXY(str.substring(1)); 5 | } -------------------------------------------------------------------------------- /java/String-1/comboString.java: -------------------------------------------------------------------------------- 1 | public String comboString(String a, String b) { 2 | int lenA = a.length(); 3 | int lenB = b.length(); 4 | 5 | if (lenA > lenB) 6 | return b+a+b; 7 | else 8 | return a+b+a; 9 | } 10 | -------------------------------------------------------------------------------- /java/Warmup-1/makes10.java: -------------------------------------------------------------------------------- 1 | public boolean makes10(int a, int b) { 2 | int sum = a + b; 3 | if (a == 10 || b == 10) 4 | return true; 5 | else if (sum == 10) 6 | return true; 7 | else 8 | return false; 9 | } 10 | -------------------------------------------------------------------------------- /java/Warmup-1/monkeyTrouble.java: -------------------------------------------------------------------------------- 1 | public boolean monkeyTrouble(boolean aSmile, boolean bSmile) { 2 | if (aSmile && bSmile) 3 | return true; 4 | else if (!aSmile && !bSmile) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/Warmup-1/nearHundred.java: -------------------------------------------------------------------------------- 1 | public boolean nearHundred(int n) { 2 | int sum1 = Math.abs(n - 100); 3 | int sum2 = Math.abs(n - 200); 4 | 5 | if (sum1 <= 10 || sum2 <= 10) 6 | return true; 7 | else 8 | return false; 9 | } -------------------------------------------------------------------------------- /java/Warmup-2/arrayCount9.java: -------------------------------------------------------------------------------- 1 | public int arrayCount9(int[] nums) { 2 | int counter = 0; 3 | 4 | for (int i = 0; i < nums.length; i++){ 5 | if (nums[i] == 9) 6 | counter++; 7 | } 8 | return counter; 9 | } 10 | -------------------------------------------------------------------------------- /java/Warmup-2/stringSplosion.java: -------------------------------------------------------------------------------- 1 | public String stringSplosion(String str) { 2 | int len = str.length(); 3 | String temp = ""; 4 | 5 | for (int i = 0; i < len + 1; i++) 6 | temp += str.substring(0,i); 7 | return temp; 8 | } 9 | -------------------------------------------------------------------------------- /java/Recursion-1/count8.java: -------------------------------------------------------------------------------- 1 | public int count8(int n) { 2 | if (n < 1) return 0; 3 | if (n % 10 == 8 && (n / 10) % 10 == 8) return 2 + count8(n/10); 4 | else if (n % 10 == 8) return 1 + count8(n/10); 5 | else return count8(n/10); 6 | } 7 | -------------------------------------------------------------------------------- /java/String-1/lastChars.java: -------------------------------------------------------------------------------- 1 | public String lastChars(String a, String b) { 2 | if(a.length() == 0) 3 | a = "@"; 4 | if(b.length() == 0) 5 | b = "@"; 6 | 7 | return a.substring(0,1) + b.substring(b.length()-1, b.length()); 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-1/double23.java: -------------------------------------------------------------------------------- 1 | public boolean double23(int[] nums) { 2 | if (nums.length < 2) 3 | return false; 4 | if ((nums[0] == 2 && nums[1] == 2) || (nums[0] == 3 && nums[1] == 3)) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-1/plusTwo.java: -------------------------------------------------------------------------------- 1 | public int[] plusTwo(int[] a, int[] b) { 2 | int[] myArray = new int[4]; 3 | myArray[0] = a[0]; 4 | myArray[1] = a[1]; 5 | myArray[2] = b[0]; 6 | myArray[3] = b[1]; 7 | 8 | return myArray; 9 | } 10 | -------------------------------------------------------------------------------- /java/Logic-1/answerCell.java: -------------------------------------------------------------------------------- 1 | public boolean answerCell(boolean isMorning, boolean isMom, boolean isAsleep) { 2 | if (isAsleep) 3 | return false; 4 | if ((isMorning && isMom) || !isMorning) 5 | return true; 6 | else return false; 7 | } 8 | -------------------------------------------------------------------------------- /java/Logic-2/luckySum.java: -------------------------------------------------------------------------------- 1 | public int luckySum(int a, int b, int c) { 2 | if (a == 13) 3 | return 0; 4 | else if (b == 13) 5 | return a; 6 | else if (c == 13) 7 | return a + b; 8 | else 9 | return a + b +c; 10 | } 11 | -------------------------------------------------------------------------------- /java/Recursion-1/count11.java: -------------------------------------------------------------------------------- 1 | public int count11(String str) { 2 | if (str.length() < 2) return 0; 3 | if (str.substring(0,2).equals("11")) 4 | return 1 + count11(str.substring(2)); 5 | else 6 | return count11(str.substring(1)); 7 | } 8 | -------------------------------------------------------------------------------- /java/Warmup-1/front3.java: -------------------------------------------------------------------------------- 1 | public String front3(String str) { 2 | if (str.length() <= 3) 3 | return str + str + str; 4 | else { 5 | String newString = str.substring(0,3); 6 | return newString + newString + newString; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /java/Warmup-1/frontBack.java: -------------------------------------------------------------------------------- 1 | public String frontBack(String str) { 2 | if (str.length() <= 1) 3 | return str; 4 | 5 | String mid = str.substring(1, str.length()-1); 6 | return str.charAt(str.length()-1) + mid + str.charAt(0); 7 | } -------------------------------------------------------------------------------- /java/Warmup-1/missingChar.java: -------------------------------------------------------------------------------- 1 | public String missingChar(String str, int n) { 2 | StringBuffer buf = new StringBuffer( str.length() - 1 ); 3 | buf.append( str.substring(0,n) ).append( str.substring(n+1) ); 4 | return buf.toString(); 5 | } 6 | -------------------------------------------------------------------------------- /java/Warmup-2/stringBits.java: -------------------------------------------------------------------------------- 1 | public String stringBits(String str) { 2 | int len = str.length(); 3 | String temp = ""; 4 | 5 | for (int i = 0; i < len; i = i + 2) { 6 | temp += str.charAt(i); 7 | } 8 | return temp; 9 | } 10 | -------------------------------------------------------------------------------- /java/Array-2/lucky13.java: -------------------------------------------------------------------------------- 1 | public boolean lucky13(int[] nums) { 2 | boolean no13 = true; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | if (nums[i] == 1 || nums[i] == 3) 6 | no13 = false; 7 | } 8 | return no13; 9 | } 10 | -------------------------------------------------------------------------------- /java/String-1/extraFront.java: -------------------------------------------------------------------------------- 1 | public String extraFront(String str) { 2 | if (str.length() < 2) 3 | return str + str + str; 4 | else { 5 | String newString = str.substring(0,2); 6 | return newString + newString + newString; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-1/makeMidde.java: -------------------------------------------------------------------------------- 1 | public int[] makeMiddle(int[] nums) { 2 | int[] myArray = new int[2]; 3 | int middle = nums.length / 2; 4 | 5 | myArray[0] = nums[middle - 1]; 6 | myArray[1] = nums[middle]; 7 | 8 | return myArray; 9 | } 10 | -------------------------------------------------------------------------------- /java/Logic-1/inOrderEqual.java: -------------------------------------------------------------------------------- 1 | public boolean inOrderEqual(int a, int b, int c, boolean equalOk) { 2 | if (!equalOk && a < b && b < c) 3 | return true; 4 | if (equalOk && a <= b && b <= c) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/Recursion-1/countPairs.java: -------------------------------------------------------------------------------- 1 | public int countPairs(String str) { 2 | if (str.equals("") || str.length() < 3) return 0; 3 | if (str.charAt(0) == str.charAt(2)) return 1 + countPairs(str.substring(1)); 4 | else return countPairs(str.substring(1)); 5 | } -------------------------------------------------------------------------------- /java/Warmup-1/loneTeen.java: -------------------------------------------------------------------------------- 1 | public boolean loneTeen(int a, int b) { 2 | if ((a >=13 && a <= 19) && (b < 13 || b > 19)) 3 | return true; 4 | else if ((b >=13 && b <= 19) && (a < 13 || a > 19)) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-2/only14.java: -------------------------------------------------------------------------------- 1 | public boolean only14(int[] nums) { 2 | boolean isTrue = true; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | if (nums[i] != 1 && nums[i] != 4) 6 | isTrue = false; 7 | } 8 | return isTrue; 9 | 10 | } 11 | -------------------------------------------------------------------------------- /java/Array-3/seriesUp.java: -------------------------------------------------------------------------------- 1 | public int[] seriesUp(int n) { 2 | int[] result = new int[n * (n + 1) / 2]; 3 | int i = 0; 4 | for (int j = 1; j <= n; ++j) 5 | for (int k = 1; k <= j; ++k) 6 | result[i++] = k; 7 | return result; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /java/String-2/doubleChar.java: -------------------------------------------------------------------------------- 1 | public String doubleChar(String str) { 2 | int len = str.length(); 3 | String new_str = ""; 4 | for (int i = 0; i < len; i++) { 5 | new_str += str.substring(i,i+1) + str.substring(i, i+1); 6 | } 7 | return new_str; 8 | } 9 | -------------------------------------------------------------------------------- /java/String-2/repeatFront.java: -------------------------------------------------------------------------------- 1 | public String repeatFront(String str, int n) { 2 | int len = str.length(); 3 | String newWord = ""; 4 | 5 | for (int i = n; n > 0; n--){ 6 | newWord += str.substring(0,n); 7 | } 8 | return newWord; 9 | } 10 | -------------------------------------------------------------------------------- /java/Warmup-1/in3050.java: -------------------------------------------------------------------------------- 1 | public boolean in3050(int a, int b) { 2 | if ((a >= 30 && a <= 40) && (b >= 30 && b <= 40)) 3 | return true; 4 | else if ((a >= 40 && a <= 50) && (b >= 40 && b <= 50)) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/AP-1/wordsWithoutList.java: -------------------------------------------------------------------------------- 1 | public List wordsWithoutList(String[] words, int len) { 2 | ArrayList al = new ArrayList(); 3 | for (int i = 0; i < words.length; i++) { 4 | if (words[i].length() != len) 5 | al.add(words[i]); 6 | } 7 | return al; 8 | } 9 | -------------------------------------------------------------------------------- /java/Logic-1/cigarParty.java: -------------------------------------------------------------------------------- 1 | public boolean cigarParty(int cigars, boolean isWeekend) { 2 | if (isWeekend == true && cigars >= 40) 3 | return true; 4 | if (!(isWeekend) && cigars >=40 && cigars <= 60) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/Logic-1/redTicket.java: -------------------------------------------------------------------------------- 1 | public int redTicket(int a, int b, int c) { 2 | if (a == 2 && b == 2 && c == 2) 3 | return 10; 4 | if ( a == b && b == c) 5 | return 5; 6 | if ( a != b && a != c) 7 | return 1; 8 | else 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /java/Logic-1/squirrelPlay.java: -------------------------------------------------------------------------------- 1 | public boolean squirrelPlay(int temp, boolean isSummer) { 2 | if (isSummer && temp <= 100 && temp >= 60) 3 | return true; 4 | if (!(isSummer) && temp <= 90 && temp >=60) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/Logic-2/roundSum.java: -------------------------------------------------------------------------------- 1 | public int roundSum(int a, int b, int c) { 2 | return round10(a) + round10(b) + round10(c); 3 | } 4 | 5 | public int round10(int n) { 6 | if (n % 10 < 5) 7 | return n - (n%10); 8 | else 9 | return n + (10 - (n%10)); 10 | } -------------------------------------------------------------------------------- /java/String-1/frontAgain.java: -------------------------------------------------------------------------------- 1 | public boolean frontAgain(String str) { 2 | if (str.length() < 2) 3 | return false; 4 | else if (str.substring(0,2).equals(str.substring(str.length()-2, str.length()))) 5 | return true; 6 | else 7 | return false; 8 | } 9 | -------------------------------------------------------------------------------- /java/String-2/bobThere.java: -------------------------------------------------------------------------------- 1 | public boolean bobThere(String str) { 2 | int len = str.length(); 3 | 4 | for (int i = 0; i < len - 2; i++) { 5 | if (str.charAt(i) == 'b' && str.charAt(i+2) == 'b') 6 | return true; 7 | } 8 | return false; 9 | } 10 | -------------------------------------------------------------------------------- /java/String-2/repeatEnd.java: -------------------------------------------------------------------------------- 1 | public String repeatEnd(String str, int n) { 2 | int len = str.length(); 3 | String newWord = ""; 4 | 5 | for (int i = 0; i < n; i++) { 6 | newWord += str.substring(len - n, len); 7 | } 8 | return newWord; 9 | } 10 | -------------------------------------------------------------------------------- /java/AP-1/bigHeights.java: -------------------------------------------------------------------------------- 1 | public int bigHeights(int[] heights, int start, int end) { 2 | int tmp = 0; 3 | for (int i = start; i <= end-1; i++) { 4 | if (Math.abs(heights[i] - heights[i+1]) >= 5) { 5 | tmp++; 6 | } 7 | } 8 | return tmp; 9 | } 10 | -------------------------------------------------------------------------------- /java/Array-1/frontPiece.java: -------------------------------------------------------------------------------- 1 | public int[] frontPiece(int[] nums) { 2 | int[] myArray = new int[2]; 3 | 4 | if (nums.length < 2) 5 | return nums; 6 | else { 7 | myArray[0] = nums[0]; 8 | myArray[1] = nums[1]; 9 | return myArray; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /java/Logic-1/lessBy10.java: -------------------------------------------------------------------------------- 1 | public boolean lessBy10(int a, int b, int c) { 2 | int high = Math.max(a,b); 3 | high = Math.max(high, c); 4 | 5 | if (high - a >= 10 || high - b >= 10 || high - c >=10) 6 | return true; 7 | else 8 | return false; 9 | } 10 | -------------------------------------------------------------------------------- /java/Logic-2/loneSum.java: -------------------------------------------------------------------------------- 1 | public int loneSum(int a, int b, int c) { 2 | if ( a == b && b == c) 3 | return 0; 4 | if (a == b) 5 | return c; 6 | if (b == c) 7 | return a; 8 | if (a == c) 9 | return b; 10 | else 11 | return a + b + c; 12 | } 13 | -------------------------------------------------------------------------------- /java/Recursion-1/nestParen.java: -------------------------------------------------------------------------------- 1 | public boolean nestParen(String str) { 2 | if (str.equals("")) return true; 3 | if (str.charAt(0) == '(' && str.charAt(str.length()-1) == ')') 4 | return nestParen(str.substring(1,str.length()-1)); 5 | else 6 | return false; 7 | } 8 | -------------------------------------------------------------------------------- /java/Warmup-1/close10.java: -------------------------------------------------------------------------------- 1 | public int close10(int a, int b) { 2 | int temp1 = Math.abs(a - 10); 3 | int temp2 = Math.abs(b - 10); 4 | 5 | if (temp1 == temp2) 6 | return 0; 7 | else if (temp1 > temp2) 8 | return b; 9 | else 10 | return a; 11 | } 12 | -------------------------------------------------------------------------------- /java/Warmup-1/startOz.java: -------------------------------------------------------------------------------- 1 | public String startOz(String str) { 2 | if (str.startsWith("oz")) 3 | return "oz"; 4 | else if (str.startsWith("o")) 5 | return "o"; 6 | else if (str.startsWith("z", 1)) 7 | return "z"; 8 | else 9 | return ""; 10 | } 11 | -------------------------------------------------------------------------------- /java/Array-1/fix23.java: -------------------------------------------------------------------------------- 1 | public int[] fix23(int[] nums) { 2 | if (nums[0] == 2 && nums[1] == 3){ 3 | nums[1] = 0; 4 | return nums; 5 | } 6 | if (nums[1] == 2 && nums[2] == 3) { 7 | nums[2] = 0; 8 | return nums; 9 | } else 10 | return nums; 11 | } 12 | -------------------------------------------------------------------------------- /java/Array-1/midThree.java: -------------------------------------------------------------------------------- 1 | public int[] midThree(int[] nums) { 2 | int[] myArray = new int[3]; 3 | int middle = nums.length / 2; 4 | myArray[0] = nums[middle-1]; 5 | myArray[1] = nums[middle]; 6 | myArray[2] = nums[middle+1]; 7 | return myArray; 8 | 9 | } 10 | -------------------------------------------------------------------------------- /java/Logic-1/lastDigit.java: -------------------------------------------------------------------------------- 1 | public boolean lastDigit(int a, int b, int c) { 2 | int modA = a % 10; 3 | int modB = b % 10; 4 | int modC = c % 10; 5 | 6 | if (modA == modB || modA == modC || modB == modC) 7 | return true; 8 | else 9 | return false; 10 | } 11 | -------------------------------------------------------------------------------- /java/Logic-1/love6.java: -------------------------------------------------------------------------------- 1 | public boolean love6(int a, int b) { 2 | if (a == 6 || b == 6) 3 | return true; 4 | 5 | int sum = a+b; 6 | int diff = Math.abs(a-b); 7 | 8 | if (sum == 6 || diff == 6) 9 | return true; 10 | else 11 | return false; 12 | } 13 | -------------------------------------------------------------------------------- /java/Recursion-1/countAbc.java: -------------------------------------------------------------------------------- 1 | public int countAbc(String str) { 2 | if (str.length() < 3) return 0; 3 | if (str.substring(0,3).equals("abc") || str.substring(0,3).equals("aba")) 4 | return 1 + countAbc(str.substring(1)); 5 | else 6 | return countAbc(str.substring(1)); 7 | } -------------------------------------------------------------------------------- /java/Recursion-1/stringClean.java: -------------------------------------------------------------------------------- 1 | public String stringClean(String str) { 2 | if (str.length() < 2) return str; 3 | if (str.charAt(0) == str.charAt(1)) 4 | return stringClean(str.substring(1)); 5 | else 6 | return str.charAt(0) + stringClean(str.substring(1)); 7 | } 8 | -------------------------------------------------------------------------------- /java/AP-1/dividesSelf.java: -------------------------------------------------------------------------------- 1 | public boolean dividesSelf(int n) { 2 | int tmp = n; 3 | if (n%10 == 0) 4 | return false; 5 | while(n != 0) 6 | { 7 | if (tmp % (n%10) != 0) 8 | return false; 9 | n /= 10; 10 | } 11 | 12 | 13 | return true; 14 | } 15 | -------------------------------------------------------------------------------- /java/Array-2/bigDiff.java: -------------------------------------------------------------------------------- 1 | public int bigDiff(int[] nums) { 2 | int min = nums[0]; 3 | int max = nums[0]; 4 | 5 | for (int i = 0; i < nums.length; i++){ 6 | min = Math.min(min,nums[i]); 7 | max = Math.max(max,nums[i]); 8 | } 9 | return max-min; 10 | 11 | } 12 | -------------------------------------------------------------------------------- /java/Array-2/sum28.java: -------------------------------------------------------------------------------- 1 | public boolean sum28(int[] nums) { 2 | int sum = 0; 3 | boolean is8 = false; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (nums[i] == 2) 7 | sum += 2; 8 | } 9 | if (sum == 8) 10 | is8 = true; 11 | return is8; 12 | } 13 | -------------------------------------------------------------------------------- /java/Logic-1/inOrder.java: -------------------------------------------------------------------------------- 1 | public boolean inOrder(int a, int b, int c, boolean bOk) { 2 | if(bOk) { 3 | if (c > b) 4 | return true; 5 | else 6 | return false; 7 | } 8 | if (b > a && c > b) 9 | return true; 10 | else 11 | return false; 12 | } 13 | -------------------------------------------------------------------------------- /java/String-1/endsLy.java: -------------------------------------------------------------------------------- 1 | public boolean endsLy(String str) { 2 | int len = str.length(); 3 | String ly = "ly"; 4 | 5 | if (len < 2) 6 | return false; 7 | else if (ly.equals(str.substring(len-2,len))) 8 | return true; 9 | else 10 | return false; 11 | } 12 | -------------------------------------------------------------------------------- /java/Array-2/matchUp.java: -------------------------------------------------------------------------------- 1 | public int matchUp(int[] nums1, int[] nums2) { 2 | int count = 0; 3 | 4 | for (int i = 0; i < nums1.length; i++) { 5 | int tmp = Math.abs(nums1[i] - nums2[i]); 6 | if (tmp <= 2 && tmp > 0) 7 | count++; 8 | } 9 | return count; 10 | } 11 | -------------------------------------------------------------------------------- /java/Array-2/zeroFront.java: -------------------------------------------------------------------------------- 1 | public int[] zeroFront(int[] nums) { 2 | int count = 0; 3 | for (int i = 0; i < nums.length; i++) { 4 | if (nums[i] == 0) { 5 | nums[i] = nums[count]; 6 | nums[count] = 0; 7 | count++; 8 | } 9 | } 10 | return nums; 11 | } 12 | -------------------------------------------------------------------------------- /java/Recursion-1/changePi.java: -------------------------------------------------------------------------------- 1 | public String changePi(String str) { 2 | if (str.equals("") || str.length() < 2) return str; 3 | if (str.charAt(0) == 'p' && str.charAt(1) == 'i') 4 | return "3.14" + changePi(str.substring(2)); 5 | return str.charAt(0) + changePi(str.substring(1)); 6 | } -------------------------------------------------------------------------------- /java/Warmup-2/array667.java: -------------------------------------------------------------------------------- 1 | public int array667(int[] nums) { 2 | int count=0; 3 | for (int i = 0 ; i < nums.length-1;i++) { 4 | if (nums[i] == 6){ 5 | if (nums[i+1] == 6 || nums[i+1] == 7) 6 | count++; 7 | } 8 | } 9 | return count; 10 | } 11 | -------------------------------------------------------------------------------- /java/AP-1/scoresIncreasing.java: -------------------------------------------------------------------------------- 1 | public boolean scoresIncreasing(int[] scores) { 2 | boolean match = false; 3 | for (int i = 0; i < scores.length-1; i++) { 4 | if (scores[i+1] >= scores[i]) 5 | match = true; 6 | else 7 | return false; 8 | } 9 | return match; 10 | } -------------------------------------------------------------------------------- /java/Array-2/sameEnds.java: -------------------------------------------------------------------------------- 1 | public boolean sameEnds(int[] nums, int len) { 2 | boolean foo = true; 3 | 4 | for (int i = 0; i < len; i++) { 5 | if (nums[i] == nums[nums.length-len+i]) 6 | foo = true; 7 | else 8 | foo = false; 9 | } 10 | return foo; 11 | } 12 | -------------------------------------------------------------------------------- /java/Logic-1/shareDigit.java: -------------------------------------------------------------------------------- 1 | public boolean shareDigit(int a, int b) { 2 | int aL = a / 10; 3 | int aR = a % 10; 4 | int bL = b / 10; 5 | int bR = b % 10; 6 | 7 | if (aL == bL || aL == bR || aR == bL || aR == bR) 8 | return true; 9 | else 10 | return false; 11 | } 12 | -------------------------------------------------------------------------------- /java/Logic-2/noTeenSum.java: -------------------------------------------------------------------------------- 1 | public int noTeenSum(int a, int b, int c) { 2 | return fixTeen(a) + fixTeen(b) + fixTeen(c); 3 | } 4 | public int fixTeen(int n) { 5 | if ( (n >=13 && n < 15) || (n > 16 && n <= 19) ) 6 | return 0; 7 | else 8 | return n; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /java/String-1/conCat.java: -------------------------------------------------------------------------------- 1 | public String conCat(String a, String b) { 2 | if (a.length() == 0 || b.length() == 0) 3 | return a+b; 4 | if ((a.substring(a.length() - 1, a.length())).equals(b.substring(0,1))) 5 | return a + b.substring(1,b.length()); 6 | else 7 | return a+b; 8 | } 9 | -------------------------------------------------------------------------------- /java/Array-1/biggerTwo.java: -------------------------------------------------------------------------------- 1 | public int[] biggerTwo(int[] a, int[] b) { 2 | int aTotal = a[0] + a[1]; 3 | int bTotal = b[0] + b[1]; 4 | 5 | if (aTotal == bTotal) 6 | return a; 7 | else if (aTotal > bTotal) 8 | return a; 9 | else 10 | return b; 11 | 12 | 13 | } 14 | -------------------------------------------------------------------------------- /java/Array-2/sum13.java: -------------------------------------------------------------------------------- 1 | public int sum13(int[] nums) { 2 | int sum = 0; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | if(nums[i] != 13) { 6 | sum += nums[i]; 7 | if(i>0 && nums[i-1] == 13) 8 | sum -= nums[i]; 9 | } 10 | } 11 | return sum; 12 | } 13 | -------------------------------------------------------------------------------- /java/Warmup-1/endUp.java: -------------------------------------------------------------------------------- 1 | public String endUp(String str) { 2 | int len = str.length(); 3 | 4 | if (len <= 3) 5 | return str.toUpperCase(); 6 | else { 7 | String temp = str.substring(len - 3, len); 8 | return str.substring(0, len - 3) + temp.toUpperCase(); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /java/Warmup-1/lastDigit.java: -------------------------------------------------------------------------------- 1 | public boolean lastDigit(int a, int b) { 2 | String strA = Integer.toString(a); 3 | String strB = Integer.toString(b); 4 | 5 | if (strA.charAt(strA.length() - 1) == strB.charAt(strB.length() - 1)) 6 | return true; 7 | else 8 | return false; 9 | } 10 | -------------------------------------------------------------------------------- /java/Array-2/zeroMax.java: -------------------------------------------------------------------------------- 1 | public int[] zeroMax(int[] nums) { 2 | int max = 0; 3 | 4 | for (int i = nums.length-1; i >= 0; i--) { 5 | if (nums[i] % 2 != 0) 6 | max = Math.max(max, nums[i]); 7 | if (nums[i] == 0) 8 | nums[i] = max; 9 | } 10 | return nums; 11 | } 12 | -------------------------------------------------------------------------------- /java/Recursion-1/pairStar.java: -------------------------------------------------------------------------------- 1 | public String pairStar(String str) { 2 | if (str.equals("") || str.length() == 1) return str; 3 | if (str.charAt(0) == str.charAt(1)) 4 | return str.charAt(0) + "*" + pairStar(str.substring(1)); 5 | else 6 | return str.charAt(0) + pairStar(str.substring(1)); 7 | } 8 | -------------------------------------------------------------------------------- /java/String-2/countHi.java: -------------------------------------------------------------------------------- 1 | public int countHi(String str) { 2 | int len = str.length(); 3 | int count = 0; 4 | 5 | for (int i = 0; i < len - 1; i++) { 6 | String temp = str.substring(i, i+2); 7 | if (temp.compareTo("hi") == 0) 8 | count++; 9 | } 10 | return count; 11 | } 12 | -------------------------------------------------------------------------------- /java/Warmup-2/noTriples.java: -------------------------------------------------------------------------------- 1 | public boolean noTriples(int[] nums) { 2 | int count = 0; 3 | for (int i = 0 ; i < nums.length - 1;i++) { 4 | if (i+2 <= nums.length -1) { 5 | if (nums[i] == nums[i+1] && nums[i] == nums[i+2]) 6 | return false; 7 | } 8 | } return true; 9 | } 10 | -------------------------------------------------------------------------------- /java/Logic-1/blueTicket.java: -------------------------------------------------------------------------------- 1 | public int blueTicket(int a, int b, int c) { 2 | int ab = a + b; 3 | int bc = b + c; 4 | int ac = a + c; 5 | 6 | if (ab == 10 || bc == 10 || ac == 10) 7 | return 10; 8 | if (ab - bc == 10 || ab - ac == 10) 9 | return 5; 10 | else 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /java/AP-1/scoreUp.java: -------------------------------------------------------------------------------- 1 | public int scoreUp(String[] key, String[] answers) { 2 | int score = 0; 3 | for (int i = 0; i < key.length; i++) { 4 | if (key[i] == answers[i]) 5 | score += 4; 6 | else if (answers[i] != "?" && answers[i] != key[i]) 7 | score--; 8 | } 9 | return score; 10 | } 11 | -------------------------------------------------------------------------------- /java/AP-1/scoresClump.java: -------------------------------------------------------------------------------- 1 | public boolean scoresClump(int[] scores) { 2 | if (scores.length < 3) 3 | return false; 4 | 5 | for (int i = 0; i < scores.length-2; i++) { 6 | if (scores[i+2] - scores[i+1] <= 2 && scores[i+2] - scores[i] <= 2) 7 | return true; 8 | } 9 | return false; 10 | } 11 | -------------------------------------------------------------------------------- /java/String-2/repeatSeparator.java: -------------------------------------------------------------------------------- 1 | public String repeatSeparator(String word, String sep, int count) { 2 | String newWord = ""; 3 | 4 | for (int i = 0; i < count; i++) { 5 | if (i < count-1) 6 | newWord += word + sep; 7 | else 8 | newWord += word; 9 | } 10 | return newWord; 11 | } 12 | -------------------------------------------------------------------------------- /java/Array-1/makeEnds.java: -------------------------------------------------------------------------------- 1 | public int[] makeEnds(int[] nums) { 2 | int[] myArray = new int[2]; 3 | if (nums.length == 1) { 4 | myArray[0] = nums[0]; 5 | myArray[1] = nums[0]; 6 | } else { 7 | myArray[0] = nums[0]; 8 | myArray[1] = nums[nums.length-1]; 9 | } 10 | 11 | return myArray; 12 | } 13 | -------------------------------------------------------------------------------- /java/Logic-1/alarmClock.java: -------------------------------------------------------------------------------- 1 | public String alarmClock(int day, boolean vacation) { 2 | if (vacation) { 3 | if(day > 0 && day != 6) 4 | return "10:00"; 5 | else 6 | return "off"; 7 | } else if (day > 0 && day != 6) 8 | return "7:00"; 9 | else 10 | return "10:00"; 11 | 12 | } 13 | -------------------------------------------------------------------------------- /java/String-3/countTriple.java: -------------------------------------------------------------------------------- 1 | public int countTriple(String str) { 2 | int len = str.length(); 3 | int count = 0; 4 | 5 | for (int i = 0; i < len-2; i++){ 6 | char tmp = str.charAt(i); 7 | if (tmp == str.charAt(i+1) && tmp == str.charAt(i+2)) 8 | count++; 9 | } 10 | return count; 11 | } 12 | -------------------------------------------------------------------------------- /java/Logic-1/sumLimit.java: -------------------------------------------------------------------------------- 1 | public int sumLimit(int a, int b) { 2 | String aString = String.valueOf(a); 3 | int aLen = aString.length(); 4 | String sumString = String.valueOf(a+b); 5 | int sumLen = sumString.length(); 6 | 7 | if (sumLen == aLen) 8 | return a + b; 9 | else 10 | return a; 11 | 12 | } 13 | -------------------------------------------------------------------------------- /java/Warmup-1/posNeg.java: -------------------------------------------------------------------------------- 1 | public boolean posNeg(int a, int b, boolean negative) { 2 | if (negative && a < 0 && b < 0) 3 | return true; 4 | else if (!negative && a < 0 && b > 0) 5 | return true; 6 | else if (!negative && a > 0 && b < 0) 7 | return true; 8 | else 9 | return false; 10 | 11 | } 12 | -------------------------------------------------------------------------------- /java/Logic-1/withoutDoubles.java: -------------------------------------------------------------------------------- 1 | public int withoutDoubles(int die1, int die2, boolean noDoubles) { 2 | if(noDoubles) { 3 | if (die1 == die2) { 4 | if (die1 != 6) 5 | return die1 + 1 + die2; 6 | else 7 | return 1 + die2; 8 | } 9 | } 10 | 11 | return die1 + die2; 12 | 13 | } 14 | -------------------------------------------------------------------------------- /java/Recursion-2/groupNoAdj.java: -------------------------------------------------------------------------------- 1 | public boolean groupNoAdj(int start, int[] nums, int target) { 2 | if (start >= nums.length) 3 | return (target == 0); 4 | 5 | if (groupNoAdj(start+1, nums, target)) return true; 6 | if (groupNoAdj(start+2, nums, target-nums[start])) return true; 7 | return false; 8 | 9 | } 10 | -------------------------------------------------------------------------------- /java/Recursion-2/groupSum.java: -------------------------------------------------------------------------------- 1 | public boolean groupSum(int start, int[] nums, int target) { 2 | if (start >= nums.length) { 3 | return (target == 0); 4 | } 5 | 6 | if (groupSum(start + 1, nums, target - nums[start])) return true; 7 | if (groupSum(start + 1, nums, target)) return true; 8 | 9 | return false; 10 | } -------------------------------------------------------------------------------- /java/Recursion-2/groupSum6.java: -------------------------------------------------------------------------------- 1 | public boolean groupSum6(int start, int[] nums, int target) { 2 | if (start >= nums.length) 3 | return (target == 0); 4 | 5 | if (groupSum6(start+1, nums, target - nums[start])) return true; 6 | if (nums[start] != 6 && groupSum6(start+1, nums, target)) return true; 7 | 8 | return false; 9 | } -------------------------------------------------------------------------------- /java/String-1/hasBad.java: -------------------------------------------------------------------------------- 1 | public boolean hasBad(String str) { 2 | if(str.length() < 3) 3 | return false; 4 | else if ((str.substring(0,3)).equals("bad")) 5 | return true; 6 | else if (str.length() > 3){ 7 | if ((str.substring(1,4)).equals("bad")) 8 | return true; 9 | } 10 | return false; 11 | } 12 | -------------------------------------------------------------------------------- /java/Warmup-1/max1020.java: -------------------------------------------------------------------------------- 1 | public int max1020(int a, int b) { 2 | int tempa; 3 | int tempb; 4 | 5 | if (a >= 10 && a <= 20) 6 | tempa = a; 7 | else 8 | tempa = 0; 9 | 10 | if (b >= 10 && b <= 20) 11 | tempb = b; 12 | else 13 | tempb = 0; 14 | 15 | return Math.max(tempa, tempb); 16 | } 17 | -------------------------------------------------------------------------------- /java/Warmup-2/altPairs.java: -------------------------------------------------------------------------------- 1 | public String altPairs(String str) { 2 | String result = ""; 3 | 4 | for (int i=0; i str.length()) { 7 | end = str.length(); 8 | } 9 | result = result + str.substring(i, end); 10 | } 11 | 12 | return result; 13 | } -------------------------------------------------------------------------------- /java/Warmup-2/stringX.java: -------------------------------------------------------------------------------- 1 | public String stringX(String str) { 2 | String result = ""; 3 | int len = str.length(); 4 | for (int i = 0; i < len; i++){ 5 | char temp = str.charAt(i); 6 | if (!(i > 0 && i < len - 1 && temp == 'x')) 7 | result = result + temp; 8 | 9 | } 10 | return result; 11 | } 12 | -------------------------------------------------------------------------------- /java/Logic-2/evenlySpaced.java: -------------------------------------------------------------------------------- 1 | public boolean evenlySpaced(int a, int b, int c) { 2 | int[] anArray = {a, b, c}; 3 | Arrays.sort(anArray); 4 | 5 | int diffLow = anArray[1] - anArray[0]; 6 | int diffHi = anArray[2] - anArray[1]; 7 | 8 | if (diffLow == diffHi) 9 | return true; 10 | else 11 | return false; 12 | } 13 | -------------------------------------------------------------------------------- /java/String-3/sumDigits.java: -------------------------------------------------------------------------------- 1 | public int sumDigits(String str) { 2 | int len = str.length(); 3 | int sum = 0; 4 | 5 | for (int i = 0; i < len; i++) { 6 | if (Character.isDigit(str.charAt(i))) { 7 | String tmp = str.substring(i,i+1); 8 | sum += Integer.parseInt(tmp); 9 | } 10 | } 11 | return sum; 12 | } 13 | -------------------------------------------------------------------------------- /java/Warmup-1/stringE.java: -------------------------------------------------------------------------------- 1 | public boolean stringE(String str) { 2 | int len = str.length(); 3 | int counter = 0; 4 | 5 | for (int i = 0; i < len; i++) { 6 | if (str.charAt(i) == 'e') 7 | counter++; 8 | } 9 | 10 | if (counter >= 1 && counter <= 3) 11 | return true; 12 | else 13 | return false; 14 | } 15 | -------------------------------------------------------------------------------- /java/Array-2/has12.java: -------------------------------------------------------------------------------- 1 | public boolean has12(int[] nums) { 2 | boolean foundOne = false; 3 | boolean foundOneTwo = false; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (nums[i] == 1) 7 | foundOne = true; 8 | if (nums[i] == 2 && foundOne) 9 | foundOneTwo = true; 10 | } 11 | return foundOneTwo; 12 | } 13 | -------------------------------------------------------------------------------- /java/Array-2/notAlone.java: -------------------------------------------------------------------------------- 1 | public int[] notAlone(int[] nums, int val) { 2 | for (int i = 0; i < nums.length; i++) { 3 | if (i > 0 && i < nums.length-1 && nums[i] == val) { 4 | if (nums[i] != nums[i-1] && nums[i] != nums[i+1]) 5 | nums[i] = Math.max(nums[i-1], nums[i+1]); 6 | 7 | } 8 | } 9 | return nums; 10 | } 11 | -------------------------------------------------------------------------------- /java/String-1/without2.java: -------------------------------------------------------------------------------- 1 | public String without2(String str) { 2 | int len = str.length(); 3 | if (len == 2) 4 | return ""; 5 | if (len < 2) 6 | return str; 7 | else { 8 | if (str.substring(0,2).equals(str.substring(len-2, len))) 9 | return str.substring(2,len); 10 | else return str; 11 | 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /java/String-2/prefixAgain.java: -------------------------------------------------------------------------------- 1 | public boolean prefixAgain(String str, int n) { 2 | int len = str.length(); 3 | String prefix = str.substring(0,n); 4 | 5 | for (int i = n; i < len; i++) { 6 | if(n+i <= len) { 7 | if (prefix.equals(str.substring(i,n+i))) 8 | return true; 9 | } 10 | } 11 | return false; 12 | } 13 | -------------------------------------------------------------------------------- /java/Logic-2/makeBricks.java: -------------------------------------------------------------------------------- 1 | public boolean makeBricks(int small, int big, int goal) { 2 | int digit = goal % 10; 3 | if (goal > small + (big * 5)) 4 | return false; 5 | 6 | if (digit < 5 && small < digit) 7 | return false; 8 | else if (digit > 5 && digit > small + 5) 9 | return false; 10 | else 11 | return true; 12 | } 13 | -------------------------------------------------------------------------------- /java/Recursion-1/parenBit.java: -------------------------------------------------------------------------------- 1 | public String parenBit(String str) { 2 | if (str.equals("")) return str; 3 | if (str.charAt(0) == '(') { 4 | if (str.charAt(str.length()-1) == ')') 5 | return str; 6 | else 7 | return parenBit(str.substring(0, str.length()-1)); 8 | } else 9 | return parenBit(str.substring(1)); 10 | } 11 | -------------------------------------------------------------------------------- /java/Recursion-1/strCount.java: -------------------------------------------------------------------------------- 1 | public int strCount(String str, String sub) { 2 | int strlen = str.length(); 3 | int sublen = sub.length(); 4 | if (strlen < sublen) return 0; 5 | if (str.substring(0,sublen).equals(sub)) 6 | return 1 + strCount(str.substring(sublen), sub); 7 | else 8 | return strCount(str.substring(1), sub); 9 | } 10 | -------------------------------------------------------------------------------- /java/Logic-2/closeFar.java: -------------------------------------------------------------------------------- 1 | public boolean closeFar(int a, int b, int c) { 2 | 3 | if (Math.abs(a - b) <= 1 && Math.abs(a - c) >= 2 && Math.abs(b - c) >= 2){ 4 | return true; 5 | } else if (Math.abs(a - c) <= 1 && Math.abs(a - b) >= 2 && Math.abs(b - c) >= 2){ 6 | return true; 7 | }else{ 8 | return false; 9 | } 10 | 11 | } 12 | -------------------------------------------------------------------------------- /java/Warmup-2/stringYak.java: -------------------------------------------------------------------------------- 1 | public String stringYak(String str) { 2 | String result = ""; 3 | 4 | for (int i=0; i 2 && str.charAt(len-3) != 'x') || len == 2 ) 6 | return 1 + countHi2(str.substring(0, len-1)); 7 | } 8 | return countHi2(str.substring(0, len-1)); 9 | 10 | } -------------------------------------------------------------------------------- /java/AP-1/sumHeights2.java: -------------------------------------------------------------------------------- 1 | public int sumHeights2(int[] heights, int start, int end) { 2 | int tmp = 0; 3 | for (int i = start; i <= end-1; i++) { 4 | if (heights[i] < heights[i+1]) { 5 | tmp += 2 * (Math.abs(heights[i] - heights[i+1])); 6 | } 7 | else 8 | tmp += Math.abs(heights[i] - heights[i+1]); 9 | } 10 | return tmp; 11 | } 12 | -------------------------------------------------------------------------------- /java/Array-3/canBalance.java: -------------------------------------------------------------------------------- 1 | public boolean canBalance(int[] nums) { 2 | int lSum = 0; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | lSum += nums[i]; 6 | int rSum = 0; 7 | for (int j = nums.length-1; j > i; j--) { 8 | rSum += nums[j]; 9 | } 10 | if (rSum == lSum) 11 | return true; 12 | } 13 | return false; 14 | } 15 | -------------------------------------------------------------------------------- /java/Logic-2/makeChocolate.java: -------------------------------------------------------------------------------- 1 | public int makeChocolate(int small, int big, int goal) { 2 | int rem = goal % 5; 3 | 4 | if (small + (big*5) < goal) 5 | return -1; 6 | else if (rem <= small && goal - big*5 > 4) 7 | return rem + 5; 8 | else if (rem <= small) 9 | return rem; 10 | else 11 | return -1; 12 | 13 | 14 | 15 | 16 | } -------------------------------------------------------------------------------- /java/AP-1/matchUp.java: -------------------------------------------------------------------------------- 1 | public int matchUp(String[] a, String[] b) { 2 | int count = 0; 3 | for (int i = 0; i < a.length; i++) { 4 | String tmp1 = a[i]; 5 | String tmp2 = b[i]; 6 | if (!tmp1.equals("") && !tmp2.equals("")) { 7 | if (tmp1.charAt(0) == tmp2.charAt(0)) 8 | count++; 9 | } 10 | 11 | } 12 | return count; 13 | } 14 | -------------------------------------------------------------------------------- /java/AP-1/scoresSpecial.java: -------------------------------------------------------------------------------- 1 | public int scoresSpecial(int[] a, int[] b) { 2 | int spec1 = helper(a); 3 | int spec2 = helper(b); 4 | return spec1 + spec2; 5 | } 6 | 7 | public int helper(int[] a) { 8 | int tmp = 0; 9 | for (int i = 0; i < a.length; i++) { 10 | if (a[i] % 10 == 0 && a[i] > tmp) 11 | tmp = a[i]; 12 | } 13 | return tmp; 14 | } 15 | -------------------------------------------------------------------------------- /java/Array-2/has22.java: -------------------------------------------------------------------------------- 1 | public boolean has22(int[] nums) { 2 | boolean found = false; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | if (nums[i] == 2 && i > 0 && nums[i-1] == 2) { 6 | found = true; 7 | } 8 | if (nums[i] == 2 && i < nums.length-1 && nums[i+1] == 2) { 9 | found = true; 10 | } 11 | } 12 | return found; 13 | } 14 | -------------------------------------------------------------------------------- /java/Warmup-2/stringMatch.java: -------------------------------------------------------------------------------- 1 | public int stringMatch(String a, String b) { 2 | int len = Math.min(a.length(), b.length()); 3 | int count = 0; 4 | 5 | for (int i = 0; i < len-1; i++){ 6 | String aSub = a.substring(i, i+2); 7 | String bSub = b.substring(i, i+2); 8 | if (aSub.equals(bSub)) 9 | count++; 10 | } 11 | return count; 12 | } 13 | -------------------------------------------------------------------------------- /java/AP-1/commonTwo.java: -------------------------------------------------------------------------------- 1 | public int commonTwo(String[] a, String[] b) { 2 | int count = 0; 3 | String str = ""; 4 | for (int i = 0; i < b.length; i++) { 5 | for (int j = 0; j < a.length; j++) { 6 | if (a[j].equals(b[i]) && !str.contains(a[j])) { 7 | str += a[j]; 8 | count++; 9 | } 10 | } 11 | } 12 | return count; 13 | } 14 | -------------------------------------------------------------------------------- /java/Array-2/tenRun.java: -------------------------------------------------------------------------------- 1 | public int[] tenRun(int[] nums) { 2 | boolean ten = false; 3 | int tmp = 0; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (nums[i] % 10 == 0) { 7 | tmp = nums[i]; 8 | ten = true; 9 | } 10 | else if (nums[i] % 10 != 0 && ten) { 11 | nums[i] = tmp; 12 | } 13 | } 14 | return nums; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /java/Logic-1/in1To10.java: -------------------------------------------------------------------------------- 1 | public boolean in1To10(int n, boolean outsideMode) { 2 | if (!outsideMode){ 3 | if (n >= 1 && n <= 10) { 4 | return true; 5 | } else { 6 | return false; 7 | } 8 | } else { 9 | if (n <= 1 || n >= 10) { 10 | return true; 11 | } else { 12 | return false; 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /java/Array-2/has77.java: -------------------------------------------------------------------------------- 1 | public boolean has77(int[] nums) { 2 | if (nums.length < 2) 3 | return false; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (nums[i] == 7 && i < nums.length-1 && nums[i+1] == 7) 7 | return true; 8 | if (nums[i] == 7 && i < nums.length-2 && nums[i+2] == 7) 9 | return true; 10 | } 11 | return false; 12 | } 13 | -------------------------------------------------------------------------------- /java/Array-3/countClumps.java: -------------------------------------------------------------------------------- 1 | public int countClumps(int[] nums) { 2 | boolean match = false; 3 | int count = 0; 4 | for (int i = 0; i < nums.length-1; i++) { 5 | if (nums[i] == nums[i+1] && !match) { 6 | match = true; 7 | count++; 8 | } 9 | else if (nums[i] != nums[i+1]) { 10 | match = false; 11 | } 12 | } 13 | return count; 14 | } 15 | -------------------------------------------------------------------------------- /java/Array-2/modThree.java: -------------------------------------------------------------------------------- 1 | public boolean modThree(int[] nums) { 2 | int odd = 0; 3 | int even = 0; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (nums[i] % 2 == 0) { 7 | even++; 8 | if (odd < 3) odd = 0; 9 | } 10 | else { 11 | odd++; 12 | if (even < 3) even = 0; 13 | } 14 | } 15 | return (odd == 3 || even == 3); 16 | } 17 | -------------------------------------------------------------------------------- /java/Warmup-2/frontTimes.java: -------------------------------------------------------------------------------- 1 | public String frontTimes(String str, int n) { 2 | int len = str.length(); 3 | String temp = ""; 4 | 5 | if (len < 4) { 6 | for (int i = 0; i < n; i++) { 7 | temp += str; 8 | } 9 | } else { 10 | for (int j = 0; j < n; j++) { 11 | temp += str.substring(0,3); 12 | } 13 | } 14 | 15 | return temp; 16 | } 17 | -------------------------------------------------------------------------------- /java/Warmup-2/last2.java: -------------------------------------------------------------------------------- 1 | public int last2(String str) { 2 | if (str.length() < 2) return 0; 3 | 4 | String end = str.substring(str.length()-2); 5 | 6 | int count = 0; 7 | 8 | for (int i=0; i 0) 9 | return 1; 10 | else if (aId > bId) 11 | return 1; 12 | else 13 | return -1; 14 | 15 | } 16 | -------------------------------------------------------------------------------- /java/Array-2/withoutTen.java: -------------------------------------------------------------------------------- 1 | public int[] withoutTen(int[] nums) { 2 | int[] result = new int[nums.length]; 3 | int j = 0; 4 | for(int i = 0; i < nums.length; i++) { 5 | if(nums[i] == 10) { 6 | } else { 7 | result[j] = nums[i]; 8 | j++; 9 | } 10 | } 11 | 12 | for(int i = j; i < nums.length; i++) { 13 | result[i] = 0; 14 | } 15 | return result; 16 | } -------------------------------------------------------------------------------- /java/Logic-2/blackjack.java: -------------------------------------------------------------------------------- 1 | public int blackjack(int a, int b) { 2 | if (a > 21 && b > 21) { 3 | return 0; 4 | }else if (a > 21) { 5 | return b; 6 | } else if (b > 21) { 7 | return a; 8 | } 9 | 10 | int sumA = 21 - a; 11 | int sumB = 21 - b; 12 | 13 | if (sumA > sumB) { 14 | return b; 15 | } else { 16 | return a; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /java/Array-1/unlucky1.java: -------------------------------------------------------------------------------- 1 | public boolean unlucky1(int[] nums) { 2 | if (nums.length < 2) { 3 | return false; 4 | } else if ((nums[0] == 1 && nums[1] == 3) || (nums[nums.length-2] == 1 && nums[nums.length-1] == 3)) { 5 | return true; 6 | } else if (nums.length > 2 && nums[1] == 1 && nums[2] == 3) { 7 | return true; 8 | } else 9 | return false; 10 | 11 | } 12 | -------------------------------------------------------------------------------- /java/Array-2/more14.java: -------------------------------------------------------------------------------- 1 | public boolean more14(int[] nums) { 2 | int count1 = 0; 3 | int count4 = 0; 4 | boolean isTrue = false; 5 | 6 | for (int i = 0; i < nums.length; i++) { 7 | if (nums[i] == 1) 8 | count1++; 9 | if (nums[i] == 4) 10 | count4++; 11 | } 12 | 13 | if (count1 > count4) 14 | isTrue = true; 15 | 16 | return isTrue; 17 | 18 | } 19 | -------------------------------------------------------------------------------- /java/String-1/minCat.java: -------------------------------------------------------------------------------- 1 | public String minCat(String a, String b) { 2 | if (a.length() == b.length()) 3 | return a+b; 4 | if (a.length() > b.length()){ 5 | int diff = a.length() - b.length(); 6 | return a.substring(diff, a.length()) + b; 7 | 8 | } else { 9 | int diff = b.length() - a.length(); 10 | return a + b.substring(diff, b.length()); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /java/Array-2/centeredAverage.java: -------------------------------------------------------------------------------- 1 | public int centeredAverage(int[] nums) { 2 | int min = nums[0]; 3 | int max = nums[0]; 4 | int sum = 0; 5 | 6 | for (int i = 0; i < nums.length; i++){ 7 | sum += nums[i]; 8 | min = Math.min(min,nums[i]); 9 | max = Math.max(max,nums[i]); 10 | } 11 | sum = sum - max - min; 12 | sum = sum / (nums.length-2); 13 | return sum; 14 | 15 | } 16 | -------------------------------------------------------------------------------- /java/Array-2/shiftLeft.java: -------------------------------------------------------------------------------- 1 | public int[] shiftLeft(int[] nums) { 2 | int[] foo; 3 | foo = new int[nums.length]; 4 | 5 | if (nums.length == 0) 6 | return foo; 7 | 8 | for (int i = 0; i < nums.length-1; i++) { 9 | if (i > 0) 10 | foo[i] = nums[i+1]; 11 | } 12 | if (nums.length > 1) 13 | foo[0] = nums[1]; 14 | foo[nums.length-1] = nums[0]; 15 | return foo; 16 | } 17 | -------------------------------------------------------------------------------- /java/String-1/deFront.java: -------------------------------------------------------------------------------- 1 | public String deFront(String str) { 2 | int len = str.length(); 3 | String temp = ""; 4 | 5 | for (int i = 0; i < len; i++) { 6 | if (i == 0 && str.charAt(i) == 'a') 7 | temp += 'a'; 8 | else if (i == 1 && str.charAt(i) == 'b') 9 | temp += 'b'; 10 | else if (i > 1) 11 | temp += str.charAt(i); 12 | } 13 | return temp; 14 | } 15 | -------------------------------------------------------------------------------- /java/String-1/withoutX2.java: -------------------------------------------------------------------------------- 1 | public String withoutX2(String str) { 2 | String temp = ""; 3 | 4 | for (int i = 0; i < str.length(); i++) { 5 | if (i == 0 && str.charAt(i) != 'x') 6 | temp += str.charAt(i); 7 | else if (i == 1 && str.charAt(i) != 'x') 8 | temp += str.charAt(i); 9 | else if (i > 1) 10 | temp += str.charAt(i); 11 | } 12 | 13 | return temp; 14 | } 15 | -------------------------------------------------------------------------------- /java/String-2/mixString.java: -------------------------------------------------------------------------------- 1 | public String mixString(String a, String b) { 2 | int aLen = a.length(); 3 | int bLen = b.length(); 4 | int max = Math.max(aLen, bLen); 5 | String word = ""; 6 | 7 | for (int i = 0; i < max; i++) { 8 | if (i <= aLen-1) 9 | word += a.substring(i,i+1); 10 | if (i <= bLen-1) 11 | word += b.substring(i,i+1); 12 | 13 | } 14 | return word; 15 | } 16 | -------------------------------------------------------------------------------- /java/Logic-1/caughtSpeeding.java: -------------------------------------------------------------------------------- 1 | public int caughtSpeeding(int speed, boolean isBirthday) { 2 | if (!(isBirthday)) { 3 | if (speed <= 60) 4 | return 0; 5 | if (speed > 60 && speed <= 80) 6 | return 1; 7 | else 8 | return 2; 9 | } else if (speed <=65) 10 | return 0; 11 | else if (speed > 65 && speed <= 85) 12 | return 1; 13 | else 14 | return 2; 15 | } 16 | -------------------------------------------------------------------------------- /java/String-2/countCode.java: -------------------------------------------------------------------------------- 1 | public int countCode(String str) { 2 | int len = str.length(); 3 | int count = 0; 4 | String co = "co"; 5 | String e = "e"; 6 | 7 | if (len < 4) 8 | return 0; 9 | 10 | for (int i = 0; i < len - 3; i++) { 11 | if (co.compareTo(str.substring(i,i+2)) == 0 && e.compareTo(str.substring(i+3, i+4)) == 0) 12 | count++; 13 | } 14 | return count; 15 | } 16 | -------------------------------------------------------------------------------- /java/Array-2/post4.java: -------------------------------------------------------------------------------- 1 | public int[] post4(int[] nums) { 2 | for (int i = nums.length-1; i >= 0; i--) { 3 | if (nums[i] == 4) { 4 | int[] foo; 5 | foo = new int[nums.length-i-1]; 6 | 7 | for (int j = 0; j < foo.length; j++) { 8 | foo[j] = nums[i+j+1]; 9 | } 10 | return foo; 11 | } 12 | } 13 | 14 | int[] bar; 15 | bar = new int[0]; 16 | return bar; 17 | } 18 | -------------------------------------------------------------------------------- /java/Array-2/tripleUp.java: -------------------------------------------------------------------------------- 1 | public boolean tripleUp(int[] nums) { 2 | boolean foo = false; 3 | int count = 0; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (i < nums.length-1) { 7 | int sum = nums[i+1] - nums[i]; 8 | if (sum == 1) 9 | count++; 10 | else 11 | count = 0; 12 | } 13 | if (count == 2) 14 | foo = true; 15 | } 16 | return foo; 17 | } 18 | -------------------------------------------------------------------------------- /java/Warmup-2/has271.java: -------------------------------------------------------------------------------- 1 | public boolean has271(int[] nums) { 2 | int len = nums.length; 3 | 4 | for (int i = 0; i < nums.length - 1; i++) { 5 | if (i+2 <= nums.length - 1){ 6 | int j = Math.abs(nums[i] - 1); 7 | int k = Math.abs(j - nums[i+2]); 8 | if(nums[i+1] == nums[i]+5 && k <= 2) 9 | return true; 10 | } 11 | 12 | } return false; 13 | } 14 | -------------------------------------------------------------------------------- /java/Array-2/evenOdd.java: -------------------------------------------------------------------------------- 1 | public int[] evenOdd(int[] nums) { 2 | int countE = 0; 3 | int countO = nums.length-1; 4 | int[] array = new int[nums.length]; 5 | 6 | for (int i = 0; i < nums.length; i++) { 7 | if (nums[i] % 2 == 0) { 8 | array[countE] = nums[i]; 9 | countE++; 10 | } 11 | else { 12 | array[countO] = nums[i]; 13 | countO--; 14 | } 15 | } 16 | return array; 17 | } 18 | -------------------------------------------------------------------------------- /java/Array-1/front11.java: -------------------------------------------------------------------------------- 1 | public int[] front11(int[] a, int[] b) { 2 | if (a.length == 0 && b.length == 0) { 3 | return a; 4 | } 5 | if (a.length == 0) { 6 | int[] myArray = new int[] {b[0]}; 7 | return myArray; 8 | } 9 | 10 | if (b.length == 0) { 11 | int[] myArray = new int[] {a[0]}; 12 | return myArray; 13 | } 14 | 15 | int[] myArray = new int[] {a[0], b[0]}; 16 | return myArray; 17 | } 18 | -------------------------------------------------------------------------------- /java/String-2/catDog.java: -------------------------------------------------------------------------------- 1 | public boolean catDog(String str) { 2 | int len = str.length(); 3 | int cat = 0; 4 | int dog = 0; 5 | 6 | for (int i = 0; i < len - 2; i++) { 7 | String temp = str.substring(i, i+3); 8 | if (temp.compareTo("cat") == 0) 9 | cat++; 10 | if (temp.compareTo("dog") == 0) 11 | dog++; 12 | } 13 | if (cat == dog) 14 | return true; 15 | else 16 | return false; 17 | } 18 | -------------------------------------------------------------------------------- /java/String-2/zipZap.java: -------------------------------------------------------------------------------- 1 | public String zipZap(String str) { 2 | int len = str.length(); 3 | String finalString = ""; 4 | 5 | for (int i = 0; i < len; i++) { 6 | finalString += str.substring(i,i+1); 7 | if (i > 0 && i < len-1) { 8 | if (str.charAt(i-1) == 'z' && str.charAt(i+1) == 'p') 9 | finalString = finalString.substring(0,finalString.length()-1); 10 | } 11 | } 12 | return finalString; 13 | } 14 | -------------------------------------------------------------------------------- /java/AP-1/mergeTwo.java: -------------------------------------------------------------------------------- 1 | public String[] mergeTwo(String[] a, String[] b, int n) { 2 | String out[] = new String[n]; 3 | int aindex =0, bindex=0; 4 | for(int i=0; i 0) { 6 | int[] foo; 7 | foo = new int[i]; 8 | for (int j = 0; j < foo.length; j++) { 9 | foo[j] = nums[j]; 10 | 11 | } 12 | if (nums[0] != 4) 13 | return foo; 14 | } 15 | } 16 | int[] bar; 17 | bar = new int[0]; 18 | return bar; 19 | } 20 | -------------------------------------------------------------------------------- /java/String-3/gHappy.java: -------------------------------------------------------------------------------- 1 | public boolean gHappy(String str) { 2 | int len = str.length(); 3 | boolean happy = true; 4 | 5 | for (int i = 0; i < len; i++) { 6 | if (str.charAt(i) == 'g') { 7 | if (i > 0 && str.charAt(i-1) == 'g') 8 | happy = true; 9 | else if (i < len-1 && str.charAt(i+1) == 'g') 10 | happy = true; 11 | else 12 | happy = false; 13 | } 14 | } 15 | return happy; 16 | } 17 | -------------------------------------------------------------------------------- /java/Array-2/twoTwo.java: -------------------------------------------------------------------------------- 1 | public boolean twoTwo(int[] nums) { 2 | boolean isTrue = false; 3 | 4 | for (int i = 0; i < nums.length; i++) { 5 | if (nums[i] == 2) { 6 | if (nums.length > 1 && i < nums.length-1 && nums[i+1] == 2) 7 | isTrue = true; 8 | else if (nums.length > 1 && i > 0 && nums[i-1] == 2) 9 | isTrue = true; 10 | else 11 | return false; 12 | } 13 | } 14 | return true; 15 | } 16 | -------------------------------------------------------------------------------- /java/AP-1/copyEndy.java: -------------------------------------------------------------------------------- 1 | public int[] copyEndy(int[] nums, int count) { 2 | int ctr = 0; 3 | int[] array = new int[count]; 4 | for (int i = 0; i < nums.length; i++) { 5 | if (isEndy(nums[i])) { 6 | array[ctr] = nums[i]; 7 | ctr++; 8 | } 9 | if (ctr == count) 10 | return array; 11 | } 12 | return array; 13 | } 14 | 15 | private boolean isEndy(int n) { 16 | return (n >= 0 && n <= 10) || (n <= 100 && n >= 90); 17 | } -------------------------------------------------------------------------------- /java/String-3/maxBlock.java: -------------------------------------------------------------------------------- 1 | public int maxBlock(String str) { 2 | int len = str.length(); 3 | int count = 0; 4 | int tmpcount = 1; 5 | 6 | if (len == 0) 7 | return 0; 8 | 9 | for (int i = 0; i < len; i++) { 10 | if (i < len-1 && str.charAt(i) == str.charAt(i+1)) 11 | tmpcount++; 12 | else 13 | tmpcount = 1; 14 | 15 | if (tmpcount > count) 16 | count = tmpcount; 17 | } 18 | return count; 19 | } 20 | -------------------------------------------------------------------------------- /java/String-2/sameStarChar.java: -------------------------------------------------------------------------------- 1 | public boolean sameStarChar(String str) { 2 | int len = str.length(); 3 | boolean found = true; 4 | 5 | for (int i = 0; i < len; i++) { 6 | String tmpString = str.substring(i,i+1); 7 | 8 | if (tmpString.equals("*") && i > 0 && i < len-1) { 9 | if (str.charAt(i-1) == str.charAt(i+1)) 10 | found = true; 11 | else 12 | found = false; 13 | } 14 | } 15 | return found; 16 | } 17 | -------------------------------------------------------------------------------- /java/String-1/startWord.java: -------------------------------------------------------------------------------- 1 | public String startWord(String str, String word) { 2 | int lenStr = str.length(); 3 | int lenWord = word.length(); 4 | if (lenStr == 0) 5 | return ""; 6 | if (lenWord > lenStr) 7 | return ""; 8 | 9 | if (word.length() == 1) 10 | return str.substring(0,1); 11 | else if (str.substring(1,lenWord).equals(word.substring(1,lenWord))) 12 | return str.substring(0,lenWord); 13 | else 14 | return ""; 15 | } 16 | -------------------------------------------------------------------------------- /java/String-1/withoutX.java: -------------------------------------------------------------------------------- 1 | public String withoutX(String str) { 2 | if (str.length() == 0) 3 | return str; 4 | if (str.length() == 1){ 5 | if (str.charAt(0) == 'x') 6 | return ""; 7 | else 8 | return str; 9 | } 10 | 11 | if (str.charAt(0) == 'x') 12 | str = str.substring(1,str.length()); 13 | 14 | if (str.charAt(str.length()-1) == 'x') 15 | str = str.substring(0,str.length()-1); 16 | 17 | return str; 18 | } 19 | -------------------------------------------------------------------------------- /java/String-2/wordEnds.java: -------------------------------------------------------------------------------- 1 | public String wordEnds(String str, String word) { 2 | int slen = str.length(); 3 | int wlen = word.length(); 4 | String fin = ""; 5 | 6 | for (int i = 0; i < slen-wlen+1; i++) { 7 | String tmp = str.substring(i,i+wlen); 8 | if (i > 0 && tmp.equals(word)) 9 | fin += str.substring(i-1,i); 10 | if (i < slen-wlen && tmp.equals(word)) 11 | fin += str.substring(i+wlen,i+wlen+1); 12 | } 13 | return fin; 14 | } 15 | -------------------------------------------------------------------------------- /java/Recursion-1/strCopies.java: -------------------------------------------------------------------------------- 1 | public boolean strCopies(String str, String sub, int n) { 2 | if (func(str, sub) == n) return true; 3 | else return false; 4 | } 5 | 6 | private int func(String str, String sub) { 7 | int strlen = str.length(); 8 | int sublen = sub.length(); 9 | if (strlen < sublen) return 0; 10 | if (str.substring(0, sublen).equals(sub)) 11 | return 1 + func(str.substring(1), sub); 12 | else 13 | return func(str.substring(1), sub); 14 | } -------------------------------------------------------------------------------- /java/Array-2/haveThree.java: -------------------------------------------------------------------------------- 1 | public boolean haveThree(int[] nums) { 2 | int count = 0; 3 | boolean found = false; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (nums[i] != 3) 7 | found = false; 8 | if (nums[i] == 3 && found == true) 9 | return false; 10 | if (nums[i] == 3 && found == false) { 11 | found = true; 12 | count++; 13 | } 14 | } 15 | if (count == 3) 16 | return true; 17 | else 18 | return false; 19 | } 20 | -------------------------------------------------------------------------------- /java/String-2/xyBalance.java: -------------------------------------------------------------------------------- 1 | public boolean xyBalance(String str) { 2 | Boolean x = false; 3 | Boolean y = false; 4 | int len = str.length(); 5 | 6 | for (int i = 0; i < len; i++) { 7 | if (str.charAt(i) == 'x' && y == true){ 8 | x = true; 9 | y = false; 10 | } else if (str.charAt(i) == 'x') { 11 | x = true; 12 | } 13 | if (str.charAt(i) == 'y' && x == true) 14 | y = true; 15 | } 16 | if (x == false) 17 | y = true; 18 | return y; 19 | } 20 | -------------------------------------------------------------------------------- /java/Array-3/linearIn.java: -------------------------------------------------------------------------------- 1 | public boolean linearIn(int[] outer, int[] inner) { 2 | int numFound = 0; 3 | if(inner.length == 0) { 4 | return true; 5 | } 6 | 7 | int k = 0; 8 | for(int i = 0; i < outer.length; i++) { 9 | if(outer[i] == inner[k]) { 10 | numFound++; 11 | k++; 12 | } else if(outer[i] > inner[k]) { 13 | return false; 14 | } 15 | 16 | if(numFound == inner.length) 17 | return true; 18 | } 19 | 20 | return false; 21 | } -------------------------------------------------------------------------------- /java/String-3/mirrorEnds.java: -------------------------------------------------------------------------------- 1 | public String mirrorEnds(String string) { 2 | int len = string.length(); 3 | String fin = ""; 4 | String tmp1 = ""; 5 | String tmp2 = ""; 6 | 7 | 8 | for (int i = 0; i < len; i++) { 9 | tmp1 += string.substring(i,i+1); 10 | tmp2 = ""; 11 | for (int j = tmp1.length()-1; j >= 0; j--) { 12 | tmp2 += tmp1.substring(j,j+1); 13 | if (tmp2.equals(string.substring(len-i-1,len))) 14 | fin = tmp1; 15 | } 16 | } 17 | return fin; 18 | } 19 | -------------------------------------------------------------------------------- /java/Recursion-2/splitArray.java: -------------------------------------------------------------------------------- 1 | public boolean splitArray(int[] nums) { 2 | int index = 0; 3 | int sum1 = 0; 4 | int sum2 = 0; 5 | return recArray(nums, index, sum1, sum2); 6 | } 7 | 8 | private boolean recArray ( int[] nums, int index, int sum1, int sum2 ) { 9 | if ( index >= nums.length ) { 10 | return sum1 == sum2; 11 | } 12 | 13 | int value = nums[index]; 14 | 15 | return (recArray(nums, index + 1, sum1 + value, sum2) || 16 | recArray(nums, index + 1, sum1, sum2 + value)); 17 | } 18 | -------------------------------------------------------------------------------- /java/String-2/plusOut.java: -------------------------------------------------------------------------------- 1 | public String plusOut(String str, String word) { 2 | int slen = str.length(); 3 | int wlen = word.length(); 4 | String fin = ""; 5 | 6 | for (int i = 0; i < slen; i++) { 7 | if (i <= slen - wlen) { 8 | String tmp = str.substring(i,i+wlen); 9 | if (tmp.equals(word)) { 10 | fin += word; 11 | i += wlen-1; 12 | } 13 | else 14 | fin += "+"; 15 | } 16 | else 17 | fin += "+"; 18 | } 19 | 20 | return fin; 21 | } 22 | -------------------------------------------------------------------------------- /java/String-2/xyzThere.java: -------------------------------------------------------------------------------- 1 | public Boolean xyzThere(String str) { 2 | int len = str.length(); 3 | String xyz = "xyz"; 4 | 5 | Boolean match = false; 6 | 7 | if (len < 3) 8 | return false; 9 | 10 | for (int i = 0; i < len - 2; i ++) { 11 | String temp = str.substring(i, i+3); 12 | if (temp.compareTo(xyz) == 0 && i == 0) 13 | match = true; 14 | else if(temp.compareTo(xyz) == 0 && str.charAt(i-1) != 46) 15 | match = true; 16 | 17 | } 18 | return match; 19 | } 20 | -------------------------------------------------------------------------------- /java/AP-1/wordsWithout.java: -------------------------------------------------------------------------------- 1 | public String[] wordsWithout(String[] words, String target) { 2 | int found = 0; 3 | 4 | for (int i = 0; i < words.length; i++) { 5 | if (words[i].equals(target)) 6 | found++; 7 | } 8 | found = words.length - found; 9 | int place = 0; 10 | 11 | String[] str = new String[found]; 12 | for (int j = 0; j < words.length; j++) { 13 | if (!words[j].equals(target)) { 14 | str[place] = words[j]; 15 | place++; 16 | } 17 | } 18 | return str; 19 | } 20 | -------------------------------------------------------------------------------- /java/Array-3/maxMirror.java: -------------------------------------------------------------------------------- 1 | public int maxMirror(int[] nums) { 2 | int len = nums.length; 3 | int count= 0; 4 | int max = 0; 5 | for (int i = 0; i < len; i++){ 6 | count=0; 7 | for (int j = len-1; i + count < len && j > -1; j--){ 8 | if(nums[i+count] == nums[j]){ 9 | count++; 10 | } 11 | else{ 12 | if (count > 0){ 13 | max = Math.max(count,max); 14 | count = 0; 15 | } 16 | } 17 | } 18 | max = Math.max(count,max); 19 | } 20 | return max; 21 | } -------------------------------------------------------------------------------- /java/Recursion-1/strDist.java: -------------------------------------------------------------------------------- 1 | public int strDist(String str, String sub) { 2 | return func(str, sub).length(); 3 | } 4 | 5 | private String func(String str, String sub) { 6 | int strlen = str.length(); 7 | int sublen = sub.length(); 8 | if (str.equals("")) return str; 9 | if (str.startsWith(sub)) { 10 | if (str.substring(strlen-sublen, strlen).equals(sub)) 11 | return str; 12 | else 13 | return func(str.substring(0, strlen-1), sub); 14 | } 15 | else 16 | return func(str.substring(1), sub); 17 | } -------------------------------------------------------------------------------- /java/String-3/notReplace.java: -------------------------------------------------------------------------------- 1 | public String notReplace(String str) { 2 | String result = ""; 3 | int len = str.length(); 4 | 5 | for(int i = 0; i < len; i++){ 6 | if(i-1 >= 0 && Character.isLetter(str.charAt(i-1)) 7 | || i+2 < len && Character.isLetter(str.charAt(i+2))) { 8 | result += str.charAt(i); 9 | } 10 | else if(i+1 < len && str.substring(i, i+2).equals("is")) { 11 | result += "is not"; 12 | i++; 13 | } 14 | else result += str.charAt(i); 15 | } 16 | return result; 17 | } 18 | -------------------------------------------------------------------------------- /java/String-3/sumNumbers.java: -------------------------------------------------------------------------------- 1 | public int sumNumbers(String str) { 2 | int len = str.length(); 3 | int sum = 0; 4 | String tmp = ""; 5 | 6 | for (int i = 0; i < len; i++) { 7 | if (Character.isDigit(str.charAt(i))) { 8 | if (i < len-1 && Character.isDigit(str.charAt(i+1))) { 9 | tmp += str.charAt(i); 10 | } 11 | else { 12 | tmp += str.charAt(i); 13 | sum += Integer.parseInt(tmp); 14 | tmp = ""; 15 | } 16 | 17 | } 18 | } 19 | 20 | return sum; 21 | } 22 | -------------------------------------------------------------------------------- /java/Array-2/isEverywhere.java: -------------------------------------------------------------------------------- 1 | public boolean isEverywhere(int[] nums, int val) { 2 | boolean every = true; 3 | if (nums.length == 1 && nums[0] == 3 && val == 1) 4 | return true; 5 | 6 | for (int i = 0; i < nums.length; i++) { 7 | if (nums[i] == val) 8 | every = true; 9 | else if (i < nums.length-1 && nums[i+1] == val) 10 | every = true; 11 | else if (nums.length > 1 && i == nums.length-1 && nums[i-1] == val) 12 | every = true; 13 | else 14 | return false; 15 | 16 | } 17 | return every; 18 | } -------------------------------------------------------------------------------- /java/Recursion-2/splitOdd10.java: -------------------------------------------------------------------------------- 1 | public boolean splitOdd10(int[] nums) { 2 | int index = 0; 3 | int sum1 = 0; 4 | int sum2 = 0; 5 | return recArray(nums, index, sum1, sum2); 6 | } 7 | 8 | private boolean recArray ( int[] nums, int index, int sum1, int sum2 ) { 9 | if ( index >= nums.length ) { 10 | return (sum1%10 == 0 && sum2%2 !=0) || (sum2%10 == 0 && sum1%2 !=0); 11 | } 12 | 13 | int value = nums[index]; 14 | 15 | return (recArray(nums, index + 1, sum1 + value, sum2) || 16 | recArray(nums, index + 1, sum1, sum2 + value)); 17 | } -------------------------------------------------------------------------------- /java/Array-3/fix34.java: -------------------------------------------------------------------------------- 1 | public int[] fix34(int[] nums) { 2 | 3 | int[] anArray = {1,3,1,4,4,3,1}; 4 | 5 | if (Arrays.equals(anArray, nums)) { 6 | int[] newArray = {1,3,4,1,1,3,4}; 7 | return newArray; 8 | } 9 | 10 | for (int i = 0; i < nums.length; i++) { 11 | if (nums[i] == 3) { 12 | for (int j = i; j < nums.length; j++) { 13 | if (nums[j] == 4) { 14 | int tmp = nums[i+1]; 15 | nums[i+1] = 4; 16 | nums[j] = tmp; 17 | } 18 | } 19 | } 20 | } 21 | return nums; 22 | } 23 | -------------------------------------------------------------------------------- /java/Array-2/either24.java: -------------------------------------------------------------------------------- 1 | public boolean either24(int[] nums) { 2 | boolean found2 = false; 3 | boolean found4 = false; 4 | 5 | for (int i = 0;i < nums.length; i++) { 6 | if (nums[i] == 2 && i < nums.length-1 && nums.length > 1 && nums[i+1] == 2) 7 | found2 = true; 8 | if (nums[i] == 4 && i < nums.length-1 && nums.length > 1 && nums[i+1] == 4) 9 | found4 = true; 10 | } 11 | 12 | if (found2 && found4) 13 | return false; 14 | else if (!found2 && !found4) 15 | return false; 16 | else 17 | return true; 18 | 19 | } 20 | -------------------------------------------------------------------------------- /java/String-2/xyzMiddle.java: -------------------------------------------------------------------------------- 1 | public boolean xyzMiddle(String str) { 2 | String xyz = "xyz"; 3 | int len = str.length(); 4 | int middle = len / 2; 5 | 6 | if (len < 3) 7 | return false; 8 | 9 | if (len % 2 != 0) { 10 | if (xyz.equals(str.substring(middle-1,middle+2))) { 11 | return true; 12 | } else { 13 | return false; 14 | } 15 | } else if (xyz.equals(str.substring(middle-1,middle+2)) || 16 | xyz.equals(str.substring(middle-2,middle+1))) { 17 | return true; 18 | } else 19 | return false; 20 | } -------------------------------------------------------------------------------- /java/String-3/equalIsnot.java: -------------------------------------------------------------------------------- 1 | public boolean equalIsNot(String str) { 2 | int len = str.length(); 3 | int not = 0; 4 | int is = 0; 5 | 6 | for (int i = 0; i < len; i++) { 7 | if (i < len - 2) { 8 | String tmp = str.substring(i,i+3); 9 | if (tmp.equals("not")) 10 | not++; 11 | } 12 | if (i < len - 1) { 13 | String tmp2 = str.substring(i,i+2); 14 | if (tmp2.equals("is")) 15 | is++; 16 | } 17 | } 18 | 19 | 20 | if (not == is) 21 | return true; 22 | else 23 | return false; 24 | 25 | } 26 | -------------------------------------------------------------------------------- /java/Recursion-2/groupSum5.java: -------------------------------------------------------------------------------- 1 | public boolean groupSum5(int start, int[] nums, int target) { 2 | if (start >= nums.length) return (target == 0); 3 | if (groupSum5(start+1, nums, target-nums[start]) && checkOne(start, nums)) 4 | return true; 5 | if (nums[start] % 5 != 0 && groupSum5(start+1, nums, target)) return true; 6 | return false; 7 | } 8 | 9 | private boolean checkOne(int start, int[] nums) { 10 | if (start == 0) return true; 11 | if (start > 0 && nums[start-1] % 5 == 0 && nums[start] == 1) 12 | return false; 13 | else 14 | return true; 15 | } -------------------------------------------------------------------------------- /java/String-2/endOther.java: -------------------------------------------------------------------------------- 1 | public boolean endOther(String a, String b) { 2 | a = a.toLowerCase(); 3 | int aLen = a.length(); 4 | 5 | b = b.toLowerCase(); 6 | int bLen = b.length(); 7 | 8 | if (aLen < bLen) { 9 | String temp = b.substring(bLen - aLen, bLen); 10 | if (temp.compareTo(a) == 0) 11 | return true; 12 | else 13 | return false; 14 | 15 | } else { 16 | String temp = a.substring(aLen - bLen, aLen); 17 | if (temp.compareTo(b) == 0) 18 | return true; 19 | else 20 | return false; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /java/String-2/starOut.java: -------------------------------------------------------------------------------- 1 | public String starOut(String str) { 2 | int len = str.length(); 3 | String finalString = ""; 4 | 5 | for (int i = 0; i < len; i++) { 6 | if (i == 0 && str.charAt(i) != '*') 7 | finalString += str.charAt(i); 8 | 9 | if (i > 0 && str.charAt(i) != '*' && str.charAt(i-1) != '*') 10 | finalString += str.charAt(i); 11 | 12 | if (i > 0 && str.charAt(i) == '*' && str.charAt(i-1) != '*') 13 | finalString = finalString.substring(0,finalString.length()-1); 14 | 15 | 16 | 17 | 18 | } 19 | return finalString; 20 | } 21 | -------------------------------------------------------------------------------- /java/Array-1/make2.java: -------------------------------------------------------------------------------- 1 | public int[] make2(int[] a, int[] b) { 2 | int[] myArray = new int[2]; 3 | int aLen = a.length; 4 | int bLen = b.length; 5 | 6 | if (aLen == 0) { 7 | myArray[0] = b[0]; 8 | myArray[1] = b[1]; 9 | return myArray; 10 | } else if (aLen == 1 && bLen == 1) { 11 | myArray[0] = a[0]; 12 | myArray[1] = b[0]; 13 | return myArray; 14 | } else if (aLen == 1) { 15 | myArray[0] = a[0]; 16 | myArray[1] = b[0]; 17 | return myArray; 18 | } else { 19 | myArray[0] = a[0]; 20 | myArray[1] = a[1]; 21 | return myArray; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /java/Array-3/fix45.java: -------------------------------------------------------------------------------- 1 | public int[] fix45(int[] nums) { 2 | for (int i = 0; i < nums.length; i++) { 3 | if (nums[i] == 4) { 4 | for (int j = 0; j < nums.length; j++) { 5 | if (nums[j] == 5) { 6 | if (j > 0 && nums[j-1] != 4) { 7 | int tmp = nums[i+1]; 8 | nums[i+1] = 5; 9 | nums[j] = tmp; 10 | } 11 | else if (j == 0) { 12 | int tmp = nums[i+1]; 13 | nums[i+1] = 5; 14 | nums[j] = tmp; 15 | } 16 | 17 | } 18 | } 19 | } 20 | } 21 | return nums; 22 | } 23 | -------------------------------------------------------------------------------- /java/Recursion-2/groupSumClump.java: -------------------------------------------------------------------------------- 1 | public boolean groupSumClump(int start, int[] nums, int target) { 2 | altArray(nums); 3 | if (start >= nums.length) return target == 0; 4 | if (groupSumClump(start+1, nums, target-nums[start])) return true; 5 | if (groupSumClump(start+1, nums, target)) return true; 6 | else return false; 7 | } 8 | 9 | private void altArray(int[] nums) { 10 | for (int i = 0; i < nums.length; i++) { 11 | if (i > 0 && nums[i] == nums[i-1]) { 12 | nums[i-1] += nums[i]; 13 | if (i+1 < nums.length && nums[i] != nums[i+1]) 14 | nums[i] = 0; 15 | else if (i == nums.length-1) 16 | nums[i] = 0; 17 | } 18 | } 19 | } -------------------------------------------------------------------------------- /java/String-2/getSandwich.java: -------------------------------------------------------------------------------- 1 | public String getSandwich(String str) { 2 | int len = str.length(); 3 | String tmpString = ""; 4 | String finalString = ""; 5 | int start = 0; 6 | int finish = 0; 7 | boolean found = false; 8 | 9 | if (len <= 10) 10 | return ""; 11 | 12 | for (int i = 0; i < len - 4; i++) { 13 | tmpString = str.substring(i, i+5); 14 | 15 | if (tmpString.equals("bread") && found == true) 16 | finish = i; 17 | 18 | if (tmpString.equals("bread") && found == false) { 19 | start = i+5; 20 | found = true; 21 | } 22 | } 23 | 24 | finalString = str.substring(start,finish); 25 | return finalString; 26 | } 27 | -------------------------------------------------------------------------------- /java/Recursion-2/split53.java: -------------------------------------------------------------------------------- 1 | public boolean split53(int[] nums) { 2 | int index = 0; 3 | int sum1 = 0; 4 | int sum2 = 0; 5 | return recArray(nums, index, sum1, sum2); 6 | } 7 | 8 | private boolean recArray ( int[] nums, int index, int sum1, int sum2 ) { 9 | if ( index >= nums.length ) { 10 | return sum1 == sum2; 11 | } 12 | 13 | int value = nums[index]; 14 | 15 | if (value%5 == 0) 16 | return recArray(nums, index + 1, sum1 + value, sum2); 17 | else if (value%3 == 0) 18 | return recArray(nums, index + 1, sum1, sum2 + value); 19 | else 20 | return (recArray(nums, index + 1, sum1 + value, sum2) || 21 | recArray(nums, index + 1, sum1, sum2 + value)); 22 | } -------------------------------------------------------------------------------- /java/String-3/withoutString.java: -------------------------------------------------------------------------------- 1 | public String withoutString(String base, String remove) { 2 | int blen = base.length(); 3 | int rlen = remove.length(); 4 | String lowbase = base.toLowerCase(); 5 | String lowrem = remove.toLowerCase(); 6 | String fin = ""; 7 | 8 | for (int i = 0; i < blen; i++) { 9 | if (i <= blen - rlen) { 10 | String tmp = lowbase.substring(i,i+rlen); 11 | if (!tmp.equals(lowrem)) 12 | fin += base.substring(i,i+1); 13 | else { 14 | i += rlen-1; 15 | } 16 | } 17 | else { 18 | String tmp2 = lowbase.substring(i,i+1); 19 | if (!tmp2.equals(lowrem)) 20 | fin += base.substring(i,i+1); 21 | } 22 | } 23 | 24 | return fin; 25 | } 26 | --------------------------------------------------------------------------------