dev.to staff

Posted on

# Daily Challenge #76 - Bingo! (or not...)

For this game of BINGO, you will receive a single array of 10 numbers from 1 to 26 as an input. Duplicate numbers within the array are possible.

Each number corresponds to their alphabetical order letter (e.g. 1 = A. 2 = B, etc). Write a function where you will win the game if your numbers can spell "BINGO". They do not need to be in the right order in the input array). Otherwise you will lose. Your outputs should be "WIN" or "LOSE" respectively.

Test Arrays:
bingo([21,13,2,7,5,14,7,15,9,10])
bingo([1,2,3,4,5,6,7,8,9,10]

Good luck!

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

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

Xavier Dubois 🇫🇷 • Edited

PHP Version

``````/**
* Bingo Challenge
*
* @param array \$input Array of 10 number
*
* @return string
*/
function bingo(array \$input = []): string
{
// BINGO
\$winSequence = [2, 9, 14, 7, 15];

return (\$winSequence === array_intersect(\$winSequence, \$input)) ? 'WIN': 'LOSE';
}
``````

Amin

Why adding `public` before the `function` keyword?

Xavier Dubois 🇫🇷 • Edited

Force of habit.
I never code in a procedural way, I always have a class, so I declare method visibility ...

It's for sure a Fatal Error in a procedural code.

I'll edit my snippet in consequence

Amin

Okay I though it was a new language feature haha.

I didn't found any use case of this function in PHP before but now I do thanks to your take at the challenge. Well done btw!

jess unrein

Python with typing indicators

``````def bingo(numbers: list) -> str:
bingo_set = set([2, 9, 14, 7, 15])
if bingo_set.issubset(set(numbers)):
return "WIN"
else:
return "LOSE"

assert bingo([21,13,2,7,5,14,7,15,9,10]) == "WIN"
assert bingo([1,2,3,4,5,6,7,8,9,10]) == "LOSE
``````

@nobody • Edited

good ol' Clojure 😏

``````(ns dailyChallenge.seventySix)

(defn- bingo! [board]
"don't do a thang if it ain't got that swang. ¯\_(ツ)_/¯"
(let [BINGO #{2 9 14 7 15}
reduc_board (set board)
contains-all? #(and (doseq [p %1]
(contains? %2 p)))]

(if (contains-all? BINGO redc_board) "WIN" "LOSE")))
``````

das tests (⌐■_■)

``````(deftest fair-game?
(is (= "WIN" (bingo! [21 13 2 7 5 14 7 15 9 10]))
(is (= "LOSE" (bingo!(vec (range 1 10)))) ;;just gettin' shwifty with the lists

(run-tests 'dailyChallenge.seventySix)
``````

Sebastian

JavaScript version:

``````const winSequence = [2, 9, 14, 7, 15];
function bingo(input = []){
return [...new Set(input)].filter(value => winSequence.includes(value)).length === winSequence.length ? "WIN" : "LOSE";
}
``````

Explanation:
The `Set` object lets you store `unique` values of any type.
That is why new `Set([1,2,1,3,3,4])` will give a set of `1,2,3,4`. Since a set is iterable whe can spread it into an new array, thus creating a new array containing only the unique values of the input array.

`const uniqueValues = [...new Set(input)]` can be written as follows:

``````const inputSet = new Set(input);
const uniqueValuesArray = [...inputSet]
``````

The unique input values are then filtered with `.filter()`checking if each and every value is in the winning sequence using `winSequence.includes(value)`.

This will result in an intersection between the unique values in the input array and the winning sequence. Then if the length of that intersection is the same as the length of the winning sequence, that means a "WIN".

Vinnie

JS:

``````const bingo = (nums) => {
const win = [2, 9, 14, 7, 15];
return  nums.reduce((acc, num) => {
if(win.includes(num)) acc.push(num);
return acc;
}, []).length > win.length ? 'WIN' : 'LOSE';
}
``````

Amin

Elm

``````module Bingo exposing (bingo)

belongsTo : List Int -> Int -> Bool
belongsTo integerList integer =
List.member integer integerList

bingo : List Int -> Bool
bingo input =
List.all (belongsTo input) [ 2, 9, 14, 7, 15 ]
``````

Eplainations

``````module Bingo exposing (bingo)
``````

Here we say that we only want the function `bingo` to be exposed to the outside world.

``````belongsTo : List Int -> Int -> Bool
belongsTo integerList integer =
List.member integer integerList
``````

We then define a helper function `belongsTo` which will not be exposed to the outside world.

It takes two parameters: the first being a list (array) of integers, and the second is an integer. The function will then return a boolean indicating if the `integer` is indeed part of the `integerList` thanks to the `List.member` function.

``````bingo : List Int -> Bool
bingo integerList =
List.all (belongsTo integerList) [ 2, 9, 14, 7, 15 ]
``````

Finally, we define our main function `bingo` which takes a list of integers. The `List.all` takes a function applied to each one of our `BINGO` list (which is just the integer representation of that word). If there is no `BINGO` integer in the `integerList`, it will return false. `List.all` expects all applied functions to return `True`. If only one of them return `False` (meaning, one of the `BINGO` integer has not been found in the `integerList`), it will return false.

Tests

``````module BingoTest exposing (suite)

import Bingo exposing (bingo)
import Expect exposing (equal)
import Test exposing (Test, describe, test)

suite : Test
suite =
describe "Basic tests"
[ test "It should return true when passing a valid array" <|
\_ ->
equal True <| bingo [ 21, 13, 2, 7, 5, 14, 7, 15, 9, 10 ]
, test "It should return false when passing an invalid array" <|
\_ ->
equal False <| bingo [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
]
``````

Andreas Jakof • Edited

C#

``````public string Bingo(byte[] numbers)
{
List<byte> bingo = new List<byte>{2,7,9,14,15};
return bingo.All(x => numbers.Contains(x)) ? "WIN" : "LOSE";
}
``````

K.V.Harish

My solution in js

``````const bingo = (arr) => [2, 9, 14, 7, 15].every((value) => arr.includes(value)) ? 'WIN' : 'LOSE';
``````

Wlloa • Edited

# Whit Python

``````
win_condition = set([2,9,14,7,15])
def isBingo(input):
if win_condition.issubset(set(input)):
return "WIN"
return "LOSE"

``````

`

karthick rajan

Solved with Purescript

bingo :: Set Int -> Boolean
bingo input =
subset (fromFoldable [ 2, 9, 14, 7, 15 ]) (fromFoldable input)