Originally published at Perl Weekly 694

Hi there,

It has been two weeks since the London Perl and Raku Workshop 2024, and we are still receiving attendee reports. Thank you to everyone who took the time to share their experiences. Last week, I came across two such reports by Lee Johnson and Olaf Alders. I'm still hoping to find a moment to reflect on my own workshop experience.

LPW holds a special place in my heart, as it was the first workshop where I gave my first talk ever. I was introduced to LPW by a colleague at work. Back then, there was always an O'Reilly stall outside the theater room, selling Perl books and surrounded by a large crowd. I remember the days when we had three strong tracks running simultaneously and, especially, the last LPW organized by Mark Keating and his team. The transition was seamless, and we continued the workshop smoothly until COVID-19 struck. For a brief period, I was part of the organizing team, but my contributions were limited to promoting the event and assisting attendees on the day.

Bringing the workshop back after COVID-19 was the brainchild of Lee Johnson and Julien Fiegenhenn. Their hard work truly paid off, as the event was well-attended and praised for its smooth execution. I would like to take this opportunity to thank the organizing team for providing a platform to reconnect with friends from around the world. The future of LPW looks bright as I’m hearing a lot of positive feedback about next year’s workshop, and I'm keeping my fingers crossed.

Enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

London Perl & Raku Workshop 2024: Recordings & Thoughts

For all who missed the LPW 2024, we now have the recordings of the event. Audio quality may not be great, I must inform you upfront.

Articles

This week in PSC (167) | 2024-11-07

It seems very busy week, lots of topics discussed amd agreed upon. Happy to see things moving really fast. Thank you Perl Steering Council.

Multiple Inheritance vs Role

A simplified comparison between Multiple Inheritance and Roles.

Further on Perl Camel

The good old discussion of Perl Camel is back ...

Discussion

I wish Mojo::UserAgent could be made to not visit private IPs

An interesting discussion started around the use of Mojo::UserAgent. What is your view on this?

Grants

Dancer2 Documentation Grant Report

Great to see the improvement work being carried out in my favourite web framework, Dancer2.

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 295

Welcome to a new week with a couple of fun tasks "Word Break" and "Jump Game". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 294

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Consecutive Sequence" and "Next Permutation" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

TWC294

Rare pairing of 'unless' inside 'foreach' and we have a compact solution, very impressive. Please keep sharing knowledge with us.

Next Consecutive

The verbosity of solutions is the main attraction for me, not just this week but every week. It gives away lots of inner details. Great work, keep it up.

Perl Weekly Challenge: Week 294

Making good use of Raku built-in functions and getting job done in no time. Smart move, well done.

Consecutive Permutations

A very interesting discussion about the use of data structure to get around O(n) time. It's worth checking out, thanks for sharing.

Perl Weekly Challenge 294

Compact one-liner in Perl for all with enough discussion to get to the core. Well done and keep it up.

Consecutive Sequences of Permutations, Anyone?

The detailed analysis to sort out the O(n) time is very impressive. There is always something new to learn from your contributions.

No music, only numbers

Anyone looking for Raku magic then this is the best place where Raku implementation is discussed in details. Having said, I missed the musical aspect.

Sequential permutations

A detailed proof of O(n) time is worth checking. Kudos for the effort, thanks for sharing knowledge with us.

The Weekly Challenge #294

Thanks for sharing the research of finding the lexicographically next permutation. Plenty to learn from this week work.

Permutationally Consecutive

Another dose of Raku gems discussed and it is not to be missed. Highly recommended.

Rakudo

2024.43 One Of 21

Weekly collections

NICEPERL's lists

Great CPAN modules released last week;
MetaCPAN weekly report.

Event reports

Smashed TVs, Broken Windows, and Cracked Plates

Hear from the organiser of LPW what it takes to origanise an event. Kudos for all thier efforts.

How I Spent My First London Perl Workshop

A very colorful presentation, I must admit. Glad that you had great time in London.

Events

Boston.pm monthly meeting

November 12, 2024, Virtual event

Purdue Perl Mongers

November 13, 2024, Virtual event

Toronto Perl Mongers monthly meeting

November 28, 2024, Virtual event

Purdue Perl Mongers

December 11, 2024, Virtual event

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Challenge 294 solutions in Perl by Matthias Muth

These are my Challenge 294 Task 1 and 2 solutions in Perl
for The Weekly Challenge - Perl and Raku.

Summary

Task 1: Consecutive Sequences
$O(n)$ solution using a small data structure and a lookup hash to keep track of 'streaks' (consecutive sequences) and to merge them with new numbers as they are processed.

Task 2: Next Permutation
Working 'locally' to flip numbers to get the next permutation, without the need to create all permutations first.

Code:
Find the complete source code for both tasks, including more tests, on Github.

Task 1: Consecutive Sequence

You are given an unsorted array of integers, @ints.
Write a script to return the length of the longest consecutive elements sequence. Return -1 if none found. The algorithm must runs in O(n) time.

Example 1
Input: @ints = (10, 4, 20, 1, 3, 2)
Output: 4
The longest consecutive sequence (1, 2, 3, 4).
The length of the sequence is 4.

Example 2
Input: @ints = (0, 6, 1, 8, 5, 2, 4, 3, 0, 7)
Output: 9

Example 3
Input: @ints = (10, 30, 20)
Output: -1

Oh. Big Oh. $O(n)$ !

This restriction means that the simplest solution, sorting the array and then walking through the ordered numbers, is not allowed. That's because sort has an $O(n\log n)$ time complexity.

So what we are allowed to do for $O(n)$ is to walk through the array. As long as we don't use another loop within a loop, we can even walk through the array several times. This only means that the runtime spent for each number is slightly higher, but this still scales linearly with rising $n$ . Actually $O(2n)$ is the same as $O(n)$ .

In fact I do walk through the data twice! I use uniq on the input data, as a first pass (Example 2 contains a 0 twice!). I do this to make sure that double entries do not disturb the detection of sequences.

Let's call a 'consecutive sequence' a 'streak' for short.
We need to build up the 'streaks' as we encounter the numbers, one by one.
The data structure I use for representing a streak is a simple hash:

    $streak = { FROM => $a, TO => $b };

When a new number is encountered, I try to merge that number with any streak that already exists at the number's immediate left or immediate right.

For knowing whether those neighboring streaks already exists , I keep a lookup hash, %streaks. For every streak I create, I put a reference to the streak's data structure into that lookup hash, one with its starting number as the key, and one with its ending number. Thus, to access the left and right neighboring streaks for any new number $n, I only need to check $streaks{ $n - 1 } and $streaks{ $n + 1 }.. And once I have those, I know their 'other ends': the left streak's starting number, and the right streak's ending number. I then can create a new streak that covers them all, the left streak, the new number, and the right streak (if they exist, that is).

What is left to do then is to update the lookup table. I delete any references to the left and right streaks that will not be needed anymore, and I store references to the merged streak in the lookup hash at its starting and ending numbers.

For returning the length of the longest streak in the end, I check whether the new one is longer than what we already have, and update accordingly.

I have left the comments inside the code to make it easier to follow:

use v5.36;
use List::Util qw( uniq );

sub consecutive_sequence_using_hash( @ints ) {
    my $max_streak_length = -1;
    my %streaks;
    for my $n ( uniq @ints ) {
        # Create a new streak from this number,
        # possibly merged with any existing adjacent streaks
        # to the left or to the right.
        my ( $left, $right ) =
            ( $streaks{ $n - 1 }, $streaks{ $n + 1 } );
        my ( $from, $to ) = (
            $left ? $left->{FROM} : $n,
            $right ? $right->{TO} : $n,
        );
        my $streak = { FROM => $from, TO => $to };

        # Update the lookup entries:
        # Remove any entries that are *inside* the merged streak,
        # and add or update entries at the streak borders.
        delete $streaks{ $left->{TO} }
            if $left;
        delete $streaks{ $right->{FROM} }
            if $right;
        $streaks{$from} = $streaks{$to} = $streak;

        # Update the maximum length if this is a streak
        # (not just a single number) and it's longer than what we have.
        $max_streak_length = $to - $from + 1
            if $to > $from && $to - $from + 1 > $max_streak_length;
    }
    return $max_streak_length;
}

No loops inside!
I think this is proper $O(n)$ solution.

Task 2: Next Permutation

You are given an array of integers, @ints.
Write a script to find out the next permutation of the given array.
The next permutation of an array of integers is the next lexicographically greater permutation of its integer.

Example 1
Input: @ints = (1, 2, 3)
Output: (1, 3, 2)
Permutations of (1, 2, 3) arranged lexicographically:
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

Example 2
Input: @ints = (2, 1, 3)
Output: (2, 3, 1)

Example 3
Input: @ints = (3, 1, 2)
Output: (3, 2, 1)

A simple, but compute-intensive solution would be to create all permutations of the numbers involved, then sort them ('lexicographically'), then find the entry that corresponds to the permutation that is given, and then return the next one.
Actually I don't like this approach too much, because in my experience, anything that has to do with permutations or combinations has a tendency to use a lot of time , or a lot of memory, or both, very fast.

Let's find a solution that works 'locally'!

In order to modify an existing permutation to the next higher one, we need to find the number with the lowest significance that can be increased.
That means that we start at the right end (least significant), and find the first number that is lower than its right neighbor. All numbers at the right of that are ordered, highest first, so they can't be 'incremented'.

What if we didn't find any number that is lower than its right neighbor?
In that case, all numbers are ordered, highest first. This must be the last permutation possible. Which means that the next permutation will restart from the beginning of the cycle of all permutations.
In the first permutation, the numbers are ordered lowest first. To get there, we can just reverse that highest permutation sequence of numbers, and we can return that as the result.

If that's not the case, and we do have found a number that can be 'incremented', we need to find the next higher number to replace this number with.
We only look in the right part of the permutation, because using any number from further left would change the order more than we want.
We are looking for the lowest possible number that still is higher than our number.

Once we have found that replacement number, we exchange the two numbers.
We then have 'increased' our number by the next possible higher value of all permutations of the right part. At the same time, we have decreased the replacement number to the next possible lower number. So the ordering of the right part thus still is 'highest to lowest'. As we need the 'first' permutation of the right part, we can just reverse this.

That's it! We have found the lowest possible increment.

Again, I have left the comments in the code for easier following.

use v5.36;

sub next_permutation( @ints ) {
    return @ints
        if @ints <= 1;

    # Starting from the end, find the first number
    # that is lower than the one following it.
    my $index = $#ints;
    while( $index > 0 && $ints[ --$index ] gt $ints[ $index + 1 ] ) {
        # Everything is in the loop condition.
    }

    # No lower number found?
    # Then we are at the end of the permutations.
    return reverse @ints
        if $index == 0;

    my $value = $ints[$index];

    # Find the next highest value within the right part,
    # for using it to replace the current value.
    # (Remember that maybe not all values in the right part are higher!)
    # It has to be higher than the one to substitute, but the
    # lowest possible one.
    my ( $index_2, $replacement ) = ( $index + 1, $ints[ $index + 1 ] );
    for ( $index_2 + 1 .. $#ints ) {
        ( $index_2, $replacement ) = ( $_, $ints[$_] )
            if $value lt $ints[$_] lt $replacement;
    }

    # Swap the two numbers.
    @ints[ $index, $index_2 ] = @ints[ $index_2, $index ];

    # We know that the right side is sorted, highest first.
    # to have it sorted lowest first, we just need to reverse it.
    @ints[ $index + 1 .. $#ints ] =
        reverse @ints[ $index + 1 .. $#ints ];

    return @ints;
}

If we run this several times in a row, we will get a 'consecutive sequence of permutations'.
How nice for the title of this blog, combining the two tasks!

Thank you for the challenge!

Find the complete source code for both tasks, including tests, on Github.

Get enough of Perl logo discussion?

You would well take a little bit more! 😉

(Picture from Askar Abayev)

I know some people think it's not worth the pain discussing again, but I suppose it's because they don't have the same needs than me and some others 😀

What if you want to use a logo to illustrate a Perl blog? What if you want to use an icon to illustrate Perl sources files (Ubuntu)? What if...?
You either have to use a random camel or ignore the law...

And it's in Perl roots and inside us to be good at free software.

If you don't know well the context, please go read my post The complex topic of Perl logos

Later, I posted my Open Letter To Tim O'Reilly To Free The Perl Camel on Hacker News and people mentioned about the fact that Perl Camel was a "trademark" of O'Reilly, not a copyright (license).

It is true and it's a fundamental thing to understand.

What's the difference between trademark and copyright

Trademark vs Patent vs Copyright

How is trademarked Perl Camel?

First, just having used the Perl Camel on a book provided to O'Reilly Media a "public statement", then quickly after (in 1998) they secured the trademark via registering trademarks against organisms like United States Patent and Trademark Office (USPTO).

Public statement?

Once a business begins to use a logo to advertise and sell goods or services, they automatically attain common law ownership and the limited protections associated with it—but only if the business can prove it was the first businesses to use the mark. Common law legal protection for a trademark only applies to the geographic area where the business operates. If nationwide protection is needed, then registering a logo with the USPTO is a wise step.

USPTO / WIPO

United States Patent and Trademark Office (USPTO) and World Intellectual Property Organization (WIPO) are organisms where one can register a trademark.

Trademarks are not "global", they apply only in jurisdictions (countries) who recognize it.

We can find USPTO registrations for Perl Camel, I was not able to find one in WIPO (is there any?).

The actual trademark and service mark

"The bottom line is that a trademark represents a product produced by a business (in this case: The Programming Perl book) while a service mark represents a service offered by the business (in this case: O'Reilly selling books). A single business can register both trademarks and service marks to brand themselves."

Trademark

Serial: 75414570
Reg number: 2262465
2nd renewal: 20190828

Camels, both bactrian and dromedary, including heads and other parts uniquely identifiable with camels, and also including stylized, costumed, and those with human attributes

Service Mark

Serial number: 75414568
Reg number: 2209120
2nd renewal: 20181012

You can search and verify by yourself at USPTO Trademark Search System

Trade dress

More in general, covers of animals (camels but also others) on O'Reilly books seem protected under a Trade dress:

"Trade dress is the characteristics of the visual appearance of a product or its packaging (or even the design of a building) that signify the source of the product to consumers. Trade dress is an aspect of trademark law, which is a form of intellectual property protection law.

In the United States, the Lanham Act protects trade dress if it serves the same source-identifying function as a trademark. It is possible to register trade dress as a trademark, but for practical reasons most trade dress and product configurations are protected without registration."

If copyrights have a duration, how long lasts a trademark?

10 years but you can renew (O'Reilly well renews them when needed).

What is the copyright (license) of O'Reilly Perl camel?

Actually, the design was free when O'Reilly decided to use it.

O'Reilly animal designs are copyright free (public domain). It implies it has no restriction and no license.

Edie Freedman and Hanna Dyers designed the Programming Perl cover based on Animals 1,419 Copyright Free Illustrations of Mammals, Birds, Fish, Insects, etc. by Jim Harter

So it's important to understand that Perl Camel is not protected because of any copyright/license or creator but because of its association with O'Reilly and books publishing.

Using Perl shadow camel?

Yes, what about this guy?

Being a derivative of the Perl Camel does not free us from the trademark. Like using Coca Cola logo just replacing with a "Koka Cola" or changing color from red to blue. No derivative can help, design should not recall in any way the initial trademark/picture and, moreover, the association.

Fair use

The concept of fair use refers to some usages of trademarked logo for some limited usage like representing the brand. For instance, using the Perl Camel to write a blog post about the Perl Camel Book or O'Reilly in general is OK.

Fair use is not well recognized everywhere though.

Blanket license

It exists some solutions to delegate permissions, in the sort of "automatic grant of permissions to use". Somewhat like a blanket license. What was done with The Perl Foundation looks like a bit to a blanket license, but with restrictions. The way it was done makes it still very far from making it "free to use".

Expanding blanket license (remove restrictions and do not attach to TPF) is difficult or impossible without an entity (Perl "community" is not what we can call "an entity").

Logo vs mascot

Using camels to represent Perl has become more like a mascot.

My hypothesis and conclusion

I'm not a lawyer 😉

When we talk about trademarks, we don't talk about something really rigorous. For instance it works on some countries, but not all.
When defending a trademark in court, it's not all black and white, it's more like you build a defense with a maximum of documents and history facts to prove your precedence and that you undoubtly own the trademark (and trade dress).

My hypothesis is that O'Reilly never trademarked other animals with books in his entirety but Perl Camel was the first one (to be trademarked, not the first published). Protecting books covers with animals seems to fall under a "Trade dress" protection, built on top of the Perl camel trademark registration (among maybe other registrations). It means Perl Camel trademark can now be used to protect all others. Sadly for us, it is probably then the cornerstone of the whole protection of "O'Reilly Trademark family" (or more appropriately: "menagerie").

It's why if we dream to have it free, we can't reasonably expect to see it happen. And even if O’Reilly would loose total interest in Perl, it would weaken too much their whole family of books.... And they still remain friends that we don't want to hurt too much.

Originally published at Perl Weekly 693

Hi there!

Throughout the years I had many brilliant ideas regarding Perl and the Perl community. I know they were brilliant because, as I found out later, they were already done by Dave Cross before me. This always gave me mixed feelings. On one hand it was always rather disappointing that my ideas weren't new or original. On the other hand it was of a great pride that my ideas aren't that dumb if Dave also had them.

Today I think I can celebrate. I think this is the first time where I had the idea (and the implementation) first.

In a recent article Dave writes about Advertising Perl. A very good idea to use the existing platforms to advertise Perl events. As I can see it is exactly 10 years after I announced shutting down the Perl Community Adserver. Wow, I am rather shocked that so many years have passed and unfortunately I can't find the posts in which I started to talk about it so I can't really verify the timeline.

In any case, I hope his attempt will be more successful than mine was.

Enjoy your week!

--
Your editor: Gabor Szabo.

Announcements

Perl and Raku Conference 2025 News

It will take place June 27-29, 2025 in Greenville, South Caroline

Articles

A Regexp::Debugger visualization for Abigail's prime number checker

Do you know how to generate prime numbers using a Regular Expression?

Advertising Perl

About the creation of the Perl Ad Server

London Perl & Raku Workshop 2024

LPW 2024

My London Perl And Raku Workshop 2024

London Perl & Raku Workshop 2024: Quick Afterwords

Perl

This week in PSC (166) | 2024-10-31

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 294

Welcome to a new week with a couple of fun tasks "Consecutive Sequence" and "Next Permutation". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 293

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Similar Dominos" and "Boomerang" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

TWC293

Yet another compact and elegant solutions in Perl. You must checkout if you are Perl fans.

Boomerang or Similar

Cool use of subset of Raku giving us the elegant solutions. Great work, keep it up.

Taking A New Angle

Here is another gem from CPAN, Math::Trig. The end result is worth checking out. Thanks for sharing.

Perl Weekly Challenge: Week 293

We all know the compact solution in Raku but replicating the same in Perl is awesome, very impressive. Keep sharing.

Perl Weekly Challenge 293: Similar Dominoes

Comparative approach to a task in Perl and Raku is never to be missed. It always special for me. Thanks for sharing knowledge.

Perl Weekly Challenge 293

Master of in-house Perl one-liners came up with yet another creative solution. Highly recommended.

Domino Frequencies and the Vectorized Boomerang

Any maths lover? I am one, so loved the pure mathematical approach and narrative. Cool work, keep it up.

Oh, oh, Domino!

Nice to see, how to deal edge cases. Very brave move and that too in multiple languages.

Matching and returning

Another mathematical angle to deal with Boomerang task. And on top, DIY tool is handy to play with.

The Weekly Challenge #293

Modularised approach makes the solution easy to read and follow. Short and concise narration comes handy. Great work.

Domino Boomerang

Python is my new love and it doesn't take any effort to decode it. Credit goes to the master, Roger.

Similar boomerang

Keep it sweet and simple, yet end up with classic end result. This is for both Perl and Python lovers.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Boston.pm monthly meeting

November 12, 2024, Virtual event

Purdue Perl Mongers

November 13, 2024, Virtual event

Toronto Perl Mongers monthly meeting

November 28, 2024, Virtual event

Purdue Perl Mongers

December 11, 2024, Virtual event

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Weekly Challenge 293

Each week Mohammad S. Anwar sends out The Weekly Challenge, a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Similar Dominos

Task

You are given a list of dominos, @dominos.

Write a script to return the number of dominoes that are similar to any other domino.

$dominos[i] = [a, b] and $dominos[j] = [c, d] are same if either (a = c and b = d) or (a = d and b = c).

My solution

I'm not sure if it's a British/US English thing or something else, but I'm using Dominoes as the plural of Domino. Dominos what what you get when you are hungry.

For this task, I take integers from the command line and convert them to a list of lists (arrays of arrays in Perl). If this was an actual real-world project, I'd probably use a Dataclass, and have an equality operator.

I have a double loop. The outer loop - called i - is from 0 to one less than the number of dominoes. The inner loop - called j - is also the same. I skip the case when i and j are the same. If the dominoes at position i and j are the same (either same number or opposite numbers), I add one to count and exit the inner loop.

def similar_dominoes(dominoes: list) -> int:
    count = 0

    for i in range(len(dominoes)):
        for j in range(len(dominoes)):
            if i == j:
                continue
            if (dominoes[i][0] == dominoes[j][0] and dominoes[i][1] == dominoes[j][1]) \
                    or (dominoes[i][0] == dominoes[j][1] and dominoes[i][1] == dominoes[j][0]):
                count += 1
                break

    return count

Examples

$ ./ch-1.py 1 3 3 1 2 4 6 8
2

$ ./ch-1.py 1 2 2 1 1 1 1 2 2 2
3

Task 2: Boomerang

Task

You are given an array of points, (x, y).

Write a script to find out if the given points are a boomerang.

A boomerang is a set of three points that are all distinct and not in a straight line.

My solution

Like with the last task, I take integers from the command line and convert them to a list of lists (arrays of arrays in Perl).

I remember enough from high school math to know we can get the slope (gradient) of two points with the formula (x2 - x1) ÷ (y2 - y1). However if y1 and y2 are the same, we get a division by zero error.

Therefore I use the following checks:

1. If all y values (second item in each list) are the same, return False as the points make a flat line.
2. If any y values are the same as the first y value, return True (as we know at least one y value is different).
3. Calculate the absolute slop between the first point and the other points using the above formula. Store this as a set. Sets don't store duplicate values.
4. If the set only has one value, it's a straight line and return False. If there is more than one value, then it's a boomerang. I'm not here to determine if it is a good boomerang :)

def is_boomerang(points: list) -> bool:
    if all(points[0][1] == points[i][1] for i in range(1, len(points))):
           return False

    if any(points[0][1] == points[i][1] for i in range(1, len(points))):
           return True

    degrees = set(abs((points[0][0] - points[i][0]) / (points[0][1] - points[i][1])) for i in range(1, len(points)))
    return False if len(degrees) == 1 else True

Examples

$ ./ch-2.py 1 1 2 3 3 2
true

$ ./ch-2.py 1 1 2 2 3 3
false

$ ./ch-2.py 1 1 1 2 2 3
true

$ ./ch-2.py 1 1 1 2 1 3
false

$ ./ch-2.py 1 1 2 1 3 1
false

$ ./ch-2.py 0 0 2 3 4 5
true