Daily Challenge #75 - Set Alarm

dev.to staff on September 24, 2019

Write a function named setAlarm which receives two parameters. The first parameter, employed, is true whenever you are employed and the second para... [Read Full]
markdown guide
 

How about prolog?
A file with one fact should do it...

setAlarm(true,false).

To run..

> gprolog --consult-file setAlarm.pl
GNU Prolog 1.4.5 (64 bits)
Compiled Aug 20 2018, 15:27:00 with clang
By Daniel Diaz
Copyright (C) 1999-2018 Daniel Diaz
compiling /Users/Will/setAlarm.pl for byte code...
/Users/Will/setAlarm.pl compiled, 1 lines read - 257 bytes written, 4 ms
| ?- setAlarm(false,false).

no
| ?- setAlarm(false,true).

no
| ?- setAlarm(true,false).

yes
| ?- setAlarm(true,true).

no
 

Prolog still scares me . . . not its syntax, but seemingly untapped potential.

 

Java

public class Employment
{
  private static boolean setAlarm(boolean employed, boolean vacation) {
    return employed && !vacation;
  }

  public static void main(String[] args)
  {
    System.out.println(setAlarm(false, false));
    System.out.println(setAlarm(false, true));
    System.out.println(setAlarm(true, true));
    System.out.println(setAlarm(true, false));
  }
}
 

I'm sorry, but it seems like you've lost the challenge somewhere.

At first I thought I've probably missed something, but then I saw the comments and realized it wasn't me, it was whoever came up with this challenge.

If I may offer a twist - Do it in a language you've never worked with before.
I'll take Scala for a ride on this one:

object challenge {
   def setAlarm( employed:Boolean, vacation:Boolean ) : Boolean = {
      return employed && !vacation
   }
}

Nope, sorry, still too easy.

 

Python with optional typing indicators and tests

def set_alarm(employed: bool, vacation: bool) -> bool:
  return employed and not vacation

assert not set_alarm(True, True)
assert not set_alarm(False, True)
assert not set_alarm(False, False)
assert set_alarm(True, False)

 

x86-64 assembly (NASM syntax):

section .text
global set_alarm
set_alarm:
    mov rax, rsi
    not rax
    and rax, rdi
    ret
 

Elm

setAlarm : Bool -> Bool -> Bool
setAlarm employed onVacation =
    case (employed, onVacation) of
        (True, False) ->
            True

        _ ->
            False

Explainations

module SetAlarm exposing (setAlarm)

This will expose our only function setAlarm to the outside world (used in our tests, see below).

setAlarm : Bool -> Bool -> Bool
setAlarm employed onVacation =

This will define a function named setAlarm. It takes three parameters. Which are all three booleans.

    case (employed, onVacation) of

We wrap our two parameters into a tuple. That way we can easily work with pattern matching.

Tests

module SetAlarmTest exposing (suite)

import Expect exposing (equal)
import SetAlarm exposing (setAlarm)
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "Set alarm"
        [ test "It should return true when employed and not on vacation" <| \_ -> equal True <| setAlarm True False
        , test "It should return true when unemployed and not on vacation" <| \_ -> equal False <| setAlarm False False
        , test "It should return true when employed and on vacation" <| \_ -> equal False <| setAlarm True True
        , test "It should return true when unemployed and on vacation" <| \_ -> equal False <| setAlarm False True
        ]
 

crackin' out the ol' Clojure 🤔

(ns dailyChallenge.seventyFive)

(defn- setAlarm [& {:keys [employed? vacation?]}]
  "A vacation is what you take when you can no longer take what you've
   been taking - Wise Man #42"
  (cond 
    (and employed? vacation?) false
    (and employed? (not vacation?)) true))

don't test me 😗

(deftest sunrise_mutha_fcka
 (is (= true (setAlarm :employed? true :vacation? false))
 (is (= false (and
                (setAlarm :employed? false :vacation? false)
                (setAlarm :employed? true :vacation? true) 
                (setAlarm :employed? false :vacation? true)))))
                  ;;i don't know if you can be unemployed and temporarily away 
                  ;;from work | in fact, you can't. 🤔🤔🤔

(run-tests 'dailyChallenge.seventyFive)

at least with named non-positional parameters . . .

. . . there's less confusion about how silly this is 😂

 

in Gwion.
Using the newly implemented pattern matching ability.

fun int setalarm(const bool employed, const bool vacation) {
  match employed {
    case true: return !vacation;
    case _: return false;
  }
}

<<< setalarm(true, true) >>>;
<<< setalarm(false, true) >>>;
<<< setalarm(false, true) >>>;
<<< setalarm(true, false) >>>;

I should implement implicit casting from bool to int and vice-versa.


EDIT: done and working.

BONUS:

  • set ! operator as boolean, which hopefully makes more sense
  • demonstrate (very) bad git usage 😕
 

My solution in js

const setAlarm = (employed = true, vacation = true) => employed && !vacation;

No prior experience in Python just wanted to give it a try. Like it :) Going to spend more time on the docs in the coming days.

My solution in Python

def setAlarm(employed = True, onVacation = True):
  return employed and not onVacation
 

Elixir:

def set_alarm(true, false), do: true
def set_alarm(_, _), do: false
 

Here is in Unison

use base

setalarm : Boolean -> Boolean -> Boolean

setalarm employed vacation = case (employed, vacation) of
(true, false) -> true
_ -> false

setalarm true true
setalarm false true
setalarm false false
setalarm true false

 

Solved On Purescript

setAlarm :: Boolean -> Boolean -> Boolean
setAlarm employed vacation =
   case (Tuple employed vacation) of
     (Tuple true false) ->
         true

     (Tuple _ _) ->
         false       
 

Javascript:

setAlarm(employed, onVacation) => employed && !onVacation
 

In C#

Public bool setalarm(bool employed = false, bool vacation = false){
return !vacation && employed;
}

 

nicer with some formatting:

Public bool setalarm(bool employed = false, bool vacation = false){
  return !vacation && employed;
}

Interresting of you use vacation first and your use of default values 😄

 

In go:

func setAlarm(e, v bool) bool {
    return e && !v
}

Go Playground example

 

Haskell

set_alarm :: Bool -> Bool -> Bool
set_alarm True False = True
set_alarm a b        = False
 
 

c++

const auto setAlarm = [](const bool& employed, const bool& vacation){
    return employed && !vacation;
};
 

Swift version:

import Foundation

/*
 SetAlarm challenge function

 @param currentlyEmployed: Bool indicating if we are currently employed.
 @param onVacation: Bool indicating if we are currently on vacation.

 @return Bool indicating if we need to set our alarm.  Only true if both employed and not on vacation.
 */
func setAlarm(currentlyEmployed:Bool, onVacation:Bool) -> Bool{
    return (currentlyEmployed && !onVacation)
}

//  run with all examples
print("Ex1 setAlarm(true,true)   -> false:     ", setAlarm(currentlyEmployed: true, onVacation: true))
print("Ex2 setAlarm(false,true)  -> false:     ", setAlarm(currentlyEmployed: false, onVacation: true))
print("Ex3 setAlarm(false,false) -> false:     ", setAlarm(currentlyEmployed: false, onVacation: false))
print("Ex4 setAlarm(true,false)  -> true:      ", setAlarm(currentlyEmployed: true, onVacation: false))


//  not exactly proper test suite, but you get the idea.
print("Passed all tests:    ", (!setAlarm(currentlyEmployed: true, onVacation: true) &&
                                !setAlarm(currentlyEmployed: false, onVacation: true) &&
                                !setAlarm(currentlyEmployed: false, onVacation: false) &&
                                setAlarm(currentlyEmployed: true, onVacation: false)))

Outputs the following:

Ex1 setAlarm(true,true)   -> false:      false
Ex2 setAlarm(false,true)  -> false:      false
Ex3 setAlarm(false,false) -> false:      false
Ex4 setAlarm(true,false)  -> true:       true
Passed all tests:     true
Program ended with exit code: 0

Overkill with all the printouts, but hey, why not?

code of conduct - report abuse