Thank you very much! This helped me out so much. If i may ask one more question how would i use "Manipulate" to see how the function increases step by step??

m=4;
Flatten[Table[{x,y}n,{n,m}]]
Flatten[Table[{x,y}n,{n,Range[m]}]]
Flatten[Table[{n x,n y},{n,m}]]
Flatten[Table[{n x,n y},{n,Range[m]}]]
Flatten[Table[n v,{n,m},{v,{x,y}}]]
Flatten[Table[n v,{n,Range[m]},{v,{x,y}}]]
Flatten[Transpose[{x Range[m],y Range[m]}]]
Flatten[#{x,y}&/@Range[m]]
Flatten[{# x,# y}&/@Range[m]]
Flatten[Range[m]#&/@{x,y},{2,1}]
Flatten[Outer[Times,Range[m],{x,y}]]
Flatten[Reap[Do[Sow[n{x,y}],{n,m}]][[2]]]
Flatten[Reap[Do[Sow[n{x,y}],{n,Range[m]}]][[2]]]
Flatten[Reap[Do[Sow[n v],{n,m},{v,{x,y}}]][[2]]]
Flatten[Reap[Do[Sow[n v],{n,Range[m]},{v,{x,y}}]][[2]]]
Flatten[Transpose[Partition[Reap[Do[Sow[n v],{v,{x,y}},{n,Range[m]}]][[2,1]],m]]]
Join@@Table[{x,y}n,{n,m}]
Join@@Table[{x,y}n,{n,Range[m]}]
Join@@Table[{n x,n y},{n,m}]
Join@@Table[{n x,n y},{n,Range[m]}]
Join@@Table[n v,{n,m},{v,{x,y}}]
Join@@Table[n v,{n,Range[m]},{v,{x,y}}]
Join@@Transpose[{x Range[m],y Range[m]}]
Join@@(#{x,y}&/@Range[m])
Join@@({# x,# y}&/@Range[m])
Join@@(Outer[Times,Range[m],{x,y}])
Join@@Reap[Do[Sow[n{x,y}],{n,m}]][[2,1]]
Join@@Reap[Do[Sow[n{x,y}],{n,Range[m]}]][[2,1]]
Join@@Reap[Do[Sow[n v],{n,m},{v,{x,y}}]][[2]]
Join@@Reap[Do[Sow[n v],{n,Range[m]},{v,{x,y}}]][[2]]
Join@@Transpose[Partition[Reap[Do[Sow[n v],{v,{x,y}},{n,Range[m]}]][[2,1]],m]]
Cases[Table[{x,y}n,{n,m}],_,{2}]
Cases[Table[{x,y}n,{n,Range[m]}],_,{2}]
Cases[Table[{n x,n y},{n,m}],_,{2}]
Cases[Table[{n x,n y},{n,Range[m]}],_,{2}]
Cases[Table[n v,{n,m},{v,{x,y}}],_,{2}]
Cases[Table[n v,{n,Range[m]},{v,{x,y}}],_,{2}]
Cases[Transpose[{x Range[m],y Range[m]}],_,{2}]
Cases[(#{x,y}&/@Range[m]),_,{2}]
Cases[({# x,# y}&/@Range[m]),_,{2}]
Cases[(Outer[Times,Range[m],{x,y}]),_,{2}]
Cases[Reap[Do[Sow[n{x,y}],{n,m}]][[2,1]],_,{2}]
Cases[Reap[Do[Sow[n{x,y}],{n,Range[m]}]][[2,1]],_,{2}]
Cases[Reap[Do[Sow[n v],{n,m},{v,{x,y}}]][[2]],_,{2}]
Cases[Reap[Do[Sow[n v],{n,Range[m]},{v,{x,y}}]][[2]],_,{2}]
Cases[Transpose[Partition[Reap[Do[Sow[n v],{v,{x,y}},{n,Range[m]}]][[2,1]],m]],_,{2}]

Module[{j={}},Do[AppendTo[j,n v],{n,m},{v,{x,y}}];j]

Module[{b={x,y}},Join@@Array[#1 b[[#2]]&,{m,2}]]
Join@@Module[{b={x,y}},Array[#1 b[[#2]]&,{m,2}]]
Module[{b={x,y}},Flatten[Array[#1 b[[#2]]&,{m,2}]]]
Flatten[Module[{b={x,y}},Array[#1 b[[#2]]&,{m,2}]]]

Riffle[Range[m] x,Range[m] y]

Times@@@Tuples[{Range[m],{x,y}}]
Flatten[Transpose[Partition[Times@@@Tuples[{{x,y},Range[m]}],m]]]
Join@@Transpose[Partition[Times@@@Tuples[{{x,y},Range[m]}],m]]

MapIndexed[#1 Ceiling[#2[[1]]/2] &, Join @@ ConstantArray[{x, y}, m]]
MapIndexed[#1 Round[#2[[1]]/2 + 0.25] &, Join @@ ConstantArray[{x, y}, m]]

As I said, you can do nearly infinite different ways, with slightly different notation and combinations of techniques: pick your favorite!

In[5]:= Flatten[#*{x, y} & /@ Range[5]]

Out[5]= {x, y, 2 x, 2 y, 3 x, 3 y, 4 x, 4 y, 5 x, 5 y}

There are many different ways of doing this, for the case of 2 variables (x and y) the most elegant way is using Riffle:

Riffle[Range[m] x, Range[m] y]

where m is the length of the integers. There are several possibilities:

Flatten[Table[{x, y}*n, {n, m}]]
Flatten[Table[{n*x, n*y}, {n, m}]]
Flatten[Transpose[{x Range[m], y Range[m]}]]
RepeatedTiming[Flatten[Outer[Times, Range[m], {x, y}]];]
Riffle[Range[m] x, Range[m] y]

We can test which is the fastest given a certain m:

ClearAll[GetTiming]
GetTiming[m_] := Module[{out},
  out = {RepeatedTiming[Flatten[Table[{x, y}*n, {n, m}]];],
     RepeatedTiming[Flatten[Table[{n*x, n*y}, {n, m}]];],
     RepeatedTiming[Flatten[Transpose[{x Range[m], y Range[m]}]];],
     RepeatedTiming[Riffle[Range[m] x, Range[m] y];],
     RepeatedTiming[Flatten[Outer[Times, Range[m], {x, y}]];]
     }[[All, 1]];
  {m, #} & /@ out
  ]
all = GetTiming /@ DeleteDuplicates[Round[PowerRange[1, 10000, 1.5]]];
ListLogLogPlot[Transpose[all], PlotLegends -> Automatic, Joined -> True, PlotRangePadding -> Scaled[.05], Frame -> True]

giving:

@Arnoud Martijn Buzing ™'s, @Frank Kampas's and my solutions are tied. Now it comes down to conceptionally the easiest and generality, which is considered better....

Note that I optimized Frank's code...

There are multiple ways of doing this.

One possibility is to first construct these {n x,n y} pairs using Table:

t = Table[ {n*x,n*y}, {n,4}]  (* gives you {{x,y},{2x,2y},{3x,3y},{4x,4y}} *)

Then you can Flatten that list:

Flatten[t]  (* gives you {x,y,2x,2y,3x,3y,4x,4y} *)

In[6]:= Flatten[Table[{x, y}*n, {n, 5}]]

Out[6]= {x, y, 2 x, 2 y, 3 x, 3 y, 4 x, 4 y, 5 x, 5 y}