[Question]
  [
In as few bytes as possible, sort the input, *a delimited string OR list/vector/array of words, words contain printable ASCII except space (ASCII values 33-126)* into a numbered list, table, or something resembling a table, by length.
Table rules are as follows:
* Order is mandatory, direction is optional, either labelled rows from shortest to longest or vice versa,
* Formatting is not the challenge. So as long as the output is some form of numerically labelled rows of words, a numbered list, or a list of lists, or similar output, then it is a satisfactory answer.
* including/excluding gaps (NA values, see below examples for both methods of output)
* Word case is untouched. How the word appears in input should be shown in output.
**Input 1:**
```
Code Golf and Coding Challenges Meta
```
**or**
```
("Code","Golf","and","Coding","Challenges","Meta")
```
**or similar**
**Output 1:**
```
 1. NA
 2. NA
 3. and
 4. Code Golf Meta
 5. NA
 6. Coding
 7. NA
 8. NA
 9. NA
 10. Challenges
```
**or**
```
3. and
4. Code Golf Meta
6. Coding
10. Challenges
```
**or**
```
[[3, ['and']], [4, ['Code', 'Golf', 'Meta']], [6, ['Coding']], [10, ['Challenges']]]
```
**Input 2:**
```
My v3ry 3xc3113nt m0th3r ju5t 53rv3d u5 nin3 pizz@5 #JusticeForPluto
```
**Output 2:**
```
1. NA
2. My u5
3. NA
4. v3ry ju5t nin3
5. NA
6. m0th3r 53rv3d pizz@5
7. NA
8. NA
9. 3xc3113nt
10. NA
11. NA
12. NA
13. NA
14. NA
15. NA
16. #JusticeForPluto
```
**or**
```
2. My u5
4. v3ry ju5t nin3
6. m0th3r 53rv3d pizz@5
9. 3xc3113nt
16. #JusticeForPluto
```
**or**
```
[[2, ['My', 'u5']], [4, ['v3ry', 'ju5t', 'nin3']], [6, ['m0th3r', '53rv3d', 'pizz@5']], [9, ['3xc3113nt']], [16, ['#JusticeForPluto']]]
```
More examples can be provided if necessary but I think this should suffice for now.
Please ask questions if you have them, this is my second attempt at a challenge. (the first failed dramatically)
  
[Answer]
# [R](https://www.r-project.org/), 28 bytes
```
split(w<-scan(,""),nchar(w))
```
[Try it online!](https://tio.run/##BcFNCoMwEAbQq3zoJgGFypBdF111URB6BYmCKXaUyST@XD6@J6XEbQlq9mcb/cCmqSrbsJ8HMbu1pT@RSU7Q4anriBX/h84k@CWncCSZRiQHDkzYwnW9HOpPihr89F7luyRdyw0 "R – Try It Online")
`split` does the trick; results in a `list()` where the element names are the lengths and the elements are `vectors` containing the words.
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~12~~ 14 bytes
```
{x@=#'x@:<#'x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqrrCwVZZvcLBygZI1v5PU9BQ8q1UslYqMy4CUcYVycaGhsZ5JUB2rkFJhnERkJFVagrimxoXlRmnABmlpkAiLzPPGEgVZFZVOYD4yl6lxSWZyalu@UUBOaUl@Uqa/wE "K (ngn/k) – Try It Online")
this returns a k dictionary. lengths are key, words are value. let me know if this output format is acceptable. 
in q (wrapper around the k4 dialect), we can evaluate using the k interpreter and get q output formatting:
```
q)k){x@=#:'x@:<#:'x}("Code"; "Golf"; "and"; "Coding"; "Challenges"; "Meta")
3 | ,"and"
4 | ("Meta";"Golf";"Code")
6 | ,"Coding"
10| ,"Challenges"
```
note the extra colons, which aren't required for "eached" monads in the ngn implementation
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Input as an array of words, output as a 2D-array.
```
üÊËiDÎÊ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=/MrLaUTOyg&input=WyJDb2RlIiwiR29sZiIsImFuZCIsIkNvZGluZyIsIkNoYWxsZW5nZXMiLCJNZXRhIl0KLVE)
```
üÊËiDÎÊ     :Implicit input of array
ü           :Group and sort by
 Ê          :  Length
  Ë         :Map each sub-array D
   i        :  Prepend
    DÎÊ     :    Length of first element of D
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 19 bytes
```
*.classify(*.chars)
```
[Try it online!](https://tio.run/##DcrRCsIgGIbh813FB0FUB6MhdhJBMCgIBt2CTN0Mp@NXV@7mbWfvA@@syF7KlLHXuKGc6t6KEIzOhy1HQeFYrlUQGfXXkwz1tmlPsMapUFovFZ7eaggnscm4Ae0orFVuUAGdiqLqMhZGGezXs6ZhLmI6x5ERPolHcEYLk0gczjiG2azrnWP3SiGaXj08vW2K/g8 "Perl 6 – Try It Online")
Pretty much does exactly as asked.
```
*.classify(       )  # Classify the list
           *.chars   # By number of characters
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 18 bytes
```
$args|group Length
```
[Try it online!](https://tio.run/##fVJdT8IwFH3fr2i0WBaHASsmPpAsMZHEgPHdGLJs3Ycp7Ww7QGC/HdtubA6Ifdi9t@f03HNvlvM1ETIllB5gPNkdYCASuU8EL3IwIyxR6aF0HL/vAH28Kpjj99Ezjwjy0JTTWIeARfqr7zKWmCQNKNXvidTFnKgAuV77eNek5iCMJlrPKLhd4MEC3UaVWJf3eOSZ5ifYaFiBraGWUNrMvTDc/Ee3WmFhAt6EeDTCTOl8OVQpFjr5KsamHmOxwmbyYqw/LGNYhzzbbn1TX78WUmUheeHinRaK/7eEe2vT9tVaFxdR@6lb22YXF9GYbNzVjk7YT5bdjne6Oa12PsLZ8lywBz1QTQPXXETSA5BschIqEoEJgIsKEkQWVOmLGxgD3xIdi/RraN9rV9IIzDJGjMix/oCLu7dgST4bKkK3@m5qf9lBSL7BVefxlSWWLhgwrkLOVJAxCWAcUEn@GnPKwy8 "PowerShell – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 147 129 bytes
Thanks to girobuz and ceilingcat for the suggestions.
This routine first finds the maximum string length of an input array of strings, then prints the words by length in reverse.
```
m,*t;f(int**s){for(t=s;*s;m=fmax(m,strlen(*s++)+1));for(;--m;)for(printf("\n%d",m),s=t;*s;)printf(" %s"+3*(strlen(*s++)!=m),*s);}
```
[Try it online!](https://tio.run/##XVHLSgMxFN3PV8SUQpJJxRK6iiOCoCCtuHFVuwiZV2SSKUmm1Jb5dccboaBucs85uY@TG71otJ4my1mUNTEuMhboue49iUWQLEhb1FYdieUh@q5yhIU8p/mSUpmS5GJhJU1o76G4JvjdzUvMLeWhiKmeXi7QPOBcMPK7z1UBiTBQjtPMON0NZYVuQyxNf93eZRkUIquMS76Q8o3mSLfKI8aAHCg6Z@gihO2uSBQhkhS23dEzfujLCnP81Hc1BOXAWNKMaxJoVQdGmioA2VRRYf7ytl6P/H@XzSckHIRPQRy1WC6Fi4DtTWyFB/AxrBJfCX8QacSwgsMZJyDszel0n/jseQjR6Oqx96/dEPs/0xIEMHJ4CUuLz4D97BfBv6D9EAPBmFJUExZhbzIbpy9dd6oJ06Kz3w "C (gcc) – Try It Online")
[Answer]
# JavaScript, 50 bytes
Input as an array of words, output as an object where the keys are the word lengths and the values are arrays of words.
```
a=>a.map(w=>o[l=w.length]=[...o[l]||[],w],o={})&&o
```
[Try it Online!](https://tio.run/##FYw9DsMgDEbvwhCBRLmBs3To1BMgBisBksrFUYnC0PTs1Fm@nze8Fx5Yp8@67bfCc@wJOsKI7o2bbjCyJ2iOYsn7EsA754SE8/TBtmAZvj8zDNwnLpUpOuKsk/bqLipl1YMpSWGZJYWtJV9jQbqMscp5xh1VMKb/AQ)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 37 bytes
```
S` 
.+
$.& $&
O#`
r`(?<=\1.+)¶(.+ )
 
```
[Try it online!](https://tio.run/##K0otycxL/P8/OEGBS0@bS0VPTUFFjctfOYGrKEHD3sY2xlBPW/PQNg09bQVNLoX//53zU1IV3PNz0hQS81IUgLzMvHQF54zEnJzUvPTUYgXf1JJEAA "Retina 0.8.2 – Try It Online") Explanation:
```
S` 
```
Split the input on spaces.
```
.+
$.& $&
```
Precede each word by its length.
```
O#`
```
Sort numerically.
```
r`(?<=\1.+)¶(.+ )
 
```
If two lines start with the same length, delete the newline and the length.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~76~~ ~~74~~ 72 bytes
```
lambda a:sorted((l,[d for d in a if len(d)==l])for l in set(map(len,a)))
```
[Try it online!](https://tio.run/##FYs9DsMgDIWvYjEZialjJaYOnXqCtoMrmwTJAURYenpilvf36bX/2Gu5zRQ/U@n4MQHdz9qHMKKGN0OqHRhyAYKcQKUg@xj16xfQBU4ZeFBDY4G897P1XAYkRPeoLC64Z9VkRoVNbctlW2Entc8mp5WXDHL2vQA "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~9~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
€gêεùy‚
```
-2 bytes thanks to *@Grimy*.
Outputs a list of lists from lowest to highest, with the label at the right side instead of left. I.e. `[[["and"],3],[["Code","Golf","Meta"],4],[["Coding"],6],[["Challenges"],10]]`.
[Try it online](https://tio.run/##yy9OTMpM/f//UdOa9MOrzm09vLPyUcOs//@jlZzzU1KVdJTc83PSgFRiXgqQBIpl5qWDGBmJOTmpeempxUCOb2pJolIsAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpipaBkX6nDpeRfWgLjHVr5/1HTmvTDq85tPbSu@PDOykcNs/7X6hzaZv8/OlrJOT8lVUlHyT0/Jw1IJealAEmgWGZeOoiRkZiTk5qXnloM5PimliQqxeooRCv5VgK5ZcZFIMq4ItnY0NA4rwTIzjUoyTAuAjKySk1BfFPjojJjkIGlpkAiLzPPGEgVZFZVOYD4yl6lxSWZyalu@UUBOaUl@UqxsQA).
**Explanation:**
```
€g       # Get the length of each string in the (implicit) input-list
  ê      # Sort and uniquify this list of lengths
   ε     # Map each length `y` to:
    ù    #  Keep strings from the (implicit) input-list equal to this length
     y‚  #  And pair it with the current length `y`
         # (after which the result is output implicitly)
```
[Answer]
# [jq](https://stedolan.github.io/jq/), 53 bytes
```
map({l:length,s:.})|group_by(.l)|.[]|[.[0].l,[.[].s]]
```
[Try it online!](https://tio.run/##FYdNC4MgGID/i7sUiBQvXjrttMNg0F1kbC3KMHV@xGrutzu9PB/LO6X1Yaqv7OSoJj9j15FfHSerg7k/94rIOhLGIyOs4UTibE4c5ykxdNsRRhvYIvgM0LagfO618TPYHEug5SnYDV45As1QQkGWEcdxLn@6BufFMF607WXwGvE/ "jq – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 15 bytes
```
(⍋⊃¨⊂)≢¨{⊂⍺⍵}⌸⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X@NRb/ejruZDKx51NWk@6lx0aEU1kPWod9ej3q21j3p2POpa9D/tUduER719j/qmevqD1K43ftQ2EcgLDnIGkiEensH/0xTUnfNTUtUV1N3zc9KAVGJeijpYLDMvHcTISMzJSc1LTy0GcnxTSxLVAQ "APL (Dyalog Unicode) – Try It Online")
APL is not particularly good at simply sorting.
### How it works
```
(⍋⊃¨⊂)≢¨{⊂⍺⍵}⌸⊢
      ≢¨     ⌸⊢  Group the arg's elements by their lengths
        {⊂⍺⍵}    Wrap each list of items, paired with the length
(⍋⊃¨⊂)           Idiom for sorting:
 ⍋               Grade up; gives indexes that will make the array sorted
  ⊃¨⊂            Map the indexes to the items
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~22~~ 28 bytes
```
->w{w.group_by(&:size).sort}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1668ulwvvSi/tCA@qVJDzao4sypVU684v6ik9n@BQlp0tJJzfkqqko6Se35OGpBKzEsBkkCxzLx0ECMjMScnNS89tRjI8U0tSVSKjf0PAA "Ruby – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~31~~ ~~27~~ 23 bytes
Takes input as a newline-separated list of words (I haven't noticed that's allowed at first).
```
.+
$.& $&
N`
D`\d+
¶ 
 
```
I'll add the explanation later (for now, the previous revision's explanation without the first line works perfectly).
[Try it online!](https://tio.run/##K0otycxLNPz/X0@bS0VPTUFFjcsvgcslISZFm@vQNgUuhf//A4ry04sSc3Mz89K5AkqrqnJSi7kS81K4nPNTUrnc83PSYDyQAueMxJyc1Lz01GIA "Retina – Try It Online\"PSFQJKq6pyUosVEvNSFJzzU1IV3PNz0mA8kALnjMScnNS89NRiAA \"Retina – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes
```
lᵍ{hl}ᶻ¹o
```
[Try it online!](https://tio.run/##DcfBCoIwGADgV/lZ14JqeK1AKAiE7tFh6dLF2mJumoqHPBQdgh6li4F1603mi1jf7dsq4kcZl@G4K1IEgwmgdGqba1ud28uzrSr7vpW2fnTc1vci4qV9fb6N7Lo1cmVAYSH5DogI4D8mQnAjwjkVIY3Bo5qgPvIySLDKAJ98PBphoeEw1BFWsDeOBgerBAdgHBBMYDiyPJ850FuaWDOfzqVacaMl2vwA "Brachylog – Try It Online")
Takes input as a list of words (the testing header converts from space-separated for convenience). Output is as a list of pairs `[length,words]`, sorted in ascending order of length. Two alternative solutions of the same length, `lᵒlᵍ{hl}ᶻ` and `lᵍ{hl}ᶻtᵒ`, output pairs reversed.
[Answer]
# [Haskell](https://www.haskell.org/), ~~59~~ 56 bytes
```
l=length
f s=[(n,[x|x<-s,l x==n])|n<-[1..maximum$l<$>s]]
```
[Try it online!](https://tio.run/##FY3NasMwEITveQqh5pCAY2qEb1YJFFooGHIXpohEjtWs1kY/QQl5d3d1mZlvYXYmHW4GYHXaIpPM6aX/ZbvFW4ysZuOeqQ1T/HO@GF7x7xlGMo0XUrpZvJYwaQCDVxMIehM1H6pS6h/Ed@GLiXwWTSMwUnbvcRKewl9qC7fC30X5mFoStCjIFvt8Hgu//aQQ7dl8zf4EKc58GFaQZS9Om5EFqXZYqfzK3SFUwLKUOOxf2B1UU9dOZ@uS20K3/QhUXP8B "Haskell – Try It Online")
* -3 bytes by using a list comprehension instead of a lambda, thanks to [79037662](https://codegolf.stackexchange.com/questions/195807/sort-and-table-a-sentence-by-word-lengths/195892?noredirect=1#comment466596_195892)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 9 bytes
```
m+lhdd.gl
```
[Try it online!](https://tio.run/##K6gsyfj/P1c7JyMlRS895/9/DSXn/JRUJR0l9/ycNCCVmJcCJIFimXnpIEZGYk5Oal56ajGQ45takqikCQA "Pyth – Try It Online")
Port of [@Shaggy](https://codegolf.stackexchange.com/a/195808/90146)'s answer, so I cant really take credit for this (lol)
# [Pyth](https://github.com/isaacg1/pyth), 14 bytes
```
m+dfqdlTQSleol
```
[Try it online!](https://tio.run/##K6gsyfj/P1c7Ja0wJSckMDgnNT/n/38NJef8lFQlHSX3/Jw0IJWYlwIkgWKZeekgRkZiTk5qXnpqMZDjm1qSqKQJAA "Pyth – Try It Online")
Saves a few bytes by mapping a filtered list to each number in a 1-indexed range. This only saves 2 bytes due to the fact that the last two bytes can be implicit (would be `m+dfqdlTQSleolNQ` otherwise)
## How it works
```
m+dfqdlTQSleol
m              - Map
 +d            - The sum of the element and...
   fqdlTQ      - The filtered input where each element of the input is length d        
         Sl    - To the range [1, length]
           eol - of the last element of the ordered list by key=length
               - Print implicitly
```
# [Pyth](https://github.com/isaacg1/pyth), 16 bytes
```
FkSleolNQkfqklTQ
```
[Try it online!](https://tio.run/##K6gsyfj/3y07OCc1P8cvMDutMDsnJPD/fw0l5/yUVCUdJff8nDQglZiXAiSBYpl56SBGRmJOTmpeemoxkOObWpKopAkA "Pyth – Try It Online")
16 bytes seems a bit high for a challenge like this but oh well. Would be 14 bytes but it looks like the last 2 bytes cant be implicit due to how filter works in pyth
## How it works
```
FkSleolNQkfqklTQ
Fk                 - For k in...
  Sl               - The range [1, length]
    eolN           - Of the last element of the sorted list by key=length
        Q          - Of the input
         k         - Print k
          fqklT    - Filter by key k == length...
               Q   - The input (prints implicitly)
```
Sorry if this answer is too long, I can cut it a bit if needed
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~6~~ 8 bytes
```
ẈẈḢ,Ɗƙ⁸Ṣ
```
[Try it online!](https://tio.run/##y0rNyan8///hrg4Q2rFI51jXsZmPGnc83Lno/@H2o5Me7pzx/7@Sc35KqpKOknt@ThqQSsxLAZJAscy8dBAjIzEnJzUvPbUYyPFNLUlUAgA "Jelly – Try It Online")
A monadic link which takes a list of Jelly strings and returns a list of lists where the first member of each list is the length and the second is a list of Jelly strings of that length. Plus 2 bytes now it’s been clarified that ordering of the list is mandatory. 
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~63~~ 53 bytes
```
$a=@{};$args|%{$a[$_.length]+=" $_"};$a|% *or|sort N*
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyXR1qG61lolsSi9uEa1WiUxWiVeLyc1L70kI1bbVklBJV4JJFujqqCVX1RTnF9UouCn9f//f3Xn/JRU9f/q7vk5aUAqMS9FHSyWmZcOYmQk5oAMSS0GcnxTSxLVAQ "PowerShell – Try It Online")
*(-10 bytes thanks to mazzy)*
Takes arguments via [splatting](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_splatting?view=powershell-6), which on TIO manifests as separate command-line arguments.
We first construct an empty hashtable `$a`, then loop through the input arguments. Each item is tacked onto `$a` in the appropriate `$_.length` slot. Then comes the lengthy `.GetEnumerator()` followed by a `sort` to get the hashtable to print out in order. That's left on the pipeline and output is implicit.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
üÊ®uZÎl
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=/MqudVrObA&input=WyJDb2RlIiwiR29sZiIsImFuZCIsIkNvZGluZyIsIkNoYWxsZW5nZXMiLCJNZXRhIl0KLVE)
```
üÊ®uZÎl // input as array of words
üÊ // group by length
  ® // for each group
   uZÎl // append length of 1st word
```
[Answer]
# [Perl 5](https://www.perl.org/) (`-040n`), ~~45~~, ~~40~~, 34 bytes
-5 bytes thanks to Xcali
```
$a[y///c].=" $_"}{say$b++,$_ for@a
```
[Try it online!](https://tio.run/##K0gtyjH9/18lMbpSX18/OVbPVklBJV6ptro4sVIlSVtbRyVeIS2/yCHx/3/n/JRUBff8nDSFxLwUBSAvMy9dwTkjMScnNS89tVjBN7Uk8V9@QUlmfl7xf10DE4O8nP@6vqZ6BoYA "Perl 5 – Try It Online")
[Answer]
# [PHP](https://php.net/), 62 bytes
```
for(;$w=$argv[++$i];ksort($a))$a[strlen($w)][]=$w;print_r($a);
```
[Try it online!](https://tio.run/##FYtBCoAgEAA/swelJ1h08NCpF4jEQqaSqKySz9/qMjAMU0Plea0fr0JCwVgAyT9mmiBadbdCXQBKCWhap@SygCGtsQsMVSnmftDfFTPrcjreSroY8/lbzJ51wPRd3jXeXccX "PHP – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 22 bytes
-2 bytes thaks to FrownyFrog
If the output can be a table with some empty boxes:
```
[:/:~#@>(,~#&.>@{.)/.]
```
[Try it online!](https://tio.run/##VctNC4IwAIfxu5/iT0JLsKkML0IiCAaREF2jg@h8w7bQTdLAr25eOzyH3@Fp1x0lJU4BCGy4CLaOFPH9mqyPwAkWMwoP9mLuaRh9qeXQ52oZMHheS5TItQKJZcFxll2JTBTY1IgKcZ11HRcVH5BylZG/I50wsn4C@@TM85hQeLmqZj1a7Sv4rB9ZAe1DNILh3cxz5MO86EE1OU9kf@u0kmT9AQ "J – Try It Online")
# [J](http://jsoftware.com/), 24 bytes
```
/:~@(#@><@(#@>@{.;])/.])
```
[Try it online!](https://tio.run/##VYvNCoJAAAbvPsVHHjah/GHxYj8IgkEkRPcOsq66Yruhu5IGvbpJtw4zMIdp5pVLShwiEGzgI1rYukhul3T2ok@8tuPj/uf47e7ujufendmxYHFWK5RgRoMkquA4qbZELgssJWSFpM7blsuK98i4zsnfkY0YaDeCvhgNAio1Hr6uaYfGhBoh7QZawISQQlI8xTTFIeyz6bVgPFXdtTVakfkL "J – Try It Online")
Just made it work - no doubt it can be golfed further.
[Answer]
# RPL, 60+10 bytes
Let's explore more creative output formats:
```
DUP«SIZE»DOLIST SWAP 2«STR→ X ROT ^ *»DOLIST ΣLIST EXPANDMOD
```
turns the list {"Code" "Golf" "and" "Coding" "Challenges" "Meta"} into the polynomial 
Challenges·X10+Coding·X6+(Code+Golf+Meta)·X4+and·X3 thanks to EXPANDMOD. 
Sadly to allow exotic names like pizz@5 – just for you to know, `@` introduces comments – `STR→` must be replaced by `#5B15h SYSEVAL` adding 10 bytes to the source code, and obfuscating the call. That does however allow printable and even non printable chars, the latters only displayed as black squares but not lost. So the garbage resistant code is
```
DUP«SIZE»DOLIST SWAP 2«#5B15h SYSEVAL X ROT ^ *»DOLIST ΣLIST EXPANDMOD
```
(EXPANDMOD is present in HP50g at least. Tested with [Emu48](https://play.google.com/store/apps/details?id=org.emulator.forty.eight) in 50g mode.
The code page is documented [here](https://en.wikipedia.org/wiki/RPL_character_set#Code_page_layout)). 
[Answer]
# SimpleTemplate, 136 bytes
Yeah, it's a long one... The order of the output is what made it longer :/
```
{@setM 0}{@eachargv.0}{@callstrlen intoR _}{@setL.[R]L.[R],_}{@ifM is lowerR}{@setM R}{@/}{@/}{@forfrom 1toM}{@echo_}.{@echojl" " L.[_]}
```
Incredibly, it is easier (and shorter) to output that to return.
You can try it on <http://sandbox.onlinephpfunctions.com/code/ec4bf4b3efa93c63c6c5c9f1458330da0178b6cd>  
(Line 974 has the words, line 976 has the golfed/ungolfed version variable)
---
**Ungolfed**:
```
{@set results}
{@set max 0}
{@each argv.0 as word}
    {@call strlen into length word}
    {@set results.[length] results.[length], word}
    {@if max is lower than length}
        {@set max length}
    {@/}
{@/}
{@for i from 1 to length}
    {@echo i}.{@echo separator " " results.[i], "\n"}
{@/}
```
Most of it should be easy to understand.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 30 bytes
```
KeySort@*GroupBy[StringLength]
```
[Try it online!](https://tio.run/##RU@9CsIwEN59CombOFhCR6EoWFALhY6lQ2hTE0mTkl6KrfjsMZfF5b6f@/m4gYHgAwPZMt@f/J0vlbGQ7XNr3Hhe6gqs1M8H108QjS@DgLqvP@RiOk4OW5Ib1SMy3SEEO4xHJphSYY1PqAoOjHybZvO/UCzYmKmNSN8tTRKqAcVwBEEtspdLo5NSO9OY4FKsWmqKOMp1zaKzu7kpfMGvxpbKgcE0/wM "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Scala](https://www.scala-lang.org/), 30 42 bytes
Correction thanks to Value Ink
```
(s:String)=>s.split(" ").groupBy(_.length)
```
[Try it online!](https://scastie.scala-lang.org/buVNQluwRumhzpeCJ1K5Qw)
[Answer]
# JavaScript (ES6), 53 bytes
Takes input as a list of words. Returns an object whose keys are the lengths and whose values are the lists of corresponding words.
```
a=>a.map(w=>(o[n=w.length]=o[n]||[]).push(w),o={})&&o
```
[Try it online!](https://tio.run/##Fcw9DsIgFADgqxCGhpcoN6BLBydP0DC8tPwZ5BGhMljPjjh@y/fAN5btFXK9JtpNt6qjmlE@MYumZkFrUk1Gk1z1Wg3p81w1yHwULxpcSH2@ME3UN0qFopGRnLCCLyNjN4qWYdrZUEiOLR7jvzKF3U1FLkuOoQrOOAD0Hw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 107 bytes
```
func[a][m: copy#()foreach w sort a[k: length? w
unless m/:k[put m k copy[]]append m/:k w]sort/skip to[]m 2]
```
[Try it online!](https://tio.run/##NY5PS8QwEMXv/RSP7kVP6xp66UVBUBAE8RpyiMl0G5smIX@2dr98TRe8zJt5w@/NRNLbF2kumqHfhuIUl4LPPZQP6@HufvCRpBqxIPmYIfnUw5I75/EJS1OcpZQwH/uJh5IxY7qBXAgZAjl9W2ERO3xMkwnInosZj2IL0X8TBvD2xWtq0b55O1SRTtdaPePOezNKux@kVIcPyrIVzT@agjW5uisuLK5gv4qdTszVPx7yyCJ@SpfRsXhhGqWDM44hmOv1ucPhvaRsFL36@GlL9m0Nk4q2Pw "Red – Try It Online")
[Answer]
[JULIA](https://julialang.org)  
Some 55 bytes:  
```
H(l,L=length.(l))=sort([(v,l[L.==v]) for v in Set(L)])
```
[Try](https://tio.run/##PU49a8MwEN31Kw5liAQi1AiPgkKhDcGBQkfjQcRKrKCejHwSSf68Ky9d3he8u3fPwdvmsa5HEVRngsMbTQcRpDRLTCR6UVTou4MxZZBwjQkKeIQfR6KTg2SMjZas6RlAzz/i6LjiXzFcK1kcK9bM420Tkw3bebdUc3Zk@aBqa5mDJ8HPTyg6PUE/LrppNBL8vtGkE9xzS9DqVPQIuQX0qGH2r9d7C7tTXshf3GdM3yFT5GoPe8kGxv53buPqkzl5pIDiKIqUzOG4rn8) it online  
]