text:
Primus-Orderus Primes
Who are they?
Primus-Orderus Primes (POP) are primes which contain their order in the sequence of primes.
So the nth prime, in order to be POP, must contain all the digits of n in a certain way which I'll explain.
Examples
Let's get things clearer:
All digits of n must appear among the digits of POP in the same order they appear in n
The 6469th prime is 64679 which is POP because it contains all digits of 6469 in the right order .
1407647 is POP because it is the 107647th prime number
14968819 is POP (968819th prime).So this challenge is NOT OEIS (A114924)
1327 is NOT POP because it is the 217th prime (digits are not in the right order)
The Challenge
You guessed right!
Given an integer n, output the nth POP
Test Cases
input-> output
1->17
3->14723
5->57089
10->64553
29->284833
34->14968819

This is code-golf so the shortest answer in bytes wins!
All these should be 1-Indexed

0-indexed, 1-indexed or dealer's choice?

@Shaggy I think this is 1-indexed such that it is compatible with the test cases (The order kind of matters).

@Mr.Xcoder It is the 1st POP, 7th prime

@MrXcoder: yeah, sorry, I probably phrased that poorly; what I was meaning to ask is 0-indexing allowed? Obviously, from the test cases, 1-indexing is allowed. Do we have a consensus, by the way, on which indexing we can use in a challenge if all we have to go by is the test cases and there's no explicit mention in the challenge specs?

@Shaggy 1-indexed. edited

Thanks, Bill. While, for the most part, your recent challenges have been very good, each of them has had a minor issue or 2 that has had to be cleared up in the comments, which is why I'd suggest you start Sandboxing your challenges, to allow us to catch those issues.

This is the sandbox, for reference.

@LuisMendo I can hardly see that f(3) = 14723. Let alone f(4).

@Mr.Xcoder it shouldn't really affect the test cases working if you zero or one index it. If you 1-index it, you check if the nth prime "contains" n. If you 0-index, you check if the n+1th prime "contains" n+1. The results are the same just shifted. That's why I think challenges like this should always be allowed to be zero or one indexed.

@geokavel The 0th POP prime would be 101 in that case.

@Mr.Xcoder There's no 0th Pop, because when you zero-index you check the n+1th prime.

@geokavel Oh yeah, I was thinking of 0-indexing the sequence, not the test cases.

Husk, 11 bytes
!fS¤o€Ṗdṗİp

Try it online!
Not that fast, computes f(5) in around 30 seconds on TIO
Explanation
!fS¤o€Ṗdṗİp
 f       İp    Filter the list of prime numbers and keep only those for which:
  S¤o€Ṗdṗ       The "d"igits of its index in the "ṗ"rime numbers are an "€"lement of the
                  "Ṗ"owerset of its "d"igits
!              Return the element at the desired index of this filtered list

Mathematica, 104 bytes
Extremely efficient
(t=i=1;While[t<#+1,If[!FreeQ[Subsets[(r=IntegerDigits)@Prime@i,{Length@r@i}],r@i],t++];i++];Prime[i-1])&

finds n=34 in under a minute

Python 2 + gmpy2, 188 162 bytes
Quite efficient, finds n=34 in 22 seconds on TIO!
Could probably be golfed a bit
from gmpy2 import*
def F(a,b):
 i=k=0
 while b[i:]and a[k:]:k+=a[k]==b[i];i+=1
 return"0">a[k:]
x=input()
u=z=1
while x:z=next_prime(z);x-=F(`u`,`z`);u+=1
print z

Try it online!

@Dopapp, wouldn't that add bytes?
__import__("gmpy2").
is longer than
from gmpy2 import*\n

Oh right I don’t know why that came out different the first time. I probably forgot the quotation marks or something

05AB1E, 11 bytes
µN<Ø©æNå½}®

Try it online!
Extremely inefficient.

Jelly, 12 bytes
ÆNDŒPḌċµ#ṪÆN

Try it online!
Extremely inefficient but works.


text:
Stretch an array
Earlier I defined the process of crushing an array

In a crush we read the array left to right. If at a point we encounter two of the same element in a row we remove the first one and double the second one.

For example here is the process of crushing the following array
[5,2,2,4]
 ^
[5,2,2,4]
   ^
[5,2,2,4]
     ^
[5,4,4]
   ^
[5,4,4]
     ^
[5,8]
   ^

Note that the same element can be collapsed multiple times.  In the example 2,2,4 was collapsed into 8 in a single pass.
Now crushing arrays is easy, whats hard is uncrushing them.  Your task is to take an array of positive integers as input and output the largest array that can form the input when crushed repeatedly.  For example the array [4] is formed by crushing [2,2] which is in turn formed by crushing [1,1,1,1].  Since we can't have non integer values [1,1,1,1] cannot be uncrushed any further and thus is our answer.
You will never receive a 0 in your input array because such arrays can be expanded indefinitely.  You will also never receive a case with two of the same odd number next to each other, such cases cannot be the result of a crushing.
This is code-golf so answers will be scored with the size of their source measured in bytes with less bytes being better.
Before you start making your answer I just want to say that this challenge is significantly more difficult than it seems.  Check your intuition as you go along and make sure your answer passes all the test cases.
Test Cases
[] -> []
[5] -> [5]
[6] -> [3,3]
[8] -> [1,1,1,1,1,1,1,1]
[4,8] -> [1,1,1,1,1,1,1,1,1,1,2]
[2,8] -> [1, 1, 1, 1, 2, 1, 1, 1, 1]
[4,4] -> [1,1,1,1,1,1,1,1]

Sorry but i still cannot understand the rule. why [1,1,1,1,1,1,1,1,1,1,2] produce [4, 8] instead of [8, 4]? should this be [1,>1,1,1,1,1,1,1,1,1,2], [2,1,>1,1,1,1,1,1,1,2], [2,>2,1,1,1,1,1,1,2], [4,1,>1,1,1,1,1,2], [4,2,1,>1,1,1,2], [4,2,>2,1,1,2], [4,>4,1,1,2], [8,1,>1,2], [8,2,>2],[8,4]?

@tsh I think you have a misconception in the way that crushing works.  Here is the path it takes first pass: [1,>1,1,1,1,1,1,1,1,1,2], [2,>1,1,1,1,1,1,1,1,2], [2,1,>1,1,1,1,1,1,1,2], [2,2,>1,1,1,1,1,1,2],[2,2,1,>1,1,1,1,1,2], [2,2,2,>1,1,1,1,2],[2,2,2,1,>1,1,1,2], [2,2,2,2,>1,1,2], [2,2,2,2,1,>1,2], [2,2,2,2,2,>2], [2,2,2,2,4>], second pass: [2,>2,2,2,4], [4,>2,2,4], [4,2,>2,4], [4,4,>4], [4,8>].  Hopefully that clears it up.  If you would like some code to look at the previous question has answers that implement a crushing function.

Is it ok if I output numbers, each separated by a newline?

@scottinet That is a reasonable way to output a list.  Go ahead.

The test case [4, 4] should be removed, as we can never get that array after a stretch=>crush sequence, since this will end up with [8]

@scottinet No the test case [4,4] is there on purpose.  Not all inputs have to be uncrushable.  [4,4] can be obtained by crushing [2,2,2,2], which in turn can be obtained from [1,1,1,1,1,1,1,1].

JavaScript (Node.js), 237 221 213 186 bytes
f=a=>a.map(b=>{for(i=1;~b%2;b/=2)i*=2;return Array(i).fill(b)}).reduce((t,c,i,s)=>{b=c.slice();if(i)r=2*s[--i].length,b.length>=r&&b[0]==s[i][0]?b[r-2]+=b.pop():b;return t.concat(b)},[])

Try it online!
This algorithm computes optimal stretched arrays, by stretching each number to the max, and then, if necessary, it crushes back a pair of number at the right place, effectively creating a "crush blocker", interrupting the crush sequence of the preceding number.
For instance:
[1, 1, 1, 1, 1, 1] gives [4,2] once crushed, but [1, 1, 1, 1, 2] results in [2, 4]
The challenge is to determine where exactly a crush blocker should be placed so that crushing the resulting array gives the right result:

A crush blocker needs to be placed only if the previous stretched number is equal to the current one, and if the current stretched sequence is greather than the previous one. For instance, [2, 4] requires a crush blocker (the stretched number is 1, repeated, and [1, 1] is shorter than [1,1,1,1]), but [4, 2] and [2, 6] do not require one
if we call n the previous stretched sequence, and if the condition above is verified, then the current sequence is a repetition of the n sequence. To interrupt the crush sequence of the previous number, we need to place the crush blocker at the end of the second n sequence of the current number to stretch. Example: [2, 8] => [(1, 1)=n, (1, 1) + (2) + (1, 1) + ...], or [4, 8] => [(1, 1, 1, 1)=n, (1, 1, 1, 1) + (1, 1, 2) + ...]

-15 bytes: Try it online!. Also how does if(i)r=2*s[--i].length work - whenever I try to replace it with something more efficient, I get ReferenceError: r is not defined.

Python 2, 230 228 226 bytes
Works by iterating all possible lists with the same sum as the input one. Removing those that do not equal to the input array in some crushed state, selecting the longest one.
Edit: -2 bytes by removing the if in the main function
Edit: -2 bytes by removing two unnecessary square brackets
lambda x:max((c(z[:],x),len(z),z)for z in b(sum(x)))[2]
def c(x,y):
 i=e=1
 while x[i:]:
	if x[~-i]==x[i]:del x[i];i-=1;x[i]*=2;e=2
	i+=1
 return x==y or~-e and c(x,y)
b=lambda s:[z+[-~i]for i in range(s)for z in b(s+~i)]+[[]]

Try it online!
Explanation
Main function, responsible for finding all possible solutions and selecting the longest one
lambda x:max((c(z[:],x),len(z),z)for z in b(sum(x)))[2]

Crush function, that checks if y is equal to one of the crushes.
def c(x,y):
 i=e=1
 while x[i:]:
	if x[~-i]==x[i]:del x[i];i-=1;x[i]*=2;e=2
	i+=1
 return x==y or~-e and c(x,y)
Generate all possible permutations with the given sum
b=lambda s:[z+[-~i]for i in range(s)for z in b(s+~i)]+[[]]

Jelly, 42 bytes
ṪḤ,⁼?⁹⁸;µ/Ḋ$¹L’$?ÐĿċ³
ṗÐ€⁸ẎS⁼¥Ðfµ€ŒpẎ€ÇÐfṪ

Try it online!
Full program. Extremely inefficient, but works.

05AB1E, 41 37 bytes
vy[DÉ#2÷]DYQX©NoDU‹&sDV¸X∍sić·®·Íǝ}»,

Try it online!
Port of my Javascript solution.
Explanations:
vy                   for each member of the list
[DÉ#2÷]              divide by 2 until odd: stack = stretched value, N = iterations
DYQ                  stetched value equal to the previous one?
X©NoDU‹              previous size < current one? (+store the new size in X)
&                    AND on the 2 previous tests
sDV¸X∍s              build a list of the new stretched value repeated X times
                      (+store the new stetched value in Y)
ić·®·Íǝ}             if the previous tests are true:
                       reduce the result list size by 1
                       multiply by 2 the number at the crush block position
»,                   join by newline + print the list

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Are the lists divisible?
Inspired (with the explanation stolen from) this
Background
Say you have two lists A = [a_1, a_2, ..., a_n] and B = [b_1, b_2, ..., b_n] of integers. We say A is potentially-divisible by B if there is a permutation of B that makes a_i divisible by b_i for all i. The problem is then: is it possible to reorder (i.e. permute) B so that a_i is divisible by b_i for all i?
For example, if you have
A = [6, 12, 8]
B = [3, 4, 6]

Then the answer would be True, as B can be reordered to be B = [3, 6, 4] and then we would have that a_1 / b_1 = 2, a_2 / b_2 = 2, and a_3 / b_3 = 2, all of which are integers, so A is potentially-divisible by B.
As an example which should output False, we could have:
A = [10, 12, 6, 5, 21, 25]
B = [2, 7, 5, 3, 12, 3]

The reason this is False is that we can't reorder B as 25 and 5 are in A, but the only divisor in B would be 5, so one would be left out.
Your task
Your task is, obviously, to determine whether two lists (given as input) are potentially divisible. You may take input in any accepted manner, as with output.
Duplicates in the lists are a possibility, and the only size restrictions on the integers are your language. All integers in both lists will be larger than 0, and both lists will be of equal size.
As with all decision-problems the output values must be 2 distinct values that represent true and false.
This is a code-golf so shortest code wins!
Test cases
Input, input => output

[6, 12, 8], [3, 4, 6] => True
[10, 5, 7], [1, 5, 100] => False
[14, 10053, 6, 9] [1,1,1,1] => True
[12] [7] => False
[0, 6, 19, 1, 3] [2, 3, 4, 5, 6] => undefined

@Shaggy from the question: both lists will be of equal size

Why is the last test case undefined?

@Dennis one of the lists has a 0 in it

Right. (Not sure why, 0 is divisible by all integers.) Do the two outputs have to be truthy and falsy, or just consistent?

@Dennis 1) it's in case 0 is in the second list, to avoid 0 division errors 2) just consistent

Husk, 7 6 5 bytes
Saved 2 bytes thanks to @Zgarb
▼▲‡¦P

Takes argents in reverse order and returns 1 for True and 0 for False.
Try it online!
Explanation
    P     -- Permutations of the first argument
  ‡       -- Deep zip (vectorises function) with second argument
   ¦      --   Does x divide y
 ▲        -- Get the maximum of that list, returns [1,1...1] if present
▼         -- Get the minimum of that list, will return 0 unless the list is all 1s

VΠMz¦P should work for 6 bytes.

Are those considered "two distinct values"?

Oh, and Mz can be ‡.

I think you need ▼▲ instead of ▲▼. Nice idea in any case!

Jelly, 5 bytes
Œ!%ḄẠ

Returns 0 for True, 1 for False.
Try it online!
How it works
Œ!%ḄẠ  Main link. Arguments: A, B (arrays)

Œ!     Generate all permutations of A.
  %    Take each permutation modulo B (element-wise).
   Ḅ   Convert all resulting arrays from binary to integer.
       This yields 0 iff the permutation is divisible by B.
    Ạ  All; yield 0 if the result contains a 0, 1 otherwise.

MATL, 8 7 6 bytes
1 byte off using an idea from Dennis' Jelly answer
Y@\!aA

Inputs are B,  then A. Output is 0 if divisible or 1 if not.
Try it online!
Explanation
Y@     % Implicit input: row vector B. Matrix of all permutations, each on a row
\      % Implicit input: row vector A. Modulo, element-wise with broadcast. Gives
       % a matrix in which each row contains the moduli of each permutation of B
       % with respect to A
!a     % True for rows that contain at least a nonzero value
A      % True if all values are true. Implicit display

05AB1E, 7 bytes
Input: takes lists B and A (reversed order)
Output: 1 when true, 0 otherwise
œvIyÖPM

Try it online!
Explanations:
œvIyÖPM    Complete program
œ          Pushes all permutations of B as a list
 v         For each permutation
  I        Pushes last input on top of the stack
   yÖ      Computes a % b == 0 for each element of A and B
     P     Pushes the total product of the list
      M    Pushes the largest number on top of the stack

JavaScript (ES6), 67 63 bytes
Returns a boolean.
f=([x,...a],b)=>!x||b.some((y,i)=>x%y?0:f(a,c=[...b],c[i]=1/0))

Test cases

f=([x,...a],b)=>!x||b.some((y,i)=>x%y?0:f(a,c=[...b],c[i]=1/0))

console.log(f([6, 12, 8],[3, 4, 6]))        // true
console.log(f([10, 5, 7],[1, 5, 100]))      // false
console.log(f([14, 10053, 6, 9],[1,1,1,1])) // true
console.log(f([12],[7]))                    // false

R + combinat, 69 66 58 bytes
-3 bytes thanks to Jarko Dubbeldam
another -8 bytes thanks to Jarko
function(a,b)any(combinat::permn(b,function(x)all(!a%%x)))

oddly, R doesn't have a builtin for generating all permutations. Returns a boolean.
Additionally, with Jarko's second improvement, any coerces the list to a vector of logical with a warning.
Try it online! (r-fiddle)

All(x<1) is longer than any(!x) and you should be able to replace sum with any

@JarkoDubbeldam good call. thank you.

Oh, and you can omit unlist, yay for implicit coercion.

@JarkoDubbeldam excellent.

Mathematica, 52 bytes
Cases[Permutations@#2,p_/;And@@IntegerQ/@(#/p)]!={}&

thanks @ngenisis for -5 bytes

Cases is generally shorter: Cases[Permutations@#2,p_/;And@@IntegerQ/@(#/p)]!={}&

Haskell, 79 74 68 62 61 bytes
import Data.List
f a=any((<1).sum.zipWith rem a).permutations

Try it online!
Saved 1 byte thanks to @nimi

61 bytes: f a=any((<1).sum.zipWith rem a).permutations.

Mathematica, 42 bytes
MemberQ[Permutations@#2,a_/;And@@(a∣#)]&

C (gcc), 191 bytes
#define F(v)for(i=0;i<v;++i){
#define X if(f(s,n,a,b))return 1
j;f(s,n,a,b,i)int*a,*b;{if(--n){F(n)X;j=i*(n%2);b[j]^=b[n];b[n]^=b[j];b[j]^=b[n];}X;}else{F(s)if(a[i]%b[i])return 0;}return 1;}}

Try it online!
Usage: f(int size, int size, int *a, int *b)
returns 1 if divisable, 0 otherwise. See example usage on TIO.
(Gotta do permutations the hard way in C, so this is hardly competitive)

Suggest b[j=n%2*i]^=b[n]; instead of j=i*(n%2);b[j]^=b[n]

Brachylog, 6 bytes
pᵐz%ᵛ0

Try it online!
The predicate succeeds if the two lists are potentially divisible and fails if they are not.
pᵐ        For some pair of permutations of the two input lists,
  z       for each pair of corresponding elements
   %ᵛ0    the first mod the second is always zero.

JavaScript (ES6), 100 bytes
f=(a,b)=>!a[0]||a.some((c,i)=>b.some((d,j)=>c%d<1&f(e=[...a],d=[...b],e.splice(i,1),d.splice(j,1))))

Somewhat inefficient; an extra & would speed it up.

Python 2, 90 bytes
lambda a,b:any(sum(map(int.__mod__,a,p))<1for p in permutations(b))
from itertools import*

Try it online!

Perl 6, 38 bytes
Actually @nwellnhof's answer seems to be too much readable, so I set out to follow the fine Perl tradition of write-only code :—).
1 byte saved thanks to @nwellnhof.
{min max (@^a,) XZ%% @^b.permutations}

Try it online!
What does it do: It's an anonymous function that takes two list arguments. When we say @^a, we mean the first one, when @^b, it's the second one.
(@^a,) is a list containing the list @^a. @^b.permutations is the list of all the permutations of @^b. The "XZ%%" operator makes all possible pairs of that one list on the left and all the permutations on the right, and uses the operator "Z%%" on them, which is the standard "zip" operation using the divisibility operator %%.
The max operator gives the largest element of the list (in this case, it's the list that has the most True's in it). We then reduce it using the logical AND operator to see if all elements of that "most true" list are true, and that's the result. It's nearly exact copy of what @nwellnhof wrote, just using obscure operators to shave off bytes.

It says permutations, it is clearly far too readable ;)

Well, Perl 6 has a really powerful introspection model. Perhaps I could study it in order to obscure that call? :D

Replace [&&] with min to save another byte.

You can remove the spaces around the XZ%%

I wish something like {all (@^a,)Z%%@^b.permutations.any} were possible

Jelly, 7 bytes
Œ!ọẠ€1e

Try it online!
Factorial complexity in the length of the list.

Does Jelly really not have an any builtin? TIL

Pyth - 11 bytes
sm!s%Vdvz.p

Test Suite.

You beat me to it :((( - Was just about to post something similar

CJam, 20 17 bytes
:A;e!{A\.%:+!}#W>

Test Version
Function that takes array B as the first argument and array A as the second argument. Note that in the test version I switch the order to A then B.

PHP, 112 180 178 bytes
I was thinking too short.
function($a,$b){for($p=array_keys($b);++$i<count($b);){foreach($b as$k=>$x)$f|=$a[$k]%$x;if($f=!$f)return 1;$p[$i]?[$b[$j],$b[$i],$i]=[$b[$i],$b[$j=$i%2*--$p[$i]],0]:$p[$i]=$i;}}

anonymous function takes two arrays, returns NULL for falsy and 1 for truthy.
Throws an error if second array contains 0.
Try it online.

Prints the wrong result for $f([6,5],[3,5]).

@nwellnhof fixed. thanks for noticing.

J, 27 bytes
0=[:*/(A.~i.@!@#)@]+/@:|"1[

Try it online!
Takes the first list as the left argument and the second list as the right.

21 bytes (|"1~e.~0*[)i.@!@#A.]

Factor + math.combinatorics math.unicode, 49 bytes
[ <permutations> [ v/ [ ratio? ] ∄ ] with ∃ ]

Try it online!

<permutations> [ ... ] with ∃ Is there any permutation of the second input where...
v/ ...the quotient of the first input and the permutation...
[ ratio? ] ∄ ...contains no ratios? (In other words, are they all integers?)

Vyxal, 7 bytes
Ṗ$vḊvAa

Try it Online!

Japt, 12 11 bytes
Outputs true or false.
Vá de@gY vX

Test it

Explanation
Implicit input of arrays U & V (A & B, respectively)
Vá

Generate an array of all permutations of V.
d

Check if any of the elements (sub-arrays) return true.
e@

Check if every element in the current sub-array returns true when passed through the following function, with X being the current element and Y the current index.
gY

Get the element in U at index Y.
vX

Check if it's divisible by X.

Ruby, 56 bytes
->x,y{x.permutation.any?{|p|p.zip(y).all?{|a,b|a%b==0}}}

Try it online!
Fairly straightforward, exploits the fact that permutation exists.

Python 2, 92 bytes
lambda a,b:any(all(x%y<1for x,y in zip(a,p))for p in permutations(b))
from itertools import*

Try it online!
Yer basic implementation.

Scala, 60 Bytes
Golfed:
a=>b=>b.permutations exists(a zip _ forall(p=>p._1%p._2==0))

Ungolfed:
a=>b=>         // Function literal taking 2 lists of integers, a and b.
b.permutations // All permutations of b.
exists(        // Whether the given function is true for any element.
a zip _        // Zips a and the current permutation of b into a list of pairs.
forall(        // Whether the given function is true for all elements.
p=>            // Function literal taking a pair of integers.
p._1%p._2==0)) // If the remainder of integer division between the members of the pair is 0.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Binary to Hexadecimal
Convert a binary number (of any size) into a hexadecimal number.
Input
A POSITIVE binary number with just the 0s and 1s. A valid input will always match the following regex: [0-1]+. If the input is not a valid binary number, that is, anything not matching this regex, the output should be 0 or the program should exit, or error. The output does not need the leading 0x nor does it need to be capitalized.
Output
The binary number converted to hexadecimal.
Winning
Original Code-Golf Rules, Lowest amount of bytes.
Examples
IN: [101]
OUT: [0x5] OR [5]

IN: [10000000010100100000]
OUT: [0x80520] OR [80520]

IN: [1010101]
OUT: [0x55] OR [55]

IN: [1111111111111111]
OUT: [0xFFFF] OR [FFFF] OR [0xffff] OR [ffff]

IN: [1012101]
OUT: [0]

IN: [a]
OUT: [0]

IN: [-1010101]
OUT: [0]

IN: [abcdef]
OUT: [0]

IN: [2]
OUT: [0]

Boo-urns to input validation!

Can we exit if the input isn't valid binary?

@cairdcoinheringaahing Yes

This should be popularity contest or something, not code golf.

@Titus popularity-contest would be a lot better

@DirtyDev Popularity contest would NOT better.

...note how many answers do not conform to the input validation requirements - this is one of the reasons to just not have such restrictions in code-golf.

You could shave one byte off your regex: [01]+

@Titus This would be closed instantly as a pop con.

5 hours was far too quick to an accept a solution, especially one that does not meet the specs on invalid input.

In tcl, these regexp is not enough to exclude -1010101, may be because the - is the parameter indicator, example: regexp -expanded ...

I wish there was a "boring" close-vote reason, the "input validation" part of this spec really ruins the challenge.

MY, 8 6 5 bytes
⍞PrH↵

Try it online!
How?

⍞ line of raw input
P basify
r convert from binary
H convert to hex
↵ output

Errors if input isn't correct.

6502 machine code (C64), 100 bytes
00 C0 20 FD AE 20 9E AD 20 A3 B6 8D 1C C0 A0 00 84 FB 84 FC 29 03 AA D0 16 A2
04 A4 FB C0 FF D0 0E A4 FC A9 00 99 62 C0 A0 C0 A9 62 4C 1E AB A9 00 85 FE CA
30 1B 06 FE A4 FB E6 FB B1 22 C9 30 F0 F1 C9 31 F0 03 4C 99 AD A5 FE 09 01 85
FE D0 E2 A9 30 05 FE C9 3A 30 02 69 06 A4 FC 99 62 C0 E6 FC D0 B5

Online demo
Usage: sys49152,"[input]", where [input] is your binary string, e.g. sys49152,"10000000010100100000".
Important: When the program was loaded from disk (like in the online demo!), issue a new command first! This is because loading the program fiddles with some BASIC pointers and the machine thinks there's no RAM left for a string...

Explanation (commented disassembly listing):
00 C0       .WORD $C000         ; load address
20 FD AE    JSR $AEFD           ; check for comma
20 9E AD    JSR $AD9E           ; evaluate expression
20 A3 B6    JSR $B6A3           ; get string from expression
8D 1C C0    STA $C01C           ; store input string length for CPY instruction
A0 00       LDY #$00            ; initialize counters to 0:
84 FB       STY $FB             ;    read counter
84 FC       STY $FC             ;    write counter
29 03       AND #$03            ; number of bits in first incomplete nibble
AA          TAX                 ;  -> to X register
D0 16       BNE .nibble         ; branch to nibble decoding if not 0
 .mainloop:
A2 04       LDX #$04            ; from here on 4 bits per nibble
A4 FB       LDY $FB             ; load read counter to Y
C0 04       CPY #$FF            ; compare with input length (argument modified)
D0 0E       BNE .nibble         ; not yet done -> branch to nibble decoding
A4 FC       LDY $FC             ; load store counter
A9 00       LDA #$00            ; write NUL terminator
99 62 C0    STA .outbuf,Y       ; to output string
A0 C0       LDY #$C0            ; load address of
A9 62       LDA #$62            ; output string
4C 1E AB    JMP $AB1E           ; and jump to string output routine
 .nibble:
A9 00       LDA #$00            ; initialize value of nibble to zero
85 FE       STA $FE             ; store to temporary variable
 .nibbleloop:
CA          DEX                 ; decrement number of bits
30 1B       BMI .nibbleout      ; no bits left -> prepare for output
06 FE       ASL $FE             ; shift temporary variable left
A4 FB       LDY $FB             ; load read counter to Y
E6 FB       INC $FB             ; increment read counter
B1 22       LDA ($22),Y         ; load next input character
C9 30       CMP #$30            ; compare with '0'
F0 F1       BEQ .nibbleloop     ; if equal, handle next bit
C9 31       CMP #$31            ; compare with '1'
F0 03       BEQ .nibbleadd      ; if equal, add that bit
4C 99 AD    JMP $AD99           ; neither '0' or '1' -> type mismatch error
 .nibbleadd:
A5 FE       LDA $FE             ; load temporary variable
09 01       ORA #$01            ; set lowest bit
85 FE       STA $FE             ; store temporary variable
D0 E2       BNE .nibbleloop     ; handle next bit
 .nibbleout:
A9 30       LDA #$30            ; load character '0'
05 FE       ORA $FE             ; combine with value from temporary variable
C9 3A       CMP #$3A            ; result smaller than 0x39 ('9') ?
30 02       BMI .nibblestore    ; then store that
69 06       ADC #$06            ; otherwise add offset to get in range 'a'-'f'
 .nibblestore:
A4 FC       LDY $FC             ; load write counter
99 62 C0    STA .outbuf,Y       ; write to output string
E6 FC       INC $FC             ; increment write counter
D0 B5       BNE .mainloop       ; back to main loop
 .outbuf:                       ; "BSS", output string is stored from here

Remarks:

Input validation is fully implemented (and takes quite a few bytes, otherwise it would be possible to directly output each decoded nibble without temporary storage)
I took the liberty to interpret "any length" as "any length my C64 system can read from a command line as a string", which is quite limited ... 69, or if you abbreviate sys with sY 70 "bits", because the whole command line is limited to 80 characters ...  hope this is acceptable :)

R, 34 bytes
function(x)as.hexmode(strtoi(x,2))

Returns NA for invalid input.
Try it online!

Java, 126 119 117 110 104 Bytes
Thanks to Jakob and Zacharý
class A{public static void main(String[]s){System.out.print(Long.toHexString(Long.parseLong(s[0],2)));}}

Expanded:
class A
{
    public static void main(String[] s)
    {
        System.out.print(Long.toHexString(Long.parseLong(s[0], 2)));
    }
}

You can shorten with a function like this: https://codegolf.stackexchange.com/a/140570/46313

Or, if you want to stick with Java 7, you can submit a method definition, e.g. int f(String s){ ... }. Also, you can save bytes by using Long.toHexString and Long.parseLong.

Also, remove the space after String[].

@Downvoter: Why?

As @geokavel mentioned, you can use a Java 8 lambda to shorten your code, since you didn't specify in your challenge you should have a full program, and the default here on PPCG is "program or function/lambda": s->Long.toHexString(Long.parseLong(s,2)). But, if you want to stick with a full program, you can also shorten it with Java 8 by replacing class A{public static void main(String[]a){ with interface A{static void main(String[]a){.

PHP, 25+1 bytes
<?=dechex(bindec($argn));

Run as pipe with -F.
or 27+1 bytes: (-R)
printf("%x",bindec($argn));

or 28+1 bytes: (-F)
<?=base_convert($argn,2,16);

or 30+1 bytes: (-R)
eval("printf('%x',0b$argn);");

Retina, 72 70 bytes
A`[^01]
T`d`l`.(?!(....)*$)
T`d`23`b\d
T`d`4-7`b.\d
T`d`89L`b..\d
a|b

Try it online! Output is blank on error. Edit: Saved 2 bytes thanks to @PunPun1000. Explanation:
A`[^01]

Delete non-binary input.
T`d`l`.(?!(....)*$)

Convert all digits not in the correct position to as and bs instead.
T`d`23`b\d

Add 2 to digits that follow a b.
T`d`4-7`b.\d

Add 4 to digits two after a b.
T`d`89L`b..\d

Add 8 to digits three after a b.
a|b

The as and bs have done their job and can be deleted.

89A-F can be replaced with 89L assuming I'm reading your explanation correctly

@PunPun1000 Thanks for reminding me; I knew there was something I'd overlooked.

C, 168 bytes
i,l,k,n;f(char*s){char*o=malloc(l=strlen(s));for(i=n=0;i<l;n+=k<<i++)if((k=s[l-i-1]-48)&&k-1)return 0;for(i=o[--l]=0;n;n/=16)k=n%16,o[l-++i]=k>9?k+55:k+48;puts(o+l-i);}

Try it online!
Unrolled:
i,l,k,n;
f(char *s)
{
    // Allocate a string for the hexadecimal digits.
    // The number of digits in the hex number is
    // sure to be less or equal to that of binary.
    char *o = malloc(l=strlen(s));

    // Convert binary to decimal.
    // The function returns zero without printing
    // anything if there are extraneous characters.
    for (i=n=0; i<l; n+=k<<i++)
        if ((k=s[l-i-1]-48) && k-1) return 0;

    // Convert decimal to hexadecimal.
    for (i=o[--l]=0; n; n/=16)
        k = n%16, o[l-++i] = k>9 ? k+55 : k+48;

    // Print the number in hexadecimal.
    puts(o+l-i);
}

CJam, 17 bytes
{2bGb{_9>'70?+}%}

Function that takes an array of bits as input.
Test Version
{
2b     e# Convert from base-2 to base-10.
Gb     e# Convert from base-10 to base-16.
{      e# For each digit in the hex version...
_      e# Duplicate it.
9>     e# Check if it's greater than 9.
'70?   e# If it is, add a '7' (char) to the stack. If not, add a 0 (int).
 +     e# Add the new item to the digit. Int + char => Increment char's ASCII value by int. (e.g '7' + 10 = 'A')
}%
}

If necessary, here's a version that checks for invalid input (29 bytes):
{_2,|$2,=1W?*2bGb{_9>'70?+}%}

Test Version
It outputs 0 for an empty array and throws an exception for all other invalid input.
How validation works....
{
_2,|$  e# Get Logical OR of input array and [0,1], sorted.
2,=    e# Does that equal [0,1]?
1W?    e# If the arrays are equal add 1 to the stack, if not add -1.
*      e# Repeat the input as many times as the number just added to the stack.
       e# If the number is 1, the input is unchanged.
       e# If it's -1 you get an error for an invalid number of repetitions.
...

Does not exit, error or yield 0 for all invalid inputs.

@Jon I did it this way because of the comments on caird's Osabie answer. I guess it's not clear what "error" as a verb means.

There would be no point in specifying that the program should "do something unexpected given invalid input" as there is no valid output for invalid input, so I think "should error" is pretty clear (although as I commented under the OP I think input validation should really be avoided).

05AB1E, 7 6 bytes
CbQ*Ch

Try it online!
Error case
It's my first try ever to a Code Golf, advices welcomed!
Handles error cases \o/
The idea is to make the conversion from base 2 to base 10, and back to base 2.
Compare the result with the initial input, if it's not the same, then the conversion have failed.
1012101 => 0
a => empty
-1010101 => 0
abcdef => empty
2 => 0

Explanation
CbQ*Ch
C  # convert input from base 2 to base 10
 b # ...and back to 2
  Q # 1 if the full conversion back and return equals the input, else 0
   * # multiply to get 0 if error case
    C # convert corrected input from base 2 to base 10
     h # convert it to base 16

You could use b instead of 2B

Ruby, 27 25 bytes
->b{'%x'%Integer('0b'+b)}

Try it online!
-2 bytes thanks to histocrat.
Inputs and outputs strings.
String#to_i vows to never throw an exception, returning 0 for many invalid inputs. That would be fine, except for this property:
Extraneous characters past the end of a valid number are ignored.
Meaning that 1012101 is read up to the 2 and interpreted as 101 (or 5), which is no good. We can use the stricter Integer() instead, which throws an exception for any number that is not binary. It lets through negative numbers, so we need to invalidate those by prepending 0b to the input. 0 as input returns 0, which is within the specification.

I don't think you need the ,2 unless I'm missing some corner case, since you're already specifying base 2 with the '0b'.

@histocrat This was long enough ago that I can't really remember but I suspect you're right. Thanks!

Tcl, 66 bytes
proc H b {expr {[regexp ^\[01\]+$ $b]?[format %x [scan $b %b]]:0}}

Try it online!

There was a bug in fifth test case. Fixed now.

Stacked, 24 bytes
[:\'1|0'-#'0=\unbin*hex]

Try it online!

Dyvil, 32 Bytes
s=>Int.parseInt(s,2).toHexString

Pretty much self-explanatory. Throws a NumberFormatException for invalid inputs. Output without 0x.

Javascript (ES6) 50 45 39 bytes

h=
s=>isNaN(n=+('0b'+s))?0:n.toString(16)
<input id="i" type="text" onchange="o.innerHTML=h(i.value)"><pre id="o"></pre">

with thanks to Shaggy 6 bytes less. Or for a 26 byte version that returns 'NaN' instead of '0' on error:
s=>+('0b'+s).toString(16)

'0b' was introduced as a binary number prefix in ES6.

You should be able to save some bytes by moving the assignment of n within isNaN and then removing the parentheses from the function parameter. Also, does the 0 need to be a string?

@Shaggy - new ways to be sneaky, thanks. And also agree that  0 converts to '0' automatically when inspecting/printing the result.

Python 2, 27 bytes
lambda s:hex(int('0b'+s,2))

Try it online!
We invalidate inputs like 0b1010 or -1010 by prefixing 0b ourselves — because 0b0b1010 and 0b-1010 are invalid base 2 literals in Python.

eval('0b'+s) for a byte

No, it’s too strong! Inputs like "0+4*5" will yield 20.

Perl 6, 19 bytes ( = 18 + 1 for "-p" )
perl6 -pe '$_=:2($_).base: 16'
Nothing creative. The :2(string) construct takes the string and interprets it as a number in base 2. (This works for arbitrary bases up to base 36.) The base method takes a number and gives a string representation in the given base.
Due to -p, it loads one line from stdin at a time, expecting each to contain one number. If you feed it something that's not valid binary number, you get an error and the program ends.

Lua, 43 40 bytes
print(("").format("%x",tonumber(...,2)))

I think it explains itself. Parses from base 2 to decimal then formats it to hex.
If it is not binary input it will simply error (tested with Lua 5.2,5.3).

Javascript, 28 bytes
x=>eval("0b"+x).toString(16)

evals x with a 0b in front of it, turning it into a binary literal. Binary literals error out on non binary values of x. .toString(16) turns x into a hexdecimal.

Python 3, 52 29 26 bytes
print(hex(int(input(),2)))

It's not very golfy

Unfortunately, since the OP changed the rules it now only differs by being a more verbose function definition.

...plus (like the other one) does not exit, error or yield 0 for all invalid inputs. (Also you have not updated the TIO link from the 52 byter)

You might be able to change it to Python2 (and remove the parens after print), since it would error on invalid inputs due to various different reasons.

@Zacharý Sadly Python 2 doesn't seem to have a hex() builtin

Okay then, -__-

Rust, 58 57 bytes
Saved one byte using 8 bit int
|n:&str|format!("{:x}",u8::from_str_radix(n,2).unwrap());

Ungolfed
fn main() {
    let bin = "101";
    println!("{:x}", u8::from_str_radix(bin, 2).unwrap()); // 5
}

Try it online!

Kotlin 1.1, 92 bytes
Submission
fun r(i:String):String{return if(i.matches(Regex("[01]+")))i.toLong(2).toString(16)else "0"}

Beautified
fun r(i: String): String {
    return if (i.matches(Regex("[01]+"))) {    // If it is valid
        i.toLong(2)                            // Convert to Long
         .toString(16)                         // Return as hex
    } else {                                   // Otherwise
        "0"                                    // Return 0
    }
}

Explanation

The number is checked to be valid by the regex
Kotlin to and from string methods are used to convert the string

Unfortunately this does not run on TryItOnline, as it uses newer Kotlin features

Perl 5, 30 + 1 (-n) = 31 bytes
printf"%x",!y/01//c&&oct"0b$_"

Try it online!

REXX, 15 bytes
say b2x(arg(1))

Julia, 24 bytes
f(x)=hex(parse(Int,x,2))

Try it online!

Common Lisp, 48 bytes
(format t"~X"(parse-integer(read-line):radix 2))

Try it online!

Bash, 19 bytes
printf %x $((2#$1))

Try it online!

><>, 84 82 Bytes
Improved somewhat. Probably still improvable.
l&1>:}*{$}2\~-?\02.
~~&\?&:-1&*/1l+<
>:f1+%:}\
\?:,+1f-/.47r~
)a:;!?ln/?
.47o+*b5/

Old version:
1l&>:}*{$}2\
~~&\?&:-1&*/l +<
>:f1+%:}-f1\1-?/
\?      :,+/r~
n/?)a:;!?l <
5/.4co+*b

I'll work on improving it later, see if I can get rid of that big chunk of whitespace.
How it works:
(This is for the old version, new version works the same but with loops in different positions)
Implicit input, assumed to be a series of bits such as '1,1,1,0,0', with the ones place on the right, as normal.
l&1

Store the length in the registry; push 1 to the stack. The 1 will record which place we are on in the binary number.
   >:}*{$}2\
   \?&:-1&*/

Replace each bit with the value it represents. For example, 1,1,1,0 goes to 8,4,2,0.
~~&

Delete the counter and position-measurer.
           /l +<
           \1-?/

Sum the stack. Results in the number that was represented in binary.
>:f1+%:}-f1\
\?      :,+/

Convert this to hexadecimal, which unfortunately reverses it and leaves a trailing 0. For example, 28 becomes 12, 1, 0.
           /r~

Remove the trailing zero and un-reverse it.
n/?)a:;!?l <
5/.4co+*b

This is all for printing. If the value is <10, just print it normally. Otherwise, add 55 and print the ascii character of this number.

><>, 50 bytes
{:?v~
!v0>}l4%?
 r
4<]nv?)9:+++*2}*4}*8[
+"W"<.33o

Try It Online
Complies with the question by erroring on invalid input, but as it always ends with an error anyway, this is a bit tongue in cheek.
How It Works
{:?v~ Pops leading 0s
...

...
!v0>}l4%? Adds leading 0s until the length of the binary is divisible by 4
 r        And reverses the input
...

...                   Repeatedly take the last 4 digits of the binary
4<]nv?)9:+++*2}*4}*8[ Calculate the value of those digits and print the hexadecimal value
+"W"<.33o             If the value is above 9, print the appropriate letter


text:
FORTY TWO? SIX? NINE? Understand these and much more!
Given the written, spelled-out representation of an integer from 1 to 10^15-1 inclusive, convert it to an actual integer in decimal.
Input Format
The input will always be a string of groups, where each group is composed only of letters and spaces(). The groups are separated by commas.
You may choose whether you want the letters to be all lowercase, all uppercase, or title case.
For the purposes of this challenge, there are no hyphens (-) between e.g. "forty-two", so tokens within groups are separated by spaces only.
The input will contain no words and.
You can test if an input is valid by putting it as input into this Retina program.
Here is a full table of tokens:
Units:

+1 | "one"
+2 | "two"
+3 | "three"
+4 | "four"
+5 | "five"
+6 | "six"
+7 | "seven"
+8 | "eight"
+9 | "nine"

Teens:

+10 | "ten"
+11 | "eleven"
+12 | "twelve"
+13 | "thirteen"
+14 | "fourteen"
+15 | "fifteen"
+16 | "sixteen"
+17 | "seventeen"
+18 | "eighteen"
+19 | "nineteen

Tens:

+20 | "twenty"
+30 | "thirty"
+40 | "forty"
+50 | "fifty"
+60 | "sixty"
+70 | "seventy"
+80 | "eighty"
+90 | "ninety"

Hundred:

×100 | "hundred"

Place markings:

×10^3  | "thousand"
×10^6  | "million"
×10^9  | "billion"
×10^12 | "trillion

How to Evaluate a Spelled-out Representation
We will be working with the example input "forty five thousand,one hundred thirteen"
First, split the input into groups by commas, to get e.g. ["forty five thousand","one hundred thirteen"]
Then, evaluate each group:

Split by spaces to get a list of tokens
Start with a running total of 0
For each token, do as the table says. If the token is 9, do +9 and add 9 to the running total. If the token is thousand, multiply the running total by 1000.

For the second example group, this would be:
running total    token
0
1                "one"
100              "hundred"
113              "thirteen"

For the first example group, this yields 45000.
After this is done, sum each group to get the output e.g.45113.
Note that you do not have to evaluate the number exactly as I had laid it out as long as you produce the same results. For example, you could do string substitution to get an expression you can eval.
Test Cases
"one" -> 1
"ten" -> 10
"forty" -> 40
"one hundred" -> 100
"one thousand" -> 1000
"ten million" -> 10000000
"one hundred billion" -> 100000000000
"ten trillion" -> 10000000000000
"nine hundred ninety nine trillion,nine hundred ninety nine billion,nine hundred ninety nine million,nine hundred ninety nine thousand,nine hundred ninety nine" -> 999999999999999
"two hundred forty one trillion,eight hundred sixty one billion,seventy seven million,one hundred fifty four thousand,twenty eight" -> 241861077154028
"four hundred eighty five trillion,six hundred fifty seven billion,six hundred million,four hundred eighty two thousand,one hundred seventy eight" -> 485657600482178
"three hundred eighty nine trillion,five hundred twenty billion,one hundred ninety seven million,nine hundred fifty thousand,nine hundred eighty four" -> 389520197950984
"one hundred fifty five trillion,five hundred five billion,four hundred fifty eight million,six hundred seventy thousand,six hundred sixty one" -> 155505458670661
"one hundred fifty two trillion,ninety three billion,two hundred twenty one million,nine hundred thirty two thousand,five hundred eighty" -> 152093221932580
"three hundred forty three trillion,two hundred eighty six billion,nine hundred sixty five million,six hundred four thousand,two hundred seventy nine" -> 343286965604279
"six hundred ninety eight trillion,nine hundred seventy five billion,one hundred five million,sixty thousand,two hundred forty" -> 698975105060240
"five hundred seventy four trillion,one hundred sixty billion,five hundred ninety eight million,one hundred nine thousand,sixty two" -> 574160598109062
"four hundred seventy seven trillion,two hundred twenty five billion,eight hundred sixty three million,one hundred eighteen thousand,eight hundred four" -> 477225863118804
"eighty seven trillion,two hundred eighty three billion,six hundred eighty eight million,eight hundred fifty three thousand,sixty nine" -> 87283688853069
"eight hundred trillion,fifty billion,five hundred seven million,eighty thousand,fifty" -> 800050507080050
"seven hundred seventy three trillion,three hundred billion,four hundred thousand,nine" -> 773300000400009
"three hundred trillion,two hundred eighty eight billion" -> 300288000000000
"four hundred trillion,two hundred six billion,sixty six million,sixty" -> 400206066000060
"eight trillion,ninety nine million,four hundred sixty thousand,four hundred" -> 8000099460400
"seventy trillion,six hundred billion,forty million,seven hundred thousand" -> 70600040700000
"one hundred twenty billion,one hundred million,seventy thousand,forty" -> 120100070040
"four billion,eight hundred million,five hundred four thousand,five hundred six" -> 4800504506
"five hundred trillion,three hundred fifty five billion,seventy six thousand" -> 500355000076000
"fifty eight trillion,ninety eight billion,forty" -> 58098000000040

Not a Duplicate
The other question involves the units only modifying the previous value, such that every 'group' is composed of only an integer and a modifier. This requires a more dynamic approach in order to calculate groups of varying sizes.

Sandbox : Here

Er, that challenge involves interpreting units in a similar way, and then asks you to print the result with some other system. Answers to that challenger generally do the two parts seperately, which means they can be copied with the second half removed

Mathematica, 28 bytes
Mathematica has a builtin for everything
Interpreter@"SemanticNumber"

Of course, Mathematica has a built-in interpreter for spelled-out numbers.
Try it on Wolfram Sandbox
Usage
f=Interpreter@"SemanticNumber"

f["three hundred trillion,two hundred eighty eight billion"]

300288000000000

f["five hundred seventy four trillion,one hundred sixty billion,five hundred ninety eight million,one hundred nine thousand,sixty two"]

574160598109062

I really don't like these answers, but I won't downvote it as there's nothing wrong with it.

@StanStrum uh... okay? I think your comment is more suitable in chat (or meta posts), not comments. It doesn't add any value to the answer.

Python 2, 491 bytes
a,m,s,r={'one':1,'two':2,'three':3,'four':4,'five':5,'six':6,'seven':7,'eight':8,'nine':9,'ten':10,'eleven':11,'twelve':12,'thirteen':13,'fourteen':14,'fifteen':15,'sixteen':16,'seventeen':17,'eighteen':18,'nineteen':19,'twenty':20,'thirty':30,'forty':40,'fifty':50,'sixty':60,'seventy':70,'eighty':80,'ninety':90},{'hundred':100,'thousand':1e3,'million':1e6,'billion':1e9,'trillion':1e12},input(),0
for i in s.split(','):
 j=0
 for k in i.split():j=j+a[k]if k in a else j*m[k]
 r+=j
print r

Try it online!

You can save some bytes by writing r as dict(one=1...


text:
Playing Darts: become an amateur with the most efficient prioritizing
Introduction:
I think most people will know how darts work. But since some might not, here are the rules of playing Darts in a nutshell:

Amount of players: 2
Starting points: 501
Goal: Get your points to 0 first
Darts per player: 3
Available numbers on the board: 1 through 20, and Bulls-eye

Here is the layout of a Dartboard:

Each number is worth an equal amount of points
Each triple (the inner red-green circle) is 3x the number
Each double (the outer red-green circle) is 2x the number
The red center is called the Bulls-eye or Double-Bull, which is worth 50 points
And the outlined part of the center around the Bulls-eye (also known as Single-Bull) is worth 25 points

Some other rules:

You'll have to finish to 0 exactly
The very last dart that puts your points to 0 must be a double or the Bulls-eye
If a dart would leave your remaining total on 1 or less than 0, the entire set of three darts of which it forms a part is discarded (since you aren't able to finish 1 or less than 0 with a double)
Once you've reached (exactly) 0, you won't have to throw any remaining darts of the three you throw in a single turn

Relevant information regarding this Challenge:
Although every player has of course preferred doubles to finish with (Double-20 is preferred by some of the pros for example), in general - and for the sake of this challenge - this will be the order of prioritization on finishing doubles:
16, 8, 20, 12, 4, 18, 14, 10, 6, 2, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1, Bulls-Eye

Why? Let's compare a double-16 and double-17 finish. If you want to throw the double-16, but throw in the 16 instead by accident, you can continue to double-8. If you want to throw the double-17, but throw in the 17 instead, you must first throw an odd number (like 1 or 3), before you can try your best on a finishing double again. If we look at the following, you can see the next move in case you accidentally throw a single instead of a double:
Bulls-eye
20-10-5
19
18-9
17
16-8-4-2-1
15
14-7
13
12-6-3
11

Clearly 16 is your best bet, hence the given order of prioritizing above. (And since the Bulls-eye is the smallest, that has the lowest preference for the sake of this challenge.)
Challenge:
So, those are the rules of playing Darts. As for this challenge:
Given an input integer in the range of 2-170 (excluding 169, 168, 166, 165, 163, 162, 159; these cannot be finished within 3 darts), output the steps required to finish it following these rules in this exact order of precedence:

You must try to finish it in as few darts as possible
You must keep the prioritizing in mind when doing so for your finishing darts
When multiple options are available with the same priority, we pick the option with the highest number. I.e. 1.) For 131 the expected result is T20, T13, D16 instead of T19, T14, D16 or T18, T15, D16 or T17, T14, D16 etc., because T20 is the highest number. 2.) For 109 the expected result is 17, T20, D16 instead of 20, T19, D16, because T20 is the highest number.
If exactly three darts must be thrown to finish, sort the first two throws by Single, Triple, Double, Bulls-Eye, Single-Bull

Keeping the rules above in mind, these will be your strict input-output pairs (format of both input and output is flexible, though):
Legend: D = Double; T = Triple; BE = Bulls-eye; SB = Single-Bull

Points left:   Darts to throw (in exact order)
2              D1
3              1, D1
4              D2
5              1, D2
6              D3
7              3, D2
8              D4
9              1, D4
10             D5
11             3, D4
12             D6
13             5, D4
14             D7
15             7, D4
16             D8
17             1, D8
18             D9
19             3, D8
20             D10
21             5, D8
22             D11
23             7, D8
24             D12
25             9, D8
26             D13
27             11, D8
28             D14
29             13, D8
30             D15
31             15, D8
32             D16
33             1, D16
34             D17
35             3, D16
36             D18
37             5, D16
38             D19
39             7, D16
40             D20
41             9, D16
42             10, D16
43             11, D16
44             12, D16
45             13, D16
46             14, D16
47             15, D16
48             16, D16
49             17, D16
50             BE
51             19, D16
52             20, D16
53             T7, D16
54             D11, D16
55             T13, D8
56             T8, D16
57             SB, D16
58             D13, D16
59             T9, D16
60             D14, D16
61             T15, D8
62             T10, D16
63             T13, D12
64             D16, D16
65             T11, D16
66             D17, D16
67             T17, D8
68             T12, D16
69             T15, D12
70             D19, D16
71             T13, D16
72             D20, D16
73             T19, D8
74             T14, D16
75             T17, D12
76             T20, D8
77             T15, D16
78             D19, D20
79             T13, D20
80             T16, D16
81             T19, D12
82             BE, D16
83             T17, D16
84             T20, D12
85             T15, D20
86             T18, D16
87             T17, D18
88             T16, D20
89             T19, D16
90             BE, D20
91             T17, D20
91             T17, D20
92             T20, D16
93             T19, D18
94             T18, D20
95             T19, D19
96             T20, D18
97             T19, D20
98             T20, D19
99             7, T20, D16
100            T20, D20
101            T17, BE
102            10, T20, D16
103            11, T20, D16
104            T18, BE
105            13, T20, D16
106            14, T20, D16
107            T19, BE
108            16, T20, D16
109            17, T20, D16
110            T20, BE
111            19, T20, D16
112            20, T20, D16
113            T20, T7, D16
114            T20, D11, D16
115            T19, D13, D16
116            T20, T8, D16
117            T20, SB, D16
118            T20, D13, D16
119            T20, T9, D16
120            T20, D14, D16
121            T19, D16, D16
122            T20, T10, D16
123            T19, D17, D16
124            T20, D16, D16
125            T20, T11, D16
126            T20, D17, D16
127            T19, D19, D16
128            T20, T12, D16
129            T19, D20, D16
130            T20, D19, D16
131            T20, T13, D16
132            T20, D20, D16
133            T17, BE, D16
134            T20, T14, D16
135            T19, D19, D20
136            T18, BE, D16
137            T20, T15, D16
138            T20, D19, D20
139            T19, BE, D16
140            T20, T16, D16
141            T17, BE, D20
142            T20, BE, D16
143            T20, T17, D16
144            T18, BE, D20
145            T20, T15, D20
146            T20, T18, D16
147            T19, BE, D20
148            T20, T16, D20
149            T20, T19, D16
150            T20, BE, D20
151            T20, T17, D20
152            T20, T20, D16
153            T20, T19, D18
154            T20, T18, D20
155            T20, T19, D19
156            T20, T20, D18
157            T20, T19, D20
158            T20, T20, D19
160            T20, T20, D20
161            T20, T17, BE
164            T20, T18, BE
167            T20, T19, BE
170            T20, T20, BE

NOTE: Test cases are done by hand, so if you see any mistakes, please comment down below.
Multiple fixed thanks to @JohanKarlsson, @JonathanAllan, and @Sebastian
Challenge rules:

Input and output format are flexible. Can be a list of Strings, array of Objects, single STDOUT-printline, your call. You can also choose your own formatting regarding the Triples, Doubles, Bulls-Eye and Single-Bull. Please state what you've used in your answer.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

the non-double dart(s) have the following priority order (...): Single, Triple, Double, ... Not that it really matters, but just out of curiosity: I suppose a (harder) Triple is preferred over a Double in order to minimize the risk of throwing a dart outside the board?

@Arnauld Yes, with a Triple first there is the possibility that you miss the Triple and hit something else, but in that case your score is going down and you can adjust. When you miss a Double and it's outside the board, you basically wasted a dart completely and your score remains the same. Of course in a real life scenario there are cases where you might prefer a dart going outside the board instead of in a Single (i.e. D16 is left and you accidentally throw 7. Throwing outside the board to try D16 again would have been better, since after 7 you'd need two darts to finish 25 instead of one).

The precedence order is (I believe) that "You must keep the prioritizing in mind when doing so for your finishing darts" is of greater priority than "When multiple options are available with the same priority, we pick the highest numbers" and "When you have to use 2 or 3 darts to finish, the non-double dart(s) have the following priority order (for the sake of this challenge): Single, Triple, Double, Bulls-Eye, Single-Bull" ... so for a finish of 139 (for example) wouldn't T19, BE, D16 be of higher priority than the listed T20, T19, D11?

@JonathanAllan You're indeed right that T19, BE, D16 should be the answer for 139. We first look if we can finish it in 1 or 2 darts instead of 3; then the best double to end with (which is D16 in this case), and then others two numbers will be ordered as "Single, Triple, Double, Bulls-Eye, Single-Bull". Will edit test case 139, and if you see any other incorrect ones let me know.

FYI I'm used to the 25 point ring being called the Inner.

@Neil Hmm, never heard anyone regering to it as Inner tbh. It's usually Single-Bull (or Outer Bull), and the center is known as Bulls-Eye or Double-Bull. Here is a Glossary of darts from Wikipedia.

@JonathanAllan Actually, that one is correct. 99 should be 7, T20, D16 (I know actual darters would never throw like this and always start with the T20, but in the challenge rules I've specified the following rule: "When you have to use 2 or 3 darts to finish, the non-double dart(s) have the following priority order (for the sake of this challenge): Single, Triple, Double, Bulls-Eye, Single-Bull" (because singles are easier to hit). Also fixed some other test cases order regarding rule 3.

Oh, that's what that means! Why is "double" in that list? (or maybe that should be why does it read "non-double dart(s)" rather than "non-final dart(s)"?)

Three more: 133 -> T17, BE, D16; 136 -> T18, BE, D16; and 146 -> T20, T18, D16

So, could (4) just be rephrased as "If [exactly] three darts must be thrown, sort the first two throws by Single, Triple, Double, Bulls-Eye, Single-Bull", or have I still misinterpreted it?

101 -> T17, BE, 104 -> T18, BE, 107 -> T19, BE

142 -> T20, BE, D16

Ah, you're right that the 25 is actually the Outer, not the Inner. My mistake.

Python 3, 987 1,003 586 bytes
Edit: Fixed problem with T20's using some hacky code.
Edit: Added in golfed version.
from itertools import*
def d(i):
 f={v*2:"D"+str(v) for v in [16,8,20,12,4,18,14,10,6,2,19,17,15,13,11,9,7,5,3,1]}
 f[50]="BE"
 t={3*i:"T"+str(i) for i in range(20,6,-1)}
 t.update({i:str(i) for i in range(20,0,-1)})
 t.update({2*i:"D"+str(i) for i in range(20,10,-1) if i%3!=0})
 t.update({50:"BE", 25:"SB"})
 if i in f:
  return f.get(i)
 else:
  for n,x in product(f,t):
   r=i-n
   if r in t:
    return ' '.join((t.get(r),f.get(n)))
  for n,x,y in product(f,t,t):
   r=i-n
   if x+y==r:
    b=x!=60 or y>20
    return ' '.join((t.get(x if b else y),t.get(y if b else x), f.get(n)))

Try it online!
Ungolfed version:
from itertools import product
def darts(inp):
    list_finishes = [16, 8, 20, 12, 4, 18, 14, 10, 6, 2, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1]
    finishes = {finish*2:"D"+str(finish) for finish in list_finishes}
    finishes.update({50:"BE"})
    throws = {3*i:"T"+str(i) for i in range(20,6,-1)}
    throws.update({i:str(i) for i in range(20,0,-1)})
    throws.update({2*i:"D"+str(i) for i in range(20,10,-1) if i%3!=0})
    throws.update({50:"BE", 25:"SB"})

    if inp in finishes:
        return finishes.get(inp)
    else:
        for finish, x in product(finishes, throws):
            remaining = inp - finish
            if remaining in throws:
                return ', '.join((throws.get(remaining), finishes.get(finish)))
        for finish, x, y in product(finishes, throws, throws):
            remaining = inp - finish
            if x + y == remaining:
                    return ', '.join((throws.get(x if x!= 60 or y>20 else y), throws.get(y if x!= 60 or y>20 else x), finishes.get(finish)))

Little effort has gone into golfing this code, as I intended it to be a reference solution more than anything. Anyone who wants to improve this code is free to post it as their own solution or edit my answer. I have also created a function to test your function against the given values (Try it online with my function):
def test_func(func, has_comma=True):
    answers  =  """
2              D1
3              1, D1
4              D2
5              1, D2
6              D3
7              3, D2
8              D4
9              1, D4
10             D5
11             3, D4
12             D6
13             5, D4
14             D7
15             7, D4
16             D8
17             1, D8
18             D9
19             3, D8
20             D10
21             5, D8
22             D11
23             7, D8
24             D12
25             9, D8
26             D13
27             11, D8
28             D14
29             13, D8
30             D15
31             15, D8
32             D16
33             1, D16
34             D17
35             3, D16
36             D18
37             5, D16
38             D19
39             7, D16
40             D20
41             9, D16
42             10, D16
43             11, D16
44             12, D16
45             13, D16
46             14, D16
47             15, D16
48             16, D16
49             17, D16
50             BE
51             19, D16
52             20, D16
53             T7, D16
54             D11, D16
55             T13, D8
56             T8, D16
57             SB, D16
58             D13, D16
59             T9, D16
60             D14, D16
61             T15, D8
62             T10, D16
63             T13, D12
64             D16, D16
65             T11, D16
66             D17, D16
67             T17, D8
68             T12, D16
69             T15, D12
70             D19, D16
71             T13, D16
72             D20, D16
73             T19, D8
74             T14, D16
75             T17, D12
76             T20, D8
77             T15, D16
78             D19, D20
79             T13, D20
80             T16, D16
81             T19, D12
82             BE, D16
83             T17, D16
84             T20, D12
85             T15, D20
86             T18, D16
87             T17, D18
88             T16, D20
89             T19, D16
90             BE, D20
91             T17, D20
91             T17, D20
92             T20, D16
93             T19, D18
94             T18, D20
95             T19, D19
96             T20, D18
97             T19, D20
98             T20, D19
99             7, T20, D16
100            T20, D20
101            T17, BE
102            10, T20, D16
103            11, T20, D16
104            T18, BE
105            13, T20, D16
106            14, T20, D16
107            T19, BE
108            16, T20, D16
109            17, T20, D16
110            T20, BE
111            19, T20, D16
112            20, T20, D16
113            T20, T7, D16
114            T20, D11, D16
115            T19, D13, D16
116            T20, T8, D16
117            T20, SB, D16
118            T20, D13, D16
119            T20, T9, D16
120            T20, D14, D16
121            T19, D16, D16
122            T20, T10, D16
123            T19, D17, D16
124            T20, D16, D16
125            T20, T11, D16
126            T20, D17, D16
127            T19, D19, D16
128            T20, T12, D16
129            T19, D20, D16
130            T20, D19, D16
131            T20, T13, D16
132            T20, D20, D16
133            T17, BE, D16
134            T20, T14, D16
135            T19, D19, D20
136            T18, BE, D16
137            T20, T15, D16
138            T20, D19, D20
139            T19, BE, D16
140            T20, T16, D16
141            T17, BE, D20
142            T20, BE, D16
143            T20, T17, D16
144            T18, BE, D20
145            T20, T15, D20
146            T20, T18, D16
147            T19, BE, D20
148            T20, T16, D20
149            T20, T19, D16
150            T20, BE, D20
151            T20, T17, D20
152            T20, T20, D16
153            T20, T19, D18
154            T20, T18, D20
155            T20, T19, D19
156            T20, T20, D18
157            T20, T19, D20
158            T20, T20, D19
160            T20, T20, D20
161            T20, T17, BE
164            T20, T18, BE
167            T20, T19, BE
170            T20, T20, BE
"""
    if not has_comma:
        answers = answers.replace(',','')
    answers_dict = {int(answer.split('  ')[0]):answer.split('  ', 1)[1].lstrip() for answer in answers.split('\n')[1:-1]}
    all_valid = True
    for key in answers_dict.keys():
        try:
           assert func(key)==answers_dict.get(key)
        except:
            print("Failure on {}: Your answer '{}' != Given answer '{}'".format(key, func(key), answers_dict.get(key)))
            all_valid = False
    if all_valid:
        print("All tests completed successfully.")

Great answer, and welcome to PPCG! I would suggest to golf it at least somewhat (variable/method names and spaces and such), since this is a code-golf challenge. :) I've fixed the test cases for 55, 119, 122, 127 and 131 in the challenge description, since you were given the correct output for those. As for the other ones, I've clarified rule number 3 a bit. Since rule 3 takes priority over rule 4, you first take the highest possible number, and then look at the others. So 109 should indeed be 17, T20, D16, because T20 is the highest possible number with the D16 finish.

Ah I understand now. Unfortunately, I couldn't think of an elegant way to implement that change, so I resorted to a hacky method. Oh well, all of the tests pass now.

Great, +1 from me! :) And I see a lot of things you could still golf in your golfed answer, but it's a bit too much to name. Tips for golfing in Python might be interesting to read through, to see if you can apply any to your code to golf it further. Thanks for being the first to answer my challenge, and enjoy your stay on PPCG!

You're still the only answer, so I've accepted it for now. If a shorter answer comes along the check might change again as is the standard here on PPCG.


text:
Get the best of two Arrays
You will be given two arrays of floating-point numbers. Your task is to pair the corresponding elements of the two arrays, and get the maximum of each pair. However, if the two corresponding elements are equal, you must take their sum instead.
For example, given the lists [1, 3, 3.2, 2.3] and [3, 1, 3.2, 2.6], you must do the following:

Pair the elements (or zip): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

Go through each pair and apply the process above: [3, 3, 6.4, 2.6].

Specs

The arrays / lists will always have equal length. They may however be empty.

The numbers they contain will always fit your language's capabilities, as long as you do not abuse that. They may be positive, zero or negative, you must handle all types.

If it helps you reduce your byte count, you may also take the length of the lists as input.

Rules

This is code-golf, so shortest answer in bytes wins.
Standard input and output rules apply. You may take input (and output) in any reasonable format.
Default Loopholes are forbidden.

Test Cases

Array_1, Array_2 -> Output

[], [] -> []
[1, 2, 3], [1, 3, 2] -> [2, 3, 3]
[1, 3, 3.2, 2.3], [3, 1, 3.2, 2.6] -> [3, 3, 6.4, 2.6]
[1,2,3,4,5,5,7,8,9,10], [10,9,8,7,6,5,4,3,2,1] -> [10, 9, 8, 7, 6, 10, 7, 8, 9, 10]
[-3.2, -3.2, -2.4, 7, -10.1], [100, -3.2, 2.4, -7, -10.1] -> [100, -6.4, 2.4, 7, -20.2]

You say that the numbers will always fit "within your language's" capabilities".  As long as you do not "abuse" that.  Would only supporting integers in a language that does not have floats be considered an abuse?  The question does say floating point but I don't really see a reason why it has to be floats.  The same process can be done on integers.  I would like to solve this in Brain-Flak but Brain-flak only supports ints.

@WheatWizard I can make an exception for that. Go ahead and post your answer and mention I allowed it to avoid confusion.

Jelly, 4 bytes
=‘×»

Try it online!
This uses the exact same approach as my APL answer, except Jelly has a builtin for adding one to a number!

Hate to be a spoilsport, but aren't some of those characters more than one byte each in any sensible encoding?

This uses the jelly codepage.

I finally won against competition!

@Zacharý ONE MAN, 4 btytes... THIS SUMMER... You... WILL... BE... JELLY OF HIM... rated J for Jelly.

Python 2, 45 bytes
A mix of my initial solution and @ovs'.
lambda*a:map(lambda x,y:max(x,y)*-~(x==y),*a)

Try it online!
Python 2, 49 bytes
lambda x,y:[max(a,b)*-~(a==b)for a,b in zip(x,y)]

Try it online!
Python 2, 46 bytes
@ovs suggested this method to save 3 bytes.
lambda*x:[max(a,b)*-~(a==b)for a,b in zip(*x)]

Try it online!

How?
First off, we pair the corresponding elements, by using either * or zip(). That allows us to do our further golfing by working either with a map or a list comprehension.
The cool trick in this answer is this part: max(x,y)*-~(x==y). How does that work? - Well, as most of you already know, Python auto-converts bool values to integers when they are used in arithmetic operations. Hence, (x==y) gets evaluated as 1, if the condition is met. However, if the two values are not equal, it returns 0 instead. Then, the bitwise operation -~ increments the value returned from the bool by 1, giving us either 2 or 1. max(a,b) gives the maximum value of the pair and * multiplies it by the value returned above (so it gets multiplied by 2 only if they are equal, in which case max() returns the value of both).
This is based on the fact that the sum of two equal numbers is in fact either of them doubled, and kind of "abuses" Python's bool class being a subclass of int.

Wow, that was really fast!

more straightforward, same number of bytes: lambda*a:map(lambda x,y:(x<=y)*y+(x>=y)*x,*a)

@jferard I fact, that's already Luis' solution.

@Mr.Xcoder Oops! I didn't read the whole page...

Never say "above," as the ordering can change (I don't see your solution above)

This isn't weak typing or converting booleans to ints. In Python the bool class is an actual subclass of int.

Python 3, 48 46 44 bytes
-2 bytes thanks to @nwellnhof
lambda*a:map(lambda*x:max(x)*2/len({*x}),*a)

Try it online!

Kotlin, 78 75 71 66 65 59 bytes
It's my first attempt, be cool :D
a.zip(b).map{(a,b)->when{b>a->b;a>b->a;else->a*2}}.toList()

TIO doesn't work with this solution (and i don't know why), source code for testing below
fun main(args: Array<String>) {
    bestOfTwo(floatArrayOf(), floatArrayOf()).print()
    bestOfTwo(floatArrayOf(0F), floatArrayOf(0F)).print()
    bestOfTwo(floatArrayOf(1F,2F,3F), floatArrayOf(1F,3F,2F)).print()
    bestOfTwo(floatArrayOf(1F,3F,3.2F,2.3F), floatArrayOf(3F,1F,3.2F,2.6F)).print()
    bestOfTwo(floatArrayOf(1F,2F,3F,4F,5F,5F,7F,8F,9F,10F), floatArrayOf(10F,9F,8F,7F,6F,5F,4F,3F,2F,1F)).print()
    bestOfTwo(floatArrayOf(-3.2F,-3.2F,-2.4F,7F,-10.1F), floatArrayOf(100F,-3.2F,2.4F,-7F,-10.1F)).print()
}

fun bestOfTwo(a :FloatArray, b :FloatArray): List<Float> =
    a.zip(b).map{(a,b)->when{b>a->b;a>b->a;else->a*2}}.toList()

fun List<Float>.print() {
    this.forEach { print("$it, ") }; println("")
}

EDIT:
-3 by replace "a+b[i]" by "a*2"
-4 by replace "mapIndexed" method by "zip" (Thanks to @AnonymousReality
 Swift solution)
-5 by replace "Math.max" method by when condition
-1 by change when condition order
-6 by change toFloatArray() by toList()

Welcome to PPCG! Please don't be discouraged by the downvote (it's the result of a slight quirk of the system that happens when a new user's first post is auto-flagged for quality and then they improve said post!!)

The worst "feature" ever...btw don't feel bad about it.

Link to Kotlin Playground: https://pl.kotl.in/Qne3U_j4l

JavaScript (ES6), 53 49 45 43 bytes
a=>b=>a.map((x,y)=>(y=b[y])>x?y:y<x?x:x+y)

4 bytes saved by borrowing a trick from Mr. Xcoder.
2 bytes saved thanks to Arnauld.

Try it

o.innerText=(f=

a=>b=>a.map((x,y)=>(y=b[y])>x?y:y<x?x:x+y)

)(i.value=[1,3,3.2,2.3])(j.value=[3,1,3.2,2.6]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))(j.value.split`,`.map(eval))
<input id=i><input id=j><pre id=o>

Explanation
a=>b=>

Anonymous function taking the 2 arrays as arguments via parameters a and b, in currying syntax (i.e., call with f(a)(b)
a.map((x,y)=>                      )

Map over the first array, passing each element through a function where x is the current element and y is the current index.
(y=b[y])

Get the element at index y in the second array and assign that as the new value of y.
>x?y

Check if y is greater than x and, if so, return y.
:y<x?x

Else, check if y is less than x and, if so, return x
:x+y

Else, return the sum of x and y. (Multiplying x or y by 2 would also work here, for the same number of bytes.)

j.value.split`,`.map(eval) or eval('['+j.value+']')? Also x+y would look neater IMHO.

@Neil: 1) I find the former easier to type. Also, I have a couple of Snippet templates on one of my machines; it's easier just to tack .map(eval) onto them. 2) Agreed, will edit in momentarily.

Haskell, 34 bytes
x!y|x>y=x|x<y=y|1<2=x+y
zipWith(!)

Try it online.

Same byte count: x!y=max x y+sum[x|x==y].

R, 31 29 bytes
function(a,b)pmax(a,b)+a*!a-b

pmax takes the parallel maximum of the two (or more) arrays (recycling the shorter as needed).
I was looking at Luis Mendo's comment and obviously I realized the approach could work for R as well. That got me to 30 bytes, but then I started playing around with different ways of getting indices instead to improve my original answer, and stumbled upon !a-b as TRUE where a==b and FALSE otherwise, equivalent to a==b. However, for whatever reason, R doesn't require parentheses around !a-b as it does for a==b, which saved me two bytes.
As mentioned by JDL in the comments, this works because ! (negation) has lower precedence than the binary operator - in R, which is strange.
Try it online! (new version)
Try it online! (original)

It turns out that unary "!" has lower precedence in R than binary "-", which I think is quite unusual (and I hadn't realised until reading this answer!)

@JDL yeah I almost always have to open up the R Syntax page while golfing in case of weird quirks like this...and also because I can never remember the precedence of : when interacting with arithmetic.

Dyalog APL, 5 bytes
⌈×1+=

Try it online!
How?

⌈, element-wise maximum of the arguments
×, element-wise multiply
1+=, 1 added to the element-wise equality of the arguments

This works because if the numbers are unequal, 1+= will be 1, which when multiplied by the maximum, is the maximum. When the numbers are equal, 1+= will return 2, when that is multiplied by the maximum, we get twice the maximum, or the maximum added to itself.

Jelly, 6 bytes
żSṀE?€

A dyadic link taking a list of numbers on each side and returning the resulting list.
Try it online! or see a test-suite*.
How?
żSṀE?€ - Link: list of numbers L, list of numbers R   e.g. [1,3,3.2,2.3], [3,1,3.2,2.6]
ż      - zip - interleave L & R                       [[1,3],[3,1],[3.2,3.2],[2.3,2.6]]
     € - for each pair:
    ?  - { if:
   E   -   ...condition: equal                          0      0       1         0
 S     -   ...then: sum                                               6.4
  Ṁ    -   ...else: maximum                             3      3                2.6
       - }                                    ... ->   [3     ,3     ,6.4      ,2.6]

An alternative is this monadic link taking a list of the two lists, also 6 bytes:
+»⁼?"/

* I don't think I've ever created a test-suite footer almost three times the byte count of the code before!

Outgolfed!. +1 for the practically verbatim interpretation of the question.

...and I've been caught out be forgetting that » vectorises before!

What else would it do, take the maximum array in some convoluted way?

No need for any convoluted definitions, Python manages - for example max([1,1,0],[1,0,3]) -> [1,1,0] (not [1,1,3]).

So, basically infinite-base?

No, max just returns the maximum of its two inputs, comparing elements starting at the left. It will fail if it reaches un-orderable elements during the comparisons for example (e.g. in py3 max([1,0,'3'],[1,0,1]) -> Type Error : '>' not supported between instances of 'int' and 'str')

05AB1E, 5 bytes
øεMÃO

Try it online!
-1 thanks to Emigna.

Nice idea using γ!

@Emigna I really wanted "maximal elements", and {γθ is probably the shortest I can get to for that.

How about øεMÃO?

@Emigna Cool, thanks! (duh why didn't I think of MÃ) yay got the lead now :p btw øεZÃO would work too

Java 8, 80 69 67 66 65 64 63 bytes
(a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);}

Modifies the second input-array instead or returning a new float-array to save bytes.
-11 bytes by taking the length as additional integer-input, which is allowed according to the challenge rules.
-5 bytes thanks to @OliverGrégoire (one byte at a time.. xD)
-1 byte indirectly thanks to @Shaggy's JS answer, by using a[l]*2 instead of a[l]+b[l].
Explanation:
Try it here.
(a,b,l)->{          // Method with 2 float-array and integer parameters and no return-type
  for(;l-->0;)      //  Loop over the array
    if(a[l]>=b[l])  //   If the current value in `a` is larger or equal to `b`:
      b[l]=         //   Modify the second input-array:
       a[l]*        //    Use `a` multiplied by:
        (a[l]>b[l]? //     If the current value in `a` is larger than `b`:
          1         //      Multiply by 1
         :          //     Else (`a` is smaller of equal to `b`):
          2)        //      Multiply by 2
                    //  End of loop (implicit / single-line body)
}                   // End of method

"If it helps you reduce your byte count, you may also take the length of the lists as input." It will definitely reduce your byte-count ;)

Also, 2 bytes shorter: a->b->l->{float A,B;for(;l-->0;b[l]=(A=a[l])<B?B:A>B?A:A+B)B=b[l];}

And you can save one more byte by putting float A, B in the for initialization.

(Sorry to spam) Last but not least: not declaring temp variables is actually shorter... (65 bytes) a->b->l->{for(;l-->0;)b[l]=a[l]<b[l]?b[l]:a[l]>b[l]?a[l]:2*a[l];}

@OlivierGrégoire Lol, was already in the process of changing that when I saw Shaggy's JavaScript answer using *2. :) Thanks either way.

Good! This'll make this easier: (a,b,l)->{for(;l-->0;)b[l]=a[l]<b[l]?b[l]:a[l]*(a[l]>b[l]?1:2);} (64 bytes) xD No, I don't stop :p

Or this: (a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);} (63 bytes)

@OlivierGrégoire Lol.. with golfing every byte helps, but that doesn't mean you need to golf it one byte at a time. ;p

Well, now you know my process of golfing ;)

MATL, 7 bytes
X>tG=s*

Input is a two-row matrix, where each row is one of the arrays.
Try it online!
Explanation
X>   % Implicit input. Maximum of each column
t    % Duplicate
G    % Push input
=    % Is equal? Element-wise with broadcast. Gives a two-row matrix
s    % Sum of each column. Gives a row vector containing 1 and 2
*    % Multiply, element-wise. Implicit display

Ruby, 42 bytes
->a,b{a.zip(b).map{|x,y|[x+y,x,y][x<=>y]}}

Try it online!
The spaceship operator is great.

05AB1E, 9 8 7 bytes
Saved a byte as Erik the Outgolfer pointed out that a list of lists is valid input.
øεMsËi·

Try it online!
Explanation
ø          # zip the lists
 ε         # apply to each pair
  M        # get max
   s       # swap the top 2 elements on the stack
    Ëi     # if all elements are equal
      ·    # double the max

Wow, that was really fast!

You can save a byte by removing the ‚ and inputting as a pair of a list and a list.

@EriktheOutgolfer: True. I assumed we weren't allowed to, but I see that the challenge does specify standard I/O rules. Thanks for notifying :)

@Emigna Tip: don't make rules out of your mind ;)

@EriktheOutgolfer: Yeah I really need to stop doing that. Especially rules which make my programs longer ;)

Pyth, 11 bytes
m*eSdhnd{dC

Try it here!
Pyth, 12 bytes
m*eSdhqhdedC

Try it here!
or
m*eSdh!tl{dC

Try it here!

@Jakube That's Erik's solution already, sadly. I wanted to use that too, but I can't now

Oh, didn't see that one.

Python 3, 49 46 45 bytes
3 bytes removed thanks to @Mr.Xcoder (splat instead of two arguments), and 1 byte thanks to @ovs (map instead of list comprehension)
lambda*x:map(lambda a,b:a*(a>=b)+b*(b>=a),*x)

Try it online!

46 bytes: lambda*c:[a*(a>=b)+b*(b>=a)for a,b in zip(*c)]. Turns out this is quite good too :) - Too bad there is no place for further golfing

@Mr.Xcoder Thanks! Good idea!

45 bytes by using map instead of zip.

Mathematica, 31 bytes
MapThread[If[#==#2,2#,Max@##]&]

J, 7 bytes
>.`+@.=

Try it online!
Takes one list as the left argument and the other as the right.
Luckily, equality is a rank zero operation.
Explanation
>.`+@.=
      =  Compare equality pairwise
    @.   If equal
   +       Sum
>.       (Else) take greater value

@. isn't really an if statement, but in this case it functions as one (it indexes into the gerund >.`+ based on the result of its right argument and applies that to the input).

Nice job, I know I couldn't do this, even though you have beenoutgolfed by my translation of my APL. >_<

J really shines here

@Zacharý rats, well-golfed nonetheless.

TI-Basic, 23 21 bytes
Prompt A,B
(ʟA=ʟB)ʟA+max(ʟA,ʟB

Too bad lists take up two bytes each...

You can save two bytes by prompting for X and Y, then using ʟX and ʟY to access them, i.e. "Prompt X,Y:ʟX(ʟX=ʟY)+max(ʟ1,ʟ2".

Also, this is currently invalid, since L1(L1=L2) attempts to get the element of L1 at a list, which throws an error. To fix that, swap the order, i.e. (L1=L2)L1.

@ScottMilner Thanks for pointing both of those out.

Uiua, 6 bytes
×+1⊃=↥

Try it!
×+1⊃=↥
   ⊃=↥  # elementwise max and equality mask
 +1     # increment
×       # multiply

Octave, 36 Byte
@(a,b)a.*(a>b)+b.*(b>a)+2.*a.*(a==b)

Welcome to the site! You can save a few bytes with @(a,b)max(a,b).*(1+(a==b))

Or better, using your approach, @(a,b)a.*(a>=b)+b.*(b>=a)

Pyth, 7 bytes
ms.MZdC

Try it here.

C# (.NET Core), using Linq 47+18=65 bytes
x=>y=>x.Zip(y,(a,b)=>a>b?a:b>a?b:b+a).ToArray()

Try it online!
C# (.NET Core), 82 bytes
x=>y=>l=>{for(int i=0;i<l;i++)x[i]=x[i]>y[i]?x[i]:y[i]>x[i]?y[i]:y[i]*2;return x;}

Try it online!

You can drop the LINQ answer by a few bytes by changing namespace System.LINQ to using System.LINQ

@jkelm yeah, I've been wondering if the 'using System;` is to be included or not like that, I guess not. I'll clean it up

System.Linq is included in the "Visual C# Interactive Compiler". I am not totally sure about returning Array vs IList vs IEnumerable, but if all are eligible then you can get the byte count to 37 - https://tio.run/##Sy7WTS7O/O9WmpesYOPpmleam1qUmJSTapOSXwqk7HRAMlglsIjZ2SmkKdj@r7C1q7S1q9CLyizQqNTRSNRJ0rS1S7RLsk@0SrJLtE@yStJO1PxvzcUVUJSZV6KRppGXWh4dW61g6KKjYAzCekZA0kjP2EWhVhMmCZIwRJI0c6nV1AvJdywqSqzU0NRENU0B4qBog1hNNC6ylv8A

Common Lisp, 60 59 bytes
(mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read))

Try it online!
-1 byte thanks to @Zacharý!

59 bytes: (mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read)).

You're welcome, I don't know lisp that well, I just translated my other answers into Lisp which ended up saving a byte.

Python with numpy, 28 bytes
lambda a,b:a*(a>=b)+b*(b>=a)

Assumes input is given as two numpy arrays.

If we are using numpy then here is my worse solution: lambda a,b:n.fmax(a,b)*((a==b)+1)

@Erich I like the idea, but to do that I would need to import numpy as n. I get away without it here because it's implicit in the input.

I guess i'm a bit shaky on the explicit byte counting, often python answers are simply lambdas, when an actual implementation of an answer would require assigning it to something. for this reason I wonder if it is allowable to get away with an implicit import statement as well?

@Erich In general, you can only refer to a variable n if you've defined n in your code, so imports must be explicit.  By default, we allow functions or full programs as answers, which includes anonymous functions.

here's an even worser version  lambda a,b:[max(n) for n in zip(a,b)]*((a==b)+1) without numpy :p

Well, this only needs input as numpy arrays, rather than importing numpy. But does this even work without using return?

@Zacharý Thanks for pointing that out.  I switched it in testing and forgot to take it out.

Perl 6, 34 28 bytes
{map {.max*2/set $_},[Z] $_}

Try it online!

Vyxal, 8 7 bytes
Zƛ≈[∑|G

-1 byte thanks to @emanresu A
Add the ḋ flag if you want to see the numbers in decimal format.
Try it Online!
Explanation:
Z        # Zip
 ƛ       # On each pair
   [     # If
  ≈      # All are equal
    ∑    # Sum
     |   # Otherwise
      G  # Get the greatest value

Vyxal, 6 bytes
₌Þ∴=›*

Try it Online!
₌      # Do both of these...
 Þ∴    # Elementwise maximum
   =›  # Equality, incremented -> list of 1s where unequal, 2s where equal
     * # Multiply by that.

Swift 3, 81 79 Bytes
func n(a:[Double],b:[Double]){for(x,y)in zip(a,b){print((x==y) ?x+y:max(x,y))}}

Swift has an interesting property in that an Int isn't directly castable to a Double, so you have to specify any arrays as being arrays of Doubles before passing them to the function.
(e.g.) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]
Edit: -2 bytes thanks to @EriktheOutgolfer

Do you need spaces around (x,y) and before ??

@EriktheOutgolfer The one before ? is needed because Swift would treat them as optional types instead of ternaries (which they aren't). The others aren't. Apart from that, this can be drastically golfed.

@EriktheOutgolfer - TheIOSCoder has already answered you partly, but you're right, you don't need the ones in the for loop, interesting!

73 bytes: func n(a:[Float],b:[Float]){print(zip(a,b).map{$0==$1 ?2*$0:max($0,$1)})} (the float inaccuracies need not to be handled by default)

Or 74 bytes: func n(a:[Float],b:[Float]){print(zip(a,b).map{($0==$1 ?2:1)*max($0,$1)})}

I got a 41 byte swift answer, check it out: https://codegolf.stackexchange.com/a/143367/11490

C, 76 75 bytes
Thanks to @Kevin Cruijssen for saving a byte!
f(a,b,n)float*a,*b;{for(;n--;++a,++b)printf("%f ",*a>*b?*a:*b>*a?*b:*a*2);}

Try it online!

Japt, 13 bytes
íV,È¥Y Ä *XwY

Try it online! with the -Q flag to format the output array.

Nicely done. I made 2 attempts at this earlier with both coming out at 17 bytes. I'd forgotten í could take a function as a second argument.

Scala, 61 Bytes
x=>y=>x zip y map(v=>if(v._1==v._2)v._1*2 else v._1 max v._2)

The above is a function literal in Scala. Here's an explanation.
x=>y=>         // Function literal taking 2 * Vector[Float], x and y.
x zip y        // Zip x and y into one list of pairs.
map(           // Replace every element in the list via a function.
v=>            // Function literal that takes a pair of floats.
if(v._1==v._2) // If the pair are equal.
v._1*2         // Set the element to the first member of the pair multiplied by 2.
else           // Otherwise.
v._1 max v._2) // Set it to their max.

Rust, 107 97 bytes
|a:V,b:V|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<V>();
type V=Vec<f32>;

Try it online!
Saved 8 bytes thanks to @mgc

I guess you can save 8 bytes by using type inference on the collected Vec and by using the max method of f32s: |a:Vec<f32>,b:Vec<f32>|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<Vec<_>>();

@mgc Thanks! Type inference was a good idea, but in this case type alias is even shorter.

J, 6 bytes
>.*1+=

A direct translation of my APL answer (and thus works the same as my MY and Jelly answers). Any tips are welcome, since I don't really know J.
Try it online!
Comparison with APL
>.*1+=
⌈ ×1+=

Swift 4, 41 bytes
{zip($0,$1).map{$0==$1 ?2*$0:max($0,$1)}}

Test cases:
let f: ([Float], [Float]) -> [Float]
    = {zip($0,$1).map{$0==$1 ?2*$0:max($0,$1)}}

let testcases: [(inputA: [Float], inputB: [Float], expected: [Float])] = [
    (
        inputA: [],
        inputB: [],
        expected: []
    ),
    (
        inputA: [1, 2, 3],
        inputB: [1, 3, 2],
        expected: [2, 3, 3]
    ),
    (
        inputA: [1, 3, 3.2, 2.3],
        inputB:  [3, 1, 3.2, 2.6],
        expected: [3, 3, 6.4, 2.6]
    ),
    (
        inputA: [1,2,3,4,5,5,7,8,9,10],
        inputB:  [10,9,8,7,6,5,4,3,2,1],
        expected: [10, 9, 8, 7, 6, 10, 7, 8, 9, 10]
    ),
    (
        inputA: [-3.2, -3.2, -2.4, 7, -10.1],
        inputB:  [100, -3.2, 2.4, -7, -10.1],
        expected: [100, -6.4, 2.4, 7, -20.2]
    ),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.inputA, testcase.inputB)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \((testcase.inputA, testcase.inputB)) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

Stax, 8 bytes
Ç√'8½B=☺

Run and debug it

Desmos, 26 bytes

f(a,b)=\{a=b:2a,a>b:a,b\}

Leading newline necessary.
Try it on Desmos!

In your TIO link, you might want to give an example giving it lists instead of numbers, like so: https://www.desmos.com/calculator/iil8pysjzu

@Steffan L1 and L2 are lists, they’re just defined through the table’s first two columns, and then the third column shows f(L1, L2) which is the result of passing the function the two lists. Desmos isn’t evaluating it row by row as it may initially seem

Python, 57 56 bytes
lambda a,b:[x==y and x+y or max(x,y)for x,y in zip(a,b)]

Generators, 57 56 bytes
lambda a,b:(x==y and x+y or max(x,y)for x,y in zip(a,b))

-1 each by Steffan

-1 byte using and and or: Try it online!

Thanks a lot! I used it on my lists and generators solutions.

BQN, 6 5 bytes
-1 byte by porting emanresu A's Vyxal answer
⌈×1+=

Anonymous tacit function that takes equal-length lists as left and right arguments. Try it at BQN online!
Explanation
⌈×1+=
    =  Compare the two lists itemwise (1 for equal, 0 for not equal)
  1+   Add 1 to each (2 for equal, 1 for not equal)
⌈       Get the itemwise maximums of the two lists
 ×     Multiply (itemwise)

Original solution
The spec can be implemented very literally in 6 bytes:
=◶⌈‿+¨
      ¨  Apply this function to corresponding pairs of elements from the arguments:
=          Test if the elements are equal (1 if so, 0 if not)
 ◶         Use that result to pick a function from this list and apply it:
  ⌈         If 0 (not equal), then max
   ‿+      If 1 (equal), then add

Turns out I unintentionally ported the Jelly/APL answers lol.

Ha--and the APL answer is actually identical to this one!

Factor, 36 bytes
[ [ 2dup = [ + ] [ max ] if ] 2map ]

Try it online!

POSIX Shell + Utilities, 40 bytes
paste $@|awk '$0=$1<$2?$2:$1>$2?$1:2*$1'

"Arrays" defined as "text files per POSIX".
Obviously buggy insofar as [0], [0] -> []. Doesn't come up in the validator, so. Append the 2-byte "" sequence to also handle that edge case.
Transcript of test cases:
$ cat cg; echo; wc -c cg
paste $@|awk '$0=$1<$2?$2:$1>$2?$1:2*$1'
40 cg
$ ./cg /dev/null                               /dev/null
$ ./cg <(printf '%s\n' 1 2 3)                  <(printf '%s\n' 1 3 2)
2
3
3
$ ./cg <(printf '%s\n' 1 3 3.2 2.3)            <(printf '%s\n' 3 1 3.2 2.6)
3
3
6.4
2.6
$ ./cg <(printf '%s\n' 1 2 3 4 5 5 7 8 9 10)   <(printf '%s\n' 10 9 8 7 6 5 4 3 2 1)
10
9
8
7
6
10
7
8
9
10
$ ./cg <(printf '%s\n' -3.2 -3.2 -2.4 7 -10.1) <(printf '%s\n' 100 -3.2 2.4 -7 -10.1)
100
-6.4
2.4
7
-20.2

CJam, 16 bytes
{.{a+_:e>\:=)*}}

Try it online!
Oh hey look, my code is cute :=) but a big dude \:=)*

Clojure, 40 bytes
#(map(fn[x y]((if(= x y)+ max)x y))% %2)

Try it online!

PHP, 74 bytes
function($a,$b){foreach($a as$i=>$p)echo$p*($p>=$q=$b[$i])+$q*($q>=$p),_;}

Prints the results separated by an underscore. Try it online.

Erlang, 65 bytes
fun(A,B)->lists:zipwith(fun(C,C)->C+C;(D,E)->max(D,E)end,A,B)end

example:
1> (fun(A,B)->lists:zipwith(fun(C,C)->C+C;(D,E)->max(D,E)end,A,B)end)([1, 3, 3.2, 2.3], [3, 1, 3.2, 2.6] ).
[3,3,6.4,2.6]

just a straightforward anonymous fun

Swift, 80 bytes
var o = [Int]();for (c, d) in zip(a,b){o.append(c==d ? c*2 : max(c,d))};return o

Create the output array
zip together a & b
for each loop through with c & d
append result to output array
return output array

You should be able to remove most of those spaces.

I got a 41 byte swift answer, check it out: https://codegolf.stackexchange.com/a/143367/11490

MY, 20 bytes
αωD6ǵ'69ǵ';ƒ⇹(αω=‘×↵

Try it online!
This uses the exact same approach as my APL and Jelly answers, except MY doesn't have some of the builtins:

D6ǵ'69ǵ';ƒ, this pushes <SPACE>⍐ in MY's codepage (where <SPACE> is a physical space) as a function, which turns two items into a list, then finds the maximum.
⇹(, map over each argument, then apply the function.

K, 12 bytes
{x|y*(1+x=y)}

Exact same strategy as my other answers.
Try it online!
Any golfing tips are welcome, as I don't really know K.

Jq 1.5, 49 44 bytes
transpose|map(if.0==.1then add else max end)

Sample input
[[], []]
[[1, 2, 3], [1, 3, 2]]
[[1, 3, 3.2, 2.3], [3, 1, 3.2, 2.6]]
[[1,2,3,4,5,5,7,8,9,10], [10,9,8,7,6,5,4,3,2,1]]
[[-3.2, -3.2, -2.4, 7, -10.1], [100, -3.2, 2.4, -7, -10.1]]

Sample run
$ jq -Mc 'transpose|map(if.0==.1then add else max end)' input
[]
[2,3,3]
[3,3,6.4,2.6]
[10,9,8,7,6,10,7,8,9,10]
[100,-6.4,2.4,7,-20.2]

Character count
$ echo -n 'transpose|map(if.0==.1then add else max end)' | wc -c
      44

Thanks again to Jonathan Frech for helping eliminate 5 bytes!

Is the space in .[1] then not omittable?

44 bytes: transpose|map(if.0==.1then add else max end).

Tcl, 57 bytes
proc M A\ B {lmap a $A b $B {expr $a-$b?max($a,$b):2*$a}}

Try it online!

Perl 5, 59 + 1 (-p) = 60 bytes
say join$",map$_>($t=$F[$i++])?$_:$_<$t?$t:$_*2,split/ /,<>

Try it online!

SmileBASIC, 120 bytes
An answer using ONLY the ARYOP function.
DEF B A,B,L
DIM C[L],D%[L]ARYOP 6,C,A,A,B
ARYOP.,A,A,B
ARYOP 1,B,A,C
ARYOP 1,B,C,B
ARYOP 6,D%,B,-1,0ARYOP 4,A,C,D%,A
END

Function is called as B array1 , array2 , length. Output is stored in array1.
Explanation:
'get minimum, sum, and maximum of B and A
ARYOP #AOPCLP,C,A,A,B 'c=clamp(a,a,b) (gets the minimum of a and b)
ARYOP #AOPADD,A,A,B 'a=a+b (get the sum)
ARYOP #AOPSUB,B,A,C 'b=a-c (get the maximum)
'check if min==max
ARYOP #AOPSUB,B,C,B 'b=c-c (min-max, will be negative or 0)
ARYOP #AOPCLP,D%,B,-1,0 'd%=clamp(b,-1,0) (d% is an integer array. 0=equal, -1=not equal)
'add subtract min from sum if elements were not equal
ARYOP #AOPMAD,A,C,D%,A 'a=c*d%+a

This challenge seemed boring at first, but there are actually a lot of different ways to do it. For example:
-calculate the maximum, add the minimum if B==A
-calculate the sum, subtract A if A<B, subtract B if B<A
-b+max(a-b,0)+a*(a==b)

APL(Dyalog Unicode), 15 bytes SBCS
(⊣⌈⊢×1+⊣=⊢)/¨,¨

Try it on APLgolf!
Can be golfed as:
((⌈×1+=)/¨,¨)
⌈×1+=

So it ends up being the same as the other APL answer...