[Question]
  [
Given three distinct numbers from \$1\$ to \$7\$, output three other distinct numbers from \$1\$ to \$7\$, that is having no numbers in common with the original numbers. Your code must produce a different output set for each possible input set. That is, no two inputs can produce the same output, treating both as unordered sets. Other than that, you can implement whatever mapping you want.
More mathematically, you're asked to give a bijection (one-to-one function) \$f:S \to S\$ where \$S\$ consists of three-element subsets of \$\{1,2,3,4,5,6,7\}\$, such that \$f(s) \cap s = \emptyset\$ for every \$s\in S\$. As a bijection, this mapping has to be invertible, though you don't have to provide the inverse function in your code.
[Here are the 35 possible triples](https://tio.run/##RcvBCoMwDADQ8/IVObZMBupBEPoxOrotaJOSxINf323ssHd/9fSX8NAalSrqSJ7VRXYD4DTBlkbgoxgm1IWfOfQd8rWPAA9RtGO1/Dn8b7e7lJV4cRK28K0dbnGGS1Vix53Mw6/F1t4) (written [space-separated](https://tio.run/##RczBCsIwDADQs/mKsFOLYzA9CMK@RDxsUjVuTUqTwfz6avHgB7yX3vYUPpRCMUk2JAvZRBYF4OEE83AEXqPigHnkR3B9i7zvPcBdMuo6afga/rPuJnEiHo2E1VXa4uzPsEuZ2LDBpnsJsbuoZbd5rM1Wh4XU3C/0V1/KBw)).
**I/O**
The format of the three-element sets is flexible. You can take the inputs in sorted order as three numbers or a three-element list/array/tuple, or as a set. You may not, however, require ordered inputs in a specific order other than sorted. You may zero index.
You may also use a sequence of seven bits of which three are on. This seven-bit sequence can also be represented as as a decimal number, byte, or character.
Output can be given in any of these formats, with the further allowance that ordered outputs don't have to be sorted.
  
[Answer]
# [Python 3](https://docs.python.org/3/), 43 bytes
```
lambda s:([*{*range(7)}-s]*4)[-sum(s):][:3]
```
**[Try it online!](https://tio.run/##VY67bsMwDEV3fQWRiTSaLm5QQIC/xPGg1FIiQA9DpIfC8Lc7Sp0ADcfLc8g7/cotp3Zz3XkLJl5GA6yxb5ammHS1@E3rkYfmi/ojzxGZ9NDrdthcyRG82CI5BwYfp1wEfnK8@GTE58RKFctzEIYO2AqScrlARdMbhq8/H9CSVlBn96rm8CEy0V88FZ8E3WHhVcOyQ@uB/in8acYRZZ6CRa597Ij7guoJZZhrXQw2PVMm6DpoT7TdAQ "Python 3 – Try It Online")**
[Answer]
# [Python 3](https://docs.python.org/3/), 53 bytes
```
def f(b):c=[*{*range(7)}-b];del c[-sum(b)%4];return c
```
[Try it online!](https://tio.run/##RY5NCoMwEIXX5hSDUIiibiwUKvYi4iKJsQ3oJGTGRSk9u03B0t3H4/2FJz88tvs@2RlmqYur6YfyVUaFdysvxbvWYzfZBcxQ07Ymw@k8dtHyFhHM7tbgI4NjG9n7hYSIlraFCXoYRiFmH4HA4d/RGL9qh4qdR5K/mQra4ioylWJkWVIhMp14lipRiA5Zqgry/pZXoJOkiFIfaEDP3/pjVWQHNCoEi1O6u38A "Python 3 – Try It Online")
-3 bytes thanks to FryAmTheEggman  
-4 bytes by zero-indexing  
-1 byte thanks to xnor
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9 8~~ 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
7RṚḟṙSḊ
```
A monadic Link accepting a list of the three numbers, from \$[1,7]\$, in sorted order which yields a list of other numbers, from \$[1,7]\$, not necessarily sorted.
**[Try it online!](https://tio.run/##ASIA3f9qZWxsef//N1LhuZrhuJ/huZlT4biK////WzEsIDIsIDNd "Jelly – Try It Online")** Or see [all 35](https://tio.run/##RY0xCsJAEEWvsoXlNs7MJuAxtJKQ0ibkApbaCN5AG8HaA2Qh2IgHmVxktVh4xcBjePw3HMbxWEq79Xz36eH5tvPpWr7z5@L5uVrOr@F/y@m9CftSum4dg8SgfQwVDUxgA7YVFVdxFVdxDcEQDCHxTXybikJNqAk1oSbUhJpQE2pCTagpC8qCsqAsKAvKgiEYgiGkiv0P "Jelly – Try It Online") (I sorted the resulting values for easier comparison).
### How?
```
7RṚḟṙSḊ - Link: list A                   e.g.  [2,4,7]
7R      - seven range                          [1,2,3,4,5,6,7]
  Ṛ     - reverse                              [7,6,5,4,3,2,1]
   ḟ    - filter discard (A) -> B              [6,5,3,1]
     S  - sum (A)                              13
    ṙ   - rotate (B) left by (that)            [5,3,1,6]
      Ḋ - remove the leftmost                  [3,1,6]
```
[Answer]
# [R](https://www.r-project.org/), ~~33~~ 31 bytes
*Edit: -2 bytes by using modulo `-4` (which returns the negative of modulo `4`)*
```
(1:7)[v<--scan()][sum(v)%%-4-1]
```
[Try it online!](https://tio.run/##ZZDRSsMwFIbv8xTHSkeCyUXXyaBYQfDaF6hFspraQJfUnGTDp69Ny2ZVyNWfP9/5Ttw40qzYs@r0IAQ20lBWVxiO9MTSVOxEVo8Z2ZKckFtwSpyd9gokQhtM47U14C14hR5k30MjUWFB2vJyO1EWujjVlaCRKyJ4d5exOiLnp6g8wgZs8EPwBYnZW8zKxh4Phu55zpbQKQz9lMth6L/otce3vGVX2rlTvlNuFlqQYMLxoByCdAreNXo92cHTyzMY62GYqMp40GY6q3ZBGulp8moSRiYWxWVqVuT3/LqfZjdUmpVLxXWdapOufWPG2GZDe2U@fEeD0Z9B0f@VsswZmzfBzp4v9q1169/9sZouqI7e0YnFfJDo1W8Z3ti@lwOqMuEJ44l4TPiqtpr/tznPGL8B "R – Try It Online")
Finds the 4 digits in 1..7 that aren't in the input, and excludes the one corresponding to the input sum (wrapping around).
TIO link tests that outputs are unique for each input, and shows output for every input.
```
(1:7)                   # vector of digits 1..7
     [          ]       # select elements
         -scan()        # excluding (negative indexes) input
      v<-               # and define v as (negative) input
                        # (so up to here we have the 4 elements that aren't in the input)  
     [              ]   # from these, select elements
      -                 # excluding (negative index)
       (sum(v)%%4+1)    # the sum of input, modulo 4, plus 1
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 14 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
As [previously advertised](https://codegolf.stackexchange.com/questions/212240/three-other-numbers/212242?noredirect=1#comment499586_212240), I'm a wee bit tipsy so this could well be wrong and, even if right, could probably be golfed a little.
```
7õ kU kÏ¶UxÍu4
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=N/Uga1Uga8%2b2VXjNdTQ&input=WzEsMiwzXQ) or [view (what I think is) the proof](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=N/UK4DMgyysiIC0%2bICIrVWtEIGvPtkR4zXU0)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~39~~ ~~38~~ ~~34~~ 32 bytes
```
ＮθＩ⁻¹²⁷⁺θＸ²⊟Φ⁷№ＥTXdhp﹪×℅λＸ²ι¹²⁷θ
```
[Try it online!](https://tio.run/##TUy7CsJAEOz9ipBqD2JhEERSBoQUpylS2J65QBY29z79/HMDFk4zM8xjXlWYraJSBuNyuufttQTwojuMAU2CXsUEEk2OcGovTTUSK89sP9xrd@HghpTYcdzbzCOpHNTTU6@ubippdSYLE25LhEfQaBQBib8LFOz4fScvfuhKOV/L8U1f "Charcoal – Try It Online") Link is to verbose version of code. I/O is as a 7-bit integer `7..112`. Explanation: The ordinals of the string `TXdhp` have five bit patterns which I have arbitrarily chosen to be such that the result excludes `1`. They are then cyclically rotated until one matches the input, at which point I have determined the excluded bit. This bit is then added to the original input, and finally the difference between `127` and the sum is printed.
```
Ｎθ                                  Cast input to integer
             ⁷                      Literal 7
            Φ                       Filter on implicit range
                TXdhp               Literal string `TXdhp`
               Ｅ                    Map over characters
                        λ           Current character
                       ℅            Ordinal
                      ×             Multiplied by
                          ²         Literal 2
                         Ｘ          Raised to power
                           ι        Outer index
                     ﹪              Modulo
                            ¹²⁷     Literal 127
              №                     Count (i.e. contains)
                               θ    Input
           ⊟                        Pop matching value
          ²                         Literal 2
         Ｘ                          Raised to that power
       ⁺                            Added to
        θ                           Input
   ⁻                                Subtracted from
    ¹²⁷                             Literal 127
  Ｉ                                 Cast to string
                                    Implicitly print
```
I arbitrarily chose the following five bit patterns to exclude `1` but any five even cyclically distinct patterns would work.
```
T   1010100
X   1011000
d   1100100
h   1101000
p   1110000
```
[Answer]
# JavaScript (ES6), ~~66~~ 65 bytes
Takes input as a 3-digit string. Returns a string in the same format.
```
f=(n,k=i=0)=>++k<8?(~n.search(k)||n*43%399%4==i++?'':k)+f(n,k):''
```
[Try it online!](https://tio.run/##VY@9TsMwFIX3PsVdKtskRNTXSWmKW6UbE0NHxBClLrgJTtWkRUIVrx5yYEAsRz4/n2wfykvZVSd/7G9Du3PDsLcyxLX19k7ZVRTVD/dr@RWSzpWn6k3W6noNN4anvFhMjbU@itZC5LWK9sBULsRQkKXnmeaYZtpAUkgGmY/CyBgZI2NkBtbAGtgUpxSnbBQNQoPQIDQIDUKD0CA0CA1Cg2C0jJbRMlpGy2gNrIE1sGk2f1lOJpvx1UXyXh5lILui8TsUkRBKjV3Vhq5tXNK0r1I8BspJjGWRHFofpKCf0b/N07n/3Wz@NjEJiSi4D9q6Xm5U0vlPh1to57veh6qnS9mcXaeEWg7f "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 [bytes](https://github.com/Adriandmen/05AB1E/Codepage)
```
7LsKsO(._¨
```
**[Try it online!](https://tio.run/##RY2xCcMwFAVXUZlCGPzel71AugQygDEhBheuXGipLJAFMkBWUhrBdcfjeHfW13bs7fe5tvleb/VxGZ7fd2vLMuaknLzm1DHAAk7g3NG4xjWucQMhEAKhsBbWqaOoiZqoiZqoiZqoiZqoiZp5MA/mwTyYB/MQCIEQCKXj@gc "05AB1E – Try It Online")**
### How?
```
7LsKsO(._¨ - (push the input)      e.g.: [2,4,7]
7          - push 7                      7,[2,4,7]
 L         - range                       [1,2,3,4,5,6,7],[2,4,7]
  s        - swap top two of the stack   [2,4,7],[1,2,3,4,5,6,7]
   K       - push a without bs           [1,3,5,6]
    s      - swap top two of the stack   [2,4,7],[1,3,5,6]  (implicit input swapped in)
     O     - sum                         13,[1,3,5,6]
      (    - negate                      -13,[1,3,5,6]
       ._  - rotate a left by b          [6,1,3,5]
         ¨ - remove rightmost            [6,1,3]
           - implicit print top of stack [6,1,3]
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~84~~ 83 bytes
Saved a whopping ~~16~~ ~~19~~ 23 bytes thanks to the man himself [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!  
Saved a byte thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil)!!!
```
p;i;f(m){for(p=i=0;(L"᰸ᨴᘬᤲᔪ"[p]>>i%7&m)-m;p+=++i%7<1);p=(64>>i%7)+m^127;}
```
[Try it online!](https://tio.run/##hZPNjpswEIDveQoLaStYJhI2/yJwqXrrG2xSBIRsLAWCEreljehT9NAH6KFa9VBVPfR1eJLsGMhuUFnVwrJn/M2Ph3E2v8@y87kKeLBRC@202R/UKuShEahvlfbX3/bHn/bbz/b77/brg3JXraKI37ivCm1eBJUe6jpKC6oFVag6Vnem6cU7ytygOfNSkCLhparNTjOCQyryusozka/vViQkJ0oZUMPAaYHnge2A74GLewa2Aa4BngU2A9cBywLmge@Ca4JHwfLB8YFRMF2gJlgUmA0O7n0wbaAIMGAOuGB6wDCG1QRdCtk2OdyS46ci3e/6FJRl/YYta/81TlsBci2bymAmM@flOq/RwuhVWCiiSn2COhrgsgiJHRBdT7QOGEEpQgnRJZhK0JFg@gyO4AzhtIczCbsSzjRyGuGXvFIu4mMu0EalZLEgX@aJhsYXIb0WMi34x0d1QC8bVblZk/6bRwTrkABJgUwZyKCHXHxIdhhzow7xXwBFXlSI9fw0Uua1eK7r9fi45btclS6mLv@UC7/fimJ/FPG@zNFRHKfv@U7wMs7E58FaFnPSQRdcD8dOptGrQmF9pKE2DQ537pYo@p/r5uU/clyWGGno1qeX0zUi9u6lqquJNPBhSmp80Mya8yM "C (gcc) – Try It Online")
Takes input as \$3\$ bits set in the least-significant-\$7\$-bits of an `int` and returns the three other numbers likewise.
### Explanation (before some golfs)
```
f(m){                                  // function taking an integer with  
                                       // 3 bits set in its 7 lsb  
                                       // representing the 3 input numbers  
     for(                              // loop over  
         p=L"ᔪᘬᤲᨴ᰸"                     // a sequence of 5 int values:
                                       //   5418,5676,6450,6708,7224
                                       // that are the 5 unique patterns of    
                                       // 3 set bits per 7 bits shifted and
                                       // repeated over 13 bits so that their  
                                       // 7th bit is unset:  
                                       //   5418 = 1010100101010
                                       //   5676 = 1011000101100  
                                       //   6450 = 1100100110010  
                                       //   6708 = 1101000110100  
                                       //   7224 = 1110000111000
                    ;;++p)             // no need to test for stopping  
                                       // since we must match one  
       for(i=7;i--;)                   // loop over shift values from 6 to 0    
         if((*p>>6-i&m)==m)            // if a shifted 7-bit slice of one of  
                                       // our patterns matches m we've found  
                                       // the correct bit to exclude from m's  
                                       // 4 unset bits
            return(1<<i)+m^127;        // add that bit to m and flip the 7   
                                       // lsb so the 3 other unset bits are  
                                       // now set to represent the 3 return
                                       // values  
 }
```
[Answer]
# Ruby, 38 bytes
```
->s{n=s.sum;(([*1..7]-s)*9)[-n..-n+2]}
```
[Try it online!](https://tio.run/##NYxRC4IwFEbf/RUXfdkEL4REBM0/YhJTJw3mVt7todTfvjTq9TvnfFNoX3EQ11hUNDNW5wfEU1MQz88cjSTPCCmMHAc9kYdyjZOiYDyBgLpJ2K5z9O4msXNjq6302llWclSyu0PvYDFLAvAIW5Jms1mhqCCbh9o0a7qB/93lAvuWKNsnX/kHMFj9RNJvBUJAeYwf)
Stealing [Eric's answer](https://codegolf.stackexchange.com/a/212275/98691) which based on [Jonathan's answer](https://codegolf.stackexchange.com/a/212249/65905). I would've commented to Eric, but i do not have enough reputation.
The actual difference: Using a range to get the three elemented slice.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 10 bytes
```
>3-%R7t*5s
```
Takes input as a 3-element list of {0, …, 6}.
[Try it online!](https://tio.run/##K6gsyfj/385YVzXIvETLtPj//2gDHQVDHQWjWAA "Pyth – Try It Online") Or see [all 35 inputs](https://tio.run/##K6gsyfj/381dLznUXMGYS8fdzlhXNci8RMu02N39/38A "Pyth – Try It Online").
### How it works
```
         sQ   sum of input
       *5     multiply by 5
      t       subtract 1
   %R7        take each element of [0, that) mod 7
  -        Q  remove elements present in input
>3            last 3 elements
```
It’s helpful to preserve symmetry under rotations modulo 7, since that leaves just five equivalence classes to consider. A good starting point is the “average” \$\frac{x + y + z}{3}\$, where division by 3 is the same as multiplication by 5 modulo 7. It happens that if we start walking down from the average minus 2, taking the first three numbers that aren’t in the input set, the five equivalence classes are conveniently mapped one-to-one:
* {0, 1, 6} ↦ {3, 4, 5} = {0, 1, 6} + 4
* {0, 2, 5} ↦ {1, 3, 4} = {3, 5, 6} + 5
* {0, 3, 4} ↦ {1, 2, 5} = {0, 3, 4} + 5
* {1, 2, 4} ↦ {0, 3, 5} = {0, 2, 5} + 5
* {3, 5, 6} ↦ {1, 2, 4} = {1, 2, 4} + 0
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
hṙ_Σ¹`-ḣ7
```
[Try it online!](https://tio.run/##AR8A4P9odXNr//9o4bmZX86jwrlgLeG4ozf///9bMiw0LDdd "Husk – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 49 bytes
```
sub{@c=grep!/[@_]/,0..6;splice@c,-sum(@_)%4,1;@c}
```
[Try it online!](https://tio.run/##ZZDRaoMwFIbv@xSppJqMmNR2K6gN5AG2y11ZKZvYLpuNWRIvhvjqc8bC6Ni5OXDO938Hjq5N8zDCEx9t99qLip9NrZesEMeSkTWlu9zqRla1qEhsuwsSR7y6J0kuqmHMF8LV1vHLiy485Rgric/3S4YopneHhIUhQ8U63pX4b2M5TPZwE4Zws4fbIVonm4jSKE3TaNIa7wTvrVQoikgIT0jAI8YEzAc90Ps7oKnV2b2hacf5dtqagSOcL7SRyoFAKt25DADRF7c6ryKzqBwOKvjF287NvDC301kCqrZTXjVXQOc0Df6nryDolPzMJu6j/rJoZfAVHb9b7WSr7Bg/PUrrsuzZyYZPb/0B "Perl 5 – Try It Online")
Just a translation of the python answer from HyperNeutrino.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 40 bytes
```
->s{(([*1..7]-s)*9).last(s.sum).first 3}
```
[Try it online!](https://tio.run/##NYxRC4IwFEbf/RUXfdkEL4REBM0/YhJTJw3mVt7todTfvjTq9TvnfFNoX3EQ11hUNDNW5wfEU1MQz88cjSTPCCmMHAc9kYdyjZOiYDyBgLpJ2K5z9O4msXNjq6302llWclSyu0PvYDFLAvAIW5Jms1mhqCCbh9o0a7qB/93lAvuWKNsnX/kHMFj9RNJvBUJAeYwf "Ruby – Try It Online")
Ruby port of Jonathan's [answer](https://codegolf.stackexchange.com/a/212249/65905).
[Answer]
# [Scala](http://www.scala-lang.org/), 64 bytes
```
b=>1.to(7).diff(b).zipWithIndex.filter(_._2!=b.sum*3%4)map(_._1)
```
[Try it online!](https://tio.run/##Zc4xa8MwEAXgPb/iOgTuihHYDhQKDnT04ClDhlCMZJ@IiiMp1iWEhP521@6SIevje3cvdXrQUzA/3Ak02nngm7DvE3zF@FgBXPUA9hNq3/ON@x2fD7WXb6i2r9Fkqm2uJOAHqd5Zi4bU3cW9k@O/VdYNwiO2qi3eKqPS5fRerjd00nHJcpoAMAcJMB@QsGOZiUksCUtSi0rLX0wZWEyzeC4gWhqNjsqGkXV3xDg6L4On1e/0ZJhnRVbSHw "Scala – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 11 bytes
```
7ɾ$⊍?∑N$ǔṫ$
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=7%C9%BE%24%E2%8A%8D%3F%E2%88%91N%24%C7%94%E1%B9%AB%24&inputs=%5B2%2C4%2C7%5D&header=&footer=)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~35~~ 63 bytes
based on the [hyper-neutrino♦](https://codegolf.stackexchange.com/a/212242/80745)'s solution
+28 bytes thanks @DLosc
```
param($a)$b=1..7|?{$_-notin$a}
$b|%{$s+=$_}
$b|?{$_-ne$b[$s%4]}
```
[Try it online!](https://tio.run/##TZJRa8IwFIXf8ysuEmeLnWCS6lOZsB@wMdmTSGklYw5tXdIyRtvf3mWm9Zinc8/9cs5Dcil/tLGf@nTq@Qcl1PSXzGTngGchz5PlYrFunxqePhZldSx41jGet9OG23nC0@vgt5rnO26nat/1HWObgEXBMiIRkQxvUkHGkCvI9SAlWAlWgpVgFQAFQAGI4cZwV4MUaBNoE2gTaBNoE2gTaBNoE2gTaJNIkEiQSJBIkEiQSFAAFAAFIB4lC6mlKTWM3OGZMdmve16e@tloW58qZzy4V/fb62L3un2ubVWeX/Ivfaj2G3///2zL2hy0uzLx/OS2eRvDJkOuX3X3VZbmCUXDwDoWzOri@F3rWTRzX4uGIdyN@OJQ1kVF7mdRMHqtLY2z3q9s6Il9/wc "PowerShell – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 9 bytes
```
∑5*‹ʁ7%⊍Ḣ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%E2%88%915*%E2%80%B9%CA%817%25%E2%8A%8D%E1%B8%A2&inputs=%5B0%2C1%2C2%5D&header=&footer=)
Porting Pyth saves two bytes.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 17 bytes
```
7LIм{3.$IO(._Dg<£
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f3Mfzwp5qYz0VT38NvXiXdJtDi///jzbSMdExjwUA "05AB1E – Try It Online")
It's a much longer version of the Jelly answer, so go upvote that too.
[Answer]
# APL+WIN, 20 bytes
Prompts for input of a vector of integers
```
3↑(-+/¯2↑n)⌽n←(⍳7)~⎕
```
[Try it online! Thanks to Dyalog Classic](https://tio.run/##LYyxDsFQFIb3PkXHNpQ45159CR6iqVQkTUlMIowljSsMmCwmmwGLxMKbnBepq/2n/5zv//NFkzQYzKJ0PAziNJpOR3Ep20O/J/mOHVmvkpIl33tBo/25kb0yXzbvzLaemHvoL@24tDNHzNmV4jJv2lrMU8xDiqOY1/8w1xouqGnvlv6eLC0Tp@OSy06dCqmRXWRYJaNn9Iye0StwBa7ANX6Nv1slwUfwEXwEH8FH8BF8BB/BR/Ax9ow9Y8/YM/aMvQJX4ApcV/kD "APL (Dyalog Classic) – Try It Online") 
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 13 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
1∘↓+/⌽(⌽⍳7)∘~
```
[Try it online!](https://tio.run/##LYwxCsJAEEV7T5FSEZHM7CYHsDGVYLxAQGIjaGtjIwQRExQRvIWFtY1HmYvENb5i9zPvf16xXY@Wu2K9WbVtbMeHVbfh2M7vfnhWv9JBYPu2tOpidWPNPZvZ6fB5qlXXcOXzSfgX0yxvyyiOJNLePx3pyYRMu1R6pVd6pXdwB3dwz@25ky4Fn@ATfIJP8Ak@wSf4BJ/gU/bKXtkre2Wv7B3cwR3c//IL "APL (Dyalog Unicode) – Try It Online")
This is an atop of a train
```
1∘↓+/⌽(⌽⍳7)∘~
      (⌽⍳7)∘~ ⍝ Right side of the atop
        ⍳7    ⍝ Range
       ⌽      ⍝ Reverse
           ∘  ⍝ Composed with...
            ~ ⍝ ...without (to remove our arguments)
     ⌽        ⍝ Rotated by...
   +/         ⍝ ...the sum of the arguments
1∘↓           ⍝ Left side of the atop
1∘↓           ⍝ Drop leftmost (drop curried with 1)
```
]