[Question]
  [
This isn't very widely known, but what we call the Fibonacci sequence, AKA
```
1, 1, 2, 3, 5, 8, 13, 21, 34...
```
is actually called the *Duonacci* sequence. This is because to get the next number, you sum the previous 2 numbers. There is also the *Tribonacci* sequence,
```
1, 1, 1, 3, 5, 9, 17, 31, 57, 105, 193, 355, 653, 1201...
```
because the next number is the sum of the previous 3 numbers. And the *Quadronacci* sequence
```
1, 1, 1, 1, 4, 7, 13, 25, 49, 94, 181, 349, 673...
```
And everybody's favorite, the *Pentanacci* sequence:
```
1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129...
```
And the *Hexanacci* sequence, the *Septanacci* sequence, the *Octonacci* sequence, and so on and so forth up to the N-Bonacci sequence.
The N-bonacci sequence will always start with **N** 1s in a row.
# The Challenge
You must write a function or program that takes two numbers *N* and *X*, and prints out the first *X* N-Bonacci numbers. N will be a whole number larger than 0, and you can safely assume no N-Bonacci numbers will exceed the default number type in your language. The output can be in any human readable format, and you can take input in any reasonable manner. (Command line arguments, function arguments, STDIN, etc.)
As usual, this is Code-golf, so standard loopholes apply and the shortest answer in bytes wins!
# Sample IO
```
#n,  x,     output
 3,  8  --> 1, 1, 1, 3, 5, 9, 17, 31
 7,  13 --> 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
 1,  20 --> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 30, 4  --> 1, 1, 1, 1       //Since the first 30 are all 1's
 5,  11 --> 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129
```
  
[Answer]
## Boolfuck, 6 bytes
```
,,[;+]
```
> 
> You can safely assume no N-Bonacci numbers will exceed the default number type in your language.
> 
> 
> 
The default number type in Boolfuck is a bit. Assuming this also extends to the input numbers N and X, and given that N>0, there are only two possible inputs - 10 (which outputs nothing) and 11 (which outputs 1).
`,` reads a bit into the current memory location. N is ignored as it must be 1. If X is 0, the loop body (surrounded by `[]`) is skipped. If X is 1, it is output and then flipped to 0 so the loop does not repeat.
[Answer]
## Python 2, 79 bytes
```
n,x=input()
i,f=0,[]
while i<x:v=[sum(f[i-n:]),1][i<n];f.append(v);print v;i+=1
```
[Try it online](http://ideone.com/fork/fHjGyW)
[Answer]
## Haskell, 56 bytes
```
g l=sum l:g(sum l:init l)
n#x|i<-1<$[1..n]=take x$i++g i
```
Usage example: `3 # 8`-> `[1,1,1,3,5,9,17,31]`.
How it works
```
i<-1<$[1..n]           -- bind i to n copies of 1
take x                 -- take the first x elements of
       i++g i          -- the list starting with i followed by (g i), which is
sum l:                 -- the sum of it's argument followed by
      g(sum l:init l)  -- a recursive call to itself with the the first element
                       -- of the argument list replaced by the sum
```
[Answer]
# Pyth, 13
```
<Qu+Gs>QGEm1Q
```
[Test Suite](http://pyth.herokuapp.com/?code=%3CQu%2BGs%3EQGEm1Q&input=3%0A8&test_suite=1&test_suite_input=3%0A8%0A7%0A13%0A1%0A20%0A30%0A4%0A5%0A11&debug=0&input_size=2)
Takes input newline separated, with `n` first.
### Explanation:
```
<Qu+Gs>QGEm1Q  ##  implicit: Q = eval(input)
  u      Em1Q  ##  read a line of input, and reduce that many times starting with
               ##  Q 1s in a list, with a lambda G,H
               ##  where G is the old value and H is the new one
   +G          ##  append to the old value
     s>QG      ##  the sum of the last Q values of the old value
<Q             ##  discard the last Q values of this list
```
[Answer]
# Javascript ES6/ES2015, ~~107~~ ~~97~~ ~~85~~ 80 Bytes
Thanks to @user81655, @Neil and @ETHproductions for save some bytes
---
```
(i,n)=>eval("for(l=Array(i).fill(1);n-->i;)l.push(eval(l.slice(-i).join`+`));l")
```
[try it online](https://jsfiddle.net/n83n11ej/12/)
---
Test cases:
```
console.log(f(3,  8))// 1, 1, 1, 3, 5, 9, 17, 31
console.log(f(7,  13))// 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
console.log(f(5,  11))// 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129
```
[Answer]
## ES6, 66 bytes
```
(i,n)=>[...Array(n)].map((_,j,a)=>a[j]=j<i?1:j-i?s+=s-a[j+~i]:s=i)
```
Sadly `map` won't let you access the result array in the callback.
[Answer]
# Jelly, 12 bytes
```
ḣ³S;
b1Ç⁴¡Uḣ
```
[Try it online!](http://jelly.tryitonline.net/#code=4bijwrNTOwpiMcOH4oG0wqFV4bij&input=&args=Nw+MTM)
### How it works
```
b1Ç⁴¡Uḣ  Main link. Left input: n. Right input: x.
b1       Convert n to base 1.
    ¡    Call...
  Ç        the helper link...
   ⁴       x times.
     U   Reverse the resulting array.
      ḣ  Take its first x elements.
ḣ³S;     Helper link. Argument: A (list)
ḣ³       Take the first n elements of A.
  S      Compute their sum.
   ;     Prepend the sum to A.
```
[Answer]
## Python 2, 55 bytes
```
def f(x,n):l=[1]*n;exec"print l[0];l=l[1:]+[sum(l)];"*x
```
Tracks a length-`n` window of the sequence in the list `l`, updated by appending the sum and removing the first element. Prints the first element each iteration for `x` iterations.
A different approach of storing all the elements and summing the last `n` values gave the same length (55).
```
def f(x,n):l=[1]*n;exec"l+=sum(l[-n:]),;"*x;print l[:x]
```
[Answer]
# [Haskell](https://www.haskell.org/), 47 bytes
```
q(h:t)=h:q(t++[h+sum t])
n?x=take x$q$1<$[1..n]
```
[Try it online!](https://tio.run/##BcFBCoMwEAXQfU/xF1koCeI0LRVpmBP0BCGLLISIJpg6BW@fvpfiuS373lrt0iy9S3PtRGuf9PnLkNDfCl9O4rbgUlXRW3kahhJajmuBQ47HB8d3LQIFb3kyeDFZA@L7aGBHfhg8mSi0Pw "Haskell – Try It Online")
`<$` might have been introduced into Prelude after this challenge was posted.
---
**[Haskell](https://www.haskell.org/), 53 bytes**
```
n%i|i>n=sum$map(n%)[i-n..i-1]|0<1=1
n?x=map(n%)[1..x]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P081sybTLs@2uDRXJTexQCNPVTM6UzdPTy9T1zC2xsDG0NaQK8@@whYmZ6inVxH7PzcxM0/BVgEo6KtQUJSZV6KgohBtbG@ho2Bub2iso2Bob2Sgo2BsYG@io2Bqb2gY@x8A "Haskell – Try It Online")
Defines the binary function `?`, used like `3?8 == [1,1,1,3,5,9,17,31]`. 
The auxiliary function `%` recursively finds the `i`th element of the `n`-bonacci sequence by summing the previous `n` values. Then, the function `?` tabulates the first `x` values of `%`.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
↑§¡ȯΣ↑_B1
```
[Try it online!](https://tio.run/##yygtzv7//1HbxEPLDy08sf7cYiAz3snw////5v8NjQE "Husk – Try It Online")
Starts from the `B`ase-`1` representation of *N* (simply a list of *N* ones) and `¡`teratively sums (`Σ`) the last (`↑_`) *N* elements and appends the result to the list. Finally, takes (`↑`) the first *X* numbers in this list and returns them.
[Answer]
# C#, 109 bytes
```
(n,x)=>{int i,j,k;var y=new int[x];for(i=-1;++i<x;y[i]=i<n?1:k){k=0;for(j=i-n;j>-1&j<i;)k+=y[j++];}return y;}
```
[Try it online!](https://tio.run/##fU/RSsMwFH3vV1z6MFp6O5ZlddY080HwQRQEH3wYfahdHGm3VJN2rox9e02HA4duHMK9yT3n5J7chHmlRdcYqZbw0pparJnz@zZ8lOqTOfkqMwaedbXU2XrnAHw0byuZg6mz2pZNJRfwlEnl@f0Q4L5ReSJVjT9nns5gAbzzFG59PtvZJ5BYYMk2mYaWK/EFPW2bsvdKe5KHhAWBTLasncuUy0TdkpvS35V8dCAUXIaKFbOQDIpEMr8MeDsvgiBley3qRito2b5jjnNXKVOtxPBVy1rYLMI77GdqbTMOHyq7sosuwsKjCNe@D5yDS7AHxQhjJFOkxIXB4JxuikDoifCIKRKK4wgnMca2j@klG4IwHv1rcxaX7OgIYXJqd4ke2RDkz@/H/BSvIiTj2HV85uwtum8 "C# (.NET Core) – Try It Online")
---
```
(n, x) => { 
    int i, j, total; 
    var result = new int[x];
    for (i = -1; ++i < x; ) { //calculate each term one at a time
        total = 0; //value of the current term
        for (j = i - n; j > -1 & j < i;) //sum the last n terms
        {
            total += result[j++]; 
        }
        result[i] = i < n ? 1 : total; //first n terms are always 1 so ignore the total if i < n
    } 
    return result; 
}
```
[Answer]
# [Haskell](https://www.haskell.org), 46 bytes
```
g _ 0=[]
g(h:t)n=h:g(t++[sum$h:t])(n-1)
```
```
g.g[1]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8GCpaUlaboWNw3SFeIVDGyjY7nSNTKsSjTzbDOs0jVKtLWji0tzVYAisZoaebqGmlxptul66dGGsVB9YbmJmXkKtgop-VwKCrmJBb4KBUWZeSVAjkK0QpqCsYIFiKkDZJorGBrD2IYKRgYwtrGBggmMbapgaAhiQ02HuQ4A)
This is based on [xnor's answer](https://codegolf.stackexchange.com/a/70522/) but it employs 1 clever trick.
The \$n\$-bonacci sequence always start with \$n\$ `1`s. A more general version of this might start with just any \$n\$ values. And this more general version is what we implement with `g`. `g` takes a list of \$n\$ integers and a value \$m\$ and gives us a list of the first \$m\$ terms of this generalized \$n\$-bonacci sequence.
The trick is then that `g[1]` is a cheap way to generate \$n\$ `1`s. Since the sequence starting with `[1]` is just an endless stream of `1`s. So we use `g` in two ways, and even though `g` might be slightly longer because it implements something a little more general, it saves bytes because it serves two purposes.
[Answer]
# Java, 82 + 58 = 140 bytes
Function to find the *ith* **n**-bonacci number (**82 bytes**):
```
int f(int i,int n){if(i<=n)return 1;int s=0,q=0;while(q++<n)s+=f(i-q,n);return s;}
```
Function to print first *k* **n**-bonacci number (**58 bytes**):
```
(k,n)->{for(int i=0;i<k;i++){System.out.println(f(i,n));}}
```
[Answer]
# C++11, 360 bytes
Hi I just like this question. I know c++ is a very hard language to win this competition. But I'll thrown a dime any way.
```
#include<vector>
#include<numeric>
#include<iostream>
using namespace std;typedef vector<int>v;void p(v& i) {for(auto&v:i)cout<<v<<" ";cout<<endl;}v b(int s,int n){v r(n<s?n:s,1);r.reserve(n);for(auto i=r.begin();r.size()<n;i++){r.push_back(accumulate(i,i+s,0));}return r;}int main(int c, char** a){if(c<3)return 1;v s=b(atoi(a[1]),atoi(a[2]));p(s);return 0;}
```
I'll leave this as the readable explanation of the code above.
```
#include <vector>
#include <numeric>
#include <iostream>
using namespace std;
typedef vector<int> vi;
void p(const vi& in) {
    for (auto& v : in )
        cout << v << " ";
    cout << endl;
}
vi bonacci(int se, int n) {
    vi s(n < se? n : se, 1);
    s.reserve(n);
    for (auto it = s.begin(); s.size() < n; it++){
        s.push_back(accumulate(it, it + se, 0));
    }
    return s;
}
int main (int c, char** v) {
    if (c < 3) return 1;
    vi s = bonacci(atoi(v[1]), atoi(v[2]));
    p(s);
    return 0;
}
```
[Answer]
[Uiua](https://www.uiua.org/) (version 0.0.7), 34 bytes
```
→(;;)⍥(⊂∶/+↙∶→,⇌.)∶→(-,,)[⍥.-1∶1].
```
[Answer]
# APL, 21
```
{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}
```
This is a function that takes *n* as its left argument and *x* as its right argument.
Explanation:
```
{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}
                   ⍺/1  ⍝ begin state: X ones    
                  +     ⍝ identity function (to separate it from the ⍵)
    ⍺{         }⍣⍵     ⍝ apply this function N times to it with X as left argument
      ⍵,               ⍝ result of the previous iteration, followed by...
        +/              ⍝ the sum of
          ⍺↑            ⍝ the first X of
            ⌽          ⍝ the reverse of
             ⍵         ⍝ the previous iteration
 ⍵↑                    ⍝ take the first X numbers of the result
```
Test cases:
```
      ↑⍕¨ {⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1} /¨ (3 8)(7 13)(1 20)(30 4)(5 11)
 1 1 1 3 5 9 17 31                       
 1 1 1 1 1 1 1 7 13 25 49 97 193         
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
 1 1 1 1                                 
 1 1 1 1 1 5 9 17 33 65 129              
```
[Answer]
# Python 3, 59
Saved 20 bytes thanks to FryAmTheEggman.
Not a great solution, but it'll work for now.
```
def r(n,x):f=[1]*n;exec('f+=[sum(f[-n:])];'*x);return f[:x]
```
Also, here are test cases:
```
assert r(3, 8) == [1, 1, 1, 3, 5, 9, 17, 31]
assert r(7, 13) == [1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193]
assert r(30, 4) == [1, 1, 1, 1]
```
[Answer]
# C, 132 bytes
The recursive approach is shorter by a couple of bytes.
```
k,n;f(i,s,j){for(j=s=0;j<i&j++<n;)s+=f(i-j);return i<n?1:s;}main(_,v)int**v;{for(n=atoi(v[1]);k++<atoi(v[2]);)printf("%d ",f(k-1));}
```
## Ungolfed
```
k,n; /* loop index, n */
f(i,s,j) /* recursive function */
{
    for(j=s=0;j<i && j++<n;) /* sum previous n n-bonacci values */
        s+=f(i-j);
    return i<n?1:s; /* return either sum or n, depending on what index we're at */
}
main(_,v) int **v;
{
    for(n=atoi(v[1]);k++<atoi(v[2]);) /* print out n-bonacci numbers */
        printf("%d ", f(k-1));
}
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~144~~ ~~124~~ 122 bytes
-20 bytes thanks to [Nitroden](https://codegolf.stackexchange.com/users/69059/nitrodon)
This is my first Brain-Flak answer, and I'm sure it can be improved. Any help is appreciated.
```
(([{}]<>)<{({}(()))}{}>)<>{({}[()]<<>({<({}<({}<>)<>>())>[()]}{})({}<><({({}<>)<>}<>)>)<>>)}{}<>{({}<{}>())}{}{({}<>)<>}<>
```
[Try it online!](https://tio.run/##TYwxCoAwDEV3T/IzOIiDS8hFSoc6CKI4uIacPSYVwaGFn/d46932a9zOdrgDRa2yECvUACIytZiSu4Aqs0A5Rn9JJCxJFCb1Y6AP5t@l7LwVjiB692@5L8M0Pw "Brain-Flak – Try It Online")
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 46 bytes
The generating function of the sequence is:
$$\frac{(n-1)x^n}{x^{n+1}-2x+1}-\frac{1}{x-1}$$
```
(n,m)->Vec(n--/(x-(2-1/x)/x^n)-1/(x-1)+O(x^m))
```
[Try it online!](https://tio.run/##FckxCsMwDIXhq4hMEpVwHLc0S3OFbl2CAyY0JeAYETq4p3ft7fvf03Du8tGywaNg4oNker1XTCIGs@Ag1mQyeUlUVRdLlyfm5SAqQTX@MIBMoOeevpVdiw7WECNuDIGIYZ4dw@gr7gzWNViGoW9wPcO14VYv6z2VPw "Pari/GP – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 60 bytes
```
function(n,m){for(i in 1:m)T[i]=`if`(i>n,sum(T[i-1:n]),1);T}
```
[Try it online!](https://tio.run/##Lcw9CoAwDEDh3VM4JhDBWEVR9BRuIohCIUNT8GcSz15Fun284e1BV699sJdup3gFJYe39TtIKppy63CcZO4XsQvIoHRcDr6ScaszEmM3Pv8CDDWY/KqJTSRTkUeanMrIipgxvA "R – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) , 8 bytes
```
1ẋ?‡W∑*Ḟ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyI1IiwiIiwiMeG6iz/igKFX4oiRKuG4niIsIiIsIjIiXQ==)
```
1ẋ       # [1] * input
   ‡W∑   # Function summing its inputs
  ?   *  # Set the arity to the input
       Ḟ # Generate an infinite list from the function and the vector of 1s.
```
[Answer]
# Julia, 78 bytes
```
f(n,x)=(z=ones(Int,n);while endof(z)<x push!(z,sum(z[end-n+1:end]))end;z[1:x])
```
This is a function that accepts two integers and returns an integer array. The approach is simple: Generate an array of ones of length `n`, then grow the array by adding the sum of the previous `n` elements until the array has length `x`.
Ungolfed:
```
function f(n, x)
    z = ones(Int, n)
    while endof(z) < x
        push!(z, sum(z[end-n+1:end]))
    end
    return z[1:x]
end
```
[Answer]
## Perl 6, ~~52~72~~ 47~67 bytes
```
sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}
```
Requires the module `MONKEY-SEE-NO-EVAL`, because of the following error:
> 
> ===SORRY!=== Error while compiling -e  
> 
>  EVAL is a very dangerous function!!! (use MONKEY-SEE-NO-EVAL to override,  
> 
>  but only if you're VERY sure your data contains no injection attacks)  
> 
>  at -e:1 
> 
> 
> 
```
$ perl6 -MMONKEY-SEE-NO-EVAL -e'a(3,8).say;sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}'
(1 1 1 3 5 9 17 31)
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 22 ~~26~~ bytes
```
1tiXIX"i:XK"tPI:)sh]K)
```
This uses [current release (10.2.1)](https://github.com/lmendo/MATL/releases/tag/10.2.1) of the language/compiler.
[**Try it online!**](http://matl.tryitonline.net/#code=MXRpWElYImk6WEsidFBJOilzaF1LKQ&input=NwoxMwo)
A few extra bytes :-( due to a bug in the `G` function (paste input; now corrected for next release)
### Explanation
```
1tiXIX"      % input N. Copy to clipboard I. Build row array of N ones
i:XK         % input X. Build row array [1,2,...X]. Copy to clipboard I
"            % for loop: repeat X times. Consumes array [1,2,...X]
  t          % duplicate (initially array of N ones)
  PI:)       % flip array and take first N elements
  sh         % compute sum and append to array
]            % end
K)           % take the first X elements of array. Implicitly display
```
[Answer]
# [Perl 6](http://perl6.org), 38 bytes
```
->\N,\X{({@_[*-N..*].sum||1}...*)[^X]} # 38 bytes
```
```
-> \N, \X {
  (
    {
      @_[
        *-N .. * # previous N values
      ].sum      # added together
      ||     # if that produces 0 or an error
      1      # return 1
    } ... *  # produce an infinite list of such values
  )[^X]      # return the first X values produced
}
```
### Usage:
```
# give it a lexical name
my &n-bonacci = >\N,\X{…}
for ( (3,8), (7,13), (1,20), (30,4), (5,11), ) {
  say n-bonacci |@_
}
```
```
(1 1 1 3 5 9 17 31)
(1 1 1 1 1 1 1 7 13 25 49 97 193)
(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
(1 1 1 1)
(1 1 1 1 1 5 9 17 33 65 129)
```
[Answer]
# J, 31 bytes
```
]{.(],[:+/[{.])^:(-@[`]`(1#~[))
```
Ungolfed:
```
] {. (] , [: +/ [ {. ])^:(-@[`]`(1 #~ [))
```
## explanation
Fun times with [the power verb in its gerund form](http://code.jsoftware.com/wiki/Vocabulary/hatco#Gerund_n):
```
(-@[`]`(1 #~ [)) NB. gerund pre-processing
```
Breakdown in detail:
* `] {. ...` Take the first `<right arg>` elements from all this stuff to the right that does the work...
* `<left> ^: <right>` apply the verb `<left>` repeatedly `<right>` times... where `<right>` is specified by the middle gerund in `(-@[`]`(1 #~ [)`, ie, `]`, ie, the right arg passed into the function itself. So what is `<left>`? ...
* `(] , [: +/ [ {. ])` The left argument to this entire phrase is first transformed by the first gerund, ie, `-@[`. That means the left argument to this phrase is the *negative* of the left argument to the overall function. This is needed so that the phrase `[ {. ]` takes the *last* elements from the return list we're building up. Those are then summed: `+/`. And finally appended to that same return list: `] ,`.
* So how is the return list initialized? That's what the third pre-processing gerund accomplishes: `(1 #~ [)` -- repeat 1 "left arg" number of times.
[Try it online!](https://tio.run/##jY/BasMwEETv@oqhPdimsq214iYWpIR8QC89GoeEYJGU0EKcW0h@3R1bOaSlhYoVvJFmlt333neYOxjw9s05ixtdu6e8PmdNsnJxuqjXzTqWx2udJH2iHjJEfu4iaFwcfKfU6zKD1cAMSNMXiL4V30qNijylkNFHgtjvvvvivzBXMDhhshp0Zccof1GYv6P/qjCsYfcfwwrCyfO3/ce2xWnXwu@P3YlubI4tNocDJOrGBuWwhfw2yt3CXOOZUopKqXa7@4SFxyzglCg2sJALc7MYikngcvBI/wU "J – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 41 bytes
```
->a,b{r=[1]*a;b.times{z,*r=r<<r.sum;p z}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ6m6yDbaMFYr0TpJryQzN7W4ukpHq8i2yMamSK@4NNe6QKGqtvZ/WrSxjkUsV0FpSbGCuq6urjpXWrS5jqExmpChjpEBmpCxgY4JmpCpjqFh7H8A "Ruby – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 68 bytes
```
function(n,x){a=1+!1:n;for(i in n+1:x){a[i]=sum(a[(i-n:1)])};a[1:x]}
```
[Try it online!](https://tio.run/##FcnBCoMwDADQ@76iuyUYwdgNR9UvKT2UQSCHRdAJg@G3V3t6h7cWcVNbZLf3VxcDox/@88zNnYONsqygTs1Zw6FG1DRv@wdyBG0tMCY8xhyvTEcR8PTCm8BA7KtMfVf1HT2qT2LGcgI "R – Try It Online")
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~26~~ 24 bytes
```
{(y-x){y,+/x#y}[-x]/x#1}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqlqjUrdCs7pSR1u/QrmyNlq3IhbIMKz9nxZtbm1oFPsfAA "K (ngn/k) – Try It Online")
]