Size Does Matter (at least referring to bottles)

Question

Introduction

I have an even number of bottles, all of different sizes. Unfortunately, I only know the size of the smallest bottle: 300ml.
I also know the following:

• Half of the bottles are twice the size of the other half, meaning that the smallest small bottle and the smallest large bottle are in a ratio of 2:1.
• The smaller bottles, from smallest to largest, increase in size by n%, where n is the number of bottles multiplied by 3.

Could you help find what sizes my bottles are?

Challenge

Your input is to be an even number of bottles.
The output should be the size of all of the small bottles (from smallest to largest), then all of the large bottles (from smallest to largest).

Example I/O

In: 2
Out: 300, 600

In: 4
Out: 300, 336, 600, 672

In: 10
Out: 300, 390, 507, 659.1, 856.83, 600, 780, 1014, 1318.2, 1713.66

(Note: commas are unnecessary; this answer can be formatted in any way you want as long as all of the "small" bottles come before the "large" bottles.)

Rules

Standard loophole rules apply.
This is code-golf, so shortest answer in bytes wins!

Winners

Esoteric Languages
15 bytes
05AB1E by Kevin Cruijssen

Standard Languages
36 bytes
Mathematica by attinat

Answer 1

Python 2, 61 60 59 bytes

lambda n:[a*(1+.03*n)**i*75for a in 4,8for i in range(n/2)]

Try it online!

_{-1 byte, thanks to Joseph Sible}

Answer 2

Wolfram Language (Mathematica), 36 bytes

{#,2#}&[300(1+.03#)^Range[0,#/2-1]]&

Try it online!

Answer 3

05AB1E, 15 bytes

₆v;F.03*>NmyтP,

Port of @TFeld's Python 2 answer, so make sure to upvote him.

Try it online or verify all test cases.

Explanation:

₆                # Push builtin integer 36
 v               # Loop `y` over both digits:
  ;              #  Halve the (implicit) input-integer
   F             #  Inner loop `N` in the range [0, input/2):
    .03*         #   Multiply the (implicit) input by 0.03
                 #   (alternative 4-byter: `т/3*` # divide by 100, multiply by 3)
        >        #   Increase this by 1
         Nm      #   Take it to the power `N`
           yт    #   Push both `y` and 100
             P   #   And take the product of the entire stack
              ,  #   Then pop and print this number with trailing newline

Answer 4

Jelly, 16 bytes

×.03‘*HḶ$×300;Ḥ$

Try it online!

-2 bytes thanks to Nick Kennedy

Explanation

×.03‘*HḶ$×300;Ḥ$  Main Link
×.03              Multiply the number of bottles by 3%
    ‘             Increment (add 100%)
     *            (Vectorized) exponent to the power of:
      HḶ$         [0, 1, ..., n-1]
         ×300     Multiply each factor by 300
             ;Ḥ$  Double the list and append it

Answer 5

Haskell, 47 bytes

f n=[75*a*(1+0.03*n)**i|a<-[4,8],i<-[0..n/2-1]]

Try it online!

Answer 6

Julia 1.0, 42 38 bytes

f(n,z=[75*(1+.03n).^(0:n÷2-1)])=4z,8z

-4 bytes using ideas from John and Joseph Sible.

Try it online!

Answer 7

Python 2, 55 bytes

n=input()/2
for c in 4,8:exec"print c*75;c*=1+.06*n;"*n

Try it online!

The *75 trick is taken from other answers.

Answer 8

JavaScript (Node.js), 63 bytes

f=(n,b=300,r=1+n*9/b,h=n/2)=>n?[b,...f(n-1,--h?b*r:600,r,h)]:[]

Try it online!

Answer 9

PHP, 70 62 bytes

for($s=300;$i++<$n=$argn;$s=$n/2-$i?$s+$s*$n*.03:600)echo$s,_;

Try it online!

Output numbers are seperated by _.

Alternative for $s+$s*$n*.03 can be $s*=1+$n*.03 too, but both are same length.

Answer 10

PowerShell, 66 54 bytes

^{-12 bytes thanks to mazzy}

param($n)300,600|%{$y=$_;1..($n/2)|%{$y;$y*=1+$n*.03}}

Try it online!

Answer 11

Icon, 60 58 bytes

procedure f(n)
write(!36*(1+.03*n)^(0to n/2-1)*100)&\z
end

Try it online!

Saved 2 bytes by replacing (3|6)(alternate 3 with 6) with !36. !generates the components of a data object. When applied to a number it generates its digits. In Unicon - the descendent of Icon - !n generates the numbers in the range 1..n.

Answer 12

Ruby, 57 53 bytes

->n{n.times.map{|a|300*(1+a*2/n)*(1+0.03*n)**a%=n/2}}

Try it online!

Answer 13

K (oK), 32 bytes

{s,2*s:(-1+x%2)((1+.03*x)*)\300}

Try it online!

Answer 14

Charcoal, 23 bytes

ＮθＦ²Ｅ⊘θＩ×׳⁰⁰⊕ιＸ⊕×θ·⁰³κ

Try it online! Link is to verbose version of code. Outputs each list element on a separate line. Explanation:

Ｎθ

Input n

Ｆ²

Loop i twice, once for the small sizes, once for the large sizes.

Ｅ⊘θ

Loop k over half of the number of bottles, and implicitly output each calculation on its own line.

Ｉ×׳⁰⁰⊕ιＸ⊕×θ·⁰³κ

Calculate 300(i+1)(.03n+1)ᵏ and cast the result to string.

Answer 15

Forth (gforth), 84 bytes

: x dup 2/ 0 do fdup f. fover f* loop ; : f dup s>f .03e f* 1e f+ 3e2 x 6e2 fnip x ;

Try it online!

Code Explanation

\ helper function to extract out common logic from the small and large numbers
: x               \ start a new word definition
  dup 2/          \ duplicate the input and divide by 2
  0 do            \ loop from 0 to n/2
    fdup f.       \ print the top of the floating point stack
    fover f*      \ multiple the top float stack value by the 2nd float stack value
  loop            \ end the loop
;

: f               \ start a new word definition
  dup s>f         \ duplicate n and place a copy on the float stack
  0.03e f*        \ multiple by 0.03 (multiply by 3 and divide by 100)
  1e f+           \ add 1 to get our increase multiplier
  3e2 x           \ print the smaller numbers by starting with 300
  6e2 fnip x      \ drop the remaining small number and print the large numbers from 600
;                 \ end word definition

Answer 16

Pyth, 23 bytes

Fk2Fb/Q2*300*hk^h*.03Qb

Try it online!

Port of @TFeld's answer, which I was able to make decently concise. Cant help but feel like there's a more clever answer with Pyth but I wasnt able to find it.

How it Works

Fk2Fb/Q2*300*hk^h*.03Qb
Fk2                     - For k in range(2)
   Fb/Q2                - For b in range(input/2)
        *300*hk         - 300 times k+1 times...
                h*.03Q  - 1 + 0.03 times input
               ^      b - The above to the exponent b
                          Implicitly prints the result

Answer 17

Wolfram Language (Mathematica), 40 bytes

Two independent 40-byte answers: the first is an unnamed function, the second is a named function g, both taking one argument.

Table[300i(1+.03#)^j,{i,2},{j,0,#/2-1}]&

g@n_:=300#(1+.03n)^(#2-1)&~Array~{2,n/2}

Answer 18

R, 46 bytes

x=scan();b=300*(1+0.03*x)^(0:(x/2-1));c(b,b*2)

Try it online

Answer 19

Java 8, 89 bytes

n->{for(int k=0,i;++k<3;)for(i=0;i<n/2;)System.out.println(Math.pow(.03*n+1,i++)*k*300);}

Port of @TFeld's Python 2 answer, so make sure to upvote him.

Try it online.

Explanation:

n->{                              // Method with integer parameter and no return-type
  for(int k=0,i;++k<3;)           //  Loop `k` in the range (0,3) (basically [1,2]):
    for(i=0;i<n/2;)               //   Inner loop `i` in the range [0, i/2):
      System.out.println(         //    Print with trailing newline:
        Math.pow(.03*n            //     `n` multiplied by 0.03
                 +1               //     incremented by 1
                   ,i++)          //     to the power `i`
                        *k*300);} //     multiplied by `k` and 300

Answer 20

Wren, 79 bytes

Fn.new{|n|
for(a in[300,600])for(i in 1..n/2){
System.print(a)
a=a+a*n*0.03
}
}

Try it online!

Wren, 81 bytes

TField answer turns out to be longer.

Fn.new{|n|
for(i in 0...n/2)for(a in[3,6])System.print(a*(1+0.03*n).pow(i)*100)
}

Try it online!

Answer 21

Japt, 27 23 bytes

_+3/L*Z*U}h[300]Uz
cUmÑ

Try it

_+3/L*Z*U} // function returning next element
h[300]Uz // runs the above func. U/2 times, starting from 300
cU®Ñ // concat the array obtained with the array multiplied * 2

Saved 4 thanks to @Shaggy

Answer 22

C (gcc), 79 74 77 bytes

78 if the dash in compile arg is ignored. Port of TField answer. Increase in bytes is to comply with rules.

-5 bytes thanks to ceilingcat and bznein

b;c;f(a){for(b=0;++b<3;c=0)while(c<a/2)printf("%f ",pow(.03*a+1,c++)*b*300);}

Try it online!

Answer 23

Husk, 20 bytes

S+mDmo*300`^→*.03¹ŀ½

Try it online! A port of the standard answer.