craftybones

Triangle

Instructions

Your task is to extend the functionality of the generatePattern(style, dimensions) function to support a new pattern type: triangle.

For this assignment, the style parameter will be "triangle", and the dimensions parameter will be an array containing a single number [size] where:

• size specifies the number of rows in the triangle.
• The width of each row corresponds to its row number (1-based). For example, the 1st row has 1 *, the 2nd row has 2 *, and so on.

craftybones

Alternating Rectangle Pattern

Instructions

Your task is to extend the functionality of the generatePattern(style, dimensions) function to support a new pattern type: alternating rectangle.

For this assignment, the style parameter will be "alternating-rectangle", and the dimensions parameter will be an array [columns, rows] where:

• columns is the number of columns in the rectangle.
• rows is the number of rows in the rectangle.

craftybones

Early exits

Early exits are a coding technique where we return from a function as soon as we encounter a condition that prevents further execution. This approach simplifies code, improves readability, and can enhance performance by avoiding unnecessary computations.

function occurrences(string, substring) {
  const lastIndex = string.length - substring.length;
  const isSubstringEmpty = !substring;

  let subStringCount = 0;

craftybones

From Hardcoded Squares to Flexible Patterns

The humble checkerboard, with its alternating squares of light and dark, holds surprising depth when it comes to programming. Generating this familiar pattern can be tackled in various ways, each showcasing fundamental programming concepts and revealing their strengths and limitations. Let's embark on a journey through code, using the checkerboard as our canvas, to explore these concepts and discover the art of building flexible and efficient solutions.

A simple printf

This section presents the simplest approach to generating a checkerboard pattern using the printf function. Here, we directly print hardcoded strings representing alternating rows of "1"s and "0"s.

#include 

craftybones

Motivation

A lot of us Clojurians make the claim that programming in Clojure has provided us unique perspectives on computing. We further claim that these perspectives make us better programmers in other languages too.

this tweeter wanted concrete examples.

While I might not be able to make a case that it makes us better programmers, I'd like to provide a small catalog of example that illustrates the difference in perspectives.

Functions, not operators

craftybones

rapheljr

TODO

• Refer README.md
• Look up todo frequently
• Add -n+num and -c+num
• Add -r and -q
• Make extraction from tailMain

craftybones

(defn length-between? [x y]
  (fn [password] (<= x (count password) y)))

(def alpha-only? (partial re-matches #"^\p{Alpha}*$"))
(def digit-only? (partial re-matches #"^\p{Digit}*$"))
(def alpha-numeric? (partial re-matches #"^\p{Alnum}*$"))
(def special-char? (partial re-find #"[^\p{Alnum}]"))

(def classifiers {:weak   [(length-between? 0 5) 
                           (some-fn alpha-only? digit-only?)]

craftybones

const firstAlgo = (x) => {
  if (x % 15 == 0) {
    return { numberOfChecks: 1, val: "fizzbuzz" };
  }
  if (x % 5 == 0) {
    return { numberOfChecks: 2, val: "buzz" };
  }
  if (x % 3 == 0) {
    return { numberOfChecks: 3, val: "fizz" };
  }

craftybones

(defn make-set-of-positions
  [positions]
  (->> positions
       (mapcat second)
       (into #{})))

(defn create-game
  "Creates a game consisting of players and their ship positions.
  positions is expected as a map {:carrier #{1 2 3 4 5}, :destroyer...}"
  [player-1-positions player-2-positions]

craftybones

// Run on node repl
// In node, type in
// .load factorial.js

// editor
// This side will be pure lambda calculus

const identity = (x) => x;

const constantlyFirst = (x) => (y) => x;