30
\$\begingroup\$

My dog ate my calendar, and now my days are all mixed up. I tried putting it back together, but I keep mixing up the days of the week! I need some help putting my calendar back together, with the days in the correct order.

And since I need my calendar put together as fast as possible, don't waste my time by sending me superfluous bytes. The fewer bytes I have to read, the better!

Input

The days of the week, in any order. Input can be taken as a list of strings, or a space separated string, or any reasonable way of representing 7 strings (one for each day of the week).

The strings themselves are all capitalized, as weekdays should be, so the exact strings are:

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Output

The days of the week, in sorted order (Monday - Sunday, because of course we adhere to ISO 8601). Output can be as a list of strings, or printed with some delimiter.

Disclaimer

Note that this is a challenge, with the added benefit of being able to use the input to shorten your code. You are not required to use the input if you don't want to. You are also free to use any approach, from a builtin datetime library to hard-coding the output.

Examples

To see example input and output, you can consult this python script.

\$\endgroup\$
  • 5
    \$\begingroup\$ I hope you've learnt your lesson from this: never leave dogs with calendars. \$\endgroup\$ – Lyxal Apr 28 at 6:50
  • \$\begingroup\$ any delimiter allowed? \$\endgroup\$ – Helena Apr 28 at 18:00
  • \$\begingroup\$ @Helena I'd say any delimiter within reason. I'd prefer space, comma, or newline, but if the language you're using has another default separator, or you'll be able to knock off a few bytes, go for it. Though I will specify that it has to be the same separator between all output words. \$\endgroup\$ – maxb Apr 29 at 6:08
  • 2
    \$\begingroup\$ I hope you have learnt your lesson from this: it is a dog-eat-calendar world. \$\endgroup\$ – Christian Gibbons Apr 29 at 20:16
  • \$\begingroup\$ in any order = in random order? because thats what many of the answers seem to be assuming \$\endgroup\$ – ASCII-only May 8 at 7:37

34 Answers 34

19
\$\begingroup\$

Pyth, 7 bytes

o%CN258

Try it online!

Convert each string to a number via treating its ASCII codes as a base 256 number, then take that mod 258, and sort. This gives the mapping

['Monday', 49]
['Tuesday', 75]
['Wednesday', 89]
['Thursday', 99]
['Friday', 103]
['Saturday', 125]
['Sunday', 211]

Same length but less fun is

.P1314S

The 1314th permutation of the sorted input in lexicographic order.

| improve this answer | |
\$\endgroup\$
  • 3
    \$\begingroup\$ How did you find that? \$\endgroup\$ – Adám Apr 28 at 7:16
  • 5
    \$\begingroup\$ @Adam I just searched the first 1000 moduluses and got very lucky. On average, it should take over 5040 (7!) moduluses to find one that gives a specific ordering, but this one appears quite early. \$\endgroup\$ – isaacg Apr 28 at 7:20
  • 4
    \$\begingroup\$ If you ask people "how did you find that", they probably just brute-forced. \$\endgroup\$ – Third-party 'Chef' Apr 28 at 7:23
  • \$\begingroup\$ I wanted to wait a bit before posting my own solution, but you had the exact same idea that I had (and you did it with 7 bytes instead of 8). Good solution! \$\endgroup\$ – maxb Apr 28 at 7:27
11
\$\begingroup\$

JavaScript (Node.js),  37 36  35 bytes

This should also work in Chrome and Edge (Chromium)

Returns a list of strings.

a=>a.sort().sort(_=>-(a=a*595|5)%7)

Try it online!

How?

We first sort the input array in lexicographical order. Whatever the input is, we get:

Friday, Monday, Saturday, Sunday, Thursday, Tuesday, Wednesday

We then invoke sort() a second time with a callback function that, while ignoring its input, generates a sequence of positive and negative values in such a way that the underlying sorting algorithm (insertion sort) is tricked into putting the array in the desired order.

Below is a summary of all steps. Note that because of the bitwise OR, the value stored in \$a\$ is always coerced to a signed 32-bit integer (and so are the 3rd and 4th columns in this table).

  A  |  B  | previous a  | -(a*595|5)  | mod 7 | new order
-----+-----+-------------+-------------+-------+-----------------------------------
 Fri | Mon |  NaN        | -5          |  -5   | Mon Fri Sat Sun Thu Tue Wed
 Mon | Sat |  5          | -2975       |   0   | unchanged
 Fri | Sat |  2975       | -1770125    |   0   | unchanged
 Fri | Sun |  1770125    | -1053224375 |   0   | unchanged
 Sat | Sun |  1053224375 |  396722091  |   3   | unchanged
 Sat | Thu | -396722091  | -173557135  |  -3   | Mon Fri Thu Sat Sun Tue Wed
 Fri | Thu |  173557135  | -187280221  |  -2   | Mon Thu Fri Sat Sun Tue Wed
 Mon | Thu |  187280221  |  237418201  |   6   | unchanged
 Fri | Tue | -237418201  | -470091173  |  -6   | Mon Thu Tue Fri Sat Sun Wed
 Thu | Tue |  470091173  | -531373695  |  -6   | Mon Tue Thu Fri Sat Sun Wed
 Mon | Tue |  531373695  |  1660231379 |   2   | unchanged
 Fri | Wed | -1660231379 | -4807575    |  -3   | Mon Tue Thu Wed Fri Sat Sun
 Tue | Wed |  4807575    |  1434460171 |   4   | unchanged
 Thu | Wed | -1434460171 | -1194690159 |  -5   | Mon Tue Wed Thu Fri Sat Sun
| improve this answer | |
\$\endgroup\$
  • 2
    \$\begingroup\$ This relies on Node's specific sorting algorithm, so it's not generic ES6. \$\endgroup\$ – Neil Apr 28 at 7:46
  • 1
    \$\begingroup\$ Wait, you're not using either argument. So whacky. \$\endgroup\$ – Steve Bennett Apr 28 at 8:20
  • 1
    \$\begingroup\$ @SteveBennett Ah, you're right. I've added a note to clarify. \$\endgroup\$ – Arnauld Apr 28 at 8:45
  • 1
    \$\begingroup\$ @Arnauld Not sure what you mean by all major JS engines, as I get Wednesday, Monday, Thursday, Tuesday, Friday, Saturday, Sunday in Safari. \$\endgroup\$ – Neil Apr 28 at 9:35
  • 1
    \$\begingroup\$ Yeah, that's much better, thanks. \$\endgroup\$ – Neil Apr 28 at 9:52
8
\$\begingroup\$

Pyke, 2 bytes

Pyke has some weird constant built-ins (a link to the Stack Exchange API, the lengths of months as numbers, the names of the days of the week and so on).

~C

Doesn't take input. Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I don't think anyone is going to beat this \$\endgroup\$ – maxb Apr 28 at 8:24
  • \$\begingroup\$ I won't be surprised if there is some language I forgot about with a 1-byter for this. \$\endgroup\$ – my pronoun is monicareinstate Apr 28 at 8:25
7
\$\begingroup\$

APL (Dyalog Unicode) 18.0 beta, 19 bytes

Full program, taking no input.

'Dddd'(1200⌶)⍳7

Returns a list of strings:

┌──────┬───────┬─────────┬────────┬──────┬────────┬──────┐
│Monday│Tuesday│Wednesday│Thursday│Friday│Saturday│Sunday│
└──────┴───────┴─────────┴────────┴──────┴────────┴──────┘

⍳7 Integers 1…7, representing the dates Jan 1–7, 1900

(1200⌶)Format Date-time ("12:00") as follows:

'Dddd' long Day name

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ I get a domain error when trying the code online: line(1,0) : error AC0008: error (DOMAIN ERROR) executing line "'Dddd'(1200⌶)⍳7" \$\endgroup\$ – maxb Apr 28 at 6:39
  • \$\begingroup\$ @maxb I forgot to remove the TIO link as TIO is on 17.1. Works locally by me. I'll add a link to the docs instead. \$\endgroup\$ – Adám Apr 28 at 6:45
  • 3
    \$\begingroup\$ "The Nineteenth Byte" \$\endgroup\$ – Third-party 'Chef' Apr 28 at 7:10
7
\$\begingroup\$

Python 3, 40 38 bytes

-2 bytes thanks to xnor

from calendar import*;print(*day_name)

Try it online!


Python 2, 44 43 bytes

lambda d:sorted(d,key=lambda x:~hash(x)%72)

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ The perfect built-in! I think from calendar import*;print(*day_name) would be allowed. \$\endgroup\$ – xnor Apr 28 at 7:38
  • \$\begingroup\$ By the way, I've been looking for a solution similar to your sorting one, but with an object method for the key so as to avoid writing a lambda. I had hopes for "...".strip or "...".translate, but it seems none of those can work. Perhaps you have a better idea with this. \$\endgroup\$ – xnor Apr 28 at 7:43
  • \$\begingroup\$ Thanks for the improvement, I clearly missed that! As for my 2nd answer, I will definitely try to shave off bytes if I can. As you said, the lambda takes up quite a few bytes. \$\endgroup\$ – dingledooper Apr 28 at 7:48
7
\$\begingroup\$

JavaScript, 37 characters

e=>[...'1564023'].map(a=>e.sort()[a])

JavaScript, 38 characters

e=>[1,5,6,4,0,2,3].map(a=>e.sort()[a])

Javascript, 39 characters

e=>e.map((a,i)=>e.sort()['1564023'[i]])

Javascript, 45 characters

e=>e.map((a,i)=>e.sort()[[1,5,6,4,0,2,3][i]])

Javascript, 51 characters

e=>(v=e.sort(),v.map((a,i)=>v[[1,5,6,4,0,2,3][i]]))

Javascript, 52 characters

e=>(v=e.sort(),[v[1],v[5],v[6],v[4],v[0],v[2],v[3]])

Javascript, 61 characters

I tried a couple of things, but they were fractionally longer than:

z=>'Monday Tuesday Wednesday Thursday Friday Saturday Sunday'
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The 54 is 52 because the z= shouldn't have been included in the count. \$\endgroup\$ – Neil Apr 28 at 10:00
  • \$\begingroup\$ Ah yes, thanks. \$\endgroup\$ – Steve Bennett Apr 28 at 10:01
  • \$\begingroup\$ I wonder if it would be possible to do e=>e.map((_,n)=>e.sort()[some_magic_with(n)]) instead, but that seems unlikely. ¯\_(ツ)_/¯ \$\endgroup\$ – Arnauld Apr 28 at 10:37
  • \$\begingroup\$ Yeah, I pondered something along those lines. There's about 8 characters to play with (assuming the magic is going to contain n and we want 36 characters or fewer total). \$\endgroup\$ – Steve Bennett Apr 28 at 11:03
6
\$\begingroup\$

APL (Dyalog Unicode), 21 bytes

Anonymous prefix lambda. Port of isaacg's Pyth solution — go upvote that!

{⍵[⍋258|256⊥¨⎕UCS¨⍵]}

Try it online!

{} "dfn"; argument is :

⍵[] reorder the argument into the following order:

  ⎕UCS¨⍵ Universal Character Set code points of each string

  256⊥¨ evaluate each in base-256

  258| the division remainder when divided by 258

   grade (permutation that would sort it)

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ You posted 3 different answers for APL... \$\endgroup\$ – Third-party 'Chef' Apr 28 at 7:24
  • 3
    \$\begingroup\$ @petStorm Sure, why not? The are completely different in their approaches. \$\endgroup\$ – Adám Apr 28 at 7:24
5
\$\begingroup\$

APL (Dyalog Unicode), 35 bytes

Anonymous prefix lambda. This one actually sorts its argument and doesn't use any "cheating" built-ins.

{⍵[⍋((∊∘⎕A⊂⊢)'MoTuWeThFrSa')⍳2↑¨⍵]}

Try it online!

{} "dfn"; argument is :

⍵[] reorder the argument into the following order:

  2↑¨ take the first two letters from each input day name

  ()⍳ find the index in the following list (missing items become 1 beyond last index)

   ()'MoTuWeThFrSa' apply the following tacit function to this string:

     the argument

     split on

    ∊∘⎕A membership of the uppercase Alphabet

   grade (permutation that would sort it)

| improve this answer | |
\$\endgroup\$
5
\$\begingroup\$

05AB1E, 6 bytes

Port of isaacg's base conversion answer.

Σ₁ö29%

Try it online!

Explanation

Σ      Filter the input by this function:
 ₁ö    Base-convert it from 256
   ₁   Constant 256
    Ì  Add 2 (= 258)
     % Modulo by this number

05AB1E, 6 bytes

-1 byte thanks to Expired Data

{œŽ5dè

Try it online!

05AB1E, 21 bytes

Σ"TuWeThFrSaSu"2ôåāsÏ

Try it online!

Explanation

Σ                     Sort by the output of this function.
 "TuWeThFrSaSu"2ô     Split every item of that by length of 2.
                 å    Contains?
                  āsÏ Find all truthy indices of that.
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ You can get 6 with the other approach too \$\endgroup\$ – Expired Data Apr 28 at 9:24
  • \$\begingroup\$ {œŽ5dè was exactly the same solution I've found o-o \$\endgroup\$ – Command Master Apr 28 at 9:31
  • 1
    \$\begingroup\$ Using ö instead of β also gives 6 bytes, and doesn't require a footer to pretty-print. \$\endgroup\$ – Grimmy Apr 28 at 10:15
  • 1
    \$\begingroup\$ You can remove the footer in that second approach of @ExpiredData by replacing the ' in the input-list with ": try it online. Also, there is an \$n^{th}\$ permutations builtin .I, which is faster than generating all permutations first before indexing: {Ž5d.I (although it's irrelevant for the byte-count). \$\endgroup\$ – Kevin Cruijssen Apr 28 at 13:43
5
\$\begingroup\$

C (gcc) -m32, 50 bytes

main(i){for(;puts(nl_langinfo(131079+i%7))-i++;);}

Try it online!

Explanation

Simply put, nl_langinfo() is a useful function which returns a particular string given an argument. It just turns out that the argument to pass for obtaining weekday names is 131079 ... 131086. One other thing is that we must add the flag -m32, which is explained nicely in this answer.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I was really confused by the -i++ part, does it work because Sunday happens to be 6 letters (and the 7th day of the week)? EDIT: In nl'_langinfo Sunday is the first day of the week, but your i%7 seems to handle that. \$\endgroup\$ – maxb Apr 29 at 9:06
  • 1
    \$\begingroup\$ The i variable starts to 1, and is incremented after every iteration. That means we actually start at 131080 instead of 131079. This is on purpose, since as you said, Sunday is the first day of the week when using nl_langinfo. On the last iteration, when i equals 7, the number becomes 131079 because of the modulo, printing Sunday. The reason it terminates after outputting Sunday is because puts returns the length of the string (including newline), so Sunday returns 7. It also happens that i equals 7, so subtracting them exits the loop. \$\endgroup\$ – dingledooper Apr 29 at 15:47
4
\$\begingroup\$

Wolfram Language (Mathematica), 27 bytes

DayName@{#}&/@198~Range~204

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I'm confused. Care to explain? \$\endgroup\$ – Adám Apr 28 at 6:54
  • \$\begingroup\$ @Adám DayName works like this: DayName[date] . So I found another way by using integers. Unfortunately the order didn't work for Friday.... \$\endgroup\$ – J42161217 Apr 28 at 6:58
  • \$\begingroup\$ How comes the integers are not representing dates in order? \$\endgroup\$ – Adám Apr 28 at 6:58
  • \$\begingroup\$ I really don't know... range[7] returns {Monday, Tuesday, Wednesday, Thursday, Saturday, Sunday, Monday}. This is not supposed to work with integers. It's an abuse \$\endgroup\$ – J42161217 Apr 28 at 7:01
  • \$\begingroup\$ Not really an abuse. The date format that DayName takes can be {year,month,day} (or even have hours/minutes/seconds); or it can be {year,month} in which case the day is assumed to be 1 if needed; or it can even be {year} in which case the month and day are assumed to be 1 if needed. So this code is calculating the day of the week for 1 January 198, 1 January 199, ... through 1 January 204. I believe it's doing so assuming (wrongly) that our current Gregorian calendar extends back indefinitely. ... \$\endgroup\$ – Greg Martin Apr 28 at 16:44
4
\$\begingroup\$

Python 2, 45 43 bytes

-2 bytes thanks to @xnor!

lambda l:map(sorted(l).pop,[1,4,4,3,0,0,0])

Try it online!

Sort by normal string comparison first, then look up the correct permutation.


Python 3, 58 bytes

lambda l:sorted(l,key=lambda s:"TuWeThFrSaSu".find(s[:2]))

Try it online!

Use the first 2 letters of each day to look up the order.

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Nice that you skip Mo, which results in -1 for Monday. \$\endgroup\$ – maxb Apr 28 at 7:05
  • 1
    \$\begingroup\$ Nice idea with the sorting! Here's a small byte save, though it needs Python 2 since Python 3 produces a map object unless you unpack. \$\endgroup\$ – xnor Apr 28 at 7:29
  • \$\begingroup\$ @xnor Thank you! I was looking at __getitem__, but totally forgot about pop. \$\endgroup\$ – Surculose Sputum Apr 28 at 7:33
4
\$\begingroup\$

Factor, 20 bytes

day-names 1 rotate .

Try it online!

Factor has a built-in sequence for the days of the week, but is starts with Sunday - that's why I need to rotate the items to the right.

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

T-SQL, 49 bytes

SELECT DATENAME(w,RANK()OVER(ORDER BY d)-1)FROM t

Input is taken as a pre-existing table t with varchar column d, per our IO standards.

My code doesn't actually use the values in the input table in any way, so the input order doesn't matter (nor do the actual strings, they just have to be distinct). Instead, it uses the fact that it has 7 rows, along with the RANK() function, to generate the numbers 1 through 7.

After subtracting 1, these numbers are implicitly cast as dates (0=Mon Jan 1, 0001, 6=Sun Jan 7, 0001), and the DATENAME function returns the corresponding day of the week.

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

Java (JDK), 27 bytes

java.time.DayOfWeek::values

Try it online!

Doing this because the challenge input is very structured, but the output is not structured at all.

No built-ins, 49 bytes

l->l.sort((a,b)->~a[0]*a[4]%-473-~b[0]*b[4]%-473)

Try it online!

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

R, 30 bytes

Assuming an English locale

weekdays(as.Date("1/1/1")+0:6)

Try it online!

January 1st of the year 1 is a Monday (according to R).

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Technically, this only works if your computer is set to a locale such as en_GB where the day names are the same as the question's. I think you are allowed to assume any reasonable locale you like for these sorts of challenges so it's not an invalid answer, but you should perhaps say at the top that you are assuming an English locale. \$\endgroup\$ – JDL Apr 29 at 9:41
  • \$\begingroup\$ @JDL Thanks, never thought about that \$\endgroup\$ – Bart-Jan van Rossum Apr 29 at 12:35
3
\$\begingroup\$

MathGolf, 8 bytes

á{$ûÞ♠$%

Try it online!

Explanation

á{         sort by the output given from a code block
  $        convert to ordinal (base 256)
   ûÞ♠     push "Þ♠"
      $    convert to ordinal (gives 1791)
       %   modulo

I had the exact same idea as isaacg's Pyth answer, but in MathGolf I had to use another modulo. I tried every number up to 1000000, and noticed that the ordinal strings for each weekday ended up in the correct order for sorting when taking them modulo 1791.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Tried to find a shorter way to generate 1791, but can't find one unfortunately. I did found an equal-bytes alternative, though: ○♠~+ (2048+~256). \$\endgroup\$ – Kevin Cruijssen Apr 28 at 13:56
  • \$\begingroup\$ @KevinCruijssen I thought about modifying the input string (e.g. "Monday") or its ordinal, in order to change the 1791 into another nicer number (hopefully a 1-byte builtin), but I didn't investigate further there. Best case scenario is that it saves 2 bytes, which would be tied with 05AB1E. \$\endgroup\$ – maxb Apr 28 at 14:16
  • \$\begingroup\$ You mean like removing the first character of the string before the $ or something along those lines? \$\endgroup\$ – Kevin Cruijssen Apr 28 at 14:17
  • \$\begingroup\$ @KevinCruijssen Yes, something along those lines. It could also be squaring the number after the $, or something similar. But there were so many operators to try that I gave up before I started. \$\endgroup\$ – maxb Apr 28 at 14:19
3
\$\begingroup\$

Kotlin , 58 bytes

DayOfWeek.values().map{it.name.toLowerCase().capitalize()}
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Perl 5, 33 29 bytes

print+(sort<>)[1,5,6,4,0,2,3]

Try it online! Just another sort/permute answer. Edit: Saved 4 bytes thanks to @Xcali.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Shaved 4 bytes: Try it online! \$\endgroup\$ – Xcali Apr 28 at 20:22
  • \$\begingroup\$ @Xcali Thanks! I don't really know Perl, I was just putting in parentheses until it stopped erroring... \$\endgroup\$ – Neil Apr 28 at 20:57
  • \$\begingroup\$ I just found another issue there. Thursday and Friday are reversed in your output. \$\endgroup\$ – Xcali Apr 28 at 21:12
  • \$\begingroup\$ @Xcali Thanks for spotting my typo... (I got the sequence of digits correct in my other answer at least.) \$\endgroup\$ – Neil Apr 28 at 21:49
3
\$\begingroup\$

Powershell, 23 bytes

1..6+0|%{[DayOfWeek]$_}

Convert integers to weekday, but bump array by one because .net prefers Sundays.

37 bytes sorting

($args|%{[DayOfWeek]$_}|sort)[1..6+0]

input is string list to args.

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ 21 bytes \$\endgroup\$ – mazzy Apr 29 at 7:05
3
\$\begingroup\$

PHP, 39 bytes

for(;$i<7;)echo" ".jddayofweek($i++,1);

Try it online!

Works in Windows but not in TIO, gotta find how to activate the extension.. takes no input.

We could save 4 bytes with an empty delimiter (which is "some delimiter" the question doesn't say a non-empty delimiter) but I'm not that nasty..

EDIT: version that works universally for 1 byte more

PHP, 40 bytes

for(;$i<7;)echo date("l ",1e6+$i++*8e4);

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

C (gcc), 72 70 bytes

Saved 2 bytes thanks to gastropner!!!

f(){puts("Monday Tuesday Wednesday Thursday Friday Saturday Sunday");}

Try it online!

Just prints the days of the week.
Unfortunately this is shorter than sorting the input! T_T

C (gcc) Little Endian Byte Order, 123 \$\cdots\$ 99 85 bytes

h,s;c(int**a,int**b){h=(h=**a%274%79)>(s=**b%274%79)-(h<s);}f(int*s){qsort(s,7,8,c);}

Try it online!

Function f takes a list of strings as input and sorts it.

How

Reads the first four characters as a 32-bit int, \$i\$, and then calculates \$((i\mod{274})\mod{79})\$:

Monday -> 5
Tuesday -> 7
Wednesday -> 11
Thursday -> 23
Friday -> 47
Saturday -> 59
Sunday -> 61

Then uses qsort to sort the array.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ You could save 2 bytes by using puts() instead of printf(). \$\endgroup\$ – gastropner Apr 30 at 1:05
  • \$\begingroup\$ @gastropner Nice one - thanks! :-) \$\endgroup\$ – Noodle9 Apr 30 at 6:07
2
\$\begingroup\$

Bash + Unix utilities, 29 bytes

jot "-wdate +%%A -d7-1-" 7|sh

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Nice solution, but it isn't ISO 8601 compliant unfortunately. The week should start with Monday for this challenge. \$\endgroup\$ – maxb Apr 28 at 7:00
  • \$\begingroup\$ Fixed. Thanks for pointing it out. \$\endgroup\$ – Mitchell Spector Apr 28 at 7:03
2
\$\begingroup\$

Keg, 15 bytes

“jnsDt[rƳm⑺dQ7⅍

Try it online!

You'd think this was some sort of fancy sorting algorithm, but no. It's simply a compressed string.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Red, 24 bytes

print system/locale/days

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

J, 10 bytes

1314 A./:~

Try it online!

J Port of isaacg's alternative Pyth solution — please upvote him!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Retina, 40 bytes

^
MTuWThFSaSu
,6L$s`(.+)(?=.*(\1\w+))
$2

Try it online! Link shuffles input in header. Explanation:

^
MTuWThFSaSu

Insert unique day name abbreviations.

,6L$s`(.+)(?=.*(\1\w+))
$2

Find the first seven duplicate substrings, and output the word containing the duplicate, thus unabbreviating the names.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Charcoal, 29 25 bytes

≔E⁷SθW⁻θυ⊞υ⌊ιE1564023§υIι

Try it online! Link is to verbose version of code. Explanation:

≔E⁷Sθ

Input the seven days.

W⁻θυ⊞υ⌊ι

Sort the days lexicographically.

E1564023§υIι

Apply the permutation to the array.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

MATL, 4 bytes

23Y2

Built-in ¯\_(ツ)_/¯. Takes no input.

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Japt, 8 bytes

n á g#4

Try it here

| improve this answer | |
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.