One of the many reasons I love working with Ruby is it has a rich vocabulary that allows you to accomplish your goals with a minimal amount of code. If there isn't a method that does exactly what you want, it's usually possible to build an elegant solution yourself.
Let's take the example of simulating the rolling of a die.
We can represent a die as an array of its faces.
die = [*?⚀..?⚅]
# => ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
The rules can be stated as followed:
Passes all testsMaximizes clarity
I have a simple Rails app that collects all the tweets I favorite on Twitter so I can sort and search through them at my leisure. Many of those favorites contain links I'd like to refer to, so I wrote a helper method that converts them to clickable anchor tags that looked like this:
# app/helpers/favorites_helper.rb
module FavoritesHelper
# snip
def text_to_true_link(tweet_text)
urls = tweet_text.scan(/https*:\/\/t.co\/\w+/)
Note: As of Ruby 3.0.0, Hash#except is now [part][1] of the language. However, Ruby does not implement Hash#except!.
Sometimes I want to remove a specific key-value pair from a Ruby hash and get the resulting hash back. If you're using Rails or ActiveSupport you can accomplish this using Hash#except:
hash = { a: 1, b: 2, c: 3 }
hash.except(:a) # => { b: 2, c: 3 }
# note, the original hash is not modified
hash # => { a: 1, b: 2, c: 3 }
| require 'matrix' | |
| # Input: an array of the n coefficients [a_n, a_n-1,..., a_1] of | |
| # a univariate polynomial p of degree n ([a_n]x^n + [a_n-1]x^n-1 + ... + a_1) | |
| # | |
| # Output: an array of all n roots of p | |
| # | |
| # Exploits the fact that the eigenvalues of the companion matrix of the | |
| # monic equivalent of p are the roots of p | |
| # |
| def get_character(hexnum) | |
| char = '' | |
| char << hexnum.to_i(16) | |
| end |
Straight from the [wiki]:
Fundamentally, objects (instances) reference one another and therefore form a graph in the mathematical sense (a network including loops and cycles). Relational schemas are, in contrast, tabular and based on the relational algebra, which defines linked heterogeneous tuples (groupings of data fields into a "row" with different types for each field).
Converting linked tabular rows to graph structures is hard, and even described as the [Vietnam of Computer Science][vietnam-of-cs].
Further reading:
| {:user {:dependencies [[org.clojure/clojure "1.8.0"] | |
| [org.clojure/tools.namespace "0.2.10"] | |
| [spyscope "0.1.5"] | |
| [criterium "0.4.3"]] | |
| :injections [(require '(clojure.tools.namespace repl find)) | |
| ; try/catch to workaround an issue where `lein repl` | |
| ; outside a project dir will not load reader literal | |
| ; definitions correctly: | |
| (try (require 'spyscope.core) | |
| (catch RuntimeException e))] |