Given a list of countries in alphabetical order, put them in the same order as they are given in the song "Yakko's World".
Specifically, you are given the following list of countries* exactly:
Abu Dhabi, Afghanistan, Albania, Algeria, Algiers, Angola, Argentina, Australia, Austria, Bahamas, Bahra...
Your goal is to print "Hello, World!" ... while only being able to use a letter only once.
The Rules
You must print "Hello, World!"
You can only use each letter once.
... that's it.
Note: This might be impossible in some languages, for obvious reasons.
For a given positive integer, try to find out the smallest possible rotation resulted by rotating it 0 or more bits.
For example, when the given number is 177, whose binary representation is \$10110001_{(2)}\$:
\$ 10110001_{(2)}=177 \$
\$ 01100011_{(2)}=99 \$
\$ 11000110_{(2)}=198 \$
\$ 1000110...
In this challenge you will be tasked with implementing a sequence of natural numbers such that:
Each number appears a natural number of times
No two numbers appear the same number of times
No two numbers appear in the sequence next to each other more than once.
For some examples, the sequence
1...
Idk, it makes sense when using operations for integers/natural numbers only. I don't see any disadvantage if you manage to make them compatible with each other.
@user In that case wouldn't it make more sense to make _ a tuple
(IMO all new languages going forward should treat f(x, y, z) as calling f with a single tuple argument to make the transition to the sensible function call syntax easier)
because you're unlikely to want to put your function's arguments into a struct (to make their meanings more explicit rather than relying on positions) if you have to declare a new struct FooArgs every time
Like if I had a function do_foo with a signature do_foo{ bar: string, baz: i64 } -> { qux: i64, quux: i64 }, I could make a variable with { bar: string, baz: i64 } as its type (so it can be passed to do_foo, or so that I can make a variable do_quuux that uses the same input type) by using do_foo::__input as the type
And if you wanted to use an existing struct you'd either do do_foo BarAndBaz -> {...} or do_foo(BarAndBaz) -> {...} when declaring the function (maybe those could even be equivalent?)
What about a nominal type system that allows you to do C-style (OtherType) xyz casting for things with the same structure?
Altho I guess that specific syntax would get confusing/ugly/ambiguous with tuple types
@pxeger although it's not really a dichotomy: as you suggest, you can add escape hatches to a nominal system, and also vice versa - you could introduce some kind of opaque type declaration that hides a type's underlying structure
@RydwolfPrograms But then you have to create a tuple object each time (unless the compiler only pretends it's a tuple but it actually compiles to a normal Lua function?)
@RydwolfPrograms I like able to give named arguments in Python whenever I feel like it, but enforcing it would be rather annoying for functions where it's obvious what the arguments are
I think it'll be pretty clear when the tuple syntax is actually warranted
I don't think this is ever really an issue in Rust, for example
You don't see fights over whether a tuple-struct is actually the right choice somewhere, it either just doesn't matter that much or a sensible decision gets made in the first place
If you're library's written by someone who thinks lib.openSocket{ nameOfTheSocketToInstantiate: "a" } is a good design choice that library's probably bad anyway
I think situations where: 1. You have to use a library 2. The library makes poor choices regarding which function call syntax to use 3. This actually wastes time/harms readability more than the tiniest amount will be fairly rare
Compare that to the advantages of having structs-for-function-calls and IMO they clearly outweigh the downsides
Your goal is to print "Hello, World!" ... while only being able to use a letter only once.
The Rules
You must print "Hello, World!"
You can only use each letter once.
... that's it.
Note: This might be impossible in some languages, for obvious reasons.
For a given positive integer, try to find out the smallest possible rotation resulted by rotating it 0 or more bits.
For example, when the given number is 177, whose binary representation is \$10110001_{(2)}\$:
\$ 10110001_{(2)}=177 \$
\$ 01100011_{(2)}=99 \$
\$ 11000110_{(2)}=198 \$
\$ 1000110...
In this challenge you will be tasked with implementing a sequence of natural numbers such that:
Each number appears a natural number of times
No two numbers appear the same number of times
No two numbers appear in the sequence next to each other more than once.
For some examples, the sequence
1...
