Відео

Nim: import os,strutils echo if( let year = parseInt paramStr 1; year mod 400 == 0 or year mod 100 == 0 or year mod 4 == 0 ):true else:false

Why does the philosophy of this language seem to be that everyone has 3 hours to wade through cruft to learn how to just get some code running?

For the Python solution (@ 5:50 ) would it be quicker to convert the string/sentence to lowercase once before running the comparison? ( s = s.lower() ) and then run all(c in s for c in ascii_lowercase)

Great video, as always.

for Rust: pub fn reverse(input: &str) -> String { let mut reverse_str = String::new(); for c in input.chars().rev() { reverse_str.push(c); } reverse_str }

4:09 I'm always a bit envious of those that can read the instructions of an exercise that says "Solve without using X" and think to themselves: "Ok, but what's the next best way that I can cheat?" Why don't I think like that?

I did it in Elixir: No regex, but efficient tail call-recursion with multiple clauses and pattern matching, which declares the domain rules quite nicely IMO. Btw: The function `split_swappable/2` is a simple example, how one can implement a state machine (what every parser essentially is) with recursion in a functional language. ```elixir defmodule PigLatin do @vowels [?a, ?e, ?i, ?o, ?u] @consonants Enum.to_list(?a..?z) -- @vowels @spec translate(phrase :: String.t()) :: String.t() def translate(phrase), do: with( words <- String.split(phrase), do: Enum.map_join(words, " ", &to_pig_latin/1)) defp to_pig_latin(word), do: with( {swappable, rest} <- split_swappable(word), do: rest <> swappable <> "ay") # splits word into the swappable prefix and the rest by the following rules: defp split_swappable(word, swappable \\ <<>>) # word starts with x or y followed by consonant -> no swap at all defp split_swappable(word = <<?x, c, _ :: binary>>, <<>>) when c in @consonants, do: {<<>>, word} defp split_swappable(word = <<?y, c, _ :: binary>>, <<>>) when c in @consonants, do: {<<>>, word} # y or a vowel terminate the swappable part defp split_swappable(rest = <<?y, _::binary>>, swappable=<<_, _::binary>>), do: {swappable, rest} defp split_swappable(rest = <<v, _::binary>>, swappable) when v in @vowels, do: {swappable, rest} # a consonant grows the swappable part, # "qu" are treated as consonant, not as consonant/vowel pair defp split_swappable("qu" <> rest, swappable), do: split_swappable(rest, swappable <> "qu") defp split_swappable(<<c, rest::binary>>, swappable) when c in @consonants, do: split_swappable(rest, swappable <> <<c>>) end ```

starting here good luck to me, and thanks for your work

great video, thanks!

thank you pewdiepie

Regular expressions just keep coming up. Maybe it's finally time to finally sit down and learn them 😅 Also, loved the pigified source code in JS was so fun!

Thanks for another great video! Enjoyed and learned something new. Keep it up! 👊

39:35, Jeremy, sooo sorry for not inventing a new avajayiptscray language. I’ll get right on that. Easily do-able in Tcl though ...

Thanks Erik Sage of Programming ! ;)

So.... Did you solve the exercise or the just get the tests to pass? 😈

Honestly, this should have conveyed more real life benefits of FP, such as Data Modeling with ADTs - "WHY is this better than looping and creating OOP classes" - why folds perfectly abstract away the need to write explicit recursion every time - the elegance of function composition - Monadic laws that guarantee that data types are safe and sound (without mentioning Monads obv). Tutorials like this are why FP is seen as a niche when a JS, Python, C++, Go or whatever dev comes to see this. No one is going to see an adder function or a pattern match on a list of numbers and think: WOW, this is much better than my language of choice which... oh wait, is already on the way to adopting pattern matching (like most modern imperative languages already did or are doing). As much as I love to see people passionate about FP, such videos need to be more comprehensive and practical in demonstrating the real-world advantages of functional programming. They need to highlight how FP can simplify complex tasks, enhance code maintainability, and improve reliability through concepts that go beyond basic examples. EVEN FOR A BEGINNER, because we're assuming coders are dumb otherwise.

Another useless programming language.

Thank you for sharing this video! I love exercism! Have a nice week!

That is a great introduction to the language, thank you! :)

I was planning to solve this exercise before the video came up using Elm, which I started my journey on exercism this year primarily with it, (plus some Go & Python "haven't solved it in either of them yet") and I refrained from watching the video until I solve it. I found that when I try to solve an exercise, I over complicate the problem if there is no obvious guidelines to solve it. Should I go for the mines '*' or clear '.'? Should I find the number of mines and then turn it to character 'n' in place for each character at a time, or should I go and scan for mines and then start counting?! Can my solution be generalized?? And different languages has different "flavours" of programming. For example Elm and Go are both simple and minimalistic languages, but the way I would solve it in Go would be dramatically different from the way I solved it in Elm. (And I got 250-ish lines to solve it, while the rest of the community is under 150) and this makes me go backwards and look for ways to optimise my solution which is more intuitive for me. (I'm not an optimization-first guy) Watching these videos is quite helpful, because unlike scrolling through communities' solutions, each exercise is getting a deep explanation and understanding for its different ways of solving it and optimise it. For example, I would never tried any bitwise solutions from the first try. Great work have been put into these videos, website, exercises, and communities. Thanks a lot for your and everyone's efforts. Maybe at the end of this year's challenge you can make a bounce video about how to tackle a problem and different optimisation technics. And next year the challenge could be 3-level project for each month similar to last year's theme "appy, analytic, system, ..."

Kotlin has floorDiv too!

Thank you for the video, it was interesting, as always. Seeing it, I got some ideeas on how I could improve my solution also and hopefully I did :). I liked the way Erik explained the issue with the pseudo-random number ganarators during the C++ solution presentation. I also found the Kotlin and Python solutions very nice. They are readable and concise.

Hi, thanks for the video! But IMHO the Erlang solution is ridiculously repetitive and frankly bad and error-prone code. What if there were far more allergies? This is particularly sad here, since Erlang has fantastic bitstring pattern matching, which is highly optimized (stemming from its history in telecom signal processing). So you would probably never implement it like that in an Erlang production system. People get a totally wrong impression of a language, when such code is showcased in your videos. Here is a clause from iteration 2 of my Elixir solution to illustrate, how one would rather code that (as you might know Elixir is pretty close to Erlang with a more modern syntax). This tail-call-recursive function consumes all known allergies together with the bits of the flags, which are shifted to the right in each recursion. Here is the clause, that adds the allergy, if the current LSB is set (the 1::1 in the pattern is the bit in question). The advantage of this solution is, that it has no repetition and would work efficiently with thousands of allergies (by a simple change of one module attribute holding their symbols), since we are using bitstrings and not limited integers: ```elixir defp decode_allergies( [allergy_marked_by_lsb | allergies], <<flags::@trailing_bits_before_lsb, 1::1>>, decoded_allergies ), do: decode_allergies(allergies, <<flags::@significant_bits>>, [ allergy_marked_by_lsb | decoded_allergies ]) ``` But in Elixir, there is an even more elegant way to implement this efficiently and maintainably: With the fantastic meta-programming. Interested? Checkout my solution and the comments below it. exercism.org/tracks/elixir/exercises/allergies/solutions/Pul

@exercism_org I meant to link my Elixir solution (tracks/elixir/exercises/minesweeper/solutions/Pul) here, which has a quite unusual approach I explained in its comment section. But once again, my comment vanished twice without any transparency about the cause or reason (I did the link right this time). It's not fun contributing under these circumstances...

It's funny that I wanted to take a look at this for this week's 48in24 puzzle :). I stopped it, solved it, and now will continue. I saw some very nice comunity solution, including your's (Erik's), and one that is using reflection to initialize the fields of the object. Thank you, for the intro, and to all the contributors for the excelent content on the site.

I like these grid navigation style exercises and I love that Crystal implementation! But it does sound a bit weird when someone talks about a Crystal method... which I just checked is what they are referred to officially. Maybe they want to change that to function. I half expected a more pure OOP version with a Point class that has its own Neighbours array. I used a Span<char> in C# (which is sort of like a slice in Rust, I think) that I pre-allocate with the size of the first string and then, since there is an action on each character, you can keep using the same span in every row loop, and create a string in the result array based on the span at the end of the loop.

I learn so much from these conversations meets tech-talks. Also love the chemistry too, just two dudes hanging out and talking about something they care about, nothing beats that sincerity. I would love to see more developer talk plainly about how/why they do X or Y. Really glad y'all are doing what you do!

thank you!

Hi. I liked Jeremy's solution most, along with the next one - probably because I went for the same strategy. I also liked the Julia and F# solutions. I have tried to put a comment with a link to my solution, but I guess it is not allowed :), so I'll try something else: /tracks/cpp/exercises/minesweeper/solutions/ionutsimion. I had several iterations, but the algorithm is the same.

At 34:56 Erik's comment that "the author had to use mutable" in F# made me intrigued! So much so that I went to install dotnet and run the F# interactive shell. After reading the docs and a few attempts, @Exercism turns out there is a short and readable way to sum items in a 2D array: > let a = array2D [[' '; '*'; ' ']; [' '; ' '; '*']; ['*'; '*'; '*']];; val a: char[,] = [[' '; '*'; ' '] [' '; ' '; '*'] ['*'; '*'; '*']] > a.[0..2, 0..2] |> Seq.cast<char> |> Seq.map (fun x -> if x = '*' then 1 else 0) |> Seq.sum;; val it: int = 5 > a.[0..2, 0..2] |> Seq.cast<char> |> Seq.filter ((=) '*') |> Seq.length;;

This is what it looks like in Phix (no such track yet, but soon) global function annotate(sequence board) integer h = length(board) sequence res = repeat(0,h) if h then integer w = length(board[1]) for y,line in board do string outline = "" for x,ch in line do if ch!='*' then integer m = 0 for i=y-(y>1) to y+(y<h) do for j=x-(x>1) to x+(x<w) do m += board[i][j]=='*' end for end for if m then ch = '0'+m end if end if outline &= ch end for res[y] = outline end for end if return res end function

Great video, thank guys. "Minesweeper" should be re-classified to "medium". It's above the level of other "easy" exercises on exercism.

ua-cam.com/video/0IkSLj-oCZ8/v-deo.html my take on prolog and ai

Great stuff. I would have also liked to hear drawbacks of Lisp and its dialects. I mean, there must be reasons why the languages are not widely used in the enterprise world, for example.

I like your enthusiasm.

what app are you using to code in?

Can't read the terminal part, covered by UA-cam UI Overlay (Title + Tags)

Lovely walkthrough each step, thanks for your effort guys, I really appreciate it.

Nim could also write the same solution as julia using the <= operator on sets while still being as efficient as the bitset-based solutions as Nim's set type is actually a bitset for ordinals. proc isPangram*(s: string): bool = {'a'..'z'} <= s.toLower.toSet

Hi, can anyone let me know why 'score & 1 << allergen' gives the answer to ''is_allergic_to' function? I know how & and << operators work but how do you know that you should perform & ? What is reason / logic behind performing & here?

What a contrast between the vibe of Golang development and management vs Luis and Gleam. Great work, Jeremy.

This is very informative. Thank you for making this

Correction to the description: Lua starts at 10:36 at 11:07, Lua patterns use `%a` for "letters" (a for alphabetic, I assume), and `%l` is lowercase letters.

Awesome video, many thanks Erik!

Thanks for the video! I liked particularly the elegance of Julia and the bitmap idea (in Rust, which can also be done in FP with recursion as I show below in Elixir). I added the bitmap approach to my existing Elixir solutions and have now 4 iterations/versions: 1. Creating and counting a unique downcase set (must be size of alphabet) 2. Subtracting the downcase charlist from the alphabet (must be empty) 3. Recursion over the sentence filling a bitmap (just an integer) until all chars are set or no characters left 4. like 3 but with clauses generated with metaprogramming Iteration 3 is the fastest, if we have long strings, in which a complete pangram can early be detected, since it terminates early, while 1 and 2 always process the whole input. Iteration 2 has the best tradeoff between performance and readability. Checkit out here: exercism.org/tracks/elixir/exercises/pangram/solutions/Pul

Minor correction: there of course _is_ a character class for lowercase letters, namely [[:lower:]]

watching this I just realized how unoptimized my python code looks lol, nice video though 😃

Another great video! I really like what ya'll are doing. I really hope more folks (students and job-seekers especially) find Exercism. I think Exercism does a great service of being a learning tool first and foremost. Keep it up :-)

The best video on recursion 👏👏

About the ASCII code difference between lower case and upper case, it was actually very good design. There are exactly 2^5 characters between corresponding letters ('a' and 'A' etc.), which means that it's enough to use bitwise OR to transform from upper-case to lower-case: c | 0b100000 or c | 0x20. Also, it's not very difficult to transform for lower-case to upper-case.