DEV Community

Daily Challenge #135 - The Wide Mouthed Frog!

dev.to staff on December 11, 2019

The wide mouth frog is particularly interested in the eating habits of other creatures. He just can't stop asking the creatures he encounters what...

Read full post

Avalander • Dec 11 '19

Haskell

mouthSize :: String -> String
mouthSize "alligator" = "small"
mouthSize x           = "wide"

Amin • Dec 11 '19 • Edited

I see you are learning about Haskell. Congratulations! This isn't an easy language to handle (I'm am myself a learner, but aren't we all?).

I guess in your solution, cases like "ALLIGATOR" and "aLlIgAtOr" won't match the first pattern and will return "wide". But the OP was mentioning that the "alligator" animal was case insensitive.

So I'm proposing this solution.

import Data.Char (toLower, isSpace)
import Data.List (dropWhile, dropWhileEnd)

trim :: String -> String
trim = dropWhile isSpace . dropWhileEnd isSpace

mouthSize :: String -> String
mouthSize animal 
    | (trim $ map toLower animal) == "alligator" = "small"
    | otherwise = "wide"

main :: IO ()
main = do
    print $ mouthSize "alligator"       -- small
    print $ mouthSize "   alligator   " -- small
    print $ mouthSize "aLlIgAtOr"       -- small
    print $ mouthSize "fox"             -- wide

I took the opportunity to handle the cases where there was too much spaces (as I did in my TypeScript proposal).

This may not be the final solution, or prone to enhancement, but I guess it is a good one. We can make it better together as a community!

Zohar Peled • Dec 11 '19

Am I missing something here or is this really not a challenge at all?

public string mouth_size(string animal)
{
    return string.Equals(animal, "alligator", StringComparison.OrdinalIgnoreCase) ?
         "small" :
         "wide";
}

Nick Holmes • Dec 11 '19

Challenge or not, at this time there are 6 solutions posted here, and (I believe) only 2 are completely to spec.

Zohar Peled • Dec 11 '19

Most seem legit to me... Maybe a typo here and there...

Nick Holmes • Dec 11 '19

and not handling case insensitivity.

Nick Holmes • Dec 11 '19 • Edited

F#:

let mouth_size = function
    | IgnoreCase "alligator" -> "small"
    | _ -> "wide"

But that uses an active pattern to make it case insensitive, like this;

let (|IgnoreCase|_|) a b = 
    match String.Equals(a, b, StringComparison.OrdinalIgnoreCase) with
    | true -> Some()
    | false -> None

Active Patterns provide a real nice way to move the ugly details of the case insensitive comparison out the the way.

Nick Holmes • Dec 13 '19

Well, I guess in this case it's down to personal preference and style.

I think that the length of String.Equals call detracts from comprehending what the code is doing, so moving it elsewhere is achieves more than just adding a layer of indirection.

I'm also not against using match over a simple bool- I quite like the kind of tabular layout of the code.

Amin • Dec 11 '19 • Edited

TypeScript

"use strict";

class MouthSizeArgumentCountError extends Error {
    constructor(message: string) {
        super(message);

        this.name = "MouthSizeArgumentCountError";
    }
}

class MouthSizeTypeError extends Error {
    constructor(message: string) {
        super(message);

        this.name = "MouthSizeArgumentCountError";
    }
}

type MouthSize = "small" | "wide";

function mouthSize(animal: string): MouthSize {
    if (arguments.length !== 1) {
        throw new MouthSizeArgumentCountError("Expected exactly one argument");
    }

    if (typeof animal !== "string") {
        throw new MouthSizeTypeError("Expect argument to be a string");
    }

    if (animal.trim().toLowerCase() === "alligator") {
        return "small";
    }

    return "wide";
}

console.log(mouthSize("alligator")); // "small"
console.log(mouthSize("aLlIgAtOr")); // "small"
console.log(mouthSize("fox"));      // "wide"

try {
    // @ts-ignore
    mouthSize();
    // @ts-ignore
    mouthSize("fox", "alligator");
} catch (error) {
    if (error instanceof MouthSizeArgumentCountError) {
        console.log("argument count error");
    }
}

try {
    // @ts-ignore
    mouthSize(123);
} catch (error) {
    if (error instanceof MouthSizeTypeError) {
        console.log("argument type error");
    }
}

erezwanderman • Dec 11 '19

mouth_size = animal => /^alligator$/i.test(animal) ? 'small' : 'wide'

kesprit • Dec 11 '19

Swift :

func mouthSize(animal: String) -> String {
    animal.lowercased() == "aligator" ? "small" : "wide"
}

Nick Holmes • Dec 11 '19

Good example of why unit tests are important!

kesprit • Dec 12 '19

Thanks a lot for this useful input, that's a good example of why constructive criticism is important.

Nick Holmes • Dec 12 '19

Sorry. You nailed it, but misspelled alligator.

Vaibhav Yadav • Dec 11 '19 • Edited

In Go.

import "strings"

func mouthSize(animal string) string {
    if strings.ToLower(animal) == "alligator" {
        return "small"
    }

    return "wide"
}

Benjamin Chislett • Dec 11 '19

const mouth_size = a => (a == "alligator") ? "small" : "wide"

Simon Landry • Dec 13 '19

The animal isn't case insensitive in your code mounth_size('aLlIgAtOr') will return 'wide' while it should return 'small'

Simon Landry • Dec 13 '19

Ruby:

def mouth_size(animal)
  animal =~ /alligator/i ? 'small' : 'wide'
end

Avalander • Dec 11 '19

Maybe, I don't write a lot of Haskell so I couldn't say.