FUNCTION stringLength(){
//...
}
stringLength("hello" ); //=> 5

closedBracket("(2+2)" ); //=> true
closedBracket("(5+3)*2)" ); => false, ((5+3)*2)

countVowel("sample" ); //=> 2, ae

1st call: argSwitch("me", "you" ) //=> me
2nd call: argSwitch("me", "you" ) //=> you
3rd call: argSwitch("me", "you" ); //=> me

isValidColor( "red" ); //=>true
isValidColor( "asshy" ); //=> false
isValidColor( "#f7c" ); //=> true

stringReplace("Hello world", "world", "Nairalanders"; //=>Hello Nairalanders

int strreplace(char *str, const char *oldstr, const char *newstr) {
    /**
     * Recursive function. Reads char *str from left to right and replaces all occurrences of
     * const char *oldstr. Upon completion, the function returns the number of times 
     * const char *oldstr had been successfully replaced.
     */

    int count = 0;
    char *tmp = strcasestr(str, oldstr); 
	
    if(tmp) {
        // get strlens
        int len = strlen(str);
        int oldstrlen = strlen(oldstr);
        int newstrlen = strlen(newstr);

        // build new char array
        char tmpstr[len - strlen(tmp) + newstrlen + strlen(&tmp[oldstrlen - 1]) + 1];
        memset(tmpstr, '\0', sizeof(tmpstr)); // initialize char array
		
        // systematically copy strings
        strncpy(tmpstr, str, len - strlen(tmp)); // copy first part of string up until occurrence of const char *oldstr
	strncpy(&tmpstr[strlen(tmpstr)], newstr, newstrlen); // copy the new string 
        strncpy(&tmpstr[strlen(tmpstr)], &tmp[oldstrlen], strlen(&tmp[oldstrlen])); // copy rest of string
		
        // resize original string
        str[strlen(tmpstr) + 1];
        memset(str, '\0', sizeof(str)); // initialize

        // copy tmpstr over to str
        strcpy(str, tmpstr);

        // recursive call to continue on to the next occurrence of const char *oldstr
        count = strreplace(str, oldstr, newstr);

        // change value of count to reflect string replacement
        count += 1;
    }

    return count;
}

import java.util.Scanner;

public class VowelCount {

	public static void main(String[] args) {
		String myText;
		int vowelsTotal = 0;
		countVowels cntVwl = new countVowels();
		Scanner scan = new Scanner(System.in);
		System.out.println("Please Enter a String with vowels: " );
		myText = scan.nextLine();
		vowelsTotal = cntVwl.vowelsCounted(myText);
		System.out.println(myText + " has " + vowelsTotal + " vowels" );
		
	}
}

   class countVowels {
	 public int vowelsCounted(String myString){
		int numVowels = 0;
		for (int i = 0; i < myString.length(); i++) {
			if (myString.charAt(i) == 'a'|| myString.charAt(i) == 'e'|| myString.charAt(i)=='i'
					|| myString.charAt(i)=='o'|| myString.charAt(i) == 'u') {
				numVowels++;
			}
		}
		return numVowels;
	}
   }

ChinenyeN:
If it's any consolation, Fulaman198, I don't think your program needs any comments. It's very self-explanatory. But you are right. It's always good to make a habit of commenting one's code. I added comments to mine mostly to make it easier to read on NL, since NL's code tag doesn't come with syntax highlighting (unless there's something I don't know).

// problem 3
function countvowels($string) {
    return count(array_filter(str_split($string), function($k) { return in_array($k, str_split("aeiou" )); }));
}

// problem 6
function strreplace($str, $search, $replace) {
    return preg_replace("/$search/", $replace, $str);
}

Fulaman198:
Programme: VowelCount
Language: Java

import java.util.Scanner;

public class VowelCount {

	public static void main(String[] args) {
		String myText;
		int vowelsTotal = 0;
		countVowels cntVwl = new countVowels();
		Scanner scan = new Scanner(System.in);
		System.out.println("Please Enter a String with vowels: " );
		myText = scan.nextLine();
		vowelsTotal = cntVwl.vowelsCounted(myText);
		System.out.println(myText + " has " + vowelsTotal + " vowels" );
		
	}
}

   class countVowels {
	 public int vowelsCounted(String myString){
		int numVowels = 0;
		for (int i = 0; i < myString.length(); i++) {
			if (myString.charAt(i) == 'a'|| myString.charAt(i) == 'e'|| myString.charAt(i)=='i'
					|| myString.charAt(i)=='o'|| myString.charAt(i) == 'u') {
				numVowels++;
			}
		}
		return numVowels;
	}
   }

Below is programme output

function vowelCount(str){
  var vowels = ["a","e","i","o","u"], count = 0, seen = "";
  for(var i=0;i<str.length;i+=1){
    if(vowels.indexOf(str[i])>-1){
    //a vowel, increment count variable and add to seen string
    count += 1;
    seen += str[i];
  }
}
return count + " vowels,("+seen+"";
}

vowelCount("this is a simple vowel test"; //=>8 vowels,(iiaieoee)

char *countvowels(const char *str) {
    // setup
    int i = 0; // iterate through string
    int count = 0; // to hold the count
    char *vowels = NULL; // to hold the vowels

    // iterate through each character in const char *str
    while(str[i] != '\0') {

        // check for vowel
        if(str[i] == 'a' || str[i] == 'A' || str[i] == 'e' || str[i] == 'E' || str[i] == 'i' || str[i] == 'I' || 
           str[i] == 'o' || str[i] == 'O' || str[i] == 'u' || str[i] == 'U') {
            
            count += 1; // increase count
            vowels = realloc(vowels, count + 1); // reallocate memory
            vowels[count] = '\0'; // initialize byte
            vowels[count - 1] = str[i]; // assign newly found vowel

        }
        i++;
    }

    // print total vowels found
    printf("Found %i vowels ... %s\n", count, vowels); 

    // will have to be manually freed by user later on in the program
    return vowels; 

}

def countVowel(word: String): String = {
      val vowels = word.toCharArray.filter(List('a', 'e', 'i', 'o', 'u').contains(_)).toList.mkString
      vowels.length + ", " + vowels
}

scala> countVowel('robert')
res1: String = 2, oe

def stringReplace(orig: String, toReplace: String, replaceWith: String) = {
      orig.split(' ').toList.map(x => if(x == toReplace) replaceWith else x).mkString(' ')
}

scala> stringReplace('hello world', 'world', 'nairalander')
res2: String = hello nairalander

Kodejuice:

You approach to solve the problem is yucky, and doesnt follow the rule completely, return the vowels!
Language: JavaScript

function vowelCount(str){
  var vowels = ["a","e","i","o","u"], count = 0, seen = "";
  for(var i=0;i<str.length;i+=1){
    if(vowels.indexOf(str[i])>-1){
    //a vowel, increment count variable and add to seen string
    count += 1;
    seen += str[i];
  }
}
return count + " vowels,("+seen+"";
}

vowelCount("this is a simple vowel test"; //=>8 vowels,(iiaieoee)

 public int vowelsCounted(String myString){
		int numVowels = 0;
		for (int i = 0; i < myString.length(); i++) {
			if (myString.charAt(i) == 'a'|| myString.charAt(i) == 'e'|| myString.charAt(i)=='i'
					|| myString.charAt(i)=='o'|| myString.charAt(i) == 'u') {
				numVowels++;
			}
		}
		return numVowels;
	}

size_t stringlength(const char *str) {

    size_t i = 0; // to iterate over string characters
    while(str[i] != '\0') i++; // iterate over string
    return i; // return value of i

}

 import java.util.*;

public class Main
{
	public static void main(String[] args)
	{
		Scanner keyboard = new Scanner( System.in);
		String inputStr;
		System.out.print("please enter a fvvcking string: ";
		inputStr = keyboard.nextLine();
		System.out.println("\n\'" + inputStr + "\'" + " ==> [ " +
				stringLength(inputStr) + " ] ";
	}
	

	private static int stringLength(String v)
	{
		int len = 0 ;
		char[] cArr = v.toCharArray();
		char c;
		try{
			for( int i = 0 ; true; len++){
			c = cArr[len];}
			
		}
		catch( ArrayIndexOutOfBoundsException e){
			return len;
		}
		
	
	}
}	 

 import java.util.*;

public class Main
{
	public static void main(String[] args)
	{
		Scanner keyboard = new Scanner( System.in);
		String inputStr;
		System.out.print("please enter a fvvcking string: ";
		inputStr = keyboard.nextLine();
		System.out.println("\n\'" + inputStr + "\'" + " ==> [ " +
				stringLength(inputStr) + " ] char(s)";
	}
	

	private static int stringLength(String v)
	{
		char[] c = v.toCharArray();
		return c.length;
	
	}
}	 

 import java.util.*;

public class Main
{
	public static void main(String[] args)
	{
		Scanner keyboard = new Scanner( System.in);
		while(true){
		String inputStr;
		System.out.print("please enter a fvvcking string: ";
		inputStr = keyboard.nextLine();
		System.out.println("\n\'" + inputStr + "\'" + " ==> [ " +
						   stringLength(inputStr) + " ] ";
	}}


	private static int stringLength(String v)
	{
		int len = 0 ;
		char[] cArr = v.toCharArray();
		
		
			for( char c : cArr)
				len++;

		return len;

	}
}	 

 //exercise 2, Closed Parenthesis
 //Language: javascript

 function closedBracket(str){
   var openedBraces = str.match(/\(/g),
   closedBraces = str.match(/\)/g),
   opened = openedBraces.length, closed = closedBraces.length;
  
   if(opened===closed){
     return true;
   }
   else if(opened>closed){
     //not well placed, eg "(()"
     var needed = opened - closed,
     fix = br(needed, "";
     return str + fix;
   }
   else if(opened<closed){
     //not well placed, eg "())"
     var needed = closed - opened,
     fix = br(needed, "(";
     return fix + str;
   }
   else{
     return str; //?!
   }
  
   function br(n, b){
     //br(2,"(" => ((
     var s = "";
     while(s.length!==n){
       s += b;
     }
     return s;
   }
  
 }
 

Fulaman198:


Look at the method vowelsCounted(), that is what it's for. Java and JavaScript are different languages. I created the main class to illustrate how it works.

EDIT: In case you don't know what I'm referring to, I'm talking about the method here

 public int vowelsCounted(String myString){
		int numVowels = 0;
		for (int i = 0; i < myString.length(); i++) {
			if (myString.charAt(i) == 'a'|| myString.charAt(i) == 'e'|| myString.charAt(i)=='i'
					|| myString.charAt(i)=='o'|| myString.charAt(i) == 'u') {
				numVowels++;
			}
		}
		return numVowels;
	}

In Java, functions are referred to as Methods.

vowelsCount("hello world"; //=> 3, eoo

Kodejuice:


You dont get, return all vowels in the passed string not just the number of vowels.

vowelsCount("hello world"; //=> 3, eoo

Kodejuice:

  //exercise 2, Closed Parenthesis
  //Language: javascript
 [code]
  function closedBracket(str){
    var openedBraces = str.match(/\(/g),
    closedBraces = str.match(/\)/g),
    opened = openedBraces.length, closed = closedBraces.length;
  
    if(opened===closed){
      return true;
    }
    else if(opened>closed){
      //not well placed, eg "(()"
      var needed = opened - closed,
      fix = br(needed, "";
      return str + fix;
    }
    else if(opened<closed){
      //not well placed, eg "())"
      var needed = closed - opened,
      fix = br(needed, "(";
      return fix + str;
    }
    else{
      return str; //?!
    }
  
    function br(n, b){
      //br(2,"(" => ((
      var s = "";
      while(s.length!==n){
        s += b;
      }
      return s;
    }
  
  }
  

bool closeparens(char *str, int pass, int opened, int closed) {
    /**
     * This is a simple implementation. It makes two assumptions: 1) that the final output will always be 
     * enclosed in brackets .. i.e. "(*)". 2) that the whomever is making the parenthetical statements at 
     * leaset knows how parentheses works and is more or less using them correctly. This function makes 
     * use of a helper function void addparen(char *str, int position). The initial call to bool closeparens 
     * should always pass in 0 for int pass, int opened and int closed.. i.e. closeparen(str, 0, 0, 0);
     */

    // set up
    bool fixed = false; // to return status of parenthetical statement
    
    if(pass == 0) {
        // ensure that string starts with opening parenthesis
        if(*str != '(') {
	    addparen(str, 0);
            opened += 1;
	    fixed = true;
        }
	
	// maintain hold of start of string
	char *tmp = str;
	
	// get number of opened and closed parentheses
	// *str is like lazy way of saying int i = 0; ... while(str[i] ..)
	// but I wasn't lazy for no reason. *str has a useul purpose
	while(*str) {  
	    if(*str == '(') opened++;
	    if(*str == ')') closed++;
	    *str++;
	}
	*str--; // to go back to the last character in string
		
	// ensure that last character is a closing parenthesis
        // see *str was useful 
	if(*str != ')') {
	    addparen(tmp, 1);
            closed += 1;
	    fixed = true;
        }
		
	if(fixed) closeparens(tmp, pass += 1, opened, closed);
	else fixed = closeparens(tmp, pass += 1, opened, closed);

    } else { // we've gone past the first pass
	
	// check number of parens and add if necessary
	if(opened > closed) {
	   addparen(str, 1);
	   fixed = true;
	}
	if(closed > opened) {
	   addparen(str, 0);
	   fixed = true;
	}
	
    }
	
    return fixed;

}

void addparen(char *str, int position) {
    /**
     * Helper function to add parenthesis to either beginning or end of string.
     * value of 0 for int position denotes beginning, while a value of
     * 1 for int position denotes the end of the string.
     */
    
    // create temporary char array
    char tmpstr[strlen(str) + 2];
    memset(tmpstr, '\0', sizeof(tmpstr));	 

    // run check
    if(position == 0) { // beginning of the string
        tmpstr[0] = '(';
	strcpy(&tmpstr[1], str);
    } else if(position == 1) { // end of the string
        strcpy(tmpstr, str);
	tmpstr[strlen(tmpstr)] = ')';
    }

    // resize and copy data
    str[strlen(tmpstr) + 1];
    memset(str, '\0', sizeof(str));
    strcpy(str, tmpstr);

}

ChinenyeN:
6. String Replace
Language: C

int strreplace(char *str, const char *oldstr, const char *newstr) {
    /**
     * Recursive function. Reads char *str from left to right and replaces all occurrences of
     * const char *oldstr. Upon completion, the function returns the number of times 
     * const char *oldstr had been successfully replaced.
     */

    int count = 0;
    char *tmp = strcasestr(str, oldstr); 
	
    if(tmp) {
        // get strlens
        int len = strlen(str);
        int oldstrlen = strlen(oldstr);
        int newstrlen = strlen(newstr);

        // build new char array
        char tmpstr[len - strlen(tmp) + newstrlen + strlen(&tmp[oldstrlen - 1]) + 1];
        memset(tmpstr, '\0', sizeof(tmpstr)); // initialize char array
		
        // systematically copy strings
        strncpy(tmpstr, str, len - strlen(tmp)); // copy first part of string up until occurrence of const char *oldstr
	strncpy(&tmpstr[strlen(tmpstr)], newstr, newstrlen); // copy the new string 
        strncpy(&tmpstr[strlen(tmpstr)], &tmp[oldstrlen], strlen(&tmp[oldstrlen])); // copy rest of string
		
        // resize original string
        str[strlen(tmpstr) + 1];
        memset(str, '\0', sizeof(str)); // initialize

        // copy tmpstr over to str
        strcpy(str, tmpstr);

        // recursive call to continue on to the next occurrence of const char *oldstr
        count = strreplace(str, oldstr, newstr);

        // change value of count to reflect string replacement
        count += 1;
    }

    return count;
}

Java - stringLength



class StringLength {
  public static void main(String[] args) {
    int len = stringLength("Hello there";
    System.out.println(len);
  }
  
  public static int stringLength(String word) {
      return word.split("".length;
  }
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.List;
import java.util.ArrayList;

class Main {
    
  private static List<String> vowels;
  
  static {
      
      vowels = new ArrayList<String>();
  }
  
  public static void main(String[] args) {
      
    int numVowels = vowelCount("sample for the test";
    
    System.out.println("Number of Vowels found: "+numVowels);
    System.out.printf("Vowels found in the string: ";
    for(int i = 0; i < vowels.size(); i++) {
        System.out.printf("%s ", vowels.get(i));
    }
    
    System.out.println();
  }
  
  public static int vowelCount(String string) {
      String regex = "[aeiou]";

      Pattern pattern = Pattern.compile(regex);
      int counter = 0;
      
      Matcher matcher = pattern.matcher(string);

      while(matcher.find()) {
          counter++;
          saveLetter(matcher.group());
      }
      
     return counter;
  }
  
  public static void saveLetter(String group)
  {
      vowels.add(group);
  }
  
}

class Main {

  private static int accessCounter;
  
  static {
      accessCounter = 1;
  }
  public static void main(String[] args) {
      
    System.out.println(switchArgs("me", "you"); //me
    System.out.println(switchArgs("me", "you"); //you
    System.out.println(switchArgs("me", "you"); //me
    System.out.println(switchArgs("me", "you"); //you
  }
  
  public static String switchArgs(String first, String second) {
      accessCounter++;
      String [] args = {first, second};
      
      return args[accessCounter % args.length];
      
  }
  
}

perl -we "print scalar split// => $ARGV[0]" hello # print 5

perl -we "print length $ARGV[0]" hello  # 5, notice the length function

perl -we "print join ', ' => map {$_, scalar split//} join '' => grep /[aeiou]/ => split// => $ARGV[0]" "Hello, world" 

perl -we "print $ARGV[argSwitch(@ARGV)] for 1 .. 3; sub argSwitch{ @m=@_;$n = 0; print sub {$m[$n++]}->()}" me you

perl -we "print join ' ' => grep {!/$ARGV[1]/i} (split/\s+/ => $ARGV[0]), $ARGV[2]" "Hello, World" world Nairalanders

#!/usr/bin/perl
use warnings;
use strict;

# call the closedBracket subroutine
# on the first argument on the command line interface
print closedBracket( $ARGV[0] );

# closedBracket subroutine
sub closedBracket {

    # get the variable
    my $str           = shift;
    my $open_bracket  = 0;
    my $close_bracket = 0;
    my $state         = "true";

    # split the variable
    for ( split //, $str ) {

        # if the variable matches open bracket
        if (/\(/) {
            $open_bracket++;
            $close_bracket--;
        }
        elsif (/\)/) {    # else if it matches closed bracket
            $open_bracket--;
            $close_bracket++;
        }
    }

    # check if the value  open bracket and
    # close bracket is 0, if not, take the absolute
    # of the variable with negative value
    if ( $open_bracket != 0 and $close_bracket != 0 ) {
        if ( $open_bracket < 0 ) {
            $open_bracket = abs $open_bracket;
            $str = join '' => '(' x $open_bracket, $str;
        }
        else {
            $close_bracket = abs $close_bracket;
            $str = join '' => $str, ')' x $close_bracket;
        }
        return join ', ' => "false", $str;
    }
    return $state;
}