Daily Challenge #49 - Dollars and Cents

Today's challenge requires you to create a function that will take a float and return the amount formatted in dollars and cents.

For example: 6.2 becomes $6.20

---

Want to propose a challenge idea for a future post? Email [e-mail] with your suggestions!

This challenge comes from kolohelios on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Comments

[La blatte]

Here we go!

f=a=>`$${a.toFixed`2`}`;

And the results:

f(.4); // "$0.40"
f(0); // "$0.00"
f(6.2); // "$6.20"

And how about some Intl?

f=a=>new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(a)

Which does a bit more, like adding commas:

f(.4); // "$0.40"
f(0); // "$0.00"
f(6.2); // "$6.20"
f(100000000.1234); // "$100,000,000.12"

[Tushar Khanna]

Hello, I am surprised, you can call a function with ``. How come is it working?

[La blatte]

ES6 added this functionality, called Tagged Template! A few examples can be found here: wesbos.com/tagged-template-literals/

[Tushar Khanna]

Thanks a ton :) learnt new thing

[Jarod Smith]

const formatDollars = money => `$${money.toFixed(2)}`;

`
love js

[Sascha]

Mind rounding "errors":

formatDollars(.126)
> '$0.13'

Same happens in python:

print(f"{123.126:.2f}")
123.13

[Josh]

It rounded up, though, so is that an error? It seems like expected behavior to me.

[Donald Feury]

Go - with tests as usual

fun fact - this was the first time I wrote anything using Vim

dollars.go

package dollars

import (
    "fmt"
)

// Dollars returns the string representation of a float as a dollar amount
func Dollars(amount float64) string {
    return fmt.Sprintf("$%.2f", amount)
}

dollars_test.go

package dollars

import (
    "testing"
)

var testCases = []struct {
    description string
    input       float64
    expected    string
}{
    {
        "only cents",
        .04,
        "$0.04",
    },
    {
        "only dollars",
        3,
        "$3.00",
    },
    {
        "cents & dollars",
        3.14,
        "$3.14",
    },
    {
        "amounts with more than two decimal places round to the nearest cent",
        4.478,
        "$4.48",
    },

}

func TestDollars(t *testing.T) {
    for _, test := range testCases {
        if result := Dollars(test.input); result != test.expected {
            t.Fatalf("FAILED: %s - Dollars(%f): %s, expected %s \n", test.description, test.input, result, test.expected)
        }
        t.Logf("PASS: %s \n", test.description)
    }
}

[Tiash]

I'm not sure, but I think that "Sprintf" rounds to nearest integer.
Try with a value like 3.149 if still returns 3.14 or 3.15

[Donald Feury]

Yeah it rounds to the nearest cent in this case, the question becomes then do we want it to work that way, or do we say "Hey you don't have a full cent" so it always rounds down?

[Donald Feury]

Added additional test case to clarify current rounding behavior.

[Mikhail Korolev]

Sometimes I just think about Rails method that does a very specific thing, type it out in console and it works

number_to_currency(number)

[Alfredo Salzillo]

With miles separator too:

const formatMoney = money => [...`$${money .toFixed(2)}`]
  .reverse()
  .flatMap((c, i) => (c != '.' && c != '$' && i > 3 && i % 3 == 0) ? [',', c]: [c])
  .reverse()
  .join('');

// formatMoney(12123123123131232.000) => $12,123,123,123,131,232.00

[SRINU]

Here is the python code

num=float(input())
print("${:,.2f}".format(num))

[Amin]

My take at the challenge written in Haskell.

toFloat :: String -> Float
toFloat string = read string :: Float

decimalToInt :: Float -> Int
decimalToInt float =
  round
    $ (*) 100
    $ toFloat
    $ take 5
    $ show
    $ float - (fromIntegral $ floor float)

decimalToDollar :: Float -> String
decimalToDollar float =
  "$" 
    ++ (show $ round float)
    ++ "."
    ++ (show $ decimalToInt float)

main :: IO ()
main = do
  putStrLn $ show $ decimalToDollar 6.2 -- "$6.20"
  putStrLn $ show $ decimalToDollar 6.227 -- "$6.23"

Try it online.

For some reason, I get imprecise floating point numbers when grabbing the decimal part of a floating point number in Haskell. I'm pretty new to this language so I must miss something. Feel free to improve my work here.

[Jay]

Rust Function:

fn format_dollar(price: f32) -> String {
    format!("${:.2}", price)
}

[Oleksii Filonenko]

Elixir:

defmodule Day49 do
  def float_to_money(float),
    do: "$#{:io_lib.format("~.2f", [float])}"
end

[Seiei Miyagi]

ruby <3

define_method(:format_dollar, &"$%.02f".:%)