[Question]
  [
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 [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") 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](https://tio.run/##dYxLCsMgFEXnrkIyUgiZdCZkAR11CeG1T4lUn@IHdPVpoMmgpZ3ec86NvayBLttmfQyp8Ac4TQiJmdmBvyPwpvIONIo2PnU/V1TO5iJOfULoC4HXcrKEugmU8rxMQBg8y2s1xmlcdjXzmf/p2VufDl18ZJLFZKmI4UqxFjWM/De@1XJw83Ugtxc). 
  
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
```
o%CN258
```
[Try it online!](https://tio.run/##K6gsyfj/P1/V2c/I1OL//2il4NK8lMRKJR2lkNLUYggrOLGktAgqmFFaBBV1K8qEMMJTU/JgSn3zwbpjAQ "Pyth – 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.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~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!](https://tio.run/##XY3NCoJAGEX3PsW3iZmpHNpIlIzgJmghLRJaRMSHP6nYjIwzQdC7248a1OqeC4d7K7xhm@iyMa5UadblokMRIG@VNpT1cRaBS1Hg1Ft5D49NlqwLQcARSKRkincyBxLbrB3wkKXyW@LC6pE3uhxoj8bqke1nA06@Ew5/IAKI0BRco0zVlTJwYcE95juJkq2qM16rCyVb2VgDayAwg5BXqpT0Pcj@vZ01L7H3chqyH7V7Ag "JavaScript (Node.js) – 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
```
[Answer]
# [Pyke](https://github.com/muddyfish/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!](https://tio.run/##K6jMTv3/v875/38A "Pyke – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/) 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](https://help.dyalog.com/18.0/#Language/Primitive%20Operators/Format%20Datetime.htm "Documentation") ("12:00") as follows:
 `'Dddd'` long **D**ay name
[Answer]
# [Python 3](https://docs.python.org/3/), ~~40~~ 38 bytes
*-2 bytes thanks to xnor*
```
from calendar import*;print(*day_name)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P60oP1chOTEnNS8lsUghM7cgv6hEy7qgKDOvREMrJbEyPi8xN1Xz/38A "Python 3 – Try It Online")
---
# [Python 2](https://docs.python.org/2/), ~~44~~ 43 bytes
```
lambda d:sorted(d,key=lambda x:~hash(x)%72)
```
[Try it online!](https://tio.run/##LYqxCsIwFEX3fsVbhAScuhQKXd2cKjioyJMkJqgv4SXBdvHXYxudzuGeG@ZkPbXFDOfyxNdNIag@ek5aCbV96Hn4r1P/sRitmOSma2VROEcY4MT4vjoKOQkJxjM4cASMdNeik5cmsKMERqx3WcZMizR7X3HIOlbazFV27FYctaJfGTFlXuQL "Python 2 – Try It Online")
[Answer]
## 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'
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 21 bytes
Anonymous prefix lambda. Port of [isaacg's Pyth solution](https://codegolf.stackexchange.com/a/204078/43319) — go upvote that!
```
{⍵[⍋258|256⊥¨⎕UCS¨⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qW9CjtgmGRhbm/6sf9W6NftTbbWRqUWNkavaoa@mhFUAFoc7BQLp3a2zt/zSg0ke9fY@6mh/1rnnUu@XQeuNHbROBaoKDnIFkiIdn8P80BfXgxJLSopTESnUF9ZCM0qJiCDO4NA8qVpoKFfLNhwqFp6bkwQTdijJBDK40OBOHQoQ5eC0EAA "APL (Dyalog Unicode) – 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)
[Answer]
# [Java (JDK)](http://jdk.java.net/), 27 bytes
```
java.time.DayOfWeek::values
```
[Try it online!](https://tio.run/##hVHLTsMwELz3K1Y5oISCVa4pBSEQJxCHgjggDkuyKW4dO3jXlSrUby/Og4egEpfMxOPdnR0vcY3Hy3K103XjvMAy/qsg2qjD6ejPWRVsIdrZvSKLJ6xbqTDIDLeoLbyPAJrwYnQBLCgR1k6XUEctnYvXdvH0DOgXnHVXAdbogWNjKq9wwzCDC@8jUcg3miVNbp0tcXN0H4hbfKTS9uz@NfiOXHvdwhwl@I6EtiJR3BgdGxwlWTbtRu3Zax6aeIv8aaeJrklFG3fVI9Hq6fkMqtluj5LnazTR0K7v@@KcIbTAoSiI2x3EB@q1ynlItRXQ8XgyjXAKJ5NJy8bjzwwGa7/HgycORmJhpRYk6bAGfA06mP2IbniPNFM1NkPWeS7uoWnIXyJTpgpnDBWSXvboPCtxXcxZpugtoOH0O6ThIYa2vZe@@d5ILNb/jBj8b7vvfMNCtXJBVBOtirHp51rnkAw0gRySCrVJutrtaLv7AA "Java (JDK) – 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!](https://tio.run/##fVHLitswFN3nKy6GFmkmFikdKOThUlK66tBFBroIWVzb8kSpLLl6pISS@fWMJNtthwnd6NyHrs49Rwc8Yn6of1xE22nj4BBy5p2Q7GYxeVVrvKqc0Opq0zrDsY2tSqK1cI9Cwe8JQOdLKSqwDl2AoxY1tKFHNs4I9bjdAZpHS9NVgCMasOFhXn/Gk4UVfBXWsUp3p28N@WRMKDK0sUiye61qPE0fPLcRv/Na9dHD3psUfDEiwgadNynwcSJjtpMiPDDNKKWLxHtF5For61tulpFtWe3RbHdFAc3qIvMi6A1bEoLTkubFE25nuxvc3u3e5Hcf3udPZczLMaeXnqTUWnJUYH1VcRvVOeN532u0ASKUAxHKs0WAJbybzWJ0ezu60/sT3QiXFP8FyZG0X0H@2kaHzyCUtdgNRs/nTq@DiDRCg6VS8sqRdY/aWOZ08nW0BGDoBTMss3vfNJKTSP7nQsMwKOncy@oAo8q3q39@lPGfHqVNA9e3DLL@v93Ac07n5mQdb5n2jnVh3klFRt6PkA1hBnPIGhQyS7PnyfnyDA "Java (JDK) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 27 bytes
```
DayName@{#}&/@198~Range~204
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2773yWx0i8xN9WhWrlWTd/B0NKiLigxLz21zsjA5H9AUWZeiYK@Q/r//wA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 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!](https://tio.run/##SyzI0U2pTMzJT///v/pR79boR73dGhqPOroedcx41DfV8VFX06OuRZrqvvkhpeGpIRluRcGJ6pqPejcbPWqbeGgFUEds7f@0R20THvX2PepqftS75lHvlkPrjYGyQO3BQc5AMsTDM/h/moJ6cGJJaVFKYqW6gnpIRmlRMYQZXJoHFStNhQr55kOFwlNT8mCCbkWZIAZXGpyJQyHCHLwWAgA "APL (Dyalog Unicode) – 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 **A**lphabet
  `⍋` grade (permutation that would sort it)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
Port of isaacg's base conversion answer.
```
Σ₁ö29%
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3OJHTY2HtxlZqv7/H63kVpSZklippKPkm58HYYSnpuSlFkPYIaUwVnBiSWkRVDCjtAgmWgrWFAsA "05AB1E – 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](https://github.com/Adriandmen/05AB1E), 6 bytes
-1 byte thanks to Expired Data
```
{œŽ5dè
```
[Try it online!](https://tio.run/##yy9OTMpM/f@/@ujko3tNUw6v@F97buvh5V7/o9V98/NSEivVdRTUQ0pTi6HM8NSUPDgnJKO0CMZ2K8qEsoITS0qLYOxSsBmx/wE "05AB1E – Try It Online")
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes
```
Σ"TuWeThFrSaSu"2ôåāsÏ
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3GKlkNLw1JAMt6LgxOBSJaPDWw4vPdJYfLj///9oJbeizJTESiUdJd/8PAgjPDUlL7UYwg4phbGCE0tKi6CCGaVFMNFSsKbY/wA "05AB1E – 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.
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/) `-m32`, 50 bytes
```
main(i){for(;puts(nl_langinfo(131079+i%7))-i++;);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1OzOi2/SMO6oLSkWCMvJz4nMS89My8tX8PQ2NDA3FI7U9VcU1M3U1vbWtO69v//f8lpOYnpxf91c42NAA "C (gcc) – 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](https://codegolf.stackexchange.com/a/96555/88546).
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##PU7LCoMwELznK/ZmhCDa9iR47a2nCj1YDylJasA8WM3Br0@TojKwzCw7s@O3dXL2ElX3jjM3H8Fhbg33dHG4SkHnsvLOs6Fht4QrqzPGMmrj0wEgt8IZwu0CHQzFw1nBt4JB0Qe57PQlhT1FPwU8@B31zp58DXjw8M8YSZo5NWUP7UiIcggatM0/v5I2ddkS2AtUyxSUmiXNnjKvk1GdyqO2qSsD7LoUF38 "Python 2 – Try It Online")
Sort by normal string comparison first, then look up the correct permutation.
---
# [Python 3](https://docs.python.org/3/), 58 bytes
```
lambda l:sorted(l,key=lambda s:"TuWeThFrSaSu".find(s[:2]))
```
[Try it online!](https://tio.run/##PY49C4MwEIb3/IrDxQSk9GMLZO3WSaGDdUhJUkM1kYsZRPztNhbb5Xjuhfe5G6ax9e6yGvFYO9k/lYSOB4@jVrQr3noSexp4VsW7rtorlrKM2cFYp2io@blhbLX9kDqA0infE@kCCKjzm3dKTnkBeRV12PGulfsvVRvxx1e0O5VyjPjj@HU0JM3Nmtw1bwgxHsGCddvNl6anI@ME9gcOoY3GdJpuHbbFqWj@24DWjdRkMy4F1DMKkaRLk7H1Aw "Python 3 – Try It Online")
Use the first 2 letters of each day to look up the order.
[Answer]
# [Factor](https://factorcode.org/), 20 bytes
```
day-names 1 rotate .
```
[Try it online!](https://tio.run/##DcQxCoAwDAXQ3VPkAhZc6wHExUXEObRfELVqEsGevvqGt3CwU8o09kPnKfCOFFlIcT9IAerwmrDSJTDLl6zJqK36wdMMbJGzlr868QGlhuQ0NpAr5QM "Factor – Try It Online")
[Factor](https://factorcode.org/) 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.
[Answer]
# 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](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
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.
[Answer]
# [R](https://www.r-project.org/), 30 bytes
Assuming an English locale
```
weekdays(as.Date("1/1/1")+0:6)
```
[Try it online!](https://tio.run/##K/r/vzw1NTslsbJYI7FYzyWxJFVDyVAfCJU0tQ2szDT//wcA "R – Try It Online")
January 1st of the year 1 is a Monday (according to R). 
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 8 bytes
```
á{$ûÞ♠$%
```
[Try it online!](https://tio.run/##y00syUjPz0n7///wwmqVw7sPz3s0c4GK6v//0UpuRZkpiZVKOkq@@XkQRnhqSl5qMYQdUgpjBSeWlBZBBTNKi2CipWBNsf8B "MathGolf – 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. 
[Answer]
# [Kotlin](https://kotlinlang.org) , 58 bytes
```
DayOfWeek.values().map{it.name.toLowerCase().capitalize()}
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~33~~ 29 bytes
```
print+(sort<>)[1,5,6,4,0,2,3]
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvRFujOL@oxMZOM9pQx1THTMdEx0DHSMc49v9/t6LMlMRKLt/8PBAVUppaDKYzSovAjODEktIiMKMUrCA8NSUPogQA "Perl 5 – Try It Online") Just another sort/permute answer. Edit: Saved 4 bytes thanks to @Xcali.
[Answer]
## 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.
[Answer]
# [PHP](https://php.net/), 39 bytes
```
for(;$i<7;)echo" ".jddayofweek($i++,1);
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVMm3MrTVTkzPylRSU9LJSUhIr89PKU1OzNVQytbV1DDWt//8HAA "PHP – 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](https://php.net/), 40 bytes
```
for(;$i<7;)echo date("l ",1e6+$i++*8e4);
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVMm3MrTVTkzPyFVISS1I1lHIUlHQMU820VTK1tbUsUk00rf//BwA "PHP – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~72~~ 70 bytes
Saved 2 bytes thanks to gastropner!!! 
```
f(){puts("Monday Tuesday Wednesday Thursday Friday Saturday Sunday");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NQ7O6oLSkWEPJNz8vJbFSIaQ0tRhEh6em5EFYIRmlRWCGW1EmiApOLCktAjNKQTqUNK1r/2fmlSjkJmbmaWgqVHMBzbTmqv0PAA "C (gcc) – Try It Online")
Just prints the days of the week.  
Unfortunately this is shorter than sorting the input! T\_T
# [C (gcc)](https://gcc.gnu.org/) 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!](https://tio.run/##tZBNS8QwEIbv/RVDoZB0pyBFqNKtR2@eVvCw7iHbD5PDppo0iJT@9pr0g7oVT7vOpSRPZ@bNk0dved73HHWaEyGbMGQ4fI605Rnhmb0I4uQ2SO7pA9H2eJyPEeFbTdOuGvo0bT90rRqiMcE7zC3o7T2cmJCEQut5YCvnTMGplvsDZOA/1bJgX366oMaUI3o2pV6xz7IY2UtZyF@04Wbq5EatYaXECB@VWCHNmhHtWGPUGpop6c6sk4aKyWKfONq6aOgSoNuE7hXoXoluALoV0I2tVa2cLRDZTQpim6Sw2QhnB6Z6VxZXxA/0q/QRhiXiQMfuzvv5S3Re4OyXBayuIztnaq@IG0f/PclftSRZDMazQisJJ4/n9matlyiMr@wwplfK0vXf "C (gcc) – 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.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Unix utilities, 29 bytes
```
jot "-wdate +%%A -d7-1-" 7|sh
```
[Try it online!](https://tio.run/##S0oszvj/Pyu/REFJtzwlsSRVQVtV1VFBN8Vc11BXScG8BiQNAA "Bash – Try It Online")
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 15 bytes
```
“jnsDt[rƳm⑺dQ7⅍
```
[Try it online!](https://tio.run/##y05N////UcOcrLxil5LoomObcx9N3JUSaP6otff/fwA "Keg – Try It Online")
You'd think this was some sort of fancy sorting algorithm, but no. It's simply a compressed string.
[Answer]
# [Red](http://www.red-lang.org), 24 bytes
```
print system/locale/days
```
[Try it online!](https://tio.run/##K0pN@R@UmhId@7@gKDOvRKG4srgkNVc/Jz85MSdVPyWxsvj/fwA "Red – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 10 bytes
```
1314 A./:~
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DY0NTRQc9fSt6v5rcilwpSZn5CukKaiHlKYWpyRWqlsrqIenpuTBOb75eVCWW1EmlBWcWFJaBGOXwuRDMkqLwLrgZhKtw5qg/Vz/AQ "J – Try It Online")
[J](http://jsoftware.com/) Port of [isaacg's alternative Pyth solution](https://codegolf.stackexchange.com/a/204078/43319) — please upvote him!
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 40 bytes
```
^
MTuWThFSaSu
,6L$s`(.+)(?=.*(\1\w+))
$2
```
[Try it online!](https://tio.run/##K0otycxLNPzvb5/wP47LN6Q0PCTDLTgxuJRLx8xHpThBQ09bU8PeVk9LI8YwplxbU5NLxej/f9/8vJTESq6Q0tRiEB2empIHYYVklBaBGW5FmSAqOLGktAjMKAXpAAA "Retina – 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.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~29~~ 25 bytes
```
≔Ｅ⁷ＳθＷ⁻θυ⊞υ⌊ιＥ1564023§υＩι
```
[Try it online!](https://tio.run/##HUy7CsMgFN3zFZLpCunSpUPHUKFDoGAgsyS2SkXN1VvI11vjdN5nNQrXoFwp74AMbpy9KBmggT19pCwzWv8Bzu9dy2V0NkM/hZkWPRuBUknqB3bldVirGYR1WeN58NhJuQTjsTo9mhDhe/YGZnm9K0Wg3dTRTcGfIFUmbISankmnhoawkUVvvlnl8nN/ "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔Ｅ⁷Ｓθ
```
Input the seven days.
```
Ｗ⁻θυ⊞υ⌊ι
```
Sort the days lexicographically.
```
Ｅ1564023§υＩι
```
Apply the permutation to the array.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 4 bytes
```
23Y2
```
Built-in ¯\\_(ツ)\_/¯. Takes no input.
[Try it online!](https://tio.run/##y00syfn/38g40uj/fwA "MATL – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
n á g#4
```
[Try it here](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=biDhIGcjgzQ&input=WyJGcmlkYXkiLCJNb25kYXkiLCJXZWRuZXNkYXkiLCJUdWVzZGF5IiwiU2F0dXJkYXkiLCJUaHVyc2RheSIsIlN1bmRheSJd)
]