text:
Replace twos with threes
Given a positive integer n write some code to take its prime factorization and replace all of its factors of 2 with 3.
For example
12 = 2 * 2 * 3 -> 3 * 3 * 3 = 27

This is code-golf so the goal is to minimize the byte count of your answer.
Test cases
1 -> 1
2 -> 3
3 -> 3
4 -> 9
5 -> 5
6 -> 9
7 -> 7
8 -> 27
9 -> 9
10 -> 15
11 -> 11
12 -> 27
13 -> 13
14 -> 21
15 -> 15
16 -> 81
17 -> 17
18 -> 27
19 -> 19
20 -> 45
21 -> 21
22 -> 33
23 -> 23
24 -> 81
25 -> 25
26 -> 39
27 -> 27
28 -> 63
29 -> 29

Fractran, 3 bytes
3/2

Fractran literally only has one builtin, but it happens to do exactly what this task is asking for. (It's also Turing-complete, by itself.)
The language doesn't really have a standardised syntax or interpreter. This interpreter (in a comment to a blog post –
 it's a very simple language) will accept the syntax shown here. (There are other Fractran interpreters with other syntaxes, e.g. some would write this program as 3 2, or even using 3 and 2 as command line arguments, which would lead to a score of 0+3 bytes. I doubt it's possible to do better than 3 in a pre-existing interpreter, though.)
Explanation
3/2
 /   Replace a factor of
  2  2
3    with 3
     {implicit: repeat until no more replacements are possible}

Talk about right tool for the job..

"Don't upvote trivial solutions that only uses a simple builtin." Well, in this case: Knowing that there's a language "Fractran" that has a single builtin that solves this specific task is by itself impressive.

Does this do primer factorization?

@Pandya: Some Fractran implementations use prime factorization internally (as an optimization), but they don't have to; the language operates on factors, not prime factors. (It just happens that 2 and 3 are prime.)

Related SO code golf (pre-PPCG): Write a Fractran interpreter.

Why does this exist? Its confusing. What was Conway looking for/studying?

@AnderBiguri: Likely looking for a Turing-complete language that's very simple/easy to implement. Fractran is really elegant as Turing tarpits go; most have a lot more rough edges, special cases, or details that could be changed without making a large difference.

@AnderBiguri It looks like it came out of his studies of the Collatz conjecture; he proved that a generalization of Collatz is equivalent to Fractran and that Fractran is Turing-complete, therefore generalized Collatz is undecidable.

Python 2, 28 bytes
f=lambda n:n%2*n or 3*f(n/2)

Try it online!
Recursively divide the number by 2 and multiplies the result by 3, as long as the number is even. Odd numbers return themselves.
32 byte alt:
lambda n:n*(n&-n)**0.58496250072

Try it online. Has some float error. The constant is log_2(3)-1.
Uses (n&-n) to find the greatest power-of-2 factor of n, the converts 3**k to 2**k by raising it to the power of log_2(3)-1.

Nice this is my solution exactly!

@WheatWizard Me as well, aha!

05AB1E, 4 bytes
Ò1~P

Try it online!
How it works
Ò     Compute the prime factorization of the input.
 1~   Perform bitwise OR with 1, making the only even prime (2) odd (3).
   P  Take the product of the result.

This beats Jelly by 1 byte simply because prime factorization is only one byte here :(

@HyperNeutrino: I noticed that too: "why is Dennis using 05AB1E? Oh, identical algorithm, shorter builtin names". So I had to go and find a language where I could do it in even fewer bytes, via the use of an even more appropriate set of builtins.

Haskell, 24 23 bytes
until odd$(*3).(`div`2)

The divide by two and multiply by 3 until odd trick in Haskell.
Try it online!
Alternative with a lambda instead of a pointfree function and with the same byte count:
odd`until`\x->div(x*3)2

Edit: @ais523 saved a byte in the original version and @Ørjan Johansen one in the alternative version, so both version have still the same length. Thanks!

The lambda version can be shortened to odd`until`\x->div(x*3)2.

The original version can also be shortened one byte via using $ to replace a pair of parentheses: Try it online!

@ØrjanJohansen: ah, nice! Thanks.

@ais523: How could I have missed that one, Thanks!

I think you forgot to remove a pair of () from the lambda version

@CAD97: Yes, I did. Thanks!

Brain-Flak, 76 bytes
{{({}[()]<([({})]()<({}{})>)>)}{}([{}]()){{}((({})){}{})<>}<>}<>({}({}){}())

Try it online!
Explanation
This program works by dividing the number by two and tripling until it gets a remainder of one from the division. Then it stops looping and doubles and adds one to the final number.
More detailed explanation eventually...

Coming soon ...

JavaScript (ES6), 19 bytes
f=x=>x%2?x:f(x*1.5)

While the input is divisible by two, multiplies it by 1.5, which is equivalent to dividing by 2 and multiplying by 3.

x*3/2 has the same bytecount

f= is usally not needed for js.

@Christoph Thanks, but in order to call itself f(x*1.5) it needs to have the name f, hence why the f= is included.

@ETHproductions Uhm ... of course ! I missed that. Is there any meta on what the calling code exactly looks like?

@Christoph Here is the relevant meta post.

Try it online!

Mathematica, 22 19 bytes
Thanks to lanlock4 for saving 3 bytes!
#//.x_?EvenQ:>3x/2&

Pure function that does the replacement repeatedly, one factor of 2 at a time. Works on all positive integers less than 265537.

Would x_?EvenQ work instead of x_/;EvenQ@x?

You're totally right, thanks!

Perl 6, 14 bytes
{1.5**.lsb*$_}

lsb returns the position of the least-significant bit, counted from the right. That is, how many trailing zeroes in the binary representation, which is the same as the number of factors of 2. So raise 3/2 to that power and we're done.
say {$_*1.5**.lsb}(24);
> 81

Lean, 139 82 71 bytes
11 bytes saved by ovs.
import data.nat.prime
open list
λx,prod$map(λp,p+1-p%2)$nat.factors x

Try it online!
I'm really new to lean so, this answer is probably really inefficient in ways I don't yet know. But it works.
We get a list of factors with nat.factors replace 2s with threes using a map and roll it back up with list.prod.

p+1-p%2 seems to work instead of the conditional expression.

@ovs Nice.  It's tough to tell what library functions there are and what they are named.

Java, 38 bytes
int f(int n){return n%2>0?n:f(n/2*3);}

Try it online!

Previous 43-byte solution:
int f(int n){for(;n%2<1;)n=n/2*3;return n;}

Try it online!

05AB1E, 6 5 bytes
Saved a byte thanks to Adnan.
ÒDÈ+P

Try it online!
Explanation
Ò       # push list of prime factors of input
 D      # duplicate
  È     # check each factor for evenness (1 if true, else 0)
   +    # add list of factors and list of comparison results
    P   # product

ÒDÈ+P should save a byte

MATL, 7, 6 bytes
Yf1Z|p

Try it online!
1 byte saved thanks to Dennis's genius observation

The best way to explain this is to show the stack at various points.
Yf  % Prime factors

[2 2 2 3]

1Z| % Bitwise OR with 1

[3 3 3 3]

p   % Product

81

Alternate solution:
Yfto~+p

Nice! I had Yf3H$X>p for 8 bytes

Alice, 9 bytes
2/S 3
o@i

Try it online!
Alice has a built-in to replace a divisor of a number with another. I didn't think I'd actually get to make use of it so soon...
Using the code points of characters for I/O, this becomes 6 bytes: I23SO@.
Explanation
2   Push 2 (irrelevant).
/   Reflect to SE. Switch to Ordinal.
i   Read all input as a string.
    The IP bounces up and down, hits the bottom right corner and turns around,
    bounces down again.
i   Try to read more input, but we're at EOF so this pushes an empty string.
/   Reflect to W. Switch to Cardinal.
2   Push 2.
    The IP wraps around to the last column.
3   Push 3.
S   Implicitly discard the empty string and convert the input string to the integer
    value it contains. Then replace the divisor 2 with the divisor 3 in the input.
    This works by multiplying the value by 3/2 as long as it's divisible by 2.
/   Reflect to NW. Switch to Ordinal.
    Immediately bounce off the top boundary. Move SW.
o   Implicitly convert the result to a string and print it.
    Bounce off the bottom left corner. Move NE.
/   Reflect to S. Switch to Cardinal.
@   Terminate the program.

Your obsession is officially confirmed.

Hexagony, 112 91 bytes
Grid size 6 (91 bytes)
      ? { 2 . . <
     / = { * = \ "
    . & . . . { _ '
   . . { . . } ' * 2
  _ } { / . } & . ! "
 . > % . . < | . . @ |
  \ . . \ . | ~ . . 3
   . . " . } . " . "
    . & . \ = & / 1
     \ = { : = } .
      [ = { { { <

Compact version
?{2..</={*=\".&...{_'..{..}'*2_}{/.}&.!".>%..<|..@|\..\.|~..3..".}.".".&.\=&/1\={:=}.[={{{<

Grid size 7 (112 bytes)
       ? { 2 " ' 2 <
      / { * \ / : \ "
     . = . = . = | . 3
    / & / { . . } { . "
   . > $ } { { } / = . 1
  _ . . } . . _ . . & . {
 . > % < . . ~ & . . " . |
  | . . } - " . ' . @ | {
   . . . = & . . * ! . {
    . . . _ . . . _ . =
     > 1 . . . . . < [
      . . . . . . . .
       . . . . . . .

Try it online!
Compact Version:
?{2"'2</{*\/:\".=.=.=|.3/&/{..}{.".>$}{{}/=.1_..}.._..&.{.>%<..~&..".||..}-".'.@|{...=&..*!.{..._..._.=>1.....<[

Ungolfed Version for better readability:

Approximate Memory Layout

Grey Path (Memory initialization)
?     Read input as integer (Input)
{     Move to memory edge "Divisor left"
2     Set current memory edge to 2
" '   Move to memory edge "Divisor right"
2     Set current memory edge to 2
"     Move to memory edge "Multiplier"
3     Set current memory edge to 3
"     Move to memory edge "Temp 2"
1     Set current memory edge to 1
{ { { Move to memory edge "Modulo"
=     Turn memory pointer around
[     Continue with next instruction pointer

Loop entry
%     Set "Modulo" to Input mod Divisor
<     Branch depending on result

Green Path (value is still divisible by 2)
} } {     Move to memory edge "Result"
=         Turn memory pointer around
*         Set "Result" to "Temp 2" times "Multiplier" (3)
{ = &     Copy "Result" into "Temp2"
{ { } } = Move to "Temp"
:         Set "Temp" to Input / Divisor (2)
{ = &     Copy "Temp" back to "Input"
"         Move back to "Modulo"

Red Path (value is no longer divisible by 2)
} = & " ~ & ' Drag what's left of "Input" along to "Multiplier"
*             Multiply "Multiplier" with "Temp 2"
! @           Output result, exit program

Welcome to PPCG! :)

@MartinEnder Thanks, awesome language btw. :)

Thanks for using it! :) Can't you simplify the memory layout (and thereby the amount of movement you need to do) if you compute %2 and :2 both into the "modulo" edge? (So you can just get rid of the top two edges.) And then, could you attach the "multiplier" branch onto the "modulo" edge instead of the "divisor" edge so you need less movement after each branch? (You could possibly even rotate that section, so that "result" or "temp 2" touches "modulo" which would mean you only need to copy the final result once before being able to compute the product.)

@MartinEnder Uhhhm probably. I'm still getting around the "Agony" part of the language so for now I'll probably stick to making the grid smaller without touching the logic ^^

Retina, 23 bytes
.+
$*
+`^(1+)\1$
$&$1
1

Try it online! Link is to test suite that runs automatically runs all inputs from 1 to 29. Explanation:
.+
$*

Convert to unary.
+`^(1+)\1$
$&$1

While the value is even, multiply it by 3/2.
1

Convert to decimal.
Note that any FRACTRAN program is trivially convertible to a Retina program with unary I/O. The fraction itself is converted into a match for a string that appears an exact number of times given by the denominator, and the substitution is then $1 repeated a number of times given by the numerator, although if this is greater than the denominator then $& can be used to golf down the code length. It then remains to loop each fraction back to the start of the script, so that the earliest possible fraction is always the next to be substituted. In the case of a single fraction no group is required of course.

Brachylog, 7 bytes
~×₂×₃↰|

Try it online!
How it works
~×₂×₃↰|      original program
?~×₂×₃↰.|?.  with implicit input (?) and output (.) added

?~×₂         input "un-multiplied" by 2
    ×₃       multiplied by 3
      ↰      recursion
       .     is the output
        |    or (in case the above fails, meaning that the input
                 cannot be "un-multiplied" by 2)
         ?.  the input is the output

Related.

Jelly, 8 5 bytes
Æf3»P

Æf3»P  Main Link, argument is z
Æf     Prime factors
  3»   Takes maximum of 3 and the value for each value in the array
    P  Takes the product of the whole thing

Try it online!
-3 bytes thanks to a hint from @Dennis!

Hint: 2 is both the only even and the smallest prime number.

@Dennis I see. Yes, got it now. Thanks! :)

Congratulations on learning Jelly.

@LeakyNun Thanks! And thanks for teaching it to me. :)

Congrats on this answer!

Thanks @EriktheOutgolfer! Thanks for getting me started off with Jelly!

Hexagony, 28 27 26 bytes
?'2{{(\}}>='!:@=$\%<..>)"*

Try it online!
Laid out:
    ? ' 2 {
   { ( \ } }
  > = ' ! : @
 = $ \ % < . .
  > ) " * . .
   . . . . .
    . . . .

This basically runs:
num = input()
while num%2 == 0:
    num = (num/2)*3
print num

At this point it's an exercise on how torturous I can get the loop path to minimise bytes.

Well damn, I didn't think of that

@ManfredRadlwimmer Don't worry, coding anything in Hexagony is an achievement in itself

Pyth - 14 10 9 bytes
*^1.5/PQ2

Counts the number of 2s in the prime factorization (/PQ2). Multiplies the input by 1.5^(# of 2s)
Try it

Interesting approach - too bad it's not as short as the existing Pyth solution.

@Challenger5 I'm not seeing any other Pyth solution here.

Oh, OK then. It's a more interesting approach than the typical one for this challenge.

Risky, 9 bytes
*\?+0+0+0__?\?+?:2

Try it online!

BQN (CBQN), 30 bytes
{0=2|?3×÷2;}
Attempt This Online!

CJam, 10 9 bytes
rimf1f|:*

Really simple.
Explanation:
ri  e# Read integer:         | 28
mf  e# Prime factors:        | [2 2 7]
1   e# Push 1:               | [2 2 7] 1
f|  e# Bitwise OR with each: | [3 3 7]
:*  e# Product:              | 63

J, 15 12 10 bytes
(+2&=)&.q:

Try it online! Works similar to below, just has different logic concerning replacement of 2 with 3.
15 bytes
(2&={,&3)"+&.q:

Try it online!
Explanation
(2&={,&3)"+&.q:
           &.    "under"; applies the verb on the right, then the left,
                 then the inverse of the right
             q:  prime factors
(       )"+      apply inside on each factor
     ,&3         pair with three: [factor, 3]
 2&=             equality with two: factor == 2
    {            list selection: [factor, 3][factor == 2]
                 gives us 3 for 2 and factor for anything else
           &.q:  under prime factor

Huh, you switched algorithm while I was writing up mine. Now we use the same.

@Adám Oh, haha. Nice answer! I couldn't resist the opportunity to use roll here. :)

Actually I might be able to save some more bytes...[edit] saved some :D

Funny you call it Roll, I call it Under. Hope to get it into APL soon.

@Adám Haha it's actually called under. I got the terms confused

As in do this while under the influence of that Open fridge, take beer, close fridge. Take a beer while the fridge is open.

J, 11 bytes
[:*/q:+2=q:

Try it online!
[: cap (placeholder to call the next verb monadically)
*/ the product of
q: the prime factors
+ plus (i.e. with one added where)
2 two
= is equal to (each of)
q: the prime factors

I thought you find [: disgusting.

@LeakyNun I do, but I wasn't as clever as Conor O'Brien.

PHP, 36 Bytes
for($a=$argn;$a%2<1;)$a*=3/2;echo$a;

Try it online!

for($a=$argn;!1&$a;)$a*=3/2;echo$a; renaming $argn saves a single byte.

Pyth, 9 bytes
Integer output \o/
*F+1.|R1P

Test suite.
How it works
*F+1.|R1P
        P   prime factorization
    .|R1    bitwise OR each element with 1
*F+1        product

APL (Dyalog Unicode), 26 bytes
{⍵(⊣×(3*⊢)×(÷2*⊢))2⍟⍵∨2*⍵}

Try it online!
This is too verbose, I must be doing something wrong...

R, 42 bytes
The only right amount of bytes in an answer.
x=gmp::factorize(scan());x[x==2]=3;prod(x)

Pretty straightforward, uses the gmp package to factorize x, replaces 2s by 3s, and returns the product.

Japt, 19 16 10 9 7 bytes
k ®w3Ã×

Try it online!
Explanation
 k ®   w3Ã ×
Uk mZ{Zw3} r*1
U              # (input)
 k m           # for every prime factor
    Z{Zw3}     # replace it by the maximum of itself and 3
           r*1 # output the product

Hah, JS is tied with Japt. A sure sign there's a much shorter solution ;-)

Hints: × is a shortcut for r@X*Y}1 (or just r*1), which might come in handy. There's also XwY which is Math.max(X,Y).

Thanks, though the recursive solution really is the shortest.

Nice one! I think you can do k m_w3Ã× to save a byte. Also, m_ can be shortened to ®.

Japt, 7 bytes
k mw3 ×

Try it online!
Explanation
k mw3 ×

k        // Factorize the input.
  mw3    // Map each item X by taking max(X, 3).
      ×  // Take the product of the resulting array.
         // Implicit: output result of last expression

Befunge-93, 20 bytes
&>:2%!#v_.@
 ^*3/2 <

Try it online!
& - take in input and add it to the stack
> - move right
: - duplicate the top of the stack
2 - add two to the stack
% - pop 2 and the input off the stack and put input%2 on the stack
! - logical not the top of the stack
# - jump over the next command
_ - horizontal if, if the top of the stack is 0 (i.e. input%2 was non zero) go
    right, else go left

If Zero:
. - output the top of the stack
@ - end code

If Not Zero:
v - move down
< - move left
2 - add 2 the top of the stack
/ - pop top two, add var/2 to the stack
3 - add 3 to stack
* - pop top two, add var*3 to the stack
^ - move up
> - move right (and start to loop)

17 bytes

Ruby, 23 bytes
f=->n{n%2<1?f[n/2*3]:n}

Try it online!
A recursive lambda, nothing shocking.

Vyxal, 5 bytes
ǐ3v∴Π

Try it Online!
ǐ    # Prime factors
  v∴ # Take max of each and...
 3   # 3
Π    # Take product

tinylisp, 47 bytes
(load library
(d F(q((N)(i(odd? N)N(F(*(/ N 2)3

Defines a function F that takes an integer and returns an integer. Try it online!
Ungolfed/explanation
The best part is, this uses tail recursion, so it works for arbitrarily large numbers (though it does get horrifically slow).
(load library)   ; The library defines the odd?, *, and / functions

(def F           ; Define F to be
 (q              ; a list representing a function
  ((N)           ; that takes one argument, N:
   (if (odd? N)  ; If N is odd
    N            ; just return it
    (F           ; else call F recursively on
     (*          ; the product of
      (/ N 2)    ; N divided by 2
      3))))))    ; with 3

Taxi, 1243 bytes
Go to Post Office:W 1 L 1 R 1 L.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:S 1 L 1 R.Pickup a passenger going to Cyclone.Go to Cyclone:N 5 L 2 L.[A]Pickup a passenger going to Narrow Path Park.Pickup a passenger going to Divide and Conquer.2 is waiting at Starchild Numerology.Go to Starchild Numerology:N 1 R 3 L.Pickup a passenger going to Divide and Conquer.Go to Zoom Zoom:W 1 R 3 R.Go to Narrow Path Park:W 1 L 1 L 1 R.Go to Divide and Conquer:E 1 R 2 R.Pickup a passenger going to Cyclone.Go to Cyclone:E 1 L 1 L 2 L.Pickup a passenger going to Equal's Corner.Pickup a passenger going to Trunkers.Go to Trunkers:S 1 L.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:W 1 L.Switch to plan B if no one is waiting.Pickup a passenger going to Multiplication Station.3 is waiting at Starchild Numerology.Go to Starchild Numerology:N 1 R.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:W 1 R 2 R 1 R 4 L.Pickup a passenger going to Cyclone.Go to Cyclone:S 1 R 2 L 2 R.Switch to plan A.[B]Go to Narrow Path Park:N 4 R 1 R 1 L 1 R.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:E 1 R.Pickup a passenger going to Post Office.Go to Post Office:N 1 L 1 R.

Try it online!

For those wondering what this does: Divide by 2. If that's an integer, multiply the result by 3 and start over. Otherwise, exit the loop and print the result before it was divided by 2.

Vyxal, 4 bytes
ǐ1⋎Π

Try it Online!
How?
ǐ1⋎Π
ǐ    # Prime factors
 1⋎  # Bitwise OR each with one
   Π # Product

Factor + math.primes.factors math.unicode, 28 bytes
[ factors """"replace Π ]

Try it online!
Note the strings have literal control characters '2' and '3' embedded in them (you can see them on TIO).

Desmos, 29 bytes
f(n)=1.5^{log_2(gcd(n,2^n))}n

A surprisingly short solution, and an interesting usage of \$\operatorname{gcd}()\$.
Try It On Desmos!
Try It On Desmos! - Prettified
It only works for numbers up to 1024 though. Here is a version that should support significantly more numbers at the cost of a few bytes:
42 bytes
f(n)=1.5^{log_2(gcd(n,2^{ceil(log_2n)}))}n

Thunno 2, 5 bytes
f1Æ|p

Try it online!
Explanation
f1Æ|p  # Implicit input
f      # Prime factorisation
 1Æ|   # Bitwise OR with 1
    p  # Product of the list
       # Implicit output

Pyke, 5 bytes
P1.|B

Try it online!

Actually, 9 bytes
w⌠i1|ⁿ⌡Mπ

Try it online!
Explanation:
w⌠i1|ⁿ⌡Mπ
w          factor into [prime, exponent] pairs
 ⌠i1|ⁿ⌡M   for each pair:
  i          flatten
   1|        prime | 1 (bitwise OR)
     ⁿ       raise to exponent
        π  product

Pari/GP, 23 bytes
f(n)=if(n%2,n,f(3*n/2))

Try it online!

Pari/GP, 23 bytes
n->n*1.5^valuation(n,2)

Try it online!

C (gcc), 23 bytes
f(n){n=n&1?n:f(n/2*3);}

Try it online!

Chip -z, 123 bytes
tv~S
a^v.bv.cv.dv.ev.fv.gv.
 zLxzLxzLxzLxzLxzLxzLxz-vh
A##L##L##L##L##L##L##L##'
B))L))L))L))L))L))L))'
   C  D  E  F  G  H

Try it online! (Includes a bashy wrapper for numeric conversion).
Explanation
This solution uses Chip's 'native' data type, an unsigned 8-bit integer. Any input or output that would be outside the bounds of that type will produce undefined results.
I and O are done via raw bytes values, hence the wrapper in the TIO.
The algorithm, in C-ish looks something like this:
uchar byte = in();
while(!(byte & 0x1)) {
  byte += byte>>1; // logical shift
}
out(byte);

The bulk of this program are the eight full adders (##) and their wiring (L, ), x, ...).
To see all steps of the computation, delete the S. You may want to adjust the hexdump format to "%d\n" for nicer output.

R, 34 bytes
function(x){while(!x%%2)x=x/2*3;x}

Try it online!
Or: recursive version (same bytes)
f=function(x)`if`(x%%2,x,f(x/2*3))

Try it online!
2 is the only even prime number, so we divide the input by 2 and multiply by 3 until it's no longer even.

Edit: now reading the other answers, this approach has already been used many times in other languages...

Assembly (NASM, 32-bit, Linux), 57 bytes
mov ebx,3
l:mul ebx
rcr eax,1
jnc l
rcl eax,1
div ebx
ret

Try it online!
Both, the input and the output are in the eax register.

MMIX, 20 bytes (5 instrs)
00000000: 4e000004 3f000001 1b000003 4f00fffe  N¡¡¥?¡¡¢ñ¡¡¤O¡”“
00000010: f8010000                             ẏ¢¡¡

r23 BEV  $0,1F      // if(!(i & 1)) goto end
0H  SRU  $0,$0,1    // loop: i >>= 1
    MULU $0,$0,3    // i *= 3
    BEV  $0,0B      // if(!(i & 1)) goto loop
1H  POP  1,0        // return i

If it could be guaranteed the number was even, it could be cut down to four instructions (the first instruction is just to avoid halving if already odd).


text:
Evaluate Index of Multidimensional Coordinates
A collection of N dimensional coordinates are provided. An example is below:
{2,3,4}

This can be thought of as a 3 dimensional array with 2x's, 3y's and 4z's; there may be any number of dimensions. In the example, there are 24 total nodes. Each node can be indexed using {x,y,z}. To access the 5th node, the provided indices would be {0, 1, 0} based on the table below.
## | x y z
     0 1 2
-----------
0  | 0 0 0
1  | 0 0 1
2  | 0 0 2
3  | 0 0 3
4  | 0 1 0
5  | 0 1 1
6  | 0 1 2
7  | 0 1 3
8  | 0 2 0
...
23 | 1 2 3

The purpose of this application is to work backwards to determine an index if given a node number.
If asked for the "y" index of the 8th node, the program should print "2".
With the following input provided:
{2,3,4}|8|1
<List of Coordinates>|<Node>|<Index>

The following should be printed:
2

You can assume that the input will be provided in some convenient manner in your language of choice and does not require bounds checking. For example you may assume that the provided index of choice ("y" in the example) is valid with respect to the provided coordinates. You may use 0 or 1 based indexing; the example presumes 0 based.
This is sort of the reverse of this question:
Index of a multidimensional array

Perhaps add a few test cases

Can we let the coordinates run from 1 to x instead of 0 to x-1? So node #0 would be (1,1,1) and node #23 (2,3,4).

@nimi Yes, 1 based indexing is fine.

APL (Dyalog Classic), 5 bytes
⎕⌷⎕⊤⎕

No, you're not missing a font. That's how it's supposed to look.
This is a REPL program that takes input from STDIN: the node number, the dimensions, and the index (in that order). The latter can be 0- or 1-based, depending on the value of ⎕IO.
Try it online!
How it works
Multidimensional array indexing is essentially mixed base conversion, so ⊤ does what the first part of the challenge asks for. Each occurrence of ⎕ reads and evals a line from STDIN, so
      ⎕ ⊤ ⎕
⎕:
      8
⎕:
      2 3 4
0 2 0

Finally, ⌷ takes the element at the specified index. The leftmost ⎕ reads the third and last input from STDIN and
      ⎕ ⌷ (0 2 0)
⎕:
      1
2

Mixed base conversion strikes again!

MATL, 8 bytes
PiX[vPi)

This uses 1-based indexing for the node and for the dimensions. So the first nodes are 1, 2 etc; and the "x" dimension is 1, "y" is 2 etc.
Try it online!
Explanation
The key is to use function X[ (corresponding to ind2sub in Matlab or Octave), which converts a linear index into multidimensional indices. However, the order of dimensions if the opposite as defined in the challenge, so P (flip) is needed before calling the function, and again after concatenating (v) its ouputs.
P    % Implicit input: size as a row vector. Flip
i    % Input: node (linear) index
X[   % Convert from linear index to multidimensional indices. Produces
     % as many outputs as entries there are in the size vector
v    % Concatenate all outputs into a column vector
P    % Flip
i    % Input: dimension
)    % Index: select result for that dimension. Implicitly display

Haskell, 38 30 29 28 bytes
l#n=(mapM(\x->[1..x])l!!n!!)

This uses 0-based indices and coordinates starting at 1. Try it online!
Turn each dimension x of the input into a list [1..x], e.g. [2,3,4] -> [[1,2],[1,2,3],[1,2,3,4]].  mapM makes a list of all possible n-tuples where the first element is taken from the first list, etc. Two times !! to index the n-tuple and dimension.
Edit: @Ørjan Johansen saved 8 9 bytes. Thanks!

Ooh, clever! But mapM id.map f=mapM f. And (`take`[0..]) is shorter.

@ØrjanJohansen: 8 bytes, that's massive! Thanks a lot! Still waiting for an answer of the OP if 1-based coordinates are allowed.

Also, l#n=(mapM(`take`[0..])l!!n!!) is shorter. (Incidentally you didn't need the f=, functions can be anonymous. Oh, I guess you aren't counting it.)

@ØrjanJohansen: Thanks again. The f= was a copy and paste error from TIO.

Haskell, 45 bytes
(#) takes three arguments and returns an integer, use as [2,3,4]#8$1.
l#n=(zipWith mod(scanr(flip div)n$tail l)l!!)

Try it online!
How it works

l is the list of coordinates, n the node number. l#n is a function that takes the final index i.
Given the example list [2,3,4] and node 8, first the list's tail is taken, giving [3,4]. Then this is scanned from the right, dividing the node number by each element consecutively, giving the list [0,2,8].
Then the list [0,2,8] and the original l=[2,3,4] are zipped with the modulus operator, giving [0,2,0].
At last the !! list indexing operator is partially applied, with the resulting function ready to be given the final index.

Brachylog, 25 23 bytes
tT&bhH&h{>ℕ}ᵐ:H≜ᶠ⁾t:T∋₎

Try it online!
The second argument is 1-indexed, the other 2 are 0 indexed.
Explanation
tT                          Input = [_, _, T]
  &bhH                      Input = [_, H, T]
      &h{>ℕ}ᵐ               Create a list where each element is between 0 and the
                              corresponding element in the first element of the Input
             :H≜ᶠ⁾          Find the first H possible labelings of that list
                  t         Take the last one
                   :T∋₎     Output is the T'th element

Jelly, 7 6 bytes
Œp⁴ị⁵ị

Try it online!
This uses 1-indexing for input and output.
How it works
Œp⁴ị⁵ị
Œp      Cartesian product of the first input
        numbers are converted to 1-based ranges
  ⁴ị    index specified by second input
    ⁵ị  index specified by third input

Mathematica, 26 23 bytes
Array[f,#,0,Or][[##2]]&

Using 1-based indexing for input, and 0-based indexing for output.
Why Or? Because it is the shortest built-in function with the attribute Flat.
Example:
In[1]:= Array[f,#,0,Or][[##2]]&[{2,3,4},9,2]

Out[1]= 2

APL (Dyalog), 6 bytes
To get 0-based indexing, ⎕IO←0, which is default on many systems. Prompts for dimensions, then enclosed list of (node,coordinate).
⎕⊃↑,⍳⎕

Try it online!
⎕ prompt for dimensions
⍳ generate an array of that shape with each item being the indices for that item
, ravel (make into list of indices)
↑ convert one level of depth to an additional level of rank
⎕⊃ prompt for enclosed list of (node,coordinate) and use that to pick an element from that

Pyth, 12 bytes
@.n]@*FUMQEE

Try it online!
How it works
@.n]@*FUMQEE
       UMQ    map each element in the first input to
              [0,1,...,that element]
     *F       reduce by Cartesian product
    @     E   obtain index at second input
 .n]          listify and flatten
@          E  obtain index at third input

R, 52 bytes
function(x,y,z,n,i)expand.grid(1:z,1:y,1:x)[n,4-i]-1

returns an anonymous function, 1-indexed.
for the example. expand.grid generates the list, but the first argument varies the fastest, so we have to input them in reverse order, i.e., z,y,x. Then we can simply index [n,4-i], where 4-i is necessary for the reversed order, and subtract 1 to ensure they run from 0:(x-1), etc.
Try it online!

Java, 77 bytes
int f(int[]a,int m,int n){for(int i=a.length-1;i>n;m/=a[i--]);return m%a[n];}

Try it online!

JavaScript (ES6), 44 bytes
(a,n,i,g=j=>a[++j]?g(j)/a[j]|0:n)=>g(i)%a[i]

Ungolfed:
(a,n,i)=>a.reduceRight(([n,...a],e)=>[n/e|0,n%e,...a],[n])[i+1]

Sadly reduce is two bytes longer:
(a,n,i)=>a.reduce((r,d,j)=>j>i?r/d|0:r,n)%a[i]

Looks like we came up with the same idea \o/

@LeakyNun Well, it's not surprising really, given how the indexing works.

Python 3, 57 bytes
lambda a,m,n:f(a[:-1],m//a[-1],n)if len(a)-n else m%a[-1]

Try it online!
Fork of my Java answer.

Octave, 63 bytes
function z=f(s,n,d)
[c{nnz(s):-1:1}]=ind2sub(flip(s),n);z=c{d};

Port of my MATL answer.
Try it online!

source: Stack Exchange

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

sort: votes


text:
Embedded Diamonds!
No, not this. And not this either. This question is nothing like those
Write the shortest code to print/return the following output:
   /\      /\      /\
  /  \    /  \    /  \
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
  \  / /\ \  / /\ \  /
   \/ /  \ \/ /  \ \/
   /\ \  / /\ \  / /\
  /  \ \/ /  \ \/ /  \
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
  \  /    \  /    \  /
   \/      \/      \/

Standard methods of input/output.
Standard loopholes apply.
Trailing/leading whitespace is okay, in any amount.

Not this, Not that, What about this?

Charcoal, 28 24 23 bytes
↗²↖↙⁴⟲Ｐ²⁴⁶↘↙↙²⟲Ｐ²⁴⁶Ｃ⁸¦⁰

Try it online! Explanation:
↗²↖↙⁴   Draw the top left 4x4 corner
         /
        //
⟲Ｐ²⁴⁶   Rotate it three times to complete a diamond
         /\
        //\\
        \\//
         \/
↘↙↙²    Draw the top left line of the inner diamond
         /\
        //\\
        \\//
         \//
⟲Ｐ²⁴⁶   Rotate three times to complete five diamonds
Ｃ⁸¦⁰    Copy everything 8 characters to the right to complete eight diamonds

Edit: My previous answer used ‖Ｍ‖Ｍ↓ to create a whole diamond by reflecting the top corner, but due to a bug in Charcoal this left the cursor out of position. Fortunately I discovered another way of achieving the same effect which doesn't move the cursor, which meant that I saved a byte drawing the inner diamond. (I also looked into overlapping operations, but I wasn't able to improve on the rotate/copy approach.)
Edit: ↖²↗↘⁴‖Ｍ¬Ｍ¹¦³↘²‖Ｍ¬Ｃ⁸¦⁰ does the job in 21 bytes, but that relies on the new reflecting behaviour, so I don't know whether this was possible with the old code.

Yeah, sorry, it was a bug - I've fixed it and will try to push ASAP, but this is still insanely short :O +1

@ASCII-only If I've been using TIO, how does that affect me?

Well, it's still cached, so as long as it is cached, it should be fine if that's what you mean

@ASCII-only What I want to know is that when TIO's behaviour changes I would like to be able to provide an updated (although non-competing) link.

Oh, in that case it already has the fix

@ASCII-only Ah, in that case, the cursor is still in a surprising place, but it doesn't change the length of the answer (currently the easiest "fix" is to change a ↖ to a ↙).

Let us continue this discussion in chat.

Charcoal, 62 50 48 45 42 40 bytes
Thanks to @Okx for saving two bytes!
↙²→↘²↙↖⁴→↗⁴‖ＭＦ²Ｃ⁸¦⁰Ｍ⁸↓→↗²↓↘²Ｍ⁴→↑↗²↓↘²‖Ｍ↓

Try it online!
Explanation:
↙²→↘²          // Draw the left half of the inner part of the first diamond.
↖⁴→↗⁴          // Draw the left half of the outer part.
‖Ｍ             // Mirror the half of the diamond to create the first full diamond.
Ｆ²Ｃ⁸¦⁰         // Copy the picture eight characters to the left twice.
               // The first copy gives us two diamonds, and the second copy of the
               // two diamonds overlaps so that the result is three diamonds.
Ｍ⁸↓→↗²↓↘²     // Move down to draw the upper inner half of the first middle diamond.
Ｍ⁴→↑↗²↓↘²     // Move right to do the same for the second middle diamond.
‖Ｍ↓           // Mirror the whole thing vertically.

You can replace Ｃ⁸¦⁰Ｃ⁸¦⁰ with Ｆ²Ｃ⁸¦⁰¦ to save a byte.

@Okx Thanks! Actually, this saves two bytes, because it works without the trailing ¦.

For the record, some update seems to have broken this, as the code no longer works properly on TIO. The answer still remains valid, because it worked with the version TIO was using back when this answer was posted.

PHP, 126 Bytes
<?=gzinflate(base64_decode("vY7BCQAwCAP/mSIbuJD7z1GJLbbiuz5yKCeEpDk1RUSQWm8iMiRnIyw178Qgi5hs3ceHOA86snN7ON2b/687X+7umuIC"));

Try it online!
PHP, 149 Bytes
$s=strtr("000
111
222
333
444
555
  \ 22 /
   \\33/   ",["   /\   ","  /  \  "," / /\ \ ","/ /  \ \\","\ \  / /"," \ \/ / "]);echo"$s
".strrev($s);

Try it online!

05AB1E, 45 44 43 bytes
Code:
…/ \©•—‹íćCé']d₂2ó@¯çX‘¯¨•3вè8äJvyÂ®Â‡«}»Â»

Pre-explanation:
The •—‹íćCé'\]d₂2ó@¯çX‘¯¨•3в part is just a compressed version of the following array:
[1, 1, 1, 0, 2, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 2, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 2, 1, 2, 0, 1, 0, 1, 2, 1, 2, 1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 2, 1, 2, 0, 1, 0, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 1, 1, 2, 0, 1, 0, 1, 1, 2, 1, 2]

Which we index into the string …/ \. This maps 0 -> /, 1 -> space, 2 -> \. After that, we process this string with the following program:
8äJvyÂ®Â‡«}»Â»

8ä               # Split the array into 8 pieces
  J              # Join each sub-array in the array
   vy     }      # For each string in the array
     Â           #   Bifurcate (duplicate and reverse)
      ®          #   Push the string "/ \" (which was copied using ©)
       Â         #   Bifurcate to get "\ /"
        ‡        #   Transliterate / -> \ and \ -> /
         «       #   Append to the original string
           »     # Join the entire stack on newlines
            Â    # Bifurcate
             »   # Join the stack by newlines

Uses the 05AB1E encoding. Try it online!

05AB1E is very good at ASCII-art, it seems...

Crossed out fourty four is still fourty four.

@Okx Unless you apply non-breaking spaces.

Ruby, 99 97 bytes
400.times{|i|print (23<x=i%25)?$/:" /  \\   "[(x^y=i/25)&4^x+y&1^(x-2&4&y-2>y/6%2*x/2%11*4?2:0)]}

Explanation
Each 4x4 square contains only spaces and / or \. We plot these to give the overall diamond pattern. To avoid partial patterns at the borders, certain 2x2 squares must be left blank as below.
.. /\ .... /\ .... /\ ..
../  \..../  \..../  \..
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
..\  / /\ \  / /\ \  /..
.. \/ /  \ \/ /  \ \/ ..
.. /\ \  / /\ \  / /\ ..
../  \ \/ /  \ \/ /  \..
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
..\  /....\  /....\  /..
.. \/ .... \/ .... \/ ..

Ungolfed version - modified to print the above to assist in explanation
400.times{|i|print (23<x=i%25)?$/:     #Calculate x. If last column, print a newline else
  " /..\\ .."[(x^y=i/25)&4^x+y&1^      #If (x^y)&4==4, use x+y&1 to select between space and /. If (x^y)&4==0 select between \ and space.
  (x-2&4&y-2>y/6%2*x/2%11*4?2:0)]      #If x-2&4&y-2==4, and we are on the 2 character wide border (y/6%2*x/2%11==0), XOR with 2 to print .
}

JavaScript, 232 bytes
_=>(a=`3868683
2/274/274/272
1/18172/18172/18171
/1/27191/27191/2717
7172/18172/18172/1/
17191/27191/27191/1
272/18172/18172/2
391/27191/27193`.replace(/\d/g,n=>n>6?['\\','/\\','\\/'][n-7]:'
'.repeat(n)))+`
`+[...a].reverse().join``

Try it online!

const f = _=>(a=`3868683
2/274/274/272
1/18172/18172/18171
/1/27191/27191/2717
7172/18172/18172/1/
17191/27191/27191/1
272/18172/18172/2
391/27191/27193`.replace(/\d/g,n=>n>6?['\\','/\\','\\/'][n-7]:' '.repeat(n)))+`
`+[...a].reverse().join``

console.log(`
${f()}
`)

I have a 126 byte solution below. :)

Pyth - 106 98 96 92 bytes
V16V24J%t+NH8K%+_2-NH8=Y&&&>H1>N1<N14<H22p?|q2J&&Y!%J4?<1%H4J!J\/?|q2K&&Y!%K4?<1%H4!KK\\d)pb

Try it

Canvas, 18 bytes
４／２／３３╋╬２／７７╋╬：９１╋

Try it here!
Explanation:
4/           push a diagonal of length 4
  2/         push a diagonal of length 2
    33╋      insert that at [3;3] in the 1st diagonal
                    /
                   /
                  / /
                 / /
╬            quad-palindromize with 0 overlap
 2/77╋       insert a 2-long diagonal in the bottom-right corner
                    /\
                   /  \
                  / /\ \
                 / /  \ \
                 \ \  / /
                  \ \/ /
                   \  / /
                    \/ /
      ╬      quad-palindromize with 0 overlap, creating most of the output
                    /\      /\
                   /  \    /  \
                  / /\ \  / /\ \
                 / /  \ \/ /  \ \
                 \ \  / /\ \  / /
                  \ \/ /  \ \/ /
                   \  / /\ \  /
                    \/ /  \ \/
                    /\ \  / /\
                   /  \ \/ /  \
                  / /\ \  / /\ \
                 / /  \ \/ /  \ \
                 \ \  / /\ \  / /
                  \ \/ /  \ \/ /
                   \  /    \  /
                    \/      \/
       :91╋  overlap self on [9;1]

C#, 608 bytes
void q(){Action<string>a=Console.Write;Func<int,int,string>b=(c,d)=>new string(' ',c)+(d<1?"/\\":d<2?"/  \\":d<3?"/ /\\ \\":d<4?"/ /  \\ \\":d<5?"\\ \\  / /":d<6?"\\ \\/ /":d<7?"\\  /":"\\/");Action e=()=>a(b(0,4)+b(0,4)+b(0,4)+"\n"+b(1,5)+b(2,5)+b(2,5)+"\n");Action f=()=>a(b(1,2)+b(2,2)+b(2,2)+"\n");Action g=()=>a(b(0,3)+b(0,3)+b(0,3)+"\n");a(b(3,0)+b(6,0)+b(6,0)+"\n"+b(2,1)+b(4,1)+b(4,1)+"\n");f();g();e();a("  \\  / /\\ \\  / /\\ \\  /\n"+"   \\/ /  \\ \\/ /  \\ \\/\n"+"   /\\ \\  / /\\ \\  / /\\\n"+"  /  \\ \\/ /  \\ \\/ /  \\\n");f();g();e();a(b(2,6)+b(4,6)+b(4,6)+"\n"+b(3,7)+b(6,7)+b(6,7)+"\n");}

Not that I want to make this any longer but it looks like you're missing using System;. I'm also pretty sure you can golf this more but I haven't spent too much time looking to be 100% sure.

Its longer than the output so just System.Console.WriteLine(@"..."); Will beat my answer by like 200 bytes.

Javascript 126 bytes
for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))C=c%22>1&&r%14>1,q=[1,,C&&r&2,,,,C&&~r&2,,1],a+=q[c+5+r&7]?'/':q[r-c+20&7]?'\\':' '

Since it's now pretty unreadable, a basic explanation:

we tile the space top left to bottom right
we draw it as basically 6 diagonal lines that repeat every 8 characters: 2 solid lines, and 4 that are "dashed" (two characters, then two spaces...)
the C=... stuff is to limit drawing of some of the lines to within a bounding box
to save a lot of characters, we deliberately add numbers to make the expressions for the upwards and downwards lines extremely similar
then, put the expressions themselves into a sparse array [1,,C&&...], which we look up into. If there is a truthy value, we draw the appropriate character.

-
for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))                 // basic grid tiling
C=c%22>1&&r%14>1,   // are we not near the edges
q=[1,               // a solid line that always draws
,                   // a line that never draws
C&&r&2,             // a line that draws if not near the edge, and if on the correct "dash" (r&2)
,,,
C&&~r&2,            // if not near the edge, and on the opposite "dash" (~r&2)
,1                  // the opposite diagonal line that always draws
],
a+=q[c+5+r&7]?'/' // compute which upward line we're on, check whether to draw it
:q[r-c+20&7]?'\\' // do the same for the downward line
:' '                // otherwise draw a space

Maybe this explanation didn't help. :)
Try online: https://codepen.io/stevebennett/pen/WjgMpY
Hopefully I got the output right:
   /\      /\      /\
  /  \    /  \    /  \
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
  \  / /\ \  / /\ \  /
   \/ /  \ \/ /  \ \/
   /\ \  / /\ \  / /\
  /  \ \/ /  \ \/ /  \
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
  \  /    \  /    \  /
   \/      \/      \/

History
130
for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))C=c%22>1&&r%14>1,q=[1,,C&&r&2,,,,C&&~r&2,,1],a+=q[(c+5+r)%8]?'/':q[(r-c+20)%8]?'\\':' '

133
for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))C=c%22>1,q=[1,,C&&r&2&&r<14,,,,C&&~r&2&&r>1,,1],a+=q[(c+5+r)%8]?'/':q[(r-c+20)%8]?'\\':' '

137
for(c=r=a='';r<16;c++==23&&(r++,c=0,a+=`
`))C=c<22&&c>1,q=[1,,C&&r&2&&r<14,,,,C&&~r&2&&r>1,,1],a+=q[(c+5+r)%8]?'/':q[(r-c+20)%8]?'\\':' '

155
for(c=r=a='';r<16;c++==23&&(r++,c=0,a+=`
`))Z=(C=c<22&&c>1)&&~r&2&&r>1,Y=C&&r&2&&r<14,B=(c-r+12)%8,A=(c+5+r)%8,q=[1,,Y,,,,Z,,1],a+=q[A]?'/':q[8-B]?'\\':' '

History: 172
for(c=r=a='';r<16;c++==23&&(r++,c=0,a+='\n'))a+=(Z=(C=c<22&&c>1)&&~r&2&&r>3,Y=C&&r&2&&r<12,B=(c-r+16)%8,A=(c+r)%8,A==3||A==5&&Y||A==1&&Z?'/':B==4||B==2&&Y||B==6&&Z?'\\':' ')

C#, 382 291 bytes
_=>string.Format(@"{5}{5}{5}
{2}{2}{2}
{0}{0}{0}
{1}{1}{1}
\ \ {0}{0} / /
 \ \{1}{1}/ /
  \ {0}{0} /
   \{1}{1}/
   /\ \ {0} / /\
  /  \ \{1}/ /  \
 {0}{0}{0}
{1}{1}{1}
\ \ {0}{0} / /
 \ \{1}{1}/ /
{4}{4}{4}
{3}{3}{3}",@" / /\ \ ",@"/ /  \ \",@"  /  \  ",@"   \/   ",@"  \  /  ",@"   /\   ");

PowerShell, 168 125 122 121 bytes
$a=(,' '*24+'
')*16
0,8,8+(88,8)*2+8|%{$i=$o+=$_
'&$:&8%$%6%&%5%&%6%$%8&:$'|% t*y|%{$i+=$_-35;$a[$i]='\/'[$i%2]}}
-join$a

Try it online!
The script creates the array of 400 chars and renders 8 diamonds started from positions with intervals 0,8,8,88,8,88,8,8.

The string '&$:&8%$%6%&%5%&%6%$%8&:$' contains the intervals of offsets for the rendered symbols.
The expression |% t*y is shortcut for |foreach-object toCharArray

First render steps:
---/\-------------------
--/--\------------------
-/-/\-\-----------------
/-/--\-\----------------
\-\--/-/----------------
-\-\/-/-----------------
--\--/------------------
---\/-------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------

---/\------/\-----------
--/--\----/--\----------
-/-/\-\--/-/\-\---------
/-/--\-\/-/--\-\--------
\-\--/-/\-\--/-/--------
-\-\/-/--\-\/-/---------
--\--/----\--/----------
---\/------\/-----------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------

---/\------/\------/\---
--/--\----/--\----/--\--
-/-/\-\--/-/\-\--/-/\-\-
/-/--\-\/-/--\-\/-/--\-\
\-\--/-/\-\--/-/\-\--/-/
-\-\/-/--\-\/-/--\-\/-/-
--\--/----\--/----\--/--
---\/------\/------\/---
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------
------------------------

---/\------/\------/\---
--/--\----/--\----/--\--
-/-/\-\--/-/\-\--/-/\-\-
/-/--\-\/-/--\-\/-/--\-\
\-\--/-/\-\--/-/\-\--/-/
-\-\/-/--\-\/-/--\-\/-/-
--\--/-/\-\--/----\--/--
---\/-/--\-\/------\/---
----\-\--/-/------------
-----\-\/-/-------------
------\--/--------------
-------\/---------------
------------------------
------------------------
------------------------
------------------------

and so on.

Retina, 214 bytes

F/\E/\E/\¶B/B\BB/B\FAD D¶F\/ C C¶FD D /\¶BC CAF\B/BB\B/¶F\/E\/E\/
F
B
E
BBB
D
/\ \B/
C
/B\ \/
B

A
 /  \¶ / /\ \  / /\ \  / /\ \¶/ /  \ \/ /  \ \/ /  \ \¶\ \  / /\ \  / /\ \  / /¶ \ \/ /  \ \/ /  \ \/ /¶  \  /

Try it online!

Japt, 75 bytes
Can't seem to golf at all today :\ This is hideous!
`66e7s2gf8447sppcpÜ;7¶p1paff2kmbj1l3odfs4q1½0j¢·lqbs`q¤®©n28" /\\"Ã·ê û

Test it

Deadfish~, 2839 bytes
{iii}iiccc{i}iiiiic{iiii}iiiiic{dddddd}cccccc{i}iiiiic{iiii}iiiiic{dddddd}cccccc{i}iiiiic{iiii}iiiiic{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddcc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{{d}ii}ddc{iiii}dddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{{d}ii}ddc{{i}dd}iic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{dddd}iiic{ii}iic{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{dddd}iiic{ii}iiccc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{{d}ii}ddc{iiii}dddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{{d}ii}ddc{{i}dd}iic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{iiii}iiiiic{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{dddd}iiic{ii}iic{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}cc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddd}dddddc{d}dddddcccccc{iiiiii}c{dddd}dddddc{d}dddddcccccc{iiiiii}c{dddd}dddddc

Try it online!
Deadfish - always way longer than the output and extremely inefficient.

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:
Roots and operators
I used to play a game while I was in the car, it consisted in taking the n-1 first numbers of another car plate and use operators and roots on them to get the nth number of the plate.
I could use the following operators and roots :

addition (ex: 1 + 1 = 2)
subtraction (ex: 2 - 4 = -2)
division (ex: 10 / 2 = 5) (Note that the division is only allowed if it returns an integer)
multiplication (ex: 7 * 7 = 49)
square root (ex : sqrt(36) = 6) (Note : must return an integer to be used)
cubic root (ex : cbrt(8) = 2) (Note : must return an integer to be used)
multiplication by -1 (ex : 8 * -1 = -8)
power 2 (ex : 2² = 4)
power 3 (ex : 2^3 = 8)
leave the integer as it was (ex : 3 = 3)

The operations must be done in order! Which means you have to do the operations between the first and the second integer before an operation between the second and the third.
Example : you can do (3 + 9) * 4 but not 3 + 9*4 if you have [3,9,4,x,y,z,...] as input
Moreover, you can use a unary operator on an integer before doing an operation.
Example : you can do 3² - 7^3
But powers and roots are only allowed on one integer and not on the results of previous operations.
Example : you're not allowed to do (3+7)²
Note that multiplication and division are done that way : it's the applications of the previous operations that's multiplied or divided. For instance :
[x,y,z,t,h] => (x+y)/z + t
[x,y,z,t,h] => (x-y+z) * t
YOUR TASK
Your code will take as input an array of integers of size n, the n-1 first integers will be the one used to obtain the nth number of the array.
You may use all the operators,roots and powers allowed by the rules above. Remember the integers must stay in the same orders to do the operations!
Your code will output a falsey value or an error if the nth number of the array cannot be obtained with the n-1first numbers of the array. On the other hand, if you can obtain the nth number you have to display the operations that led to it. Your code needs to output only one way of obtaining the nth number.
TEST CASES
(Note that I write square root sqrt and cube root cbrt but you can write it the way you want : x**(1/3) for instance)
[1] => error or 1
[2,8] => 2^3
[3,7,46] => 3*(-1) + 7²
[1,2,3,4] => 1*(-1) + 2 + 3
[0,0,0,0,0,0,0,8] => error
[7,4,3,8,16] => 7 + 4² - 3² + cbrt(8)
[28,4,8,7,5,1] => (28 - 4² - cbrt(8) - 7 ) / 5
This is code-golf, thus the shortest answer in bytes wins!

Please consider using the Sandbox for future cahllenges,

Closely related. Likely not a duplicate, as the addition of unary operators will likely significantly change the approaches required.

What is "in order" mean? Why 3*(-1) + 7² is allowed? Should it be [3*(-1) + 7]²?

@tsh like shown in the test cases roots and powers only apply to one number, [3*(-1) + 7]² as you described would be suited for a division or a multiplication but not a unary operator

@tsh I edited the post to make it clearer, thank you for pointing that

Is the last one correct? That looks like it comes out to 3/5, which isn't 1.

Being able to do urnary then binary makes this 10x harder than it at first seems.

Python 2, 797 547 527 515 504 503 bytes
s=eval("[('N,'%sN*-1,'(-%s)N*n,'%s^2N**3,'%s^3N**.5,'s(%s)N**(1./3),'c(%s)N+m,'%s+%sN-m,'%s-%sN*1./(m or.1),'(%s)/%sN*m,'(%s)*%s'),]".replace("N","'),(lambda n,m=0:n"))
P=__import__("itertools").product
def f(l):
 r=l.pop();L=len(l)
 for S in P(s[1:7],repeat=L):
	if any(s.index(x)>y<2for x,y in zip(S,l))<1<=L:
	 for D in P(s[7:],repeat=L-1):
		I,J=zip(*map(lambda((a,b),l):(a(l),b%l),zip(S,l)));R=I[0];C=J[0];e=0
		for a,b in D:I,J=I[1:],J[1:];R,C=a(R,I[0]),b%(C,J[0]);e=R%1or e
		if e<(R==r):return C

Try it online!
Returns None or a string with the calculation.
Prints:

(-n) for n*-1
s(n) for square root
c(n) for cube root

Explanation
Works by checking all combinations of unary and binary operators on the input.
Outer loop gets all combinations of unary operations, which are applied to each number in the input list.
The inner loop then applies the binary operations on the result of the previous operation, and the next number.
If the result matches, a string with the calculation is returned.
Short-circuits a little by removing all outer loops where a number is 0 and the unary operator is not n => n, or the number is 1 and the operator is not n => n or n => -n

503 bytes; using a feature I never thought could come in handy.

@JonathanFrech Wow thanks, I didn't know about that one


text:
Make me a password generator!
I am making a customizable password generator.
But I (for some reason) thought it'd be better to let you guys do it.

Umm.. then?
You only get one integer. That will include all the information about the customization.
The first 4 bits (1,2,4,8) will be used for choosing which charsets will be used.
Each bit corresponds to:
1: Lowercase alphabet(qwertyuiopasdfghjklzxcvbnm)
2: Uppercase alphabet(QWERTYUIOPASDFGHJKLZXCVBNM)
4: Numbers(0123456789)
8: Special chars(All printable characters except ones stated above and the space)
The length of the password will be shifted 4 bits. In other words, multiplied by 16.
Then generate the password with the charsets and the length.
Examples
175 (10*16 + 15 (1111)): a_U0!/h96%

In other words, multiplied by 16. I don't think that's correct. Perhaps "floor division by 16"?

Does this mean newlines are allowed in the generated password? Seems a bit unusual for a password.

Randomly? All possible passwords equally likely?

Python 2, 217 203 bytes
from random import*
r=[10]+range(33,127)
r=[r[65:91],r[33:59],r[16:26],r[:16]+r[26:33]+r[59:65]+r[91:]]
x=input()
l=x>>4
print''.join(map(chr,sample(sum([k[1]for k in enumerate(r)if x&2**k[0]],[])*l,l)))

Ugh this is horribly long. The part I think could be golfed the most is the part to get the charsets; that part was a pain.
By the way, I am @HyperNeutrino; I'm just getting enough rep to chat. :P
-14 bytes thanks @ValueInk!
Bug fix thanks to @ovs!

Isn't from random import* shorter? Also is there anything in Python 3 that requires you to use it over Python 2? Python 2's print saves a byte, you can drop the int call around input, and range returns the list right away.

@ValueInk Right, thanks. -14 bytes total! :)

Currently 9 is in special chars, fix that by replacing r[16:25] with r[16:26] and r[25:33] with r[26:33]

Oh wait I just thought you were a sockpuppet of HyperNeutrino's.

@SIGSEGV I am pretty much, except this account and that won't be transferring any rep between them. :P

@ovs Thanks; I'll fix that.

Stacked, 80 79 78 bytes
:2 tb _4 drop ascii'\' 'modI'toarr+match[''#`]map\keep''#`\16/~~:>$randin~2/"!

Try it online! Takes input from the top of the stack and leaves output on the top of the stack. TIO link includes test suite (thingy) for convenience.

Mathematica 175 Bytes
""<>RandomChoice[(j=Join)@@Pick[c~j~{Complement[(r=CharacterRange)[1,127],j@@(c=r@@#&/@{{97,122},{65,90},{48,57}})]},(i=IntegerDigits[#,2])[[-4;;]],1],i[[;;-5]]~FromDigits~2]&

Coded pretty much as explained in the question. Seems like rearranging the ASCII table was expensive.
Also, there is a bug in CharacterRange which doesn't allow it to accept 0 as an argument (at least in M10.2, which is what I have handy on my laptop), so to fix that would need another 7 bytes to include the ASCII null character.

If the error you're getting is "Arguments 0 and 127 of CharacterRange are not both strings of length 1 or integers", I'm getting that on 11.1.1 too.

yep,that's the one

Infix notations can decrease a few bytes, and @@#&/@ is just @@@

PHP, 127 113 bytes
Jörg helped my tired brain with 10-2 bytes and I found another 2+4.
for(;$i<$argn>>4;$c=chr(rand()))foreach([lower,upper,digit,punct]as$t=>$f)$argn>>$t&(ctype_.$f)($c)&&$i+=print$c;

breakdown
Run as pipe with php -nR '<code>'.
// loop while length not reached
for(;$i<$argn>>4;
    // pick random character
    $c=chr(rand())
)
    // loop through bits and functions
    foreach([lower,upper,digit,punct]as$t=>$f)
        // if test is positive, increment length counter and print character
        $argn>>$t&(ctype_.$f)($c)&&$i+=print$c;

Neat tricks:
The ctype functions return false on failure (resulting in $argn>>$t&0, so the bit is irrelevant);
true on success (resulting in $argn>>$t&1, i.e. a test on bit $t).
If that test fails, short circuit kicks in and the character is skipped.
If it is positive, $i will be increased by the return value of print (always 1).

Why eval? $argn>>$t&(ctype_.$f)($c)&&print$c.!++$i; should do the same - 1 Byte for chr(rand()%127) instead of chr(rand(9,126))

@JörgHülsermann Ah I couldn´t remember how to do that concatenation thing. Thanks! But I don´t need that modulo: cast to char implies 8 bit, and the unprintables still get kicked by ctype.

Japt, 93 78 bytes
Saved 15 bytes thanks to ETHproductions
;>>4 o_=ApU&1©CU&2©BU&4©9o U&8©Q+"\{|}\\!#$%&'()*+,-.:;<=>?@[]^_`" f q)gMqZlÃq

Try it online!

Let's see... you can save several bytes by changing o r_+(Y=...gMqYl}P to o_=...gMqZl} q, another two by changing r+P to q, and some more by creating the range [0...9] instead of 165+"7890"+234. (You're missing a \{|} from the end of the string, btw)

Python 2, 180 bytes
lambda x,r=[10]+range(33,127):''.join(chr(choice(r[65:91]*(x&1)+r[33:59]*(x&2>0)+r[16:26]*(x&4>0)+(r[:16]+r[26:33]+r[59:65]+r[91:])*(x&8>0)))for i in' '*(x>>4))
from random import*

Try it online!

Jelly, 54 bytes
ØBUð,ø33r126µFỌQðṁø“ııµþ’b250Rðị@ø³%16b2UTµF
¢XȮµ:⁴’µ¡

Try it online!
Explanation
ØBUð,ø33r126µFỌQðṁø“ııµþ’b250Rðị@ø³%16b2UTµF  - nilad which returns charset
ØB                                            - yield alphanumeric characters
  U                                           - reverse to get proper order
   ð,ø33r126                                  - append char values of printable characters
            µFỌQ                              - flatten and remove repeats to get "z-aZ-A9-0[specials]"
                ðṁø                           - mold this string like ...
                   “ııµþ’b250                 - literal [26,26,10,32]
                             R                - [26R,26R,10R,32R]. All that matters is the length of each sublist.
                              ðị@             - get the elements numbered ...
                                 ³%16b2UT     - those indices we want based on the last 4 bits of the input.

¢XȮµ:⁴’µ¡ - monad with input a
 X        - pick a random element from ...
¢         - the above charset.
  Ȯ       - Print it.
        ¡ - Repeat this ...
    µ:⁴’  - floor(a/16)-1 times. (⁴ is literal 16).


text:
Can I Sp|Lit this wo|Rd?
Note that this is similar to my other challenge, but it is widened to be similar to most challenges (input -> truthy/falsey), instead of asking you all to brute force something. If this makes it a dupe, let me know, but I posted it on Sandbox and asked on chat, and didn't get any negative responses.
Input
Input will be a "word" consisting of a-z, A-Z, -, and '. The case is important. Instead of my previous challenge, where you run through all permutations, in this challenge, you will be given a permutation. Your program's response on invalid input does not matter. Input can be taken in reasonable text input formats, and can contain a trailing newline if required.
Output
Output will be a standard truthy/falsey values on if the permutation can be split in half. A permutation can be split in half if the width values (see below) of one half of the word equal the point values of the other half, or if the same is true if the middle word is removed. Trailing newlines allowed if required.
Please note that "half" does not mean that you have moved halfway into the string. "Half" means that the points on both sides are equal.
Examples:
W is 5 points. i is 1 point. Splitting the permutation Wiiiii in half will result in W | iiiii, with 5 points on each side of the |.
T is 3 points. Splitting the permutation TTTT in half will result in TT | TT, with 6 points on each side of the |.
w is 4 points. a is 3 points. Splitting the permutation waw in half will result in w (a) w, with 5.5 points on each side. The points from a are distributed to both sides, as a is split in half.
See the test cases for more clarification.
Letter Scores
Width  Characters
1      i l I '
2      f j r t -
3      a b c d e g h k n o p q s u v x y z
4      m w A B C D E F G H J K L N O P Q R S T U V X Y Z
5      M W

Test Cases
( ) indicate that the permutation can be split if the character inside the parantheses is cut in half. | indicates that the permutation can be split in between those two letters.
Input : Output : Visualization
a : truthy : (a)
ab : truthy : a|b
Ab : falsey
AB : truthy : A|B
r- : truthy : r|-
iiiiw : truthy : iiii|w
iiiiiiW : truthy : iiiii(i)W
STEPHEN : truthy : STE(P)HEN
STEphen : truthy : STE|phen
STEpheN : falsey
splitwoRdS : truthy : splitw|oRdS

And here's a visualization for splitwoRdS:
s p l i t w | o R d S
3 3 1 1 2 4   3 4 3 4

Related

Jelly, 52 50 bytes
Œuðẇ⁾MW+=
ẇÐ€“fjrt“il-“I'”T_@Ç+3µ€Hx2FŒṖṖLÐṂS€E$€Ṁ

Try it online! (exceeds memory limitations on TIO for the "splitwoRdS" test case)
Although slower and more memory hungry than the below 50 byte alternative that borrows the reduction method from fireflame241's answer:
Œuðẇ⁾MW+=
ẇÐ€“fjrt“il-“I'”T_@Ç+3µ€Hx2F+\©ð_ø®ṪHµẠ¬

How?
Œuðẇ⁾MW+= - Link 1, character index offset helper: character list c (of length one)
Œu        - to uppercase
  ð       - dyadic chain separation (call that u)
    ⁾MW   - char pair literal ['M', 'W']
   ẇ      - sublist exists in? (is u in there - True if c is 'm', 'w', 'M', or 'W')
        = - equal? (vectorised u=c? [1] for uppercase or non-alpha c, [0] for lowercase c)
       +  - add the two results (vectorises)

ẇÐ€“fjrt“il-“I'”T_@Ç+3µ€Hx2FŒṖṖLÐṂS€E$€Ṁ - Main link: character list w
                      µ€                 - for each c in w:
   “fjrt“il-“I'”                         -   list of character lists: ["fjrt","il-","I'"]
ẇÐ€                                      -   sublist (w) exists in, mapped across right
                T                        -   truthy indexes (gets [the index at which the character was found] or an empty list)
                   Ç                     -   call the last link (1) as a monad
                 _@                      -   subtract with reversed @rguments
                    +3                   -   add 3
                        H                - halve (vectorises)
                         x2              - times two (repeats each list)
                           F             - flatten into a single list
                            ŒṖ           - partitions (all ways to split the list into contiguous slices)
                              Ṗ          - pop (remove the right-most; the only one of length 1)
                                ÐṂ       - filter keep those with minimal:
                               L         -   length
                                     $€  - last two links as a monad for €ach
                                  S€     -   sum €ach
                                    E    -   all (two) equal? (1 for a split, 0 otherwise)
                                       Ṁ - maximum (1 if any split was possible, 0 otherwise)

Jelly, 79 bytes
“¡-Ị’b26
“µııẈḟ(µ⁹\fy¦°Ẓ=ȮH@Q0Ẋƈẏ9Ė=ẹṬɗƇ’ðœ?øØa;ØA;⁾'-ð,ø5Rx¢
¢yHx2+\©ð_ø®ṪHµẠ¬

Try it online!

Together we could do it in 50.

Retina, 88 bytes
T`MWi\lI'`551
T`-fjrt`2
T`m\wL`4
T`l`3
\d
$*1
+`^ ?1(1* 1*( 1*)+)1 ?$
$1
^ ?(1+) \1? ?$

Try it online!


text:
Where did Jill end up?
Jill lives in the (magnetic) north pole. One day, Jill decided to go for a walk, travelling in the four directions (north, east, west, south) for some lengths, with the help of a compass. Your task is to find whether Jill ended up where Jill lives, i.e. the magnetic north pole.
Only south is defined at the north pole. Walking north or south changes the latitude, while walking east or west changes the longitude. The longitude is not defined at the north pole. As a result, Jill would have ended up at the north pole if and only if the distances Jill walked to the south sum up to be equal to the sum of the distances Jill walked to the north, and the distance Jill walked east and west do not matter.
Input
A list of pairs of (direction, amount). The input shall be valid. The amounts will be integers. Acceptable formats include:

"N200"
"200N"
200i (complex number)
(0, 200) (0123 for NESW)
(200,0) (the above reversed)

Output
Two consistent values, one for the case that Jill did end up in the magnetic north pole, and one for the case that Jill did not.
Testcases
Truthy inputs:
S100, E50, N50, W50, N50
S10, E1000, S30, W400, S10, W10, N50
S30, N30
S10, E50, E50, N10

Falsey inputs:
S100
S10, E314, N5
S300, W135, S10, E35, N290

Scoring
This is code-golf. Shortest answer in bytes wins. Standard loopholes apply.

I have a feeling that whomever can get away with the worst abuse of the input format will win this one...

@Dennis I have a feeling that regardless of the input format, you will win this one...

Would 100S 50¬ 50N 50Ṇ 50N (NSṆ¬ indicating north-south-west-east) be an acceptable input format for the first test case? Would -100j, 50, 50j, -50, 50j (real or imaginary numbers)?

Will all initial directions be South? Otherwise, North, East and West will take you off the planet.

Why is Jill a he?

@Dennis - If my suspicions are correct, the intent might be to include polar coordinates. So actually the only criteria to check is that distanceSouth - distanceNorth = 0

Can we assume that Jill will never try to go north from the magnetic north pole?

@YiminRong Yes, sure. What I'm unclear about is how many bytes I have to waste parsing the input, because the actual computation can be done in three bytes.

"The input shall be valid." Only south is defined at the north pole.

Is this equivalent to happening on a plane, or is there something that matters about the pole?

@xnor read the truthy testcases

@LeakyNun I'd rather not try to figure out the spec from the test cases, but from what I gather, is this equivalent to the sums of Souths and Norths being 0, with the Easts and Wests ignored?

Yes, they are equivalent.

I'll vote to reopen as soon as the OP integrates all their responses into the challenge.

"The format can be any reasonable format" - can I skip E and W directions in my input, since they are irrelevant (and thus unreasonable).

Jelly, 3 bytes
SĊṆ

Input is in form of complex numbers, which will be real or purely imaginary.
Try it online!
How it works
SĊṆ  Main link. Argument: A (array of directions)

S    Take the sum of A.
 Ċ   Get the imaginary part of the sum.
  Ṇ  Take the logical NOT of the imaginary part.

I never knew Jelly has a complex part built-in

Yes, it's one of the very few overloaded operators. Ḟ, Ċ, and Ṡ (floor, ceil, and sign) don't make sense for complex numbers, so I recycled them for real, imag, and conjugate.

What are you going to do with < etc?

Not really sure yet.

@Dennis Why didn't you overload more operators?

@Challenger5 Because Jelly doesn't really work like that. For starters, all arithmetic operations vectorize at depth 0 (numbers), so + is addition, no matter what shape its arguments take.

@Dennis Why not overload between characters and numbers?

JavaScript (ES6), 36 bytes
Takes input as an array of [orientation, distance] arrays, with 0123 = NESW. Returns a boolean.
a=>!a.reduce((p,[o,d])=>p+--o%2*d,0)

The result of the modulo in JS has the same sign as the dividend:

(0 - 1) % 2 == -1 (north)
(2 - 1) % 2 == 1 (south)

.map() alternative, 36 bytes
a=>a.map(([o,d])=>a=~~a+--o%2*d)&&!a

Test cases

let f =

a=>!a.reduce((p,[o,d])=>p+--o%2*d,0)

// truthy
console.log(f([[2,100], [1,50], [0,50], [3,50], [0,50]]))
console.log(f([[2,10], [1,1000], [2,30], [3,400], [2,10], [0,50]]))
console.log(f([[2,30], [0,30]]))
console.log(f([[2,10], [1,50], [1,50], [0,10]]))

// falsy
console.log(f([[2,100]]))
console.log(f([[2,10], [1,314], [0,5]]))
console.log(f([[2,300], [3,135], [2,10], [1,35], [0,290]]))

Nice; blows the reduce solution I was working on out of the water. +1

Batch, 78 bytes
@set l=0
@for %%s in (%*)do @set t=%%s&call set/al+=%%t:i=*0%%
@cmd/cset/a!l

Takes input as command-line arguments in complex format (e.g. -100 50i 50 -50i 50). Outputs 1 if Jill arrives back at the pole, 0 if not.

Pyth, 3 bytes
!es

Input as a list of complex numbers.
Try it online!
!es
  s  # Sum
 e   # Imaginary part
!    # Not

Mathematica, 10 bytes
1>Im@Tr@#&

Pure function taking a list of complex numbers (same format, and implementation, as Dennis's Jelly answer). 1> saves a byte over 0==, and is valid thanks to the facts that distances will always be integers and you can't go north from the north pole.

Java 7, 135 bytes
boolean c(String[]a){int n=0,s=0,c,i;for(String x:a){c=x.charAt(0);i=new Short(x.substring(1));n+=c==78?i:0;s+=c==83?i:0;}return n==s;}

Those restricted input-format are pretty annoying, but I guess that was the main part of the challenge..
Explanation:
boolean c(String[]a){             // Method with String-array parameter and boolean return-type
  int n=0,                        //  North-sum
      s=0,                        //  South-sum
      c,i;                        //  Two temp integers to save bytes
  for(String x:a){                //  Loop over the input-array
    c=x.charAt(0);                //   Set `c` to the first character
    i=new Short(x.substring(1));  //   Set `i` to the actual number
    n+=c==78?i:0;                 //   If `c` == 'N': increase the North-sum with `i`
    s+=c==83?i:0;                 //   If `c` == 'S': increase the South-sum with `i`
  }                               //  End of loop
  return n==s;                    //  Return if the North- and South-sums are equal
}                                 // End of method

Test code:
Try it here.
class M{
  static boolean c(String[]a){int n=0,s=0,c,i;for(String x:a){c=x.charAt(0);i=new Short(x.substring(1));n+=c==78?i:0;s+=c==83?i:0;}return n==s;}

  public static void main(String[] a){
    System.out.println(c(new String[]{ "S100", "E50", "N50", "W50", "N50" }));
    System.out.println(c(new String[]{ "S10", "E1000", "S30", "W400", "S10", "W10", "N50" }));
    System.out.println(c(new String[]{ "S30", "N30" }));
    System.out.println(c(new String[]{ "S10", "E50", "E50", "N10" }));
    System.out.println(c(new String[]{ "S100" }));
    System.out.println(c(new String[]{ "S10", "E314", "N5" }));
    System.out.println(c(new String[]{ "S300", "W135", "S10", "E35", "N290" }));
  }
}

Output:
true
true
true
true
false
false
false

Microsoft Sql Server, 94 bytes
select sign(sum(iif(m like'[NS]%',stuff(m,1,1,iif(m like'S%','-','')),0)))+1 from a group by g

Check it.

Python, 23 bytes
lambda s:sum(s).imag==0

Input as a list of complex numbers.


text:
Mean Reputation Change
Challenge
Given a the ID for a PPCG user who has existed for at least a month, output the average amount of reputation they gain per month. You can do this by dividing their reputation by the time since their account was created (which you can find on the profile). This should be returned floored; that is, truncate all of the decimals. (We don't care about the small stuff).
Input
A single integer, which is the user's ID
Output
A single integer, representing the floored rep change per month.
Test Cases
input -> output
42649 -> 127 (me)
12012 -> 3475 (Dennis)
8478  -> 3015 (Martin Ender)

Can you define what a month is considered to be - a calendar month, a lunar month or 30 days? Or is it at our discretion?

@Shaggy When you go to a user profile, under the profile tab, it says "User for ". Go by that.

@HyperNeutrino so the formula is (rep/daysSinceAccountCreate)*30? You need to give us a constant for what a month is.

@Sirens Go here and Ctrl-F for 1 year, 9 months. That's what I mean.

Should a check that the user has existed for at least a month be included?

@DimP I will say you can assume that.

JS, ES6 243 235 168 166 165 164 bytes
i=>fetch(`//api.stackexchange.com/users/${i}?site=codegolf`).then(x=>x.json()).then(x=>alert(~~((y=x.items[0]).reputation/((new Date/1e3-y.creation_date)/2592e3))))

Based on the Python answer.
Run this in the console:
(i=>fetch(`//api.stackexchange.com/users/${i}?site=codegolf`).then(x=>x.json()).then(x=>alert(~~((y=x.items[0]).reputation/((new Date/1e3-y.creation_date)/2592e3)))))(+prompt("Enter a userId"))

-4 thanks to @insert_name_here
Old answer:
z=>fetch("//codegolf.stackexchange.com/u/"+z).then(x=>x.text()).then(x=>alert((/([\d,]+) repu/.exec(x)[1].replace(/,/g,"")/(((y=/Member for <.+>((\d+) years?, )?(\d+) month/.exec(x))[2]||0)*12+ +y[3]||0))))

Improvements welcome! Just fetches the profile page and parses it with regular expressions!
Won't work as a stack snippet, but you can paste this in your console:
(z=>fetch("//codegolf.stackexchange.com/u/"+z).then(x=>x.text()).then(x=>alert(Math.floor(/([\d,]+) repu/.exec(x)[1].replace(/,/g,"")/(((y=/Member for <.+>((\d+) years?, )?(\d+) month/.exec(x))[2]||0)*12+ +y[3]||0)))))(+prompt("Enter a userId"))

Okay :) You have a much higher rep change than me D: I think about double

You could save two bytes by using new Date instead of Date.now(). You could also save one more by using 1e3 instead of 1000 and another by using 2592e3 instead of 2592000.

Python 3 2, 206 219 201 193 bytes
import requests,time
a=requests.get('http://api.stackexchange.com/users/'+str(input())+'?site=codegolf').json()['items'][0]
print a['reputation']/((int(time.time())-a['creation_date'])/2592000)

I am estimating the months as the OP suggested, but actually print(int(b/((d-c)/2592000))) is a more accurate solution than print(int(b/int((d-c)/2592000))) and also saves a few bytes.

get is not defined

@HyperNeutrino try it again now, should work (Python 2). Obviously needs requests.


text:
Is my integer significant?
Your task is to write a function that takes an even-digit integer and compares the 2 halves of the integer. If the sum of the digits in the first half is greater than the sum of the digits in the second half, output a truthy value, otherwise, output falsey.
For example:
12345678
1234 5678
(1+2+3+4)>(5+6+7+8)
10>26

Output falsey

Input
A single integer.

This must be passed as a single whole integer in base 10, a single string, an array of integers, or an array of characters. Please specify which format your answer accepts
The input can be passed via Command Line Arguments, STDIN, or any other standard method of input supported by your language
Assume the input will always have an even digit count
Assume the input will always be positive and greater than 0
Assume the input will be within feasible number handling capacities for your language
The input will not contain leading zeroes

Output
A truthy value if the sum of the digits in the first half is greater than the sum of the digits in the second half.
A falsey value if the sum of the digits in the first half is less than or equal to the sum of the digits in the second half.
Test cases
Input > Output

12345678 > False
87654321 > True
12344321 > False
12 > False
214758392639543385 > False
1001 > False
100000 > True

Scoring
This is code-golf so fewest bytes wins.

The "duplicate" is an = check, this is a > check. I don't think they're duplicates.

Voting to reopen, because even though the differences are small, they obviously make a large difference given that answers to this are often 15-20 bytes smaller than the :duplicate".

I am reopening this challenge because the difference between > and = is not too major, but the guarantee of an even length integer changes the entire approach that a lot of answers use (not just removing one or two bytes).

Brachylog, 5 bytes
ḍ+ᵐ>₁

Try it online!
How it works
ḍ+ᵐ>₁                     example input: 12345678
ḍ        split in half                   [[1,2,3,4],[5,6,7,8]]
 +ᵐ      sum each half                   [10,26]
   >₁    results in a decreasing list    false

Octave, 39 35 28 bytes
@(x)sum(x)/2<sum(x(1:end/2))

Input integers as a string '12345678'.
Takes the sum of all the digits (as ASCII-values), and divides it by two, to get the mean of the two sides. Compares this to the sum of the first half of the integer, to check if it's smaller or not.

I like the use of ASCII values and calculating the mean, always cool to see different approaches to the task.

Retina, 34 bytes
\d
$*1;
+`;(.*);(.)
$1$2
1(1*);\1;

Try it online! Works by inserting ;s after each digit as they are converted to unary. The ;s are then deleted in pairs until only the middle and final ;s remain and the numbers can then be compared.

How does it only remove the first and last semicolons each iteration?

The * in .* is maximal matching (greedy), so it would match as much as possible.

@KritixiLithos * is greedy, so it skips as many ;s as possible.

Regex, 226 bytes
^(9(){9}|8(?<2>){8}|7(?<2>){7}|6(?<2>){6}|5(?<2>){5}|4(?<2>){4}|3(?<2>){3}|2(?<2>){2}|1(?<2>)|0)+(?<-1>9(?<-2>){9}|8(?<-2>){8}|7(?<-2>){7}|6(?<-2>){6}|5(?<-2>){5}|4(?<-2>){4}|3(?<-2>){3}|2(?<-2>){2}|1(?<-2>)|0)+(?<-2>)(?(1)^)$

Try it online! (uses Retina to check)

I assume the 0 or 1 output is the number of matches? Meaning this will only match "significant" numbers? That's pretty cool.

What does the (?<number>) do?

They are called balancing groups. Please refer to an answer written by Martin Ender on SO.

Haskell, 34 bytes
g(h:t)=h-g(reverse t)
g _=0
(>0).g

Try it online! Take list as input.
Computes the sum of the first half minus that of the second half by recursively taking the first element and subtracting the recursive result on the reverse. For example:
g [1,2,3,4]    =
1-g[4,3,2]     =
1-(4-g[2,3])   =
1-(4-(2-g[3])) =
1-(4-(2-3))    =
1-4+2-3        =
(1+2)-(3+4)

Python 2, 52 Bytes thanks to help in comments
lambda x:sum(x[i]-x[~i] for i in range(len(x)//2))>0

The idea was to substract the first digit from the last, second from second last... and check if the sum of all substractions is greater then 0.
Try it online!

Can you use string indexes?

@erbsenhirn use x[i]-x[~i] for the same output. you can index python lists with negative indices, -1 being the last, so x[-i-1] would do the trick, but -i-1 == ~i :D

@erbsenhirn you can remove [ ] from the sum, as: sum(x[i]....range(len(x)/2))>0

Nice approach, but it doesn't beat doing it the regular way.

PHP, 54 bytes
for($n=$argn;~$n[2*$i];)$s+=$n[$i]-$n[-++$i];echo$s>0;

takes input from STDIN; empty output for falsy. Requires PHP 7.1. Run with -nR.
breakdown
for($n=$argn;       # import input
    ~$n[2*$i];      # loop while there is a 2*$i-th digit (0-indexed)
)
    $s+=$n[$i]          # 1. add $i-th digit
        -$n[-++$i];     # 2. subtract -1-$i-th digit
echo$s>0;           # if $s>0, print "1" , else print nothing

Retina, 60 40 bytes
Saved some bytes thanks to @MartinEnder
^(.)+?(?=(?<-1>.)+$)
$&;
\d
$*
.(1*);\1$

Try it online!

05AB1E, 5 bytes
2äO`›

Try it online!
Explanation
Takes input as list of digits.
2ä     # split in half
  O    # sum each part
   `›  # is the first half greater than the second

To take input as an integer you could just add S for
S2äO`›

Oh, we're even now...

@LeakyNun: I like yours better though, due to the input format.

Python 3, 68 62 bytes
i=input()
print(sum(map(int,i))>2*sum(map(int,i[len(i)//2:])))

Short explanation:

input() reads a string from stdin.
i[len(i)//2:] takes the second half of the string.
The map functions turn the string to an integer list.
sum, >, *2 and print do what they say.

Python 2, 78 62 44 35 bytes
Crossed out 44 is still regular 44. :c
-16 bytes thanks to LeakyNun. -18 bytes on allowance of integer array input. -9 bytes thanks to Dennis.
Takes input as an array of integers and returns True/False. Note that it relies on Python 2's integer division.
lambda s:sum(s[:len(s)/2])*2>sum(s)

Try it online!
Explanation:
I know this (or anything in Python) doesn't need an explanation but I'm doing it anyways for good practise. :P
    s[:len(s)/2]             # Gets first half of array
sum(s[:len(s)/2])            # Calculates the sum of the values
sum(s[:len(s)/2])*2          # Multiplies it by 2 (explanations...)
                    sum(s)   # Total sum of the digits
sum(s[:len(s)/2])*2>sum(s)   # Compares the two sums

Golfed

@LeakyNun I should really learn how map() works. o0 Thanks!

Hint: the sum of both halves is the total.

@Dennis I hope this is what you meant.

C#, 148 bytes
void q(){var a=Console.ReadLine();int b=0,c=0,i=0,d=a.Length/2;for(;i<d;i++){b+=int.Parse(a[i]+"");c+=int.Parse(a[i+d]+"");}Console.WriteLine(b>c);}

Actually, 7 bytes
2,╡♂Σi>

Input is taken as a list of digits. Try it online!
Explanation:
2,╡♂Σi>
2,╡      split input into two equal sublists
   ♂Σ    sum each sublist
     i>  is first sum greater than second sum?

Jelly, 10 7 bytes
œs2S€>/

Saved a byte by changing the input to a list of digits.
Saved several more thanks to Leaky Nun!
Try it online!
Explanation:
œs2    Split that list into 2 chunks
   S€  Sum each chunk individually
>/     Reduce the resulting list by relative compare.

Prepend this to work with integer input instead of a list:

D       Turn the integer into a list of digits

You can remove 2 bytes with the latest version of Jelly: Try it online!

C (gcc), 79  or 75, 74
better version (80 char -> 79 thanks to titus )
f(char*s){int i=0,n=strlen(s--)/2;for(;*(++s+n);)i-=*s-s[n];putchar(48+(i<0));}

Try it online!
next, 75 bytes if we rely on constant undefined behaviour,
f(char*s){int i=0,n=strlen(s)/2;for(;s[n];)i-=*s-s++[n];putchar(48+(i<0);}

Try it online!
input valid string in C (a zero terminated array of char)
output 1 for true, 0 for false
ungolfed version
f(char*s)
{
    int i=0;
    int n=strlen(s)/2; /* n is the length of each strings  so we have
                          the start of the first string at *s or s[0],
                          and the start of the second sequence at s[n]
                        */
    for(;s[n];) /* until we get 0, all string in C are terminated by 0 */
        i-=*s-s++[n]; /* i is the difference between the two characters *s and s[n],
        then we move the cursor to the next character (s++) :)
        on the string 12345678, after the first iteration we have
        i == -4 and 234,678 the proceed
        */
    putchar(48+(i<0)); /* put char '0' if i<0, char '0'+1 otherwise (the char '1')
 }

and now 74 thanks to "a stone arachnid"
C (gcc), 74 bytes
f(char*s){int i=0,n=strlen(s)/2;for(;s[n];)i-=*s-s++[n];printf("%d",i<0);}

Try it online!

i-=*s-s++[n]; invokes undefined behaviour.

Would 48+(i<0) work?

printf("%d",i<0) is shorter than putchar(48+(i<0)): Try it online!

JavaScript (ES6), 44 bytes

f=([n,...a],d=0)=>1/n?f(a,d-=n-=a.pop()):d<0
<input oninput=o.textContent=this.value.length%2?``:f(this.value)><pre id=o>

Takes input as a string or array of digits as characters or integers.

Husk, 5 bytes
F<mΣ½

Try it online!
Input as an array of integers.

GolfScript, 13 bytes
.,2//{{+}*}/>

Try it online!
.,              # Get the length of the input                        "12345678" 8
  2/            # Half it                                            "12345678" 4
    /           # Divide the string in groups of that many digits    ["1234" "5678"]
     {    }/    # For each string
      {+}*      # Add the ascii values                               202 218
            >   # Is the first bigger than the second?               0

It actually adds the ascii values of the numbers, but both groups of digits have d digits, so both results are 48*d more than the actual value. This would only be a problem if the groups had different lengths.

Vyxal, 8 7 6 bytes
Thanks to @Razetime for saving 1 byte due to the ⌊ command auto-vectorising.
½⌊v∑>t

Try it Online!
Takes input in the form of "12345678". Alternatively, the quotes can be left out if the Ṡ flag is used.
I’m gonna be honest, I’m not really sure what the > is doing since (a:string, b:list) isn’t documented for that command, but I was messing with it and found that in this case it returns <1|0> or <1|1>, so I take the last value of the list and that’s the answer.
Explanation:
        # Implicit input
½       # Split the input into two chunks
 ⌊      # Convert both chunks to integers
  v∑    # Sum the digits of each chunk
    >   # Some sort of a>b thing?
     t  # Tail; last item
        # Implicit output

v⌊ -> ⌊ since it auto vectorizes

@Razetime Added. Thanks for pointing that out.

Very clever usage of ḭ. +1

Haskell, 40 38 bytes
f s=sum s<2*sum(take(div(length s)2)s)

Try it online! Takes the integer as list of digits and returns either True or False. Example usage: f [1,2,3,4].
f s=                                   -- function f takes a list s
    sum s                              -- return whether the sum of s
         <2*sum(                     ) -- is smaller than two times the sum of
                take(div(length s)2)s  -- the first (length s/2) elements of s

Edit: Thanks to @nimi for -2 bytes.

Mathematica 36 Bytes
#>#2&@@BlockMap[Total,#,Length@#/2]&

Lua, 65 bytes
s=...load("x="..s:gsub(".","+%0"):gsub("+","-",#s/2))()print(x<0)
Steps of conversion:
1234
+1+2+3+4
-1-2+3+4
x=-1-2+3+4
eval the last string
print(x<0)

Usage:
$ lua program.lua 1234
false

Braingolf, 20 bytes
dl2/2->[+]>l3->[+],-

Try it online!
Figured nobody else is likely to post a braingolf answer, so here's mine.
Takes input as an integer, Prints a positive number for truthy, and a negative number or zero for falsey
Explanation:
dl2/2->[+]>l3->[+],-
d                     Split last item on stack into digits, push each digit to stack
 l                    Push length of stack to stack
  2/                  Halve last item on stack
    2-                Subtract 2 from last item on stack
      >               Move last item on stack to start of stack
       [+]            Sum last 2 items of stack 3 times (last 4 items)
          >           Move last item on stack to start of stack
           l          Push length of stack to stack
            3-        Subtract 3 from last item on stack
              [+]     Sum last 2 items of stack 3 times (last 4 items)
                 ,-   Subtract last item (sum of first half) from 2nd to last (sum of 2nd half)
                      Implicit: Print last item on stack

JavaScript (ES6), 67 65 bytes
I think it might be too early in the morning for golf; this seems much longer than it needs to be!
Takes input as an array of individual digits.
n=>(g=(a,b)=>eval(n.slice(a,b).join`+`))(0,l=n.length/2)>g(l,l+l)

Try it

f=
n=>(g=(a,b)=>eval(n.slice(a,b).join`+`))(0,l=n.length/2)>g(l,l+l)
console.log(f([1,2,3,4,5,6,7,8])) // false
console.log(f([8,7,6,5,4,3,2,1])) // true
console.log(f([1,2,3,4,4,3,2,1])) // false
console.log(f([1,2])) // false
console.log(f([2,1,4,7,5,8,3,9,2,6,3,9,5,4,3,3,8,5])) // false
console.log(f([1,0,0,1])) // false
console.log(f([1,0,0,0,0,0])) // true

Batch, 122 bytes
@set/al=r=0
@set/ps=
:l
@set/al+=%s:~,1%,r+=%s:~-1%
@set s=%s:~1,-1%
@if not "%s%"=="" goto l
@if %l% gtr %r% echo 1

Takes input on STDIN and outputs 1 if the value is significant.

Java, 95 94 bytes
boolean f(long n){int x=10,a=x,s=0;for(;a<n;n/=x,a*=x)s+=n%x;for(;n>0;n/=x)s-=n%x;return s<0;}

Try it online!

Japt, 29 17 bytes
Saved 12 bytes thanks to ETHproductions and obarakon
¯½*Ul)x >Us½*Ul)x

Try it online!

Nice answer! The input can be an array, so you can do something like A=Ul /2U¯A x >UtA x

¯½*Ul)x >UsUl /2 x for 18 bytes!

@obarakon And another byte off that: ¯½*Ul)x >Us½*Ul)x (It brings a tear of joy to my eye to see someone other than myself helping someone else golf in Japt, haha)

@ETHproductions Oh, I didn't think s½ would work. Sweet!

@obarakon It's a bug in the current version of the online interpreter, but not in TIO. I'll push a fix in a couple minutes...

Should be fixed now.

K (oK), 13 10 9 bytes
-4 bytes by making tacit
>/+/0N 2#

Try it online!
Takes a list of integers as the input.

0N 2# split input into pairs
+/ sum the pairs column-wise
>/ is the sum of the first chunk larger than the sum of the second?

Factor + math.unicode, 20 bytes
[ halves v- Σ 0 > ]

Try it online!
Explanation:
It's a quotation (anonymous function) that takes a sequence of integers from the data stack as input and leaves a boolean value on the data stack as output. Assuming { 1 2 3 4 5 6 7 8 } is on top of the data stack when this quotation is called...

halves Split a sequence in half.
Stack: { 1 2 3 4 } { 5 6 7 8 }

v- Element-wise subtraction of two vectors. (This is shorter than summing each sequence individually.)
Stack: { -4 -4 -4 -4 }

Σ Sum.
Stack: -16

0 > Is it greater than zero?
Stack: f

Thunno 2, 5 bytes
2ẆʂØv

Try it online!
Explanation
2ẆʂØv  # Implicit input
2Ẇ     # Split into 2 pieces
  ʂ    # Sum each inner list
   Øv  # Strictly decreasing?
       # Implicit output

Ruby, 56 bytes
->(x){n=x.length/2;c=x.codepoints;c[0,n].sum>c[n,n].sum}

Try it online!
This works with a string of digit characters via gets.

Arturo, 29 bytes
$=>[0a:0loop&[x,y][y+'a+x]a>]

Try it!

Brain-Flak, 98 bytes
(()){{}({}<>)([][<>[]])}{}({{}})<>({{}}<>[{}()])([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

Try it online!
#Push half of the input onto the alternate stack in reverse
(()){{}({}<>)([][<>[]])}{}

#Sum the main stack
({{}})<>

#Sum the alternate stack and subtract the sum of the main stack +1 from it
({{}}<>[{}()])

#Greater than or equal to 0?
([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

Credit to Wheat Wizard, Riley, and MegaTom for collaboratively coming up with that greater than 0 snippet in chat

It's a bit sad how half of the code is >=0.

CJam, 12 bytes
l~_,2//::+~>

Explanation:
l~  e# Read line and evaluate:   | [1 2 3 4 5 6 7 8]
_,  e# Duplicate and get length: | [1 2 3 4 5 6 7 8] 8
2/  e# Divide by 2:              | [1 2 3 4 5 6 7 8] 4
/   e# Break into groups:        | [[1 2 3 4] [5 6 7 8]]
::+ e# Sum each:                 | [10 26]
~   e# Unpack:                   | 10 26
>   e# More than:                | 0 (false)

Clojure, 44 bytes
#(neg?(apply +(map -(drop(/(count %)2)%)%)))

Input is a sequence of ASCII integers. This ended up being a bit shorted than using split-at, and also avoids for as map stops when one of the input lists runs out. So this substracts element-wise the two halves of the input and checks if the sum of differences is negative or not (as we are substracting the second half from the first).
(def f #(neg?(apply +(map -(drop(/(count %)2)%)%))))
(f (map int "214758392639543385"))

Pyth, 9 bytes
>.*msdc2Q

Takes an array of integers.
Try it!

Golfed

Python 3, 61 bytes
n=[int(i) for i in list(input())];sum(n[:len(n)//2])*2>sum(n)

Try it online!

Welcome to Code Golf, and nice first answer! Be sure to check out our Tips for golfing in Python page for ways you can golf your program. This currently doesn't output anything, as it doesn't have a print(...) around the comparison. Alternatively, you can change it to a function that returns its result. Right now, this is just a snippet

Vyxal, 39 bitsv2, 4.875 bytes
½EṠƒ<

Try it Online!
Explained
½EṠƒ<
½E     # Push the input string into two halves and evaluate each
  Ṡ    # Vectorised sums
   ƒ<  # Reduce by less than.

Created with the help of Luminespire.

JavaScript (Node.js), 45 bytes
Sadly, this solution is 1 byte longer than the shortest JS answer!
As allowed by OP, it takes an array of single-digit integers as input.
t=>t.map((e,i)=>t[i*2]+1?a+=e:b+=e,a=b=0)|a>b

Try it online!

a and b store the sum of the digits of the first and second half of the parameter, respectively.

We use t[i*2]+1 to check in which half of the array we are. The +1 is mandatory because the input array can contain zeroes, which would lead to a wrong answer in particular test cases like 4508 -> true.

Desmos, 61 50 49 bytes
-1 byte thanks to Aiden Chow!
Takes an array of digits as input.
a=A.length/2
f(A)=\{\sum_{n=1}^a(A[n]-A[n+a])>0\}

(if you paste this into your own graph paste it line-by-line and while pasting \$f(A)\$ into Desmos add a newline in front - the Desmos parser is kind of bugged in that respect)
Try it on Desmos!

Rust, 61 bytes
Takes the input as an array of base 10 digits, splits it in half, and then checks if sums of the halves are in order.
|s|!s.chunks(s.len()/2).map(|c|u8::sum(c.iter())).is_sorted()

Rust Playground