Forem: tommy-3

Learning Algorithms with JS, Python and Java #11: Count the Vowels

tommy-3 — Mon, 07 Jan 2019 22:27:42 +0000

This series of articles follows Stephen Grider's Udemy course in three different languages.

Today's question is a simple introduction to regular expressions.

--- Directions
Write a function that returns the number of vowels
used in a string. Vowels are the characters 'a', 'e'
'i', 'o', and 'u'.
--- Examples
vowels('Hi There!') --> 3
vowels('Why do you ask?') --> 4
vowels('Why?') --> 0

1: Iterative Solution

JavaScript:

function vowels(str) {
  let count = 0;
  let checker = ['a', 'e', 'i', 'o', 'u'];
  for (char of str.toLowerCase()) {
    if (checker.includes(char)) {
      count++;
    }
  }
  return count;
}

Python:

def vowels(string):
    count = 0
    checker = ['a', 'e', 'i', 'o', 'u']
    for char in string.lower():
        if char in checker:
            count += 1
    return count

Java:

import java.util.Arrays;
import java.util.List;

static int vowels(String str) {
    int count = 0;
    List<Character> checker = Arrays.asList('a', 'e', 'i', 'o', 'u');
    for (char chr : str.toLowerCase().toCharArray()) {
        if (checker.contains(chr)) {
            count++;
        }
    }
    return count;
}

2: Using Regular Expression

JavaScript:

function vowels(str) {
  const matches = str.match(/[aeiou]/gi); // an array or null
  return matches ? matches.length : 0;
}

Python:

import re

def vowels(string):
    matches = re.findall('[aeiou]', string, re.IGNORECASE)  # a list
    return len(matches)

Java:

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

static int vowels(String str) {
    Pattern pattern = Pattern.compile("[aeiou]", Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(str);
    int count = 0;
    while (matcher.find()) {
        count++;
    }
    return count;
}

Java 9+:

import java.util.regex.Pattern;

static long vowels(String str) {
    return Pattern.compile("[aeiou]", Pattern.CASE_INSENSITIVE)
            .matcher(str)
            .results()
            .count();
}

Learning Algorithms with JS, Python and Java #10: Pyramid

tommy-3 — Sat, 29 Dec 2018 04:18:50 +0000

This series of articles follows Stephen Grider's Udemy course in three different languages.

Today's question is a slight variation on the last one.

--- Directions
Write a function that accepts a positive number N.
The function should console log a pyramid shape
with N levels using the # character. Make sure the
pyramid has spaces on both the left and right hand sides
--- Examples
pyramid(1)
'#'
pyramid(2)
' # '
'###'
pyramid(3)
' # '
' ### '
'#####'

1: Iterative Solution

JavaScript:

function pyramid(n) {
    const columnCount = 2 * n - 1;
    const midColumn = Math.floor(columnCount / 2);

    for (let row = 0; row < n; row++) {
        let level = '';

        for (let column = 0; column < columnCount; column++) {
            if (Math.abs(column - midColumn) <= row) {
                level += '#';
            } else {
                level += ' ';
            }
        }

        console.log(level);
    }
}

Python:

def pyramid(n):
    column_count = 2 * n - 1
    mid_column = column_count // 2

    for row in range(n):
        level = ''

        for column in range(column_count):
            if abs(column - mid_column) <= row:
                level += '#'
            else:
                level += ' '

        print(level)

Java:

static void pyramid1(int n) {
    int columnCount = 2 * n - 1;
    int midColumn = columnCount / 2;

    for (int row = 0; row < n; row++) {
        StringBuilder level = new StringBuilder();

        for (int column = 0; column < columnCount; column++) {
            if (Math.abs(column - midColumn) <= row) {
                level.append("#");
            } else {
                level.append(" ");
            }
        }

        System.out.println(level);
    }
}

2: Recursive Solution

Here I take an approach a bit different from the one introduced in the course.

JavaScript:

function pyramid(n, row = 0, level = '#') {
    if (n === row) {
        return;
    }

    if (level.length === 2 * n - 1) {
        console.log(level);
        return pyramid(n, row + 1);
    }

    level = level.length < 2 * row ? `#${level}#` : ` ${level} `;
    pyramid(n, row, level);
}

Python:

def pyramid(n, row=0, level='#'):
    if n == row:
        return

    if len(level) == 2 * n - 1:
        print(level)
        return pyramid(n, row+1)

    level = f'#{level}#' if len(level) < 2 * row else f' {level} '
    pyramid(n, row, level)

Java:

static void pyramid(int n) {
    pyramid(n, 0, new StringBuilder("#"));
}

static void pyramid(int n, int row, StringBuilder level) {
    if (n == row) {
        return;
    }

    if (level.length() == 2 * n - 1) {
        System.out.println(level);
        pyramid(n, row + 1, new StringBuilder("#"));
        return;
    }

    if (level.length() < 2 * row) {
        level.insert(0, "#").append("#");
    } else {
        level.insert(0, " ").append(" ");
    }

    pyramid(n, row, level);
}

Thank you for reading. I do plan to write this series more often, so I hope to see you soon!

Learning Algorithms with JS, Python and Java 9: Printing Steps

tommy-3 — Wed, 10 Oct 2018 00:38:08 +0000

This series of articles follows Stephen Grider's Udemy course in three different languages. JavaScript solutions are by Stephen. I try to "translate" them into Python and Java.

Today's question is meant to be an introduction to recursions.

--- Directions
Write a function that accepts a positive number N.
The function should console log a step shape
with N levels using the # character. Make sure the
step has spaces on the right hand side!
--- Examples
steps(2)
'# '
'##'
steps(3)
'# '
'## '
'###'
steps(4)
'# '
'## '
'### '
'####'

1: Iterative Solution

JavaScript:

function steps(n) {
    for (let row = 0; row < n; row++) {
        let stair = '';
        for (let column = 0; column < n; column++) {
            if (column <= row) {
                stair += '#';
            } else {
                stair += ' ';
            }
        }
        console.log(stair);
    }
}

Python:

def steps(n):
    for row in range(n):
        stair = ''
        for column in range(n):
            if column <= row:
                stair += '#'
            else:
                stair += ' '
        print(stair)

Java:

static void steps(int n) {
    for (int row = 0; row < n; row++) {
        StringBuilder stair = new StringBuilder();
        for (int column = 0; column < n; column++) {
            if (column <= row) {
                stair.append("#");
            } else {
                stair.append(" ");
            }
        }
        System.out.println(stair);
    }
}

2: Recursive Solution

JavaScript:

function steps(n, row = 0, stair = '') {
    if (n === row) {
        return;
    }

    if (n === stair.length) {
        console.log(stair);
        return steps(n, row + 1);
    }

    stair += stair.length <= row ? '#' : ' ';
    steps(n, row, stair);
}

Python:

def steps(n, row=0, stair=''):
    if n == row:
        return

    if n == len(stair):
        print(stair)
        return steps(n, row+1)

    stair += '#' if len(stair) <= row else ' '
    steps(n, row, stair)

Java:

static void steps(int n) {
    steps(n, 0, new StringBuilder());
}

static void steps(int n, int row, StringBuilder stair) {
    if (n == row) {
        return;
    }

    if (n == stair.length()) {
        System.out.println(stair);
        steps(n, row + 1, new StringBuilder());
        return;
    }

    stair.append(stair.length() <= row ? "#" : " ");
    steps(n, row, stair);
}

Learning Algorithms with JS, Python and Java 8: Sentence Capitalization

tommy-3 — Wed, 19 Sep 2018 00:51:42 +0000

It's been a while since I posted the last article. Today's is a nice and simple one for rehab.

This series of articles follows Stephen Grider's Udemy course in three different languages. JavaScript solutions are by Stephen. I try to "translate" them into Python and Java.

Today's question is:

--- Directions
Write a function that accepts a string. The function should
capitalize the first letter of each word in the string then
return the capitalized string.
--- Examples
capitalize('a short sentence') --> 'A Short Sentence'
capitalize('a lazy fox') --> 'A Lazy Fox'
capitalize('look, it is working!') --> 'Look, It Is Working!'

1: Concise solution using built-in libraries

JavaScript:

function capitalize(sentence) {
    const words = [];

    for (let word of sentence.split(' ')) {
        words.push(word[0].toUpperCase() + word.slice(1));
    }

    return words.join(' ');
}

Python:

def capitalize1(sentence: str) -> str:
    words = [word[0].upper() + word[1:] for word in sentence.split()]
    return ' '.join(words)

def capitalize2(sentence: str) -> str:
    return ' '.join([word.capitalize() for word in sentence.split()])

def capitalize3(sentence: str) -> str:
    return sentence.title()

Java:

import java.util.LinkedList;
import java.util.List;

public static String capitalize(String sentence) {
    List<String> words = new LinkedList<>();

    for (String word : sentence.split(" ")) {
        words.add(String.valueOf(word.charAt(0)).toUpperCase() + word.substring(1));
    }

    return String.join(" ", words);
}

2: Brute force solution using a loop

JavaScript:

function capitalize(sentence) {
    let result = sentence[0].toUpperCase();

    for (let i = 1; i < sentence.length; i++) {
        if (sentence[i - 1] === ' ') {
            result += sentence[i].toUpperCase();
        } else {
            result += sentence[i];
        }
    }

    return result;
}

Python:

def capitalize(sentence: str) -> str:
    result = ''

    for i, char in enumerate(sentence):
        if i == 0 or sentence[i - 1] == ' ':
            result += char.upper()
        else:
            result += char

    return result

Java:

public static String capitalize(String sentence) {
    StringBuilder result = new StringBuilder(String.valueOf(sentence.charAt(0)).toUpperCase());

    for (int i = 1; i < sentence.length(); i++) {
        if (sentence.charAt(i - 1) == ' ') {
            result.append(String.valueOf(sentence.charAt(i)).toUpperCase());
        } else {
            result.append(sentence.charAt(i));
        }
    }

    return result.toString();
}

Thank you for reading so far. I hope to see you again soon!

Learning Algorithms with JS, Python and Java 7: Anagrams

tommy-3 — Tue, 28 Aug 2018 22:24:12 +0000

This is the seventh article of my attempts to follow Stephen Grider's Udemy course in three different languages. JavaScript solutions are by Stephen. I try to "translate" it into Python and Java.

Today's question is:

Check to see if two provided strings are anagrams of eachother.
One string is an anagram of another if it uses the same characters
in the same quantity. Only consider characters, not spaces
or punctuation. Consider capital letters to be the same as lower case
--- Examples
anagrams('rail safety', 'fairy tales') --> True
anagrams('RAIL! SAFETY!', 'fairy tales') --> True
anagrams('Hi there', 'Bye there') --> False

1: Counting each letter

JavaScript:

function anagrams(stringA, stringB) {
  const charMapA = buildCharMap(stringA);
  const charMapB = buildCharMap(stringB);

  if (Object.keys(charMapA).length !== Object.keys(charMapB).length) {
    return false;
  }

  for (let char in charMapA) {
    if (charMapA[char] !== charMapB[char]) {
      return false;
    }
  }

  return true;
}

function buildCharMap(str) {
  const charMap = {};

  for (let char of str.replace(/[^\w]/g, '').toLowerCase()) {
    charMap[char] = charMap[char] + 1 || 1;
  }

  return charMap;
}

Python:

import re
from collections import Counter

def anagrams(string_a: str, string_b: str) -> bool:
    char_map_a = build_counter(string_a)
    char_map_b = build_counter(string_b)

    if len(char_map_a.keys()) != len(char_map_b.keys()):
        return False

    for char in char_map_a.keys():
        if char not in char_map_b or char_map_a[char] != char_map_b[char]:
            return False

    return True

def build_counter(string: str) -> Counter:
    return Counter(re.sub(r'[^\w]', '', string, flags=re.UNICODE).lower())

Actually this works, too:

import re
from collections import Counter

def anagrams(string_a: str, string_b: str) -> bool:
    return build_counter(string_a) == build_counter(string_b)

def build_counter(string: str) -> Counter:
    return Counter(re.sub(r'[^\w]', '', string, flags=re.UNICODE).lower())

Java:

import java.util.Map;
import java.util.stream.Collectors;

public static boolean anagrams(String stringA, String stringB) {
    Map<Character, Long> charMapA = buildCharMap(stringA);
    Map<Character, Long> charMapB = buildCharMap(stringB);

    if (charMapA.keySet().size() != charMapB.keySet().size()) {
        return false;
    }

    for (char chr : charMapA.keySet()) {
        if (!charMapB.containsKey(chr) || !charMapA.get(chr).equals(charMapB.get(chr))) {
            return false;
        }
    }
    return true;
}

private static Map<Character, Long> buildCharMap(String str) {
    return str.replaceAll("[^\\w]", "")
            .toLowerCase()
            .chars()
            .mapToObj(i -> (char) i)
            .collect(Collectors.groupingBy(c -> c, Collectors.counting()));
}

2: Sort to compare

JavaScript:

function anagrams(stringA, stringB) {
  return cleanString(stringA) === cleanString(stringB);
}

function cleanString(str) {
  return str
    .replace(/[^\w]/g, '')
    .toLowerCase()
    .split('')
    .sort()
    .join('');
}

Python:

import re

def anagrams(string_a: str, string_b: str) -> bool:
    return clean_string(string_a) == clean_string(string_b)

def clean_string(string: str) -> str:
    lower = re.sub(r'[^\w]', '', string, flags=re.UNICODE).lower()
    return ''.join(sorted(lower))

Java:

import java.util.stream.Collectors;

public static boolean anagrams(String stringA, String stringB) {
    return cleanString(stringA).equals(cleanString(stringB));
}

private static String cleanString(String str) {
    return str.replaceAll("[^\\w]", "")
            .toLowerCase()
            .chars()
            .mapToObj(i -> (char) i)
            .sorted()
            .map(String::valueOf)
            .collect(Collectors.joining());
}

I hope you enjoyed this. I'd appreciate any comments and feedback.

Learning Algorithms with JS, Python and Java 6: Array Chunking

tommy-3 — Tue, 14 Aug 2018 23:51:04 +0000

This is the sixth article of my attempts to follow Stephen Grider's Udemy course in three different languages. JavaScript solutions are by Stephen. I try to "translate" it into Python and Java.

Today's question is:

--- Directions
Given an array and chunk size, divide the array into many subarrays
where each subarray is of length size
--- Examples
chunk([1, 2, 3, 4], 2) --> [[ 1, 2], [3, 4]]
chunk([1, 2, 3, 4, 5], 2) --> [[ 1, 2], [3, 4], [5]]
chunk([1, 2, 3, 4, 5, 6, 7, 8], 3) --> [[ 1, 2, 3], [4, 5, 6], [7, 8]]
chunk([1, 2, 3, 4, 5], 4) --> [[ 1, 2, 3, 4], [5]]
chunk([1, 2, 3, 4, 5], 10) --> [[ 1, 2, 3, 4, 5]]

I add to each solution the time (ms) it took to divide the array with 10,000,000 elements into subarrays with 1,000 elements.

1: Adding each element

JavaScript:

function chunk1(array, size) { // 227.480ms
    const chunked = [];

    for (let element of array) {
        const lastChunk = chunked[chunked.length - 1];

        if (!lastChunk || lastChunk.length === size) {
            chunked.push([element]);
        } else {
            lastChunk.push(element);
        }
    }

    return chunked;
}

Python:

def chunk1a(lst: list, size: int) -> list: # 2409.636ms
    chunked = []

    for element in lst:
        if not chunked or len(chunked[-1]) == size:
            chunked.append([])
        last_chunk = chunked[-1]
        last_chunk.append(element)

    return chunked

Like in exercise 4, we can't start with last_chunk = chunked[-1] as in JS because it would cause an IndexError.

Since this looks for the last element of chunked twice, it gets a little faster by rewriting it as:

def chunk1b(lst: list, size: int) -> list: # 2014.493ms
    chunked = []

    for element in lst:
        if not chunked:
            chunked.append([])
        last_chunk = chunked[-1]
        if len(last_chunk) == size:
            last_chunk = []
            chunked.append(last_chunk)
        last_chunk.append(element)

    return chunked

I also thought of using collections.deque instead of a list:

from collections import deque

def chunk1c(lst: list, size: int) -> list: # 2618.956ms
    chunked = deque()

    for element in lst:
        if not chunked or len(chunked[-1]) == size:
            chunked.append([])
        last_chunk = chunked[-1]
        last_chunk.append(element)

    return list(chunked)

but this resulted in a bit longer execution time than the first solution.

Java:

import java.util.ArrayList;
import java.util.List;

public static List<List<Integer>> chunk1a(List<Integer> list, int size) { // 2072.358ms
    List<List<Integer>> chunked = new ArrayList<>();

    for (int element : list) {
        if (chunked.isEmpty() || chunked.get(chunked.size() - 1).size() == size) {
            chunked.add(new ArrayList<>());
        }
        List<Integer> lastChunk = chunked.get(chunked.size() - 1);
        lastChunk.add(element);
    }

    return chunked;
}

A solution like the Python 1b is much faster than the first one.

import java.util.ArrayList;
import java.util.List;

public static List<List<Integer>> chunk1b(List<Integer> list, int size) { // 404.818ms
    List<List<Integer>> chunked = new ArrayList<>();

    for (int element : list) {
        if (chunked.isEmpty()) {
            chunked.add(new ArrayList<>());
        }
        List<Integer> lastChunk = chunked.get(chunked.size() - 1);
        if (lastChunk.size() == size) {
            lastChunk = new ArrayList<>();
            chunked.add(lastChunk);
        }
        lastChunk.add(element);
    }

    return chunked;
}

It can be improved even more when I use LinkedLists:

import java.util.LinkedList;
import java.util.List;

public static List<List<Integer>> chunk1c(List<Integer> list, int size) { // 295.885ms
    LinkedList<List<Integer>> chunked = new LinkedList<>();

    for (int element : list) {
        if (chunked.isEmpty()) {
            chunked.add(new LinkedList<>());
        }
        List<Integer> lastChunk = chunked.getLast();
        if (lastChunk.size() == size) {
            lastChunk = new ArrayList<>();
            chunked.add(lastChunk);
        }
        lastChunk.add(element);
    }

    return chunked;
}

Incidentally, here's the LinkedList version of the first Java code, and it's much slower than any solution. I wonder why because it looks to me essentially the same as the 1c above.

public static List<List<Integer>> chunk1d(List<Integer> list, int size) { // 4556.835ms
    LinkedList<List<Integer>> chunked = new LinkedList<>();

    for (int element : list) {
        if (chunked.isEmpty() || chunked.getLast().size() == size) {
            chunked.add(new LinkedList<>());
        }
        List<Integer> lastChunk = chunked.getLast();
        lastChunk.add(element);
    }

    return chunked;
}

This post has got longer than I'd expected, but now comes the second set of solutions, which are more concise and also faster.

2: Using a slice method

JavaScript:

function chunk2(array, size) { // 83.652ms
    const chunked = [];
    let index = 0;

    while (index < array.length) {
        chunked.push(array.slice(index, index + size));
        index += size;
    }

    return chunked;
}

Python:

def chunk2a(lst: list, size: int) -> list: # 240.898ms
    chunked = []
    index = 0

    while index < len(lst):
        chunked.append(lst[index:index+size])
        index += size

    return chunked

A Pythonic one-liner:

def chunk2b(lst: list, size: int) -> list: # 234.880ms
    return [lst[i:i+size] for i in range(0, len(lst), size)]

Java:

import java.util.ArrayList;
import java.util.List;
import java.lang.Math;

public static List<List<Integer>> chunk2(List<Integer> list, int size) { // 1.250ms
    List<List<Integer>> chunked = new LinkedList<>();
    int index = 0;

    while (index < list.size()) {
        chunked.add(list.subList(index, Math.min(index + size, list.size())));
        index += size;
    }

    return chunked;
}

This one is definitely the fastest of all!

Learning Algorithms with JS, Python and Java 5: FizzBuzz

tommy-3 — Wed, 08 Aug 2018 15:56:57 +0000

This is the fifth article of my attempts to follow Stephen Grider's Udemy course in three different languages.

When I wrote my last post a couple of days ago, I had only 5 followers, and now I have 35! I also received comments for the first time. I'm so happy I started this series, but now I feel kind of embarrassed to write about so famous a question at this timing.

There must be thousands of solutions, but here I just focus on showing two JS codes and trying to "translate" them into Python and Java as faithfully as possible.

--- Directions
Write a program that console logs the numbers
from 1 to n. But for multiples of three print
“fizz” instead of the number and for the multiples
of five print “buzz”. For numbers which are multiples
of both three and five print “fizzbuzz”.
--- Example
fizzBuzz(5);
1
2
fizz
4
buzz

1. Simple

JavaScript:

function fizzBuzz(n) {
    for (let i = 1; i <= n; i++) {
        if (i % 15 === 0) {
            console.log('fizzbuzz');
        } else if (i % 3 === 0) {
            console.log('fizz');
        } else if (i % 5 === 0) {
            console.log('buzz');
        } else {
            console.log(i);
        }
    }
}

Python:

def fizz_buzz(n):
    for i in range(1, n+1):
        if i % 15 == 0:
            print('fizzbuzz')
        elif i % 3 == 0:
            print('fizz')
        elif i % 5 == 0:
            print('buzz')
        else:
            print(i)

Java:

public static void fizzBuzz(int n) {
    for (int i = 1; i <= n; i++) {
        if (i % 15 == 0) {
            System.out.println("fizzbuzz");
        } else if (i % 3 == 0) {
            System.out.println("fizz");
        } else if (i % 5 == 0) {
            System.out.println("buzz");
        } else {
            System.out.println(i);
        }
    }
}

2. More Concise

JavaScript:

function fizzBuzz(n) {
    for (let i = 1; i <= n; i++) {
        console.log((i % 3 ? '' : 'fizz')
            + (i % 5 ? '' : 'buzz') || i);
    }
}

Python:

def fizz_buzz(n):
    for i in range(1, n+1):
        print(('' if i % 3 else 'fizz') +
              ('' if i % 5 else 'buzz') or i)

Java:

public static void fizzBuzz(int n) {
    for (int i = 1; i <= n; i++) {
        String result = (i % 3 > 0 ? "" : "fizz") 
                + (i % 5 > 0 ? "" : "buzz");
        if (result.equals("")) {
            result = String.valueOf(i);
        }
        System.out.println(result);
    }
}

I'm not really satisfied with the last Java code. I'd love to know if a more literal equivalent is possible. Thank you in advance for your comments!

Learning Algorithms with JS, Python and Java 4: MaxChar

tommy-3 — Mon, 06 Aug 2018 15:36:20 +0000

This is the fourth article of my attempts to follow Stephen Grider's Udemy course in three different languages.

First I quote todays's question:

--- Directions
Given a string, return the character that is most
commonly used in the string.
--- Examples
maxChar("abcccccccd") === "c"
maxChar("apple 1231111") === "1"

JavaScript:

function maxChar(str) {
    const charMap = {};
    let max = 0;
    let maxChar = '';

    for (let char of str) {
        if (charMap[char]) {
            charMap[char]++
        } else {
            charMap[char] = 1;
        }
    }

    for (let char in charMap) {
        if (charMap[char] > max) {
            max = charMap[char];
            maxChar = char;
        }
    }

    return maxChar;
}

Stephen rewrites the first for loop as:

    for (let char of str) {
        charMap[char] = charMap[char] + 1 || 1;
    }

This is possible because anObject['nonexistentKey'] returns undefined, undefined + 1 return NaN, which is falsy.

Python:

def max_char(str):
    char_map = {}
    max = 0
    max_char = ''

    for char in str:
        char_map.setdefault(char, 0)
        char_map[char] += 1

    for char in char_map:
        if char_map[char] > max:
            max = char_map[char]
            max_char = char

    return max_char

In Python, you can't just try char_map[char] += 1 as in JS, because it would throw a KeyError if the key doesn't exist yet.

More concisely:

def max_char(str):
    char_map = {}

    for char in str:
        char_map.setdefault(char, 0)
        char_map[char] += 1

    return max(char_map, key=char_map.get)

Source: https://stackoverflow.com/questions/268272/getting-key-with-maximum-value-in-dictionary
max(char_map, key=char_map.get) is the same as max(char_map.keys(), key=char_map.get).
key=char_map.get is needed to find the (key, value) tuple pair in the dictionary whose value is the largest. max({'a': 2, 'b': 1}) returns 'b'.

Java:

import java.util.HashMap;
import java.util.Map;

public static char maxChar2(String str) {
    Map<Character, Integer> charMap = new HashMap<>();

    for (char chr : str.toCharArray()) {
        Integer chrCount = charMap.get(chr);
        if (chrCount == null) {
            chrCount = 0;
        }
        charMap.put(chr, chrCount + 1);
    }

    int max = 0;
    char maxChar = '\0';

    for (Map.Entry<Character, Integer> entry : charMap.entrySet()) {
        int value = entry.getValue();
        if (value > max) {
            max = value;
            maxChar = entry.getKey();
        }
    }

    return maxChar;
}

Using Stream:

public static char maxChar(String str) {
    Map<Character, Long> charMap = str.chars()
            .mapToObj(i -> (char) i)
            .collect(Collectors.groupingBy(
                    c -> c, Collectors.counting()));

    return charMap.entrySet().stream()
            .collect(Collectors.groupingBy(
                    Map.Entry::getValue,
                    TreeMap::new,
                    Collectors.mapping(
                            Map.Entry::getKey, Collectors.toList())))
            .lastEntry()
            .getValue()
            .get(0);
}

The return statement can be made simpler:

    return charMap.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .get()
            .getKey();

References:
https://codereview.stackexchange.com/questions/133058/print-max-occurring-character-in-a-string
https://stackoverflow.com/questions/48280361/how-to-count-occurrences-for-each-value-in-multimap-java
https://stackoverflow.com/questions/42060294/using-java8-stream-to-find-the-highest-values-from-map

Learning Algorithms with JS, Python and Java 3: Integer Reversal

tommy-3 — Thu, 02 Aug 2018 13:02:57 +0000

I joined dev.to this week and posted two little articles. Thank you for the hearts and unicorns (though I'm still not really sure what unicorns mean)!

The third question in the Stephen Grider's course is to reverse an integer. I'll just quote the directions here.

--- Directions
Given an integer, return an integer that is the reverse ordering of numbers.
--- Examples
reverseInt(15) === 51
reverseInt(981) === 189
reverseInt(500) === 5
reverseInt(-15) === -51
reverseInt(-90) === -9

Stephen's JS solution is:

function reverseInt(n) {
    const reversed = n
        .toString()
        .split('')
        .reverse()
        .join('');

    return parseInt(reversed) * Math.sign(n);
}

This works because parseInt('12-') returns 12.

A neater solution might be:

function reverseInt(n) {
    const absReversed = Math.abs(n)
        .toString()
        .split('')
        .reverse()
        .join('');

    return Number(absReversed) * Math.sign(n);
}

My attempt in Python:

def reverse_int(n):
    abs_reversed = str(abs(n))[::-1]
    if n > 0:
        return int(abs_reversed)
    else:
        return -int(abs_reversed)

int('12-') throws a ValueError, so abs() cannot be omitted.
I wonder if there's a cooler way to do it.

And Java:

public static int reverseInt(int n) {
    String abs = Integer.toString(Math.abs(n));
    String absReversed = new StringBuilder(abs).reverse().toString();
    return Integer.parseInt(absReversed) * Integer.signum(n);
}

parseInt('12-') throws a NumberFormatException in Java, so Math.abs() cannot be omitted.

Learning Algorithms with JS, Python and Java 2: Palindrome

tommy-3 — Tue, 31 Jul 2018 15:46:00 +0000

Here's my second attempt at solving the same problem using three different languages: JavaScript, Python and Java.

Today's question is to judge whether the given string is a palindrome.

1 The Most Straightforward Solution

JavaScript:

function isPalindrome(str) {
    const reversed = str.split('').reverse().join('');
    return str === reversed;
}

Python:

def is_palindrome(str):
    return str[::-1] == str

Java:

static boolean isPalindrome(String str) {
    String reversed = new StringBuilder(str).reverse().toString();
    return reversed.equals(str);
}

Note that return reversed == str; doesn't work because reversed and str point to different objects.

2. Elegant (But Redundant)

JavaScript:

function isPalindrome(str) {
    return str.split('').every((char, i) => {
        return char === str[str.length - i - 1];
    });
}

Its Python equivalent, without redundancy, would be perhaps:

def is_palindrome(str):
    return all([str[i] == str[-i-1] for i in range(len(str)//2)])

And Java:

static boolean isPalindrome(String str) {
    int n = str.length();
    return IntStream.range(0, n/2)
            .allMatch(i -> str.charAt(i) == str.charAt(n - i - 1));
}

3. An Alternative With a For Loop

JavaScript:

function isPalindrome(str) {
    const n = str.length;
    for (let i = 0; i < Math.floor(n/2); i++) {
        if (str[i] != str[n - i - 1]) {
            return false;
        }
    }
    return true;
}

Python:

def is_palindrome(str):
   for i in range(len(str)//2):
         if str[i] != str[-i-1]:
                 return False
   return True

Java:

static boolean isPalindrome(String str) {
    int n = str.length();
    for (int i = 0; i < n / 2; i++)
        if (str.charAt(i) != str.charAt(n - i - 1)) {
            return false;
        }
    return true;
}

Notes:
5 / 2 is 2.5 in JavaScript and Python 3.
5 / 2 is 2 in Java.
5 // 2 is 2 in Python 3.

References:
https://stackoverflow.com/questions/11758791/python-3-2-palindrome
https://stackoverflow.com/questions/4138827/check-string-for-palindrome

Learning Algorithms with JS, Python and Java 1: String Reversal

tommy-3 — Tue, 31 Jul 2018 00:47:33 +0000

When I study natural languages, I've always enjoyed comparing them. It was intriguing to know, for example, that the English and German prefix "un-", the Latin prefix "in-" and the Greek prefix "ἀ-" are all thought to stem from the same Proto-Indo-European prefix "*n̥-". As a (semi-)beginner of programming, I thought it might be also fun to try to learn them in a comparative manner.

I'll follow Stephen Grider's Udemy course The Coding Interview Bootcamp: Algorithms + Data Structures, which is completely in JavaScript, and solve the same question in JavaScript, Python and Java, which are just three languages I happen to know the basics of.

The first task in the course is to reverse the given string. Stephen introduces three JavaScript answers.

1. Simple Solution

JavaScript:

function reverse(str) {
    return str.split('').reverse().join('');
}

Its translation into Python would be:

def reverse(str):
    chars = [char for char in str]
    chars.reverse()
    return ''.join(chars)

In idiomatic Python:

def reverse(str):
    return str[::-1]

The Java equivalent of the first JS code would be:

import org.apache.commons.lang3.ArrayUtils;

static String reverse(String str) {
    char[] chars = str.toCharArray();
    ArrayUtils.reverse(chars);
    return String.valueOf(chars);
}

The standard Java way to achieve it seems to be:

static String reverse(String str) {
    return new StringBuilder(str).reverse().toString();
}

2. Using a For Loop

JavaScript:

function reverse(str) {
    let reversed = '';

    for (let char of str) {
        reversed = char + reversed;
    }

    return reversed;
}

Python:

def reverse(str):
    reversed = ''

    for char in str:
        reversed = char + reversed

    return reversed

Java:

static String reverse(String str) {
    StringBuilder reversed = new StringBuilder();

    for (char character : str.toCharArray()) {
        reversed.insert(0, character);
    }

    return reversed.toString();
}

which is actually very slow when a long string is given, because it searches for the 0th position every time.

This one works fast enough:

static String reverse(String str) {
    StringBuilder reversed = new StringBuilder();

    for (int i = str.length() - 1; i >= 0; i--) {
        reversed.append(str.charAt(i));
    }

    return reversed.toString();
}

3. Using the Reduce Method

This is not very practical or efficient, but just to explore what the languages offer.

JavaScript:

function reverse(str) {
    return str.split('').reduce((reversed, char) => char + reversed, '');
}

Python:

from functools import reduce

def reverse(str):
    return reduce(lambda reversed, char: char + reversed, str)

Java:

static String reverse6(String str) {
    return str.chars()
            .mapToObj(c -> String.valueOf((char) c))
            .reduce("", (reversed, chr) -> chr + reversed);
}

I hope someone would find this interesting or helpful and I'd appreciate any suggestion or comment.