[Question]
  [
A doubling sequence is an array of numbers where each subsequent number is at least twice the previous number.
Given an ordered list of numbers, determine if the numbers in the list (\$n\_{x}\$) have the property that:
\$n\_1 \times 2 \le n\_2\$
\$n\_2 \times 2 \le n\_3\ ...\$
and so on until reaching the end of the list.
# Input
A list of two or more numbers.
# Output
Any distinct True or False value.
# Examples:
```
[10,20,30] -> False
[10,20,40] -> True
[1,2,3] -> False
[1,2,4] -> True
[1,2,10] -> True
[1,1] -> False
[10,1] -> False
```
  
[Answer]
# [R](https://www.r-project.org/), ~~27~~ 26 bytes
```
all(diff(log2(scan()))>=1)
```
[Try it online!](https://tio.run/##K/r/PzEnRyMlMy1NIyc/3UijODkxT0NTU9PO1lDzv6GCkYKhwX8A "R – Try It Online")
1 byte saved by Giuseppe.
[Answer]
# Jelly, 4 (5?) bytes
Monadic link taking the list as input.
```
I<ṖẸ
```
If I am allowed to output 0 for Truthy and 1 for Falsy... Otherwise,
```
I<ṖẸ¬
```
You can [try all test cases](https://tio.run/##y0rNyan8/9/T5uHOaQ937Ti05v/h9kdNa/7/j442NNAxMtAxNojV4YKyTSBsHSMdYxjDBMYwhMoZQpUbxsYCAA)!
Notice that \$x\_{i+1} \geq 2x\_i \iff x\_{i+1} - x\_i \geq x\_i\$.
```
 <      Compare
I       the forward differences
  Ṗ     with the original list without the last item.
   Ẹ    Check if any comparison returned true
    ¬   and negate that
```
# Jelly, 6 bytes
We can instead take pairwise quotients and check directly if they satisfy the inequality with this monadic link:
```
÷Ɲ>.Ẹ¬
```
You can [verify all test cases](https://tio.run/##y0rNyan8///w9mNz7fQe7tpxaM3/w@2Pmtb8/x8dbWigY2SgY2wQq8MFZZtA2DpGOsYwhgmMYQiVM4QqN4yNBQA)!
```
÷Ɲ      Compute the quotient for all pairs of elements in the input list.
  >.    See if the elements are greater than 0.5
    Ẹ   and take the "OR" of that list,
     ¬  finishing off with the negation of that.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0, 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ä÷ e§½
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&code=5PcgZae9&input=WzEsMiwxMF0)
```
ä÷ e§½     :Implicit input of array
ä          :Consecutive pairs
 ÷         :  Reduced by division
   e       :All
    §½     :  Less than or equal to 0.5
```
[Answer]
# [Haskell](https://www.haskell.org/), 30 bytes
```
f(x:s)=any(<2)$zipWith(/)s$x:s
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02jwqpY0zYxr1LDxkhTpSqzIDyzJENDX7NYBSjxPzcxM0/BVqGgKDOvREFFITexQCFNITra0EDHyEDH2CBWB8o0ATN1jHSMobQJlDaESBhCVBrGxv4HAA "Haskell – Try It Online")
`True` for false and `False` for true.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~37~~ 29 bytes
-8 bytes thanks to xnor.
Fails for doubling sequences, completes otherwise.
```
f=lambda a,*b:2*a<=b[0]>f(*b)
```
[Try it online!](https://tio.run/##nY89C4NADIb3@xVZxFNS8GuSnlsL3buJw1lPKliVuwj66@1pKaV1a4YkPLz5eIeZ7n0XL0stWvkoKwkS/TKNfHkUZR4UWc390ltIGTIggDPgeRhgFGAcFAhn2Rrl4YcmK73q8Q0xwvhHZ1GyE4W/c@Fu@4d48EcwVvcaCBU0HWx@UgZAel4LgPVJ3tZpZcaWrNntmEVquqmB4NJVajpp3ev0W7e@zSwadNMRdx0DhwxsFsJm1@GELynaz5cn "Python 3 – Try It Online")
# [Python 3](https://docs.python.org/3/), 40 bytes
```
f=lambda a,*b:b==()or 2*a<=b[0]and f(*b)
```
[Try it online!](https://tio.run/##nY@/CoMwHIR3n@LolMivEP9M0nTsE3QThwQTKtgomkKL@OypLRRBt974cXfw9S9/61wWgpWtuutaQVGsCy0l492ANFYnqUtRKVfDsljz4M3oR0iwCKxMBKWCMlERLqodDaeV5h96HR4/SCllm96C8l0p2e6S3ftKOP5IFNnFzZNB4/D1KSL0Q@M8s4fJzzieMS22ns8wzx6TmQ88vAE "Python 3 – Try It Online") Test suite by Noodle9.
[Answer]
# JavaScript (ES6), ~~26~~ 24 bytes
*Saved 2 bytes thanks to @Grimmy*
```
a=>!a.some(n=>2*a>(a=n))
```
[Try it online!](https://tio.run/##fc2xDsIgEIDh3ac4NzDYHrQrjD6Bm2G4VGo0yJmivj5qotFEZf/y/we6Uh6m/em8TLwNZbSFrJtTk/kYRLLOLMgJsknKMnDKHEMTeSdGsdGoDKoOvZTQtrCimMPsp@lfZj1dvokyqvMAUMvcTf82/zIafZ3oR6N@wif6MOUG "JavaScript (Node.js) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 4 bytes
```
Λ·≤D
```
[Try it online!](https://tio.run/##yygtzv7//9zsQ9sfdS5x@f//f7ShjpGOoUEsAA "Husk – Try It Online")
Returns 0 if False, a positive number if True.
```
Λ     Check if adjacent pairs of elements satisfy the predicate
 · D    by doubling the first number
  ≤     and checking if the second number is less than it
```
[Answer]
# [Dyalog APL](https://www.dyalog.com/), 8 bytes
```
∧/2≤2÷/÷
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhEcdy/WNHnUuMTq8Xf/wdqCYgqGBgpGBgrEBF4xpAmYqGCkYQ2kTKG0IkTCEqDQEAA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 18 bytes
```
@(e)istril(e<2*e')
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999BI1Uzs7ikKDNHI9XGSCtVXfN/mka0oYGOkYGOsUGsJhecZwLk/QcA "Octave – Try It Online")
Octave has a nice feature known as broadcasting. Here, we take broadcast less-than of the input and the input doubled, by transposing the input. This creates a matrix of ones and zeroes. Iff this matrix is lower triangular (no nonzero entries above the diagonal), the sequence is a doubling sequence.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 31 bytes
```
->l{x,*l=l;l.all?{|y|x*2<=x=y}}
```
[Try it online!](https://tio.run/##NcqxCoAgEIDhV2mOS9Tc6upB5AYbmi6IIDhRn92GdPvg/5/3iPXEOm2cBEZGXlgF5j3lmGW0KwrGUqr3RoPVMGuCodn9Bgtzh@swrZm2GyJ1hTtlyffgBU4vRKV@ "Ruby – Try It Online")
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-rR`, ~~15~~ 13 bytes
```
1&÷{!;|":'½≤⑾
```
[Try it online!](https://tio.run/##y05N///fUO3w9mpF6xolK/VDex91Lnk0cd///9GGOgpGOgrGsf91i4IA "Keg – Try It Online")
*-2 bytes thanks to @a'\_'*
## Answer History
### 15 Bytes
```
1&÷^{!;|":'2*≥⑾
```
[Try it online!](https://tio.run/##y05N///fUO3w9rhqResaJSt1I61HnUsfTdz3/3@0oY6CkY6Ccex/3aIgAA "Keg – Try It Online")
I'm quite happy with this answer, and I'm quite happy with the explanation. 
**Explained**
```
1&
```
First, we store the number 1 in the register. This will end up being the means by which the result is shown.
```
÷^
```
We then item split the input list and reverse it, so that things are in descending order.
```
{!;|
```
Now, we start a while loop that will run while the length of the stack - 1 is not zero. 
```
":'
```
This bit of the algorithm took me a while to visualise and write... I had to resort to move playing cards around my living room floor to understand which stack shifting mechanics to use. 
Lets say the input stack (after item splitting and reversal) is `[4, 2, 1]`. Right shifting the stack (`"`) gives `[1, 4, 2]`, duplicating the top gives `[1, 4, 2, 2]` and then left shifting the stack (`'`) gives `[4, 2, 2, 1]`.
We do this so that we can compare the top of the stack with the next item and preserve that second item (in other words, circumnavigate the side effects of operators consuming stack items). 
```
2*≥
```
We then multiply the top item by two and see if the result is greater than or equal to the next item in the series. 
```
⑾
```
The result is then augmented multiplied into the register and the while loop continues. 
`-rR` prints the value of the register at the end of execution as an integer. 
[Answer]
# [Python 3](https://docs.python.org/3/), ~~57~~ \$\cdots\$ ~~44~~ 43 bytes
Saved a byte thanks to [kaya3](https://codegolf.stackexchange.com/users/91685/kaya3)!!!
```
lambda l:all(b>=a*2for a,b in zip(l,l[1:]))
```
[Try it online!](https://tio.run/##nY/BCoJAFEX38xWPVjPxAkddCbrsC9qZi5FmSHjpoC@oxG@fMghBd93l4d4Lxz/52rVJcPk5kLnVFwOUGSJZF7nZx67rwWANTQuvxktCKnVWKRXYDjxADlKALHWEcYRJVCEcDQ1W4ULTmZ76@w9ijMmq90HppqTXO715X4iCPyLEbMdoZ7uvTybA903L0u1GnuBQwOgkqwnsw8Nop50Kbw "Python 3 – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~53~~ ~~49~~ ~~47~~ 43 bytes
```
for(;$argv[$i++]*2<=$k=$argv[$i];);echo!$k;
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVEovSy6JVMrW1Y7WMbGxVsm1hIrHWmtapyRn5iirZ1v///zf8b/Tf0OC/kQEA "PHP – Try It Online")
-4 bytes thanks to @Kaddath.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~46~~ ~~33~~ 31 bytes
```
@(n)all(2*n(1:end-1)<=n(2:end))
```
[Try it online!](https://tio.run/##y08uSSxL/f8/zdZBI08zMSdHw0grT8PQKjUvRddQ08Y2T8MIxNbU/J@mEW1ooGNkoGNiEKv5HwA "Octave – Try It Online")
Thanks to Luis Mendo for `all`. Much shorter!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~4~~ 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
[Crossed out 4 is still regular 4 ;(](https://codegolf.stackexchange.com/questions/170188/crossed-out-44-is-still-regular-44)
```
¥›à
```
Outputs `0` for truthy and `1` for falsey.
Port of [*@RGS*' first Jelly answer](https://codegolf.stackexchange.com/a/199416/52210), so make sure to upvote him!  
-1 byte thanks for *@Grimmy* for mentioning any two distinct truthy/falsey values are allowed, so I can drop the invert at the end
[Try it online](https://tio.run/##yy9OTMpM/f//0NJHDbsOL/j/P9rQQMfIQMfEIBYA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@koGunoGRf6fL/0NJHDbsOL/iv8z862tBAx8hAx9ggVgfKNAEzdYx0jKG0CZQ2hEgYQlQaxsYCAA).
**Explanation:**
```
¥    # Get the deltas (forward differences) of the (implicit) input-list
 ›   # Check for each whether it's larger than value at the same position in the (implicit)
     # input-list, which automatically ignores the trailing item of the input
  à  # Get the maximum of this, to check if any are truthy
     # (after which it is output implicitly as result)
```
[Answer]
# [Clojure](https://clojure.org/), ~~42~~ 40 bytes
```
(fn[s](every? #(<= 2%)(map /(rest s)s)))
```
[Try it online!](https://tio.run/##TcwxCoAwEETRPqcYEGG3EBO11oOIhWhSiEZJYuHpo53bzYPhL/u53cFmWq2Dy@T8GCfyZ6pm/wwoqEeDkumYL9QUbEyIHJk5s6IreAVyGI1Go9HqiaW731@klegkjPgZkfg25xc "Clojure – Try It Online")
Basically the obvious pairwise thing, with a fun way to generate consecutive pairs of a sequence.
[Answer]
# [Lua](https://www.lua.org/), 54 bytes
```
for i=2,#arg do b=b or arg[i-1]*2>0+arg[i]end print(b)
```
[Try it online!](https://tio.run/##yylN/P8/Lb9IIdPWSEc5sShdISVfIck2SQEoBORFZ@oaxmoZ2RlogzmxqXkpCgVFmXklGkma////NzT4b2Tw38QAAA "Lua – Try It Online")
`true` and `false` are swapped.
[Answer]
# Desmos, 41 Bytes
```
f(n)=1-l(n[2n[0...l(n)]>n])
l(n)=n.length
```
[Try It Over Here](https://www.desmos.com/calculator/u24c7rpumy?nographpaper)
[Answer]
# [J](http://jsoftware.com/), 14 bytes
```
[:*/0.5>:2%/\]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o6209A30TO2sjFT1Y2L/a3IpcKUmZ@QrpCkYGigYGSgYG6DyTRB8BSMFY2SOCTLHEEmdIZIRhv8B "J – Try It Online")
[Answer]
# x86-16 machine code, 11 bytes
```
49          DEC  CX                 ; adjust to loop N-1 times
        N_LOOP:
AD          LODSW                   ; load N1 into AX 
D1 E0       SHL  AX, 1              ; double AX 
39 04       CMP  WORD PTR[SI], AX   ; compare to N2
7C 02       JL   DONE               ; if less, return
E2 F7       LOOP N_LOOP             ; keep looping 
        DONE:
C3          RET                     ; return to caller
```
Input array at `[SI]`, length in `CX`. Returns `ZF` if `truthy`, `NZ` if `falsey`.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 28 bytes
GolfScript has its clunky zip function (I need a lot of code to convert the string to a list of codepoints).
```
.1>]zip);{1/~0=\0=2*<!}%{&}*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPkfbWigYGSgYGwQ@1/P0C62KrNA07raUL/OwDbGwNZIy0axVrVarVbrf2zCfwA "GolfScript – Try It Online")
# Explanation
```
.1>]zip                      # Zip itself with itself without the first item
       );                    # Discard the extra trailing item
         {1/~0=\0=2*<!}%     # Is the first item * 2 greater than or equal to the next item?
                        {&}* # All of them?
```
# [GolfScript](http://www.golfscript.com/golfscript/), 31 bytes
```
.(+{2/}%]zip);{1/{0=}%~>!}%{&}*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPkfbahgpGBoEPtfT0O72ki/VjW2KrNA07raUL/awLZWtc5OsVa1Wq1W639swn8A "GolfScript – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 11 bytes
```
<1hS/MP.T,t
```
[Try it online!](https://tio.run/##K6gsyfj/38YwI1jfN0AvRKfk//9oQx1jHTMdQxMdY2MdQwMDHRMDo1gA "Pyth – Try It Online")
### Explanation
```
<1hS/MP.T,tQQ  # full program, last two Q (=input) are implicit
         ,tQQ  # [Q[1:], Q]
       .T      # Transpose -> [[Q[1],Q[0]], [Q[2],Q[1]], ...,  [Q[-1]]]
      P        # all but last element (gets rid of lone Q[-1])
    /M         # Map all pairs by division
   S           # Sort quotients
  h            # first element (minimum quotient)
<1             # is 1 smaller than this?
```
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 15 bytes
```
raJ0{2.*>=}LO==
```
[Try it online!](https://tio.run/##SyotykktLixN/Z@TV/2/KNHLoNpIT8vOttbH39b2f21u9P9oQwMdIwMdY4NYLijTBMzUMdIxhtImUNoQImEIUWkYCwA "Burlesque – Try It Online")
Finally got an answer where using `LO` is advantageous.
```
ra   # Read as array
J    # Duplicate
0    # 0 (start of loop)
{2.* # Double
 >=  # Greater than or equal to previous elem
}LO  # Loop through array performing op on each pair
     # Push to array if true
==   # Arrays are the same
```
# Burlesque, 16 bytes
Alternative (but longer) solutions using 2-grams and map-reduce
```
ra2CO{./2>=}m^r&
ra2CO{p^./2>=}al
```
[Try it online!](https://tio.run/##SyotykktLixN/Z@TV/2/KNHI2b9aT9/IzrY2N65I7X9tbvT/aEMDHSMDHWODWC4o0wTM1DHSMYbSJlDaECJhCFFpGAsA "Burlesque – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 49 bytes
```
param($n)($n|?{$_-ge2*$l;$l=$_}).count-eq$n.count
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVPE4hr7KtV4nXTU420VHKsVXJsVeJrNfWS80vzSnRTC1XyIMz///87aBjqGOmYaAIA "PowerShell – Try It Online")
Takes input `$n` then uses a `Where-Object` to pull out those elements that are `-g`reaterthanor`e`qual to `2` times the `$l`ast element. Those are left on the pipeline, and we set our `$l`ast element for the next iteration. We then take the `.count` of that collection and make sure it's `-eq`ual to the `.count` of our input array. That Boolean value is left on the pipeline and output is implicit.
---
If we don't need to worry about negative numbers, we can use the following instead, thanks to mazzy:
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 27 bytes
```
!($args|?{$_-lt2*$l;$l=$_})
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X1FDJbEovbjGvlolXjenxEhLJcdaJcdWJb5W8////4b/jf6bAAA "PowerShell – Try It Online")
This again takes input `$args`, and pulls out those items where they're `-l`ess`t`han `2` times the `$l`ast element (i.e., they're not "big enough" to make the doubling sequence). If there are any left, then the Boolean-not surrounding the collection results in `False`, otherwise if the collection is empty we get `True`. That's left on the pipeline and output is implicit.
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-r`, 11 bytes
```
$&2*_<=BMPg
```
[Try it online!](https://tio.run/##K8gs@P9fRc1IK97G1sk3IP3/f0MDLiMDLmOD/7pFAA "Pip – Try It Online")
Takes input numbers separater by newlines. (`-r` flag)
## Explanation
```
$&2*_<=BMPg  g → input
        MP   pass pairs from g to function on the left
  2*_<=B     a ≤ b? for pair (a, b)
$&           Fold with & operator
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~25~~ 15 bytes
```
Min@Ratios@#<2&
```
Returns `True` for false and `False` for true.
-10 bytes thanks to @att
[Try it online!](https://tio.run/##y00syUjNTSzJTE7876Zg@983M88hCMjNL3ZQtjFS@x9QlJlXEq2soGun4BatHBuroKag76BQXW1ooKNgBMTGBrU6CnCeCYQH5ABlEEwTBNMQpsIQps@wtvY/AA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 41 bytes
```
a=>all([a[x+1]/a[x]>=2for x:0..len(a)-1])
```
[Try it online!](https://tio.run/##KyjKL8nP@59m@z/R1i4xJ0cjOjG6QtswVh9IxdrZGqXlFylUWBno6eWk5mkkauoaxmr@LyjKzCvRSNOINtRRMNJRMNVRMASxjGI1Nf8DAA "Proton – Try It Online")
This isn't very efficient because Proton is too buggy to do this right.
[Answer]
# [Arturo](https://arturo-lang.io), ~~29~~ 28 bytes
```
$=>[l:0every?&'x[x>=l*2l:x]]
```
[Try it](http://arturo-lang.io/playground?FlfhwT)
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 6 bytes
```
↔ʁ/2≥Π
```
[Try it online!](https://tio.run/##K6gs@f//UduUU436Ro86l55b8P9/tLGOmY6haSwA "Pyt – Try It Online")
Outputs 1 if doubling array, 0 otherwise
```
↔           implicit input; flip array
 ʁ/         ʁeduce by division
   2≥       is each element greater than or equal to 2?
     Π      take product of list; implicit print
```
[Answer]
# [><> (Fish)](https://esolangs.org/wiki/Fish), 27 bytes
```
rl1)?v1n;n0<
@:$+:<|.!:0^?)
```
[Try it](https://mousetail.github.io/Fish/#eyJ0ZXh0IjoicmwxKT92MW47bjA8XG5AOiQrOjx8LiE6MF4/KSIsImlucHV0IjoiIiwic3RhY2siOiIxIDIgNCA4IDEwMCIsInN0YWNrX2Zvcm1hdCI6Im51bWJlcnMiLCJpbnB1dF9mb3JtYXQiOiJjaGFycyJ9)
* `r` reverse
* `l1)?` is the length greater than 1?
* `v` then go down
* `1n;` otherwise, output 1 (true)
* `<` go left
* `:+` double
* `$:@` duplicate NOS
* `)?` is NOS greater than TOS?
* `^<0n;` then output 0 (false)
* `0:!.|` go back to start after inverting direction
]