AdventOfCode is coming midnight est tonight

Okay, here is the challenge for this week.

Tennis is a cool sport to watch. Especially, if either Serena or Venus or both are playing. :) However, the scoring is really odd, because it is based on the clock face. To make it even more fun, it did come from France, so instead of Zero we refer to l'œuf or "the egg". However, as we now pronounce it , it is "love". I am certain that there can be some interesting jokes in there, but I am not going for any of them. :)

Anyway, when you begin a game both players have scored zero times so their score is said to be "love - love" or "love all". When a player has scored 1 time, they are said to have "15" as advancing around the clock face 1/4 of the way. Their second score would be called "30" since that would be 1/2 way around. Obviously, their third score should be "40" because that forces you to win by 2 :) Not sure it makes sense, but that is how it works. So as an example a game might go like this:

love - love
15 - love
30 - love
40 - love
Game - player1

Not all games work out that one player gets to run the score, so it could also go like this:
love - love
15 - love
15 - 15
15 - 30
30 - 30
30 - 40
Game - player2

However, after the 3rd point is scored if both players have 40 the score is said as
"Deuce"
Because, France. :)

At any point when a player becomes 2 points ahead after 40 they win, and we say Game - <player name>
But after the score is tied at 40 or higher, the next point is called "advantage" so we no longer care about the underlying clock face scores, and merely go through "Deuce", "Advantage - player1" "Deuce" "Advantage - player2" "Game - player2". In theory, one could continually bounce from "Deuce" to advantage one player or the other until one of them players simply falls out or dies. Though I am not aware of that ever actually happening. There have been some pretty long games.

"Back in 1975 on May 26, at the Surrey Grass Court Championships at Surbiton, Anthony Fawcett and Keith Glass racked up a record 37 deuces in a single game for a grand total of 80 points."

But I digress. Here is your challenge if you choose to accept it.

Write a method/function that takes any legal tennis game score, such as (0, 0) or (5,3) and so on, and have it output the traditional tennis score as described above, "love - love" or "Game - player1" in my example of legal scores. Keep in mind, (12, 2) is not a legal score, as once the first player achieved 4 he would have already won. You don't need to test for this, but be aware it is not a scenario you should have to deal with. You can represent any tie up to 2 simply as 'love - love' or '15 - 15' or '30 - 30' but starting at 3 you would not say '40 - 40' but rather "Deuce" at that level and any higher. If you would like to do so, as a bonus you could represent the simple ties less than 3:3 (Deuce) with the 'all' so 'love all', '15 all', or '30 all' would be a bonus representation, but '40 all' would be incorrect, as it should merely be 'Deuce'.

Use whatever language or methods you like. I am using Java. I will also have unit tests. You are free not to use them, but I am not interested in testing anyone's code for accuracy, so if you don't provide them, the best you can hope for is "Nice job. Good effort. I guess." At least from me :)
Try to focus on good quality code. Also focus on reduction of complexity, DRY, and certainly use subroutines as necessary.

Good Luck!!

I will probably be checking mine in to my GitHub or GitLab repo at some point later in the week.

Here should be a simple one. It was fun to do in Java and with chained calls it turns out to be somewhat of a one-liner. This is not a code-golf thing, but feel free to try it that way if that is your interest.

"Square Odd"
Let's process an integer. The idea is that if the number contains odd digits they need to be converted to their squared value. Even digits are passed through unchanged.

For example, given the number 232, you would output 292. Or in the case of 99, you would output 8181. But if it were 22 then the output would be 22.

If this is too simple and you would like a bit more of a challenge see if you can try a couple bonus situations.

1*. determine if a number is already in this state. For example 232 wouldn't be because 3 is not squared. However, 212 could be, as could 2814 since that could have come from 294.

and
2*. given a number possibly in this state already, decode it back to the original number.

Since 1 squared is 1 and some squares have even digits like 81 such a number could have started out as '9' or actually '81'. So in 1 and 2 you may want to come up with multiple initial beginnings. So given such '81' the answer would be both of those '81' and '9'.

Things in my life have changed. I am now in a much larger focus on Java. I am still a huge fan of TDD and Test First, but I guess that is a religious thing so I will try to contain my zeal.

Initially the challenges were intended as small problems that should be in the 1-3 hour at most. As well, I focused towards Python and the problems I was using to learn the particular concepts I was working on at the time. Since my shift to Java I am less interested in some of the finer concepts and more interested in general issues. So even though I might find a solution that uses a whole pile of chained references interesting, its solution in some other language may not be nearly as interesting to you :)

I will try to be better about posting more often. Unless I find people aren't interested, in which case I won't waste the bandwidth :)

I just boosted the last that I had posted from over a year ago.

I still think this is an interesting problem to solve. I have yet to attack it myself, but am definitely considering it. I have recently been doing a bunch more smaller exercises, and perhaps can post a few of those. Though I haven't necessarily written them, I have found them fun to do.

I do have some ideas, but for now I am waiting to see if anyone is even still interested in the puzzles anyway.

Okay, here's one with a story :) Let's see if this is entertaining enough :D

Here is a problem that involves being jerk.

You receive a parking ticket and decide to pay in the least
convient way possible... change. This decision comes to mind
because the tickets are in strange amounts because they use
the cents portion for some kind of internal encoding.

You decide to pay all in pennies but when you start to collect
them someone informs you that although change will be accepted,
if the counts of coins exceed the quantities required for a wrapper
then you must roll them.

US Coinage count to a roll
0.01 = 50
0.05 = 40
0.10 = 50
0.25 = 40
0.50 = 20
$1.00 = 25 (small) or 20 (large) Question 1. How many rolls and free coins of each can you provide to pay your$100.37 ticket in order to use the highest count of unrolled coins?

Considering that a ticket can cost anywhere from $1.00 to$250.00.
You start telling everyone else about your plan and they decide to
play too, so you calculate how they should pay as well.

For example, 45 pennies 21 nickles for a $1.00 ticket might be pretty obnoxious :). Question 2. Which fine amount (in that range) would allow you to provide the highest number of unrolled coins? Question 3. The parking authority figures out what you are doing and decides to change things up by hiring you. Your job is to determine the best fine values to get paid in the least amount of unrolled coins. What are those amounts what are those amounts (still within that range of$1.00 to \$250.00)

@Lossberg by the way, I do a here, you can look at the origination of it all the way back the 'Ninety-Nine Bottles of Beer" challenge. qoto.org/@Absinthe/10280565958

Feel free to play at any of them that interest you. There is no timebox on these. Watch for the tag and include it on any answers you offer to any of them.

Okay folks, this should be simple, but maybe not.

The goal is to write a function that takes a positive integer and returns a list of its prime factors. So if you did 12 you should get the list [2, 2, 3]

As neither 1 nor zero are prime, as a result should return an empty list.

This is taken from a , so if you have not done this one I encourage you to do so. If you are not into then solve it however you like.

As long as I continue working on the I will not be posting a new

However, I encourage you all to give the a try. You don't have to do them all, though I would recommend doing them in order. You can even go back and do them from previous years.

Okay, this isn't me, but consider doing this this month:

It is the Advent of Code for 2019
Unfortunately the fediverse is not a supporter or OAth so you will have to use Twitter, Google, Github to login.

I shall be lazy and only do a freebie.

This problem was asked by Microsoft.

Given a 2D matrix of characters and a target word, write a function that returns whether the word can be found in the matrix by going left-to-right, or up-to-down.

For example, given the following matrix:

[['F', 'A', 'C', 'I'],
['O', 'B', 'Q', 'P'],
['A', 'N', 'O', 'B'],
['M', 'A', 'S', 'S']]
and the target word 'FOAM', you should return true, since it's the leftmost column. Similarly, given the target word 'MASS', you should return true, since it's the last row.

okay, here's a freebie!!

Given a multiset of integers, return whether it can be partitioned into two subsets whose sums are the same.

For example, given the multiset {15, 5, 20, 10, 35, 15, 10}, it would return true, since we can split it up into {15, 5, 10, 15, 10} and {20, 35}, which both add up to 55.

Given the multiset {15, 5, 20, 10, 35}, it would return false, since we can't split it up into two subsets that add up to the same sum.

Okay, here is a fun one. We've all seen Fibonacci sequences. But they are all played out. Let's look at a different sequence. They are called Hamming Numbers after Richard Hamming, who proposed the problem of finding computer algorithms for generating these numbers in ascending order.

For number H is equal to 2**i * 3**j * 2**k where i,k,k are all non negative.

For example
2**0 * 3**0 * 5**0 = 1
2**1 * 3**0 * 5**0 = 2
2**0 * 3**1 * 5**0 = 3
2**2 * 3**0 * 5**0 = 4
2**0 * 3**0 * 5**1 = 5
2**2 * 3**1 * 5**0 = 6
2**3 * 3**0 * 5**0 = 8

So hopefully that explains what the sequence looks like. Your challenge, if you choose to accept it is to generate the first 25 of them. An arbitrary nth one such as 1700th. And given a number X determine if it is or is not a valid hamming number.

Here is the wiki article on them:

en.wikipedia.org/wiki/Regular_

Okay, here is one before the weekend.

Conway's Game of Life. It is a simple concept. Set up some cool patterns and let it run on a good cycle. I just did it, using '*' and ' ' but feel free to do it graphically if you prefer. Here are the rules, and my code is in the same repo so let that be a spoiler warning:

git.qoto.org/Absinthe/life-con

I borrowed this one from codewars

Snail Sort
Given an n x n array, return the array elements arranged from outermost elements to the middle element, traveling clockwise.

array = [[1,2,3],
[4,5,6],
[7,8,9]]
snail(array) #=> [1,2,3,6,9,8,7,4,5]
For better understanding, please follow the numbers of the next array consecutively:

array = [[1,2,3],
[8,9,4],
[7,6,5]]
snail(array) #=> [1,2,3,4,5,6,7,8,9]
This image will illustrate things more clearly:

NOTE: The idea is not sort the elements from the lowest value to the highest; the idea is to traverse the 2-d array in a clockwise snailshell pattern.

Here's a freebie!

Given a list of integers S and a target number k, write a function that returns a subset of S that adds up to k. If such a subset cannot be made, then return null.

Integers can appear more than once in the list. You may assume all numbers in the list are positive.

For example, given S = [12, 1, 61, 5, 9, 2] and k = 24, return [12, 9, 2, 1] since it sums up to 24.

okay, this is not exactly a but I hope you hate this problem as much as I did...

The problem is not just getting the right solution, but getting it in under the running timeout of 12000 ms. Good luck.

codewars.com/kata/54d81488b981

Kind of feels like I am phoning this one in, but I really liked this puzzle and hadn't really seen it before. However, if you have already seen this (and it is likely that you have) feel free to just ignore it.

Given a short message containing no more than 10 unique letters
written in the form of a simple equasion. Show the numeric values
for the letters to make it true. No letter that starts a word can
have the value Zero.

For example:

I + LOVE + YOU == DORA
1 + 2784 + 975 == 3760

Here is an interesting that is true in both cases, and will have only one solution:

ONE + TWO + FIVE + NINE + ELEVEN + TWELVE + FIFTY = NINETY

Okay, here's one. I just finished helping someone worth through this. So it's pretty fun.

Write a program in Python, that can accept a paragraph string and and page
width and return an array of left AND right justified strings. NOTE: No words
should be broken, the beginning and end of the line should be characters).

You should provide instructions on how to execute your program and provide a
sample output.

Example:

Sample input:

Paragraph = "This is a sample text but a complicated problem to be solved, so
we are adding more text to see that it actually works."

Page Width = 20

Output should look like this:

Array [1] = "This is a sample"
Array [2] = "text but a"
Array [3] = "complicated problem"
Array [4] = "to be solved, so we"
Array [5] = "are adding more text"
Array [6] = "to see that it"
Array [7] = "actually works.”

Wow, lots of followers today!

If you are interested in any of my coding challenges they should all be tagged with :

If you put that in your search and scroll to to bottom you will see my original proposal. Here is a link with the explanation of where my head is at. The ones I post that I call freebies, are from a subscription to Job Interview problems, and they should be a little tricky, but are usually rated as easy, medium or hard.

qoto.org/@Absinthe/10280565958