text:
Tips for golfing in R
I'm looking for tips for golfing in the R statistical language.  R is perhaps an unconventional choice for Golf.  However, it does certain things very compactly (sequences, randomness, vectors, and lists), many of the built-in functions have very short names, and it has an optional line terminator (;).  What tips and tricks can you give to help solve code golf problems in R?

The answers to this question could double as an anti-styleguide for R, given that code golf is really the only time you should do a lot of these things :-)

Some tips:

In R, it's recommended to use <- over =. For golfing, the
opposite holds since = is shorter...
If you call a function more than once, it is often beneficial to
define a short alias for it:
as.numeric(x)+as.numeric(y)

a=as.numeric;a(x)+a(y)

Partial matching can be your friend, especially when functions
    return lists which you only need one item of.  Compare
    rle(x)$lengths to rle(x)$l
Many challenges require you to read input. scan is often a good fit for this (the user ends the input by entring an empty line).
scan()    # reads numbers into a vector
scan(,'') # reads strings into a vector

Coercion can be useful.  t=1 is much shorter than t=TRUE.  Alternatively, switch can save you precious characters as well, but you'll want to use 1,2 rather than 0,1.
if(length(x)) {} # TRUE if length != 0
sum(x<3)         # Adds all the TRUE:s (count TRUE)

If a function computes something complicated and you need various other types of calculations based on the same core value, it is often beneficial to either: a) break it up into smaller functions, b) return all the results you need as a list, or c) have it return different types of values depending on an argument to the function.
As in any language, know it well - R has thousands of functions, there is probably some that can solve the problem in very few characters - the trick is to know which ones!

Some obscure but useful functions:
sequence
diff
rle
embed
gl # Like rep(seq(),each=...) but returns a factor

Some built-in data sets and symbols:
letters     # 'a','b','c'...
LETTERS     # 'A','B','C'...
month.abb   # 'Jan','Feb'...
month.name  # 'January','Feburary'...
T           # TRUE
F           # FALSE
pi          # 3.14...

Instead of importing a package with library, grab the variable from the package using :: . Compare the followings:
library(splancs);inout(...)
splancs::inout(...)

Of course, it is only valid if one single function  is used from the package.
This is trivial but a rule of thumb for when to use @Tommy's trick of aliasing a function: if your function name has a length of m and is used n times, then alias only if m*n > m+n+3 (because when defining the alias you spend m+3 and then you still spend 1 everytime the alias is used). An example:
nrow(a)+nrow(b)     # 4*2 < 4+3+2
n=nrow;n(a)+n(b)
length(a)+length(b) # 6*2 > 6+3+2
l=length;l(a)+l(b)

Coercion as side-effect of functions:

instead of using as.integer, character strings can be coerced to integer using : :
as.integer("19")
("19":1)[1] #Shorter version using force coercion.

integer, numeric, etc. can be similarly coerced to character using paste instead of as.character:
as.character(19)
paste(19) #Shorter version using force coercion.

Re: 3rd tip, el("19":1) is even shorter by one byte.

Some very specific golfing tips:

if you need to extract the length of a vector, sum(x|1) is shorter than length(x) as long as x is numeric, integer, complex or logical.

if you need to extract the last element of a vector, it may be cheaper (if possible) to initialise the vector backwards using rev() and then calling x[1] rather than x[length(x)] (or using the above tip, x[sum(x|1)]) (or tail(x,1) --- thanks Giuseppe!). A slight variation on this (where the second-last element was desired) can be seen here. Even if you can't initialise the vector backwards, rev(x)[1] is still shorter than x[sum(x|1)] (and it works for character vectors too). Sometimes you don't even need rev, for example using n:1 instead of 1:n.

(As seen here). If you want to coerce a data frame to a matrix, don't use as.matrix(x). Take the transpose of the transpose, t(t(x)).

if is a formal function. For example, "if"(x<y,2,3) is shorter than if(x<y)2 else 3 (though of course, 3-(x<y) is shorter than either). This only saves characters if you don't need an extra pair of braces to formulate it this way, which you often do.

For testing non-equality of numeric objects, if(x-y) is shorter than if(x!=y). Any nonzero numeric is regarded as TRUE. If you are testing equality, say, if(x==y)a else b then try if(x-y)b else a instead. Also see the previous point.

The function el is useful when you need to extract an item from a list. The most common example is probably strsplit: el(strsplit(x,"")) is one fewer byte than strsplit(x,"")[[1]].

(As used here) Vector extension can save you characters: if vector v has length n you can assign into v[n+1] without error. For example, if you wanted to print the first ten factorials you could do: v=1;for(i in 2:10)v[i]=v[i-1]*i rather than v=1:10:for(...) (though as always, there is another, better, way: cumprod(1:10))

Sometimes, for text based challenges (particularly 2-D ones), it's easier to plot the text rather than cat it. the argument pch= to plot controls which characters are plotted. This can be shortened to pc= (which will also give a warning) to save a byte. Example here.

To take the floor of a number, don't use floor(x). Use x%/%1 instead.

To test if the elements of a numeric or integer vector are all equal, you can often use sd rather than something verbose such as all.equal. If all the elements are the same, their standard deviation is zero (FALSE) else the standard deviation is positive (TRUE). Example here.

Some functions which you would expect to require integer input actually don't. For example, seq(3.5) will return 1 2 3 (the same is true for the : operator). This can avoid calls to floor and sometimes means you can use / instead of %/%.

The most common function for text output is cat. But if you needed to use print for some reason, then you might be able to save a character by using show instead (which in most circumstances just calls print anyway though you forego any extra arguments like digits)

don't forget about complex numbers! The functions to operate on them (Re, Im, Mod, Arg) have quite short names which can occasionally be useful, and complex numbers as a concept can sometimes yield simple solutions to some calculations.

for functions with very long names (>13–15 characters), you can use get to get at the function. For example, in R 3.4.4 with no packages loaded other than the default, get(ls(9)[501]) is more economical than getDLLRegisteredRoutines. This can also get around source code restrictions such as this answer. Note that using this trick makes your code R-version-dependent (and perhaps platform dependent), so make sure you include the version in your header so it can be reproduced if necessary.

tail(v,1) is the same length as rev(v)[1] for the "last element of an array" golfing tip as well.

read.csv(t="a,b,c",,F) is shorter than el(strsplit("a,b,c",",")).

An equivalent to sum(x|1) is sum(1^x). When we have a shorthand for sum, this can be useful due to operator precedence, as in "!"=sum;!1^x.

Abuse the builtins T and F. By default, they evaluate to TRUE and FALSE, which can be automatically converted to numerics 1 and 0, and they can be re-defined at will. This means that you don't need to initialize a counter (e.g. i=0 ... i=i+1), you can just use T or F as needed (and jump straight to F=F+1 later).
Remember that functions return the last object called and do not need an explicit return() call.
Defining short aliases for commonly used functions is great, such as p=paste. If you use a function a lot, and with exactly two arguments, it is possible that an infixing alias will save you some bytes. Infixing aliases must be surrounded by %. For example:
`%p%`=paste

And subsequently x%p%y, which is 1 byte shorter than p(x,y). The infixing alias definition is 4 bytes longer than the non-infixing p=paste though, so you have to be sure it's worth it.

You can use primitive functions and you save many bytes: \+`=paste; x+y`

You can assign a variable to the current environment while simultaneously supplying it as an argument to a function:
sum(x <- 4, y <- 5)
x
y

If you are subseting a data.frame and your condition depends on several of its columns, you can avoid repeating the data.frame name by using with (or subset).
d <- data.frame(a=letters[1:3], b=1:3, c=4:6, e=7:9)
with(d, d[a=='b' & b==2 & c==5 & e==8,])

instead of
d[d$a=='b' & d$b==2 & d$c==5 & d$e==8,]

Of course, this only saves characters if the length of your references to the data.frame exceeds the length of with(,)
if...else blocks can return the value of the final statement in which ever part of the block executes. For instance, instead of
a <- 3
if (a==1) y<-1 else
if (a==2) y<-2 else y<-3

you can write
y <- if (a==1) 1 else
     if (a==2) 2 else 3

Only caution about (1) is that when you do that you're passing it in by order not by named arguments.  If f <- function(a,b) cat(a,b), then f(a <- 'A', b <- 'B') is not the same as f(b <- 'B', a <- 'A').

Using if, ifelse, and `if`
There are several ways to do if-statements in R. Golf-optimal solutions can vary a lot.
The basics

if is for control flow. It is not vectorized, i.e. can only evaluate conditions of length 1. It requires else to (optionally) return an else value.
ifelse is a function. It is vectorized, and can return values of arbitrary length. Its third argument (the else value) is obligatory.*
`if` is a function, with the same syntax as ifelse. It is not vectorized, nor are any of the return arguments obligatory.

* It's not technically obligatory; ifelse(TRUE,x) works just fine, but it throws an error if the third argument is empty and the condition evaluates to FALSE. So it's only safe to use if you are sure that the condition is always TRUE, and if that's the case, why are you even bothering with an if-statement?
Examples
These are all equivalent:
if(x)y else z # 13 bytes
ifelse(x,y,z) # 13 bytes
`if`(x,y,z)   # 11 bytes

Note that the spaces around else are not required if you are using strings directly in the code:
if(x)"foo"else"bar"   # 19 bytes
ifelse(x,"foo","bar") # 21 bytes
`if`(x,"foo","bar")   # 19 bytes

So far, `if` looks to be the winner, as long as we don't have vectorized input. But what about cases where we don't care about the else condition? Say we only want to execute some code if the condition is TRUE. For one line of code alone, if is usually best:
if(x)z=f(y)         # 11 bytes
ifelse(x,z<-f(y),0) # 19 bytes
`if`(x,z<-f(y))     # 15 bytes

For multiple lines of code, if is still the winner:
if(x){z=f(y);a=g(y)}        # 20 bytes
ifelse(x,{z=f(y);a=g(y)},0) # 27 bytes
`if`(x,{z=f(y);a=g(y)})     # 23 bytes

There's also the possibility where we do care about the else condition, and where we want to execute arbitrary code rather than return a value. In these cases, if and `if` are equivalent in byte count.
if(x)a=b else z=b   # 17 bytes
ifelse(x,a<-b,z<-b) # 19 bytes
`if`(x,a<-b,z<-b)   # 17 bytes

if(x){z=y;a=b}else z=b   # 22 bytes
ifelse(x,{z=y;a=b},z<-b) # 24 bytes
`if`(x,{z=y;a=b},z<-b)   # 22 bytes

if(x)a=b else{z=b;a=y}   # 22 bytes
ifelse(x,a<-b,{z=b;a=y}) # 24 bytes
`if`(x,a<-b,{z=b;a=y})   # 22 bytes

if(x){z=y;a=b}else{z=b;a=y}   # 27 bytes
ifelse(x,{z=y;a=b},{z=b;a=y}) # 29 bytes
`if`(x,{z=y;a=b},{z=b;a=y})   # 27 bytes

Summary

Use ifelse when you have input of length > 1.
If you're returning a simple value rather than executing many lines of code, using the `if` function is probably shorter than a full if...else statement.
If you just want a single value when TRUE, use if.
For executing arbitrary code, `if` and if are usually the same in terms of byte count; I recommend if mainly because it's easier to read.

Nice! Very good comparisons, +1!

Do-while loops in R
Occasionally, I find myself wishing R had a do-while loop, because:
 some_code
while(condition){
 some_code # repeated
}

is far too long and very un-golfy. However, we can recover this behavior and shave off some bytes with the power of the { function.
{ and ( are each .Primitive functions in R.
The documentation for them reads:

Effectively, ( is semantically equivalent to the identity function(x) x, whereas { is slightly more interesting, see examples.

and under Value,

For (, the result of evaluating the argument. This has visibility set, so will auto-print if used at top-level.
For {, the result of the last expression evaluated. This has the visibility of the last evaluation.

(emphasis added)
So, what does this mean? It means a do-while loop is as simple as
while({some_code;condition})0

because the expressions inside {} are each evaluated, and only the last one is returned by {, allowing us to evaluate some_code before entering the loop, and it runs each time condition is TRUE (or truthy). The 0 is one of the many 1-byte expressions that forms the "real" body of the while loop.
Additionally, this can be combined with print (which invisibly returns its argument) to repeatedly print an intermediate result until (and including) it reaches 0. An example of this can be found here.

Save values in-line: Others have mentioned that you can pass values in-order and assign them for use elsewhere, i.e.
 sum(x<- 1:10, y<- seq(10,1,2))

However, you can also save values inline for use in the same line!
For instance
    n=scan();(x=1:n)[abs(x-n/2)<4]

reads from stdin, creates a variable x=1:n, then indexes into x using that value of x. This can sometimes save bytes.

Alias for the empty vector You can use {} as the empty vector c() as they both return NULL.

Base Conversion For integer digits of n in base 10, use n%/%10^(0:nchar(n))%%10. This will leave a trailing zero, so if that is important to you, use n%/%10^(1:nchar(n)-1)%%10 ot n%/%10^(0:log10(n)). This can be adapted to other bases, using 0:log(n,b) instead of log10(n).

Using seq and :: Rather than using 1:length(l) (or 1:sum(x|1)), you can use seq(l) as long as l is a list or vector of length greater than 1, as it defaults to seq_along(l). If l is numeric and could potentially be length 1, seq(!l) or seq(a=l) will do the trick.
Additionally, : will (with a warning) use the first element of its arguments.

Removing attributes Using c() on an array (or matrix) will do the same as as.vector; it generally removes non-name attributes.

Factorial Using gamma(n+1) is shorter than using factorial(n) and factorial is defined as gamma(n+1) anyway.

Coin Flipping When needing to do a random task 50% of the time, using rt(1,1)<0 is shorter than runif(1)<0.5 by three bytes.

Extracting/Excluding elements head and tail are often useful to extract the first/last few elements of an array; head(x,-1) extracts all but the last element and is shorter than using negative indexing, if you don't already know the length:head(x,-1)
x[-length(x)]
x[-sum(x|1)]

@J.Doe worthy of its own post, I think! Perhaps with a title of "alternatives to rep". Other tips questions have a restriction of one tip per answer, which I wholeheartedly endorse for this question, too! Also, 1:n*0 is shorter than Im(1:n) by two bytes, which means your second trick can be x+0*-n:n as well :-)

@J.Doe Or even better, !1:n is also an array of n zeros depending on use case; credit to the MATL/MATLAB tips question (probably Luis Mendo) for that one, though.

Thanks, @Giuseppe! Can I suggest you create this post, as I don't want to take reputation from your good ideas.

@J.Doe oh, I don't mind. Always good to have other R golfers getting more visibility; I think it's fair to say I'm a pretty known entity at this point! You've been going around suggesting quite impressive improvements, so take the rep (pun not intended) and keep up the good work golfing :-)

not (log(i,b)%/%1):0) instead of floor(log(n,b))+1?

@ASCII-only wow. Yeah, that'd work. I think even 0:log(i,b) would work, as : is really an alias for seq(a,b,by=1), so it will truncate the log(i,b). Sometimes, simpler is better :-(

Yeah, but for reverse looks like intdiv is shortest

For item 4, you can use seq(!l) in all cases, even if l might be of length 1 (put in use here). This is 1 byte shorter than seq(a=l).

Also always see if a colon sequence  can be rewritten shorter by changing indexing, ex. 1:(length(x)-4) rewriting as 5:length(x) using different indexing

@qwr this collection of tips has grown way too big to be of great help; you can post that as your own tip. If you are OK with it, I'd also allow you to move point 4. in the answer above into one standalone set of tips about the various uses of : and seq.

Abuse outer to apply an arbitrary function to all the combinations of two lists. Imagine a matrix with i, j indexed by the first args, then you can define an arbitrary function(i,j) for each pair.
Use Map as a shortcut for mapply. My claim is that mapply is cheaper than a for loop in situations where you need to access the index. Abuse the list structure in R. unlist is expensive. methods::el allows you to cheaply unlist the first element. Try to use functions with list support natively.
Use do.call to generalize function calls with arbitrary inputs.
The accumulate args for Reduce is extremely helpful for code golf.
Writing to console line by line with cat(blah, "\n") is cheaper with write(blah, 1). Hard coded strings with "\n" may be cheaper in some situations.
If a function comes with default arguments, you can use function(,,n-arg) to specify the n-th argument directly. Example:seq(1, 10, , 101) In some functions, partial argument matching is supported. Example: seq(1, 10, l = 101).
If you see a challenge involving string manipulation, just press the back button and read the next question. strsplit is single handily responsible for ruining R golf.

Now for some newly discovered tips from 2018

A[cbind(i,j)] = z can be a good way to manipulate matrices. This operation is very byte efficient assuming you design i, j, z as vectors with correct lengths. You may save even more by calling the actual index/assign function "[<-"(cbind(i,j), z). This way of calling returns the modified matrix.
Use a new line instead of \n for line breaks.
Squeezing down line counts can save you bytes. In-line assignment lapply(A<-1:10,function(y) blah) and function args assignment function(X, U = X^2, V = X^3) are ways of doing this.
So "[<-" is a function in R (and is related to my ancient question on SO)! That is the underlying function responsible for operations such as x[1:5] = rnorm(5). The neat property of calling the function by name allows you to return the modified vector. In order words "[<-"(x, 1:5, normr(5)) does almost the same thing as the code above except it returns the modified x. The related "length<-", "names<-", "anything<-" all return modified output

I think using "[<-" is worthy of its own "Tips" answer, as it will return the modified array/matrix/whatever.

Implicit type conversion
The functions as.character, as.numeric, and as.logical are too byte-heavy. Let's trim them down.
Conversion to logical from numeric (4 bytes)
Suppose x is a numeric vector. Using the logical not operator ! implicitly recasts the numeric to a logical vector, where 0 is FALSE and nonzero values are TRUE. ! then inverts that.
x=!x

x=0:3;x=!x returns TRUE FALSE FALSE FALSE.
Conversion to character from numeric or logical (7 bytes)
This is a fun one. (From this tweet.)
x[0]=''

R sees that you're updating the vector x with '', which is of class character. So it casts x into class character so it's compatible with the new data point. Next, it goes to put '' in the appropriate place... but the index 0 doesn't exist (this trick also works with Inf, NaN, NA, NULL, and so on). As a result, x is modified in class only.
x=1:3;x[0]='' returns "1" "2" "3", and x=c(TRUE,FALSE);x[0]='' returns "TRUE" "FALSE".
If you have a character object already defined in your workspace, you can use that instead of '' to save a byte. E.g., x[0]=y!
Conversion to character from numeric or logical under certain conditions (6 bytes)
J.Doe pointed out in the comments a six-byte solution:
c(x,"")

This works if x is atomic and if you intend to pass it to a function which requires an atomic vector. (The function may throw a warning about ignoring elements of the argument.)
Conversion to numeric from logical (4 bytes)
You can use the funky indexing trick from above (e.g. x[0]=3), but there's actually a quicker way:
x=+x

The positive operator implicitly recasts the vector as a numeric vector, so TRUE FALSE becomes 1 0.

Your last trick could be x=+x to keep TRUE as 1.

@Giuseppe Oh, duh, of course! Thanks, updated now.

Conversion from numeric or logical to character. You can use c(x,"") if x is atomic, provided that you're then going to use x in a function that only cares about the first element (it may complain). This is 1 byte cheaper than x[0]="";.

Change the meaning of operators
R operators are just functions that get special treatment by the parser. For example < is actually a function of two variables. These two lines of code do the same thing:
x < 3
`<`(x, 3)

You can reassign another function to an operator, and the parser will still do it's thing, including respecting operator precedence, but the final function call will be the new one rather than the original. For example:
`<`=rep

now means these two lines of code do the same thing:
rep("a", 3)
"a"<3

and precedence is respected, resulting in things like
"a"<3+2
#[1] "a" "a" "a" "a" "a"

See for example this answer, and also the operator precedence page. As a side effect, your code will become as cryptic as one written in a golf language.
Some operators like + and - can accept either one or two parameters, so you can even do things like:
`-`=sample
set.seed(1)
-5  # means sample(5)
#[1] 2 5 4 3 1
5-2 # means sample(5, 2)
#[1] 5 4

See for example this answer.
See also this answer for using [ as a two-byte, three-argument operator.

This is a comment on rturnbull's tips but I think we need to start enforcing a "one tip per answer" rule because it's so freakin' hard to find the one I need when I come here.

also depending on the precedence of the operators, you can do some funky stuff that might help; like < has lower precedence than +, but * has higher precedence than + so you could potentially chain them together!

@Giuseppe you know what I tried to find before posting and couldn't find it. Thanks for pointing it out. I'm planning to add more details on operator precedence with examples as I start using this trick more and more.

Here's a fun one: if you bind ? to paste or some other function that can take two arguments, the precedence order means you can still use inline assignments via a<-b?d<-e.

You should add [ as a three-element alias (that's two bytes); I often find it helpful for things like outer (and consistently forget about it!), although of course you need to ensure you don't actually need to use [. It would also likely be helpful to link to the operator precedence page to help with alias selection.

@Giuseppe good point! I wish I had more time to golf... golfing made me a better programmer by forcing me to fully understand the impact of any character I type... and I'm not even joking!

Scenarios where you can avoid paste(...,collapse="") and strsplit
These are a pain in the usual string challenges. There are some workarounds.

Reduce(paste0,letters) for -5 bytes from paste0(letters,collapse="")
A 2-byte golf where you have a list containing two vectors c(1,2,3) and c(4,5,6) and want to concatenate them element-wise to a string "142536". Operator abuse gives you p=paste0;"^"=Reduce;p^p^r which saves two bytes on the usual paste0 call.
Instead of paste0("(.{",n,"})") to construct (eg) a regex for 20 bytes, consider a regex in a regex: sub(0,"(.{0})",n) for 17 bytes.

Sometimes (quite often, actually) you'll need to iterate through a vector of characters or strings, or split a word into letters. There are two common use cases: one where you need to take a vector of characters as input to a function or program, and one where you know the vector in advance and need to store it in your code somewhere.
a. Where you need to take a string as input and split it into either words or characters.

If you need words (including characters as a special case):

If a newline 0x10 (ASCII 16) separating the words is OK, x=scan(,"") is preferred to wrapping your code in function(s,x=el(strsplit(s," "))).
If the words can be separated by any other whitespace, including multiple spaces, tabs, newlines etc, you can use @ngm's double scan trick: x=scan(,"",t=scan(,"")). This gives the scanned in string to scan as the text arg and separates it by whitespace.
The second argument in scan can be any string so if you have created one, you can recycle it to save a byte.

If you need to turn an input string into a vector of characters:

x=el(strsplit(s,"")) is the shortest general solution. The split argument works on anything of length zero including c(), {} etc so if you happen to have created a zero length variable, you could use it to save a byte.
If you can work with the ASCII character codes, consider utf8ToInt, since utf8ToInt(x) is shorter than the strsplit call. To paste them back together, intToutf8(utf8ToInt(x)) is shorter than Reduce(paste0,el(strsplit(x,""))).
If you need to split arbitrary strings of numbers like "31415926535" as input, you can use utf8ToInt(s)-48 to save 3 bytes on el(strsplit(s,"")), provided you can use the integer digits instead of the characters, as is often the case. This is also shorter than the usual recipe for splitting numbers into decimal digits.

b. Where you need a fixed vector of either words or characters in advance.

If you need a vector of single characters that have some regular pattern or are in alphabetic order, look at using intToUtf8 or chartr applied to a sequence via a:b or on the built in letters sets letters or LETTERS. The pattern language built into chartr is especially powerful.
For 1 to 3 characters or words, c("a","b","c") is the only general shortest solution.
If you need a fixed vector of between 4 and 10 non whitespace characters or words, use scan with stdin as the file arg:

f(x=scan(,""))
q
w
e
r
t
y
u

If scan from stdin isn't possible, for 6 or more non whitespace characters or words, use scan with the text argument scan(,"",t="a b c d e f").
If you need a vector of (a) 6 or more characters of any type or (b) 10 or more non-whitespace characters , strsplit via x=el(strsplit("qwertyuiop","")) is probably the way to go.
You may be able to get away with the following quote trick: quote(Q(W,E,R,T,Y)), which creates that expression. Some functions like strrep, and grep will coerce this to a vector of strings! If you do, this is good for any length of word or character vector from 3 to 11.
There's no good reason to use strsplit on words via x=el(strsplit("q w e r t y"," ")). It always loses to scan(,"",t="q w e r t y")) by a fixed overhead of 5 bytes.

Here's a table of the byte counts used by each approach to read in a vector of single characters of length n. The relative ordering within each row is valid for characters or words, except for strsplit on "" which only works on characters.
| n  | c(...) | scan | scan | strsplit | quote |
|    |        |+stdin|+text | on ""    | hack  |
|    |        |      |      | CHAR ONLY|       |
|----|--------|------|------|----------|-------|
| 1  | 3      | 11   | 15   | 20       | 8     |
| 2  | 10     | 13   | 17   | 21       | 11    |
| 3  | 14     | 15   | 19   | 22       | 13    |
| 4  | 18     | 17   | 21   | 23       | 15    |
| 5  | 22     | 19   | 23   | 24       | 17    |
| 6  | 26     | 21   | 25   | 25       | 19    |
| 7  | 30     | 23   | 27   | 26       | 21    |
| 8  | 34     | 25   | 29   | 27       | 23    |
| 9  | 38     | 27   | 31   | 28       | 25    |
| 10 | 42     | 29   | 33   | 29       | 27    |
| 11 | 46     | 31   | 35   | 30       | 29    |
| 12 | 50     | 33   | 37   | 31       | 31    |

c. If you need to input text as a character matrix, a few recipes that seem short are
s="hello\nworld\n foo"

# 43 bytes, returns "" padded data frame
# If lines > 5 are longer than lines <= 5, wraps around and causes error
read.csv(t=gsub("(?<=.)(?=.)",",",s,,T),,F)

# 54 bytes with readLines(), "" padded matrix
sapply(p<-readLines(),substring,p<-1:max(nchar(p)),p))

# plyr not available on TIO
# 58 bytes, returns NA padded matrix, all words split by whitespace
plyr::rbind.fill.matrix(Map(t,strsplit(scan(,"",t=s),"")))
# 61 bytes, returns NA padded matrix
plyr::rbind.fill.matrix(Map(t,(a=strsplit)(el(a(s,"\n")),"")))

scan has a text argument, which is more competitive than el(strsplit(x," ")) if you only need strings! Try it online! As opposed to your last suggestion of read.csv.

If you just want characters, your call of scan is better up to 5 characters, el(strsplit(x,"")) is more competitive than scan for 6 or more. Try it online! I haven't yet found a good use for read.csv, but maybe it would be useful if you needed a data table for some reason?

I've never found a use for a data.frame but maybe we need to find / create a challenge where it would be helpful! Maybe a dplyr style group_by() and summarize() type of manipulation? IDK.

And for reading in strings scan(,"") still seems better? Try it online!

Yeah for sure, although if you interpret an input format strictly as ngm does here then double scan is handy.

Some basic concepts but should be somewhat useful:

In control flow statements you can abuse that any number not equal to zero will be evaluated as TRUE, e.g.: if(x) is equivalent to if(x!=0). Conversely, if(!x) is equivalent to if(x==0).
When generating sequences using : (e.g. 1:5) one can abuse the fact that the exponentiation operator ^ is the only operator that has precedence over the :-operator (as opposed to +-*/).
1:2^2 => 1 2 3 4

which saves you two bytes on the parentheses that you would normally have to use in case you wanted to e.g. loop over the elements of an n x n matrix (1:n^2) or any other integer that can be expressed in a shorter manner using exponential notation (1:10^6).
A related trick can of course be used on the vectorized operations as well +-*/, although most commonly applicaple to +-:
for(i in 1:(n+1)) can instead be written as for(i in 0:n+1)

This works because +1is vectorized and adds 1 to each element of 0:n resulting in the vector 1 2 ... n+1. Similarly 0:(n+1) == -1:n+1 saves you one byte as well.
When writing short functions (that can be expressed on one line), one can abuse variable assignment to save two bytes on the enclosing curly brackets {...}:
f=function(n,l=length(n))for(i in 1:l)cat(i*l,"\n")
f=function(n){l=length(n);for(i in 1:l)cat(i*l,"\n")}

Note that this might not always comply to rules of certain challenges.

Alternatives to rep()
Sometimes rep() can be avoided with the colon operator : and R's vector recycling.

For repeating n zeroes, where n>0, 0*1:n is 3 bytes shorter than rep(0,n) and !1:n, an array of FALSE, is 4 bytes shorter, if the use case allows it.
To repeat x n times, x+!1:n is 2 bytes shorter than rep(x,n). For n ones, use !!1:n if you can use an array of TRUE.
To repeat x 2n+1 times, where n>=0, x+0*-n:n is 4 bytes shorter than rep(x,2*n+1).
The statement !-n:n will give a TRUE flanked on both sides by n FALSE. This can be used to generate even numbers of characters in calls to intToUtf8() if you remember that a zero is ignored.

Modular arithmetic can be useful. rep statements with the each argument can sometimes be avoided using integer division.

To generate the vector c(-1,-1,-1,0,0,0,1,1,1), -3:5%/%3 is 5 bytes shorter than rep(-1:1,e=3).
To generate the vector c(0,1,2,0,1,2,0,1,2), 0:8%%3 saves 4 bytes on rep(0:2,3).
Sometimes nonlinear transformations can shorten sequence arithmetic. To map i in 1:15 to c(1,1,3,1,1,3,1,1,3,1,1,3,1,1,3) inside a compound statement, the obvious golfy answer is 1+2*(!i%%3) for 11 bytes. However, 3/(i%%3+1) is 10 bytes, and will floor to the same sequence, so it can be used if you need the sequence for array indexing.

I don't know if you're still around, but you can use a%x%!!1:n in place of rep(a,e=n) for arbitrary numeric a.

When you do need to use a function, use pryr::f() instead of function().
Example:
function(x,y){x+y}

is equivalent to
pryr::f(x,y,x+y)

or, even better,
pryr::f(x+y)

Since  If there is only one argument, the formals are guessed from the code.

Unless you can get it down to one argument (like in the third example), this isn't a golf, for function(x,y){x+y} can be written as function(x,y)x+y for the same bytecount as pryr::f(x,y,x+y) but with more readability.

pryr::f(x+y) does work though

Note that this is obsolete now that R 4.1 has new shorthand function syntax \(arglist) expr.

Actually writing functions like pryr::f(x+y) isn't obsolete yet

Surviving challenges involving strings
As mentioned in another answer, unlist(strsplit(x,split="") and paste(...,collapse="") can be depressing. But don't just walk away from these, there are workarounds!

utf8ToInt converts a string to a vector, intToUtf8 does the reverse operation. You're getting a vector of int, not a vector of char but sometimes this is what you're looking for. For instance to generate a list of -, better useintToUtf8(rep(45,34)) than paste(rep("-",34),collapse="")
gsub is more useful than other function of the grep family when operating on a single string.
The two approaches above can be combined as in this answer which benefited from the advice of ovs, Giuseppe and ngm.
Choose a convenient I/O format as in this answer taking input as lines of text (without quotes) or this one taking a vector of chars. Check with the OP when in doubt.
As pointed out in the comments, < compares strings lexicographically as one would expect.

intToUtf8 also has a second argument multiple = FALSE which will convert from ints to individual characters (length-one strings) rather than a single string if set to TRUE.

Also, starting in 3.5.0, there's a third argument allow_surrogate_pairs = FALSE , but I don't know what it does; the docs say something about reading two-bytes as a UTF-16 but I barely know what UTF-8 is so I'll just ignore it until someone else finds a way to golf with it.

R 4.1.0: new shorthand function syntax
I just found out the very new release R 4.1.0 comes with some new syntax. https://www.r-bloggers.com/2021/05/new-features-in-r-4-1-0/
The new shorthand syntax \(arglist) expr performs exactly as function(arglist) expr and makes writing R functions 7 bytes shorter:
\(x,y)x+y

instead of
function(x,y)x+y

There's also the new native pipe |>, but this isn't shorter than just using parentheses (and the pipe has to be used with parentheses, unlike magrittr.)

Some ways to find the first non-zero element of an array.
If it has a name x:
x[!!x][1]

Returns NA if no non-zero elements (including when x is empty, but not NULL which errors.)
Anonymously:
Find(c, c(0,0,0,1:3))

Returns NULL if no non-zero elements, or empty or NULL.

This will return NA if all elements of x are zero, I believe, so use it with caution!

Find(c,x) is the same bytecount with: the advantage you don't need to repeat(define) x, and a different behavior if no match.TIO

Find is also a little safer as it works on NULL, as long as nothing else needs to happen to the result, in which case I'm not sure if returning NA or NULL is safer.

oh that's right. the issue with returning NULL is errors... in the version comparison question I first tried sign(Find(c,w)) which caused errors - had to do Find(c,sign(w)) to get it not to error. I think both ways have their uses.

Tips for restricted source challenges :

Characters in R literals constants can be replaced by hex codes, octal codes and unicodes.
e.g. the string "abcd" can be written :
    # in octal codes
    "\141\142\143\144"

    # in hex codes
    "\x61\x62\x63\x64"

    # in unicodes
     "\u61\u62\u63\u64"
    # or
    "\U61\U62\U63\U64"

We can also mix characters with octal/hex/unicode and use some oct codes and some hex codes together, as long as unicode characters are not mixed with octal/hex e.g. :
    # Valid
    "a\142\x63\x64"

    # Valid
    "ab\u63\U64"

    # Error: mixing Unicode and octal/hex escapes in a string is not allowed
    "\141\142\x63\u64"

See the end of this section for further details.
Since functions can be written using string literals, e.g. cat() can be written alternatively :
'cat'()
"cat"()
`cat`()

we can use octal codes, hex codes and unicode for function names as well :
# all equal to cat()
"\143\141\164"()
`\x63\x61\x74`()
'\u63\u61\u74'()
"ca\u74"()

with the only exception that unicode sequences are not supported inside backticks ``
Round brackets can be avoided abusing operators e.g. :
cat('hello')

# can be written as
`+`=cat;+'hello'

An application of all the three tricks can be found in this answer

Also, numbers can be written in hexadecimal: 0xB and 0xb return 11 (no need for backticks or quotes).

there's also the infamous as.roman

Searching datasets
R's builtin datasets can be a trove, in particular for restricted-source challenges, but searching through them is not easy.
For instance, for this answer, creating the value 100 thanks to a dataset was useful. It could be that the value was there as is, or as the sum of a column, or as the size of the dataset.
Here is the code I used; credit goes to Giuseppe in the chat:
x = data(package = "datasets")
res = x$results
for(dataset_name in paste0(res[,1],"::",res[,3])){
  curr = try(eval(parse(t=dataset_name)), T)
  if(length(curr) == 100) print(c("Length found in", dataset_name))
  if(100 %in% unlist(curr)) print(c("Value found in", dataset_name))
  try(if(try(sum(curr),T) == 100) print("Sum found in", dataset_name), T)
}

This searches all the datasets which are included by default; you can search datasets in other packages by changing the first line to x <- data(package = .packages(all.available = TRUE)).
You will need to make lavish use of try to avoid issues with different types of data. Remember that some datasets are vectors and not matrices or data frames. Other functions to try instead of sum include min, max, mean, prod, sd and var.

all and any on lists
Apparently, all and any both accept lists of depth 1 and work just as well as on vectors (with a warning).
So, if you used all(sapply(list,function)) in your code, in most places you may replace it with all(Map(function,list)) for -3 bytes.
I didn't know that before the answer (linked above) by @Dominic van Essen.

Know your apply functions

As already mentioned, use Map instead of mapply (and possibly lapply, depending on whether you want vectorisation also on further arguments to the function).
Use sapply when you want the result simplified when possible.
Use apply on matrices to apply a function rowwise or columnwise. But remember of functions like colSums and colMeans.
Use tapply(x,y,f) instead of sapply(split(x,y),f) or Map(f,split(x,y)) - but you may want to use simplify=FALSE in the second case sometimes.

Remember that sometimes the function you're using can apply another function to the results (through the FUN argument), e.g. combn.

Numeric Tricks
Ignoring precision error:

x%/%1 instead of floor(x) (integer part for positive x)
x%%1 instead of x-floor(x) (fractional part for positive x)
!x%%1, x%%1 to check if integer or not
x^.5 instead of sqrt(x)
gamma(x+1) instead of factorial(x)

Constants: \$\pi\$ pi, \$e\$ exp(1), \$1/e\$ exp(-1)
(if you need these for some reason)  \$1 / \sqrt{2\pi}\$ dnorm(0), \$\gamma\$ -digamma(1)

I would note that x%/%1 is not integer part for negative x.

@Giuseppe noted


text:
Adding without using a + or - sign
There have been many "Do __ without __" challenges before, but I hope that this is one of the most challenging.
The Challenge
You are to write a program that takes two natural numbers (whole numbers > 0) from STDIN, and prints the sum of the two numbers to STDOUT. The challenge is that you must use as few + and - signs as possible. You are not allowed to use any sum-like or negation functions.
Examples
input
123
468

output
591

input
702
720

output
1422

Tie Breaker:
If two programs have the same number of + and - characters, the winner is the person with fewer / * ( ) = . , and 0-9 characters.
Not Allowed: Languages in which the standard addition/subtraction and increment/decrement operators are symbols other than + or - are not allowed. This means that Whitespace the language is not allowed.

Perhaps this challenge was a lot easier than I thought it would be, especially in other languages, where there are sum() functions. I have to fix this.

Just to clarify, this challenge does not care about code length right? Only the number of +,- and tie breaker characters? ...or do you need to change the rules again :-)

@Tommy No, it does not.

Concatenating strings works?

Are languages allowed that don't have arithmetic operators at all?  I think that last sentence permits them, but it's not completely clear.

Next challenge would be "Comparing two numbers without any of ><+-*/%&|"

Perl (no +/-, no tie-breakers, 29 chars)
s!!xx!;s!x!$"x<>!eg;say y!!!c

As a bonus, you can make the code sum more than two numbers by adding more xs to the s!!xx!.
Alternatively, here are two 21-char solutions with 1 and 3 tie-breakers respectively
say length$"x<>.$"x<>

say log exp(<>)*exp<>

Note: These solutions use the say function, available since Perl 5.10.0 with the -E command line switch or with use 5.010.  See the edit history of this answer for versions that work on older perls.

How does the solution with no tie-breakers work?

s!!xx! is a regexp replacement operator, operating by default on the $_ variable, which replaces the empty string with the string xx.  (Usually / is used as the regexp delimiter in Perl, but really almost any character can be used.  I chose ! since it's not a tie-breaker.)  This is just a fancy way of prepending "xx" to $_ — or, since $_ starts out empty (undefined, actually), it's really a way to write $_ = "xx" without using the equals sign (and with one character less, too).
s!x!$"x<>!eg is another regexp replacement, this time replacing each x in $_ with the value of the expression $" x <>.  (The g switch specifies global replacement, e specifies that the replacement is to be evaluated as Perl code instead of being used as a literal string.)  $" is a special variable whose default value happens to be a single space; using it instead of " " saves one char.  (Any other variable known to have a one-character value, such as $& or $/, would work equally well here, except that using $/ would cost me a tie-breaker.)  The <> line input operator, in scalar context, reads one line from standard input and returns it.  The x before it is the Perl string repetition operator, and is really the core of this solution: it returns its left operand (a single space character) repeated the number of times given by its right operand (the line we just read as input).
y!!!c is just an obscure way to (ab)use the transliteration operator to count the characters in a string ($_ by default, again).  I could've just written say length, but the obfuscated version is one character shorter. :)

+1 - awsome and totally unreadable ;-) This seems to be the perfect answer since the character count doesn't matter in this challenge.

@Tommy, there are other perfect answers too. Maybe we should push for character count to be the final tie-breaker.

@Peter: I sort of assumed it already was, by default.

if character count is the final tie breaker, and many entries exist tied for zero in the other categories, doesn't this just become code-golf with some source restrictions?

R (24 characters)
length(sequence(scan()))

What this does:

scan reads input from STDIN (or a file)
sequence generates integer sequences starting from 1 and concatenates the sequences.  For example, sequence(c(2, 3)) results in the vector 1 2 1 2 3
length calculates the number of elements in the concatenated vector

Example 1:
> length(sequence(scan()))
1: 123
2: 468
3:
Read 2 items
[1] 591

Example 2:
> length(sequence(scan()))
1: 702
2: 720
3:
Read 2 items
[1] 1422

Very clever, good job.

This blows my mind

+/- and above mentioned tie-breakers are interesting, not characters.

How does it calculate length? without using any addition? If so, I'd be surprised.

@TemPora The question only restricts the code in the answer, not the operations done behind the scenes. We're not going to restrict the question so the underlying computer architecture cannot increment a register.

D
main(){
    int a,b;
    readf("%d %d",&a,&b);
    while(b){a^=b;b=((a^b)&b)<<1;}
    write(a);
}

bit twiddling for the win
as a bonus the compiled code doesn't contain a add operation (can't speak for the readf call though)

Python 2, 43 bytes
print len('%s%s'%(input()*'?',input()*'!'))

Very inventive, but you might want to change the character used in the string to something other than a tie-breaker such as "~"

Thanks for the advice Alex, I had already forgotten about the tie-breaker rule.

print sum(input(),input())

razpeitia: I think sum is a "sum-like" function and thus not allowed.

Seed, 3904 3846 11 bytes, 0 +/-, 10 tie breakers
4 141745954

Next up: the self-hosted version of seed LOL!!

C (32bit only)
int main(int ac, char *av) {
    scanf("%d\n%d", &ac, &av);
    return printf("%d\n", &av[ac]);
}

Pointer arithmetic is just as good.
How does it match the requirements?
* No + or -
* No /, =, ., 0-9
* Only 3 pairs of parenthesis, which seems to me minimal (you need main, scanf, printf).
* One * (the pointer approach requires it).
* Four , (could save one by defining normal variables, not ac,av)

C++ 0 +/-, 3 tie-breakers
#include <vector>
#include <iostream>

#define WAX (
#define WANE )
#define SPOT .

int main WAX WANE {
    unsigned x;
    unsigned y;
    std::cin >> x >> y;
    std::vector<int> v WAX x WANE;
    std::vector<int> u WAX y WANE;
    for WAX auto n : u WANE {
        v SPOT push_back WAX n WANE;
    }
    std::cout << v SPOT size WAX WANE;
}

GolfScript
No +/- or tie-breakers:
# Twiddle some bits to get a few small integers
[]!~abs:two~abs:three!:zero~:minusone;

~[two base minusone%\two base minusone%]zip
zero:c;
{
    # Stack holds [x y] or [x] with implicit y is zero
    # Half adder using x y c: want to end up with sum on stack and carry back in c
    [~c zero]three<zero$
    ~^^\
    $~;:c;;
}%
[~c]minusone%two base

Much simpler version with two tie-breaker characters, using the same list-concatenation trick that other people are using:
~[\]{,~}%,

I'm assuming that GolfScript isn't disqualified for having ) as an increment operator, as I'm not actually using it.

Haskell, 0+2
import Monad
main = join $ fmap print $ fmap length $ fmap f $ fmap lines getContents
f x = join $ flip replicate [] `fmap` fmap read x

This uses no + or - characters, and only two = from the set of tie breaker characters, one of which is mandatory for binding main. The sum is done by concatenating lists of the appropriate lengths.

I didn't see anyone do it the Electrical Engineering way, so here's my take (in ruby):
def please_sum(a, b)
    return (a&b !=0)? please_sum( ((a&b)<<1) , a^b ):a^b
end

It is a little bit ugly, but it gets the job done.  The two values are compared by a bitwise AND.  If they don't have any bits in common, there is no "carry" into the next binary column, so the addition can be completed by bitwise XORing them.  If there is a carry, you have to add the carry to the bitwise XOR.  Here's a little ruby script I used to make sure my digital logic was not too rusty:
100.times do
    a=rand 10
    b=rand 10
    c=please_sum(a,b)
    puts "#{a}+#{b}=#{c}"
    end

Cheers!

EDIT This was posted BEFORE the rules changed to disallow sum...
The R language: No calls to + or -... And 9 tie-breaker characters!
sum(as.numeric(readLines(n=2)))

Example:
> sum(as.numeric(readLines(n=2)))
123
456
[1] 579

The [1] 579 is the answer 579 (the [1] is to keep track of where in the result vector your are since in R all values are vectors - in this case of length 1)
Note that R has + operators just like most languages - it just so happens that it has sum too that sums up a bunch of vectors.
In this case, readLines returns a string vector of length 2. I then coerce it to numeric (doubles) and sum it up...
Just to show some other features of R:
> 11:20 # Generate a sequence
 [1] 11 12 13 14 15 16 17 18 19 20

> sum(1:10, 101:110, pi)
[1] 1113.142

+1 For making me have to change the rules to outlaw the sum() function.

@PhiNotPi - Changing the rules?! That's cheating! :-) ...But you should probably say "sum-like functions" or I'll just use colSums instead... Maybe also outlaw "negation-like functions" while your at it...

I'm going to take your advice. From what I can tell, everyone (including me) on this site loves to point out loopholes in the rules.

The R language
New rules, new answer, same language. No calls to + or -
UPDATE Using scan, it drops to 11 tie-breaker characters (and 27 characters in all).
as.numeric(scan())%*%c(1,1)

Original: 13 tie-breaker characters!
as.numeric(readLines(n=2)) %*% c(1,1)

Example:
> as.numeric(readLines(n=2)) %*% c(1,1)
123
456
     [,1]
[1,]  579

This time the result is achieved by matrix multiplication. The answer is displayed as a 1x1 matrix.

There's nothing that I can do to outlaw this. Perhaps R is just good at this challenge, since it is mostly mathematics-based. Or maybe this challenge is just easy.

+1 Nice.  You can make this even shorter with scan() instead of readlines(n=2)

@Andrie - yes, but then you rely on the user entering exactly two numbers... Which is OK for this challenge I guess...

Haskell, 0 +/-, 6 2 tie-breakers (=)
(does not use the string/list concatenation trick)
main = interact f
f x = show $ log $ product $ map exp $ map read $ lines x

You can eliminate all the dots at the expense of an extra = by replacing the composition: instead of "f.g.h" write "a where a x = f$g$h x"

05AB1E, 2 4 bytes, 0 +/-
F>

Try it online!
Apologies if I misunderstood this challenge, but I was
surprised there was no 05AB1E answer. Shortest answer in
this language I could come up with that doesn't use + or
the built in sum function.
Explanation:
 F   #Loop A many times
  >  #Increment B
     #(Implicit output)

-2 Bytes thanks to Grimy.

Python 3, 64 62 bytes
Without relying on hidden summations in other functions.
x=int(input());y=int(input())
while y:x,y=x^y,(x&y)*2
print(x)

Try it online!

by replacing the first line by x=int(input());y=int(input()) you save 2 tie breakers (and without loosing any byte). You should also redo your TIO link, to make it mach your post

Excel, (25, 8) (22, 6) 13, 4 tie-breakers
Inputs are A1, A2.
=2*MEDIAN(A:A
^^^      ^

Because MEDIAN is shorter than AVERAGE and AGGREGATE.

C
b[500];i;j;main(){scanf("%d%d",&i,&j);printf("%d\n",sprintf(b,"%*s%*s",i,"",j,""));

APL (no +/-, no tie breakers, 8 or 10 characters)
This entry is similar to the other ones that concatenate sequences generated from the input and find the length... but it's in APL, which can appear confusing even for a small problem like this. I used Dyalog APL, which offers a free educational license.
Code:
⍴⊃⍪⌿⍳¨⎕⎕

From right to left:

Each quote-quad ( ⎕ ) requests input from the user and evaluates it.
The each operator ( ¨ ) applies the index generator function (  ⍳ ) to each of the items in the array to its right.
This flattens the resulting array of arrays into one array. The input array is reduced to a flat list by the reduction operator ( / ), which folds the array using the concatenation function ( , ). For the sake of this challenge, the one-dimensional reduction operator ( ⌿ ) is used, along with the concatenation operator along the first axis ( ⍪ ).
As a result of using the reduction operator, the array is enclosed, which is like placing it in the bag; all we see on the outside is a bag, not its contents. The disclose operator ( ⊃ ) gives us the contents of the enclosed array (the bag).
Finally, the shape-of function ( ⍴ ) gives us the lengths of the dimensions of an array. In this case, we have a one-dimensional array, so we obtain the number of items in the array, which is our result.

If we need to explicitly output the result, we can do so like this:
⎕←⍴⊃⍪⌿⍳¨⎕⎕

Comparable Python code, with corresponding APL symbols above:
import operator

⎕←     ⍴    ⌿        ⍪                 ¨              ⍳                ⎕        ⎕         ⊃
print (len (reduce (operator.__add__, [map (lambda n: range (1, n+1), [input(), input()])][0])))

I'd like to know if there's a shorter version possible in APL - another, simpler version I came up with that has more tie breakers (although still at 8 characters) is: ⍴(⍳⎕),⍳⎕.

Does your index generator start at 1 or 0?

Javascript (17 tie-breaker characters)
eval('걢갽거걲걯걭거건갨걡갽거걲걯걭거건갨걹갽걦걵걮걣건걩걯걮갨걡갩걻걣갽걮걥걷갠걕걩걮건갸걁걲걲걡걹갨걡갩갻걦걯걲갨걩갠걩걮갠걣갩걩걦갨걩갽갽걾걾걩갩걸갮거걵걳걨갨갱갩걽갬걸갽걛걝갩갩갻걹갨걡갩갻걹갨걢갩갻걡걬걥걲건갨걸갮걬걥걮걧건걨갩갻'['split']('')['map'](function(_){return String['fromCharCode'](_['charCodeAt'](~~[])^0xac00)})['join'](''))

:P ("Obfuscated" to reduce number of tie-breaker characters. Internally, it's
b=prompt(a=prompt(y=function(a){c=new Uint8Array(a);for(i in c)if(i==~~i)x.push(1)},x=[]));y(a);y(b);alert(x.length);
.)

Clever use of obfuscation! Love it!

Javascript, 56
p=prompt;alert(Array(~~p()).concat(Array(~~p())).length)

Thanks to @JiminP on the ~~ tip! I'm going for least bytes, so the 1 byte saving on the p=prompt; is still worth it. I understand your argument about tie-breaker chars, but to be honest wouldn't you rather the least bytes :-p
Version, 69
i=parseInt;p=prompt;alert(Array(i(p())).concat(Array(i(p()))).length)

Thanks to some feedback from @Ilmari and @JiminP, I've shaved 13 bytes off my original solution.
Originally, 82
i=parseInt;p=prompt;a=Array(i(p()));a.push.apply(a, Array(i(p())));alert(a.length)

That space after the comma is completely unnecessary; removing it gets you down to 81.

Using concat and put calculations in alert is shorter. i=parseInt;p=prompt;alert(Array(i(p())).concat(Array(i(p()))).length)   BTW, I didn't know that Array(n) returns an array with length n. The Google Chrome console gave me [] and I thought there was nothing...

Oh, since the important thing is tie-breaker characters, p=prompt is not good. And, parseInt(x) is almost equivalent to ~~x. alert(Array(~~prompt())['concat'](Array(~~prompt()))['length']) (12 tie-breaker chars)  PS. I could use this as my entry, but that just gives me feeling of stealing.

ES6 version: _=>Array(~~prompt``)["concat"](Array(~~prompt``))["length"] with 7 TB

Befunge-93, 0 +- characters, 0 tiebreakers, 33 bytes
"e:"%"X:"%::%p"h:"%"Y:"%::%p&&  @

Try it online!
Explanation
Like @negative seven's Befunge answer, we generate + and . at runtime and put them onto the field to be executed. However, Befunge-93 does not include the y instruction, so we abuse the % modulo operator instead.
"e:"%                                            # Calculate 101 ('e') mod 58 (':') to get 43 ('+')
     "X:"%                                       # Calculate 88 ('X') mod 58 to get 30
          ::%                                    # Calculate 30 mod 30 to get 0
             p                                   # Put character 43 ('+') at position (30, 0)
              "h:"%                              # Calculate 104 ('h') mod 58 to get 46 ('.')
                   "Y:"%                         # Calculate 89 ('Y') mod 58 to get 31
                        ::%                      # Calculate 31 mod 31 to get 0
                           p                     # Put character 46 ('.') at position (31, 0)
                            &&                   # Get two numbers from STDIN
                              (changed to '+')   # Add the numbers together
                               (changed to '.')  # Output the result
                                @                # End the program

Scala 2.12, 20 bytes, 0 +/- signs
readInt\u002breadInt

The unicode literal is just turned into a + before compilation

This is in no way cheating. In fact, this answer emphasizes the very reason why "do X without Y" is now discouraged.

Vyxal as, 0 bytes

Try it Online!
The a flag takes newline separated inputs as a list, and the s flag sums the top of the stack.
Non-trivial a, 4 2 bytes
-2 bytes because I realized the challenge guarantees 2 number input.
ṁd

Try it Online!
Explanation:
    # 'a' flag - take newline separated inputs as a list
ṁ   # Mean of inputs
 d  # Multiply by 2
    # Implicit output

Effectively calculates ((a + b) / 2) * 2, which is equivalent to a + b. The previous version worked for any amount of numbers, but it turns out the challenge specifies taking 2 numbers as input, so this works fine.

C#,
Program works on 1 line; separated on multiple lines to avoid horizontal scrolling.
using C=System.Console;
class A{
static void Main(){
int a,b,x,y;
a=int.Parse(C.ReadLine());
b=int.Parse(C.ReadLine());
do{x=a&b;y=a^b;a=x<<1;b=y;}while(x>0);
C.WriteLine(y);
}}

Shell, 52
read a
read b
(seq 1 $a;seq 1 $b)|wc|awk '{print$1}'

This is basically the same answer I gave for another problem.

Similar:  xargs -n1 jot | wc -l which takes the same - reduction awk but I can't see how to avoid it in the xargs

+/- and above mentioned tie-breakers are interesting, not characters.

C
a,b;A(int a,int b){return a&b?A(a^b,(a&b)<<1):a^b;}
main(){scanf("%d%d",&a,&b);printf("%d\n",A(a,b));}

I count 20 tie breakers... Am I right?

22 tie breakers: 0 /*=., 7 (, 7 ), 7 ,, 1 [0-9]

C#
It's not the shortest by any stretch:
private static int getIntFromBitArray(BitArray bitArray)
{
    int[] array = new int[1];
    bitArray.CopyTo(array, 0);
    return array[0];
}

private static BitArray getBitArrayFromInt32(Int32 a)
{
    byte[] bytes = BitConverter.GetBytes(a);
    return new BitArray(bytes);
}

static void Main(string[] args)
{
    BitArray first = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray second = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray result = new BitArray(32);

    bool carry = false;
    for (int i = 0; i < result.Length; i++)
    {
        if (first[i] && second[i] && carry)
        {
            result[i] = true;
        }
        else if (first[i] && second[i])
        {
            result[i] = false;
            carry = true;
        }
        else if (carry && (first[i] || second[i]))
        {
            result[i] = false;
            carry = true;
        }
        else
        {
            result[i] = carry || first[i] || second[i];
            carry = false;
        }
    }
    Console.WriteLine(getIntFromBitArray(result));
}

That's exhausting, Matthew.

Is this a literal full adder circuit implemented in a program?

J, 15 7 chars, 1 tie breaker, incomplete program
This is my J attempt. It is not a full program, because I have not yet figured out how to write one. Just put that line in a script to get the function p that can be used for adding an arbitrary amount of numbers. It is a monad and takes a list of numbers to add (such as p 1 2 3 4):
p=:#@#~

The idea is very simple. The function is written in tacit aka pointless style. Here is a pointed definition:
p=:3 :'##~y'

Read from right to left. In the tacit version, @ composes the parts of the function. (like a ∘ in mathematics [(f∘g)(x) = f(g(x)])

y is the parameter of p.
~ makes a verb reflexive. For some verb m, m~ a is equal to a m a.
# (copy, a#b): Each element in a is replicated i times, where i is the element at the same index as the current element of a of b. Thus, #~ replicates an item n n times.
# (count, #b): Counts the number of elements in b.

Conclusion: J is awsome and less readable than Perl (that makes it even more awsome)
Edits

15 -> 7 using # instead of i.. Yeah! Less chars than golfscript.

More of a program
This one queries for input, but it still isn't a full program: (13 chars, 3 breakers)
##~".1!:1<#a:

J is definitely awesome, but believe me, you can't just leave out the parsing part of the problem when you solve challenges with it ;-)

@J B Well, you can use the builtin function toJ, but I keep getting domain errors.

Python 3
import numpy as n;i=lambda:n.e**int(input());print(int(n.log(i()*i())))

Try it online!

I was trying to remove the log and e but forgot about the original restrictions... :( Reverted now.

Okay it's working now. You should probably include the link in your answer: Try it online!

Welcome! Please consider adding an explanation or a link to an online interpreter. Code-only answers tend to be automatically flagged as low-quality.

Zsh, 26 25 bytes, 7 5 tiebreakers
-1 byte, -2 tiebreakers thanks to @Nahuel Fouilleul.
set {1..$1} {1..$2}
<<<$#

Try it online!

Zsh, 62 60 bytes, 0 tiebreakers
-2 bytes because repeat foo evaluates foo in arithmetic mode.
read a b
{repeat a;printf x;repeat b;printf x}|read x
<<<$#x

Try it online!

25 bytes, 5 tiebreakers

C++, () only for main
#include <iostream>

int main()
{
    unsigned int a, b;
    std::cin >> a;
    std::cin >> b;

    unsigned int p = a ^ b;
    unsigned int g = a & b;

    unsigned int gg {g | p & g << 1};
    unsigned int pp {p & p << 1};

    unsigned int ggg {gg | pp & gg << 2};
    unsigned int ppp {pp | pp << 2};

    unsigned int gggg {ggg | ppp & ggg << 4};
    unsigned int pppp {ppp & ppp << 4};

    unsigned int ggggg {gggg | pppp & gggg << 8};
    unsigned int ppppp {pppp | pppp << 8};

    unsigned int gggggg {ggggg | ppppp & ggggg << 16};

    unsigned int result {a ^ b ^ gggggg << 1};
    std::cout << result;
}

Assumes 32-bit unsigned ints. Very ugly code to remove tiebreak characters. Emulates a Kogge-Stone adder.

Octave/MATLAB, 37 bytes
f=@()e^(input(''));disp(log(f()*f()))

Try it online!

Welcome to the site! I'd recommend you split these up into two answers so that users can vote and improve them separately.

31 by using the implicit output

Also, your answer does not actually work in Matlab since it does not have e defined. I believe the shortest answer in Matlab (at least with this approach) is, therefore, 32.

Gol><>, 8 bytes
IRmIRmlh

Minus one byte!, I figured out that I didn't need to take both inputs first
Try it online!
Previous answer, 9 bytes
IIRfrRflh

Explanation below
II        take both inputs
  Rm      Pop and repeat that number of times, pushing -1
    r     Reverse stack (to get the first num on top)
     Rm   Pop and repeat that number of times, pushing -1
       lh Push length of stack, and output as a number halting

Basically what I did was count it all out in unary, it would only take a few more bytes to expand it to be able to handle more than two numbers
Try it online!

JavaScript (ES6), 48 bytes, 12 tie-breakers
a=>b=>"0".repeat(a).concat("0".repeat(b)).length

JavaScript, 26 bytes
Tiebreakers: 11?
a=>b=>Math.log2(2**a*2**b)

Takes input as (a)(b).
Uses the power index rule \$a^{x+y}=a^{x}a^{y}\$ and returns the \$log_2(2^{a}2^{b})\$ which is basically \$log_2(2^{a+b}) = a+b\$.

Pip, 0 +/-, 0 tiebreakers (5 bytes)
#JoXg

Try it online!
Explanation
A string-concatenation approach:
    g  List containing the command-line args
  oX   For each arg, make a string of that many 1s (o is a variable preinitialized to 1)
 J     Join the list into a single string
#      Get its length

Python 2, 0 +/-, 2 tie-breaker (144 bytes)
exec`["%c"%[ord(i)^True<<True<<True<<True][False]for i in"""xzaf| :""afx}| !":""afx}| !'':!&ja|Wdmfo|` !"""]`[True<<True::True<<True<<True|True]

Try it online!
How it works :
The general idea is to remove tie-breaker character of a non cheaty working solution. To do that I converted a solution by changing the 5th bit of each character.
Some tricks are used to avoid using tiebreaker character during the translation :

True and False are evaluated by python as 1 and 0. Using that I can easyly create some usefull integers like 2, 5 and 8 in my solution without using [0-9]
Parenthesis are bad (for this challenge at least). To replace them I used [expression][False] which return the first element of an 1-element array, using the []-priority over other operators.
To join an array of char, the common technique is to use "".join(my_array) but it uses 3 tie-breakers. I instead uses `my_array`[2::5] which take the representation of the array and select only the wanted character by concatenating them.
To get the ascii character from its interger representation, intead of using the built-in chr(i) (which uses 2 tie-breaker), I used "%c"%i wich does the same

In better understandable python, here is my solution :
exec`["%c"%(ord(i)^8)for i in""" CODED_SOLUTION """]`[2::5]

with CODED_SOLUTION once decoded :
print(2*input()*2**input()//2).bit_length()

which looks like my older solution (and which doesn't use any form of addition :p)
Older Solution (7 tiebreaker, 50 bytes)
print int.bit_length(True<<input()<<input()>>True)

Try it online!
The idea is to shift a True interpreted as 1 by python Xtimes and Ytimes then shift once the other way and take the len of the binary representation
Cheated solution (45 bytes, 6 Tie-breaker)
I also have a cheated solution in 45 bytes:
print eval("\x2binput()"*[True<<True][False])

Try it online!
which evaluates the string +input()+input() but convert the char + by its hexadecimal representation.
the [True<<True][False] is equal to 2
Other Ideas:
I had the idea to use a=abs(~a) to increment a by 1 but I didn't totaly managed to produce a working solution with that.

Python 3, 0 +/-, 2 Tie-breaker, (68 bytes)
lambda x,y:A[f"{True<<x<<y:b}"[True:]]
class A:__class_getitem__=len

Try it online!
class A:__class_getitem__=len allows me to replace len(x) by A[x]
Old, 3 Tie-breaker, (40 bytes)
lambda x,y:len(f"{True<<x<<y:b}"[True:])

Try it online!
Explanation :

Truein python is evaluated as 1 => 1
shift x times then y times => 4 => 32 (for x=2 and y=3)
convert it to its string binary representation => "100000"
remove the first char of the string => "00000"
get the length => 5

Clojure (44 chars)
(pr(#(count(concat(%)(%)))#(repeat(read)0)))

Edit: fixed to print on STDOUT instead of just returning sum.

+/- and above mentioned tie-breakers are interesting, not characters.

D
main(){
    int a,b;
    readf("%d %d",&a,&b);
    write((new int[a]~new int[b]).length);
}

this time using array lengths

Scala

score:

+-  : 0
(). : 5+5+3=13

Code:
(List.fill (readInt) (1) ::: List.fill (readInt) (2)).size

List.fill (4)(7) produces List (7, 7, 7, 7)
a ::: b concatenates 2 Lists into one
The rest should be obvious

K, 11
{#,[!x;!y]}

Same concatenation trick as the R solution. Reading right to left: Enumerate the two input variables, concatenate and then count.

Ruby, 0 +/-, 0 tie-breakers, 39 bytes
And fairly unreadable.
p"#{"%#{"%ss%%%ss"%$F}"%%w[o o]}"::size

Try it online!

Keg (SBCS on Keg wiki)
Basically a port of the R answer.
¿¿Ï_"Ï_!.

Explanation
¿¿#        Take 2 integer inputs
  Ï_"Ï_#   Generate 2 arrays the length of the integer inputs
       !.# Output the length of the stack

PowerShell, 27 42 bytes, 0 +-, 4 1 secondary
Thanks to mazzy for saving a + and 4 secondaries
$args|%{[int[]]$_*$_}|measure|select count

Try it online! or Pretty Table for an extra 3 bytes
-Or- adding four secondaries to save 19 bytes:
32 23 bytes, 1 0 +-, 12 5 secondaries
-9 bytes thanks to mazzy
($args|%{,$_*$_}).count

Try it online!
For each argument, we push n array elements (consisting of [n] but that's not important) to the pipeline which are grouped by the parens and then counted.

23 bytes, 0 +-, 5 secondaries

I'm sorry, this is NOT codegolf. 0 +-, 3 secondries, 27 bytes

@mazzy That's 4 by my count but thanks nonetheless :D

you are right. thanks. 0+-, 1 Tie Breaker, 42 bytes. you could add |fl for a pretty format Try it online!

Ruby -na0, no +/-, no tiebreakers, 60 bytes
$F<<?a until~%r[
]&&$F::join[%r[a{#$`}a{#$'}]]
p$F::count ?a

Try it online!
Actually harder than I thought, I'm almost certainly missing a trick.
Reads in the input, then adds a characters to the argument array until the array, when joined into a string, matches a regular expression that uses the two input numbers as quantifiers, then counts how many it added.
Syntax tricks include using %r[] instead of // for a regexp, and :: instead . for a method call.

MathGolf, 3 bytes, 0 +-, 1 tiebreaker
~{)

Input as a list. If taking the two inputs separated is mandatory, a trailing ê should be added (read entire STDIN input as integer-array).
Try it online.
Explanation:
~    # Push the value of the (implicit) input-list to the stack
 {   # Loop the top value amount of times
  )  #  And increase the other value once every iteration
     # (after which the entire stack joined together is output implicitly as result)

Lua, 46 bytes
print(load'return io.read"n"\x2Bio.read"n"'())

Try it online!
How It Works
load loads a string and returns a function, we pass a hexadecimal to it and call the function.

brainfuck, 11 bytes, 2 +-, 3 tie breaker
,>,[-<+>]<.

Sadly i can’t think up anyway of manipulating number without +-
Try it online!

If + and - are used, it is simply invalid.

@Razetime It's mentioned in question that use as few +- a possible

ah, it isn't too clear or exact about what's banned. I suppose it's ok

@Razetime This answer is bad anyway, I just can't think up anyway to use 1 +- only.

Desmos, 22 bytes, 0 +/-, 2 tiebreakers
lne^{\ans_0}e^{\ans_1}

Input numbers in the first two lines. I have to admit, I spent an embarrassing amount of time trying to go from the obvious 4 tiebreakers solution [\ans_0,\ans_1].total to a 2 tiebreakers solution. I considered many other interesting ideas to go from 3 to 2 (integrals, percent of, {} evaluates to 1, etc.), but at the end, it turned out to be very simple...
I'm pretty sure 2 tiebreakers is optimal for Desmos because a 0 and 1 are required to obtain input. Defining a function is even worse: You need (, ) and =, which is 3 tiebreakers.
Try It On Desmos!

JavaScript, 2 tie-breakers
alert(`${``[`repeat`][`call`]`${prompt``}`}${``[`repeat`][`call`]`${prompt``}`}`[`length`])

Could I have made it shorter? Yes. But I find this version especially amusing.
Peculiarities:

Only uses lowercase letters and the symbols $ [ ] ` { }
Uses no mathematical operators.
Relies heavily on especially cryptic JavaScript features

Tricks used:

obj['prop'] instead of obj.prop to avoid using .
tagged template literals to avoid using ( ) to call functions

func`string` evaluates to  func(['string'])
func`${ expression }` evaluates to func(['', ''], expression)

['', ''].toString() produces ','
''.repeat.call(',', value) is equivalent to ','.repeat(value). This hack is used to turn the repeat function into one which takes the number of repeats as its second argument, so that we can use that function as a tag.

Edit: oops, forgot to alert the result. Uh, I'll just wrap that in an alert for now, feel free to suggest an improvement

Python
i=input
print eval('%d\x2b%d'%(i(),i()))

37 chars with a little bit of cheating :p

Common Lisp
Always surprising for such a verbose language.
((lambda(n m)(princ(length(append(make-list n)(make-list m)))))(read)(read))

A very yucky C version
Has no +, -, / or any digits. One use of * for a pointer type. The others (()=,) are needed a lot in the language itself.
#include <malloc.h>
#include <string.h>
#include <stdio.h>
typedef unsigned char *ptr;

char
  y;

const size_t
  one = sizeof y;

unsigned char
  zero='a'^'a',
  a [] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  z [] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  x [] = "xxxxxxxxxxxxxxxxx";

size_t plus_one (size_t i)
{
  ptr b=&a[one];
  memset (a,'x',sizeof a);
  b[i]=zero;
  return strlen(a);
}

size_t minus_one (size_t i)
{
  ptr b=&a[one];
  memset (a,'x',sizeof a);
  a[i]=zero;
  return strlen(b);
}

size_t minus_zero (size_t i)
{
  size_t p;
  for (p = zero ; z[p] ; p = plus_one (p))
  {
    i = minus_one(i);
  }
  return i;
}

unsigned char to_zero (unsigned char i)
{
  size_t p;
  for (p = one>>one ; x[p] ; p = plus_one (p))
  {
    i = (unsigned char) minus_one(i);
  }
  return i;
}

main (int argc, ptr argv [])
{
  ptr
    a = argv [argc>>one],
    b = argv [argc>>one<<one];

  size_t
    len_a = strlen (a),
    len_b = strlen (b),
    len = len_a > len_b ? len_a : len_b,
    o = plus_one(len),
    i,
    c=one>>one;

  ptr
    res=(ptr)malloc(plus_one(o));

  res[o]=zero;

  for (i = zero ; i < len ; i=plus_one(i))
  {
    size_t va;
    unsigned char r;

    va = (len_a > zero ? minus_zero (a[minus_one(len_a)]) <<one<<one<<one<<one : zero) | (len_b > zero ? minus_zero (b[minus_one (len_b)]) : zero);
    r = (c?"bcdefghijAuhjsadcdefghijABsadlkfdefghijABCvsxwerefghijABCDDNIWjsfghijABCDEOQJdccghijABCDEFIndDjlhijABCDEFGCnjndwijABCDEFGHsadXSkjABCDEFGHICSjshdABCDEFGHIJcbaCBA":"abcdefghijaswhHDbcdefghijAQWuciucdefghijABCOasdpdefghijABCCnjaskefghijABCDCIUdasfghijABCDEuoiDSAghijABCDEFCsalkjhijABCDEFGcapCPcijABCDEFGHCWEoerjABCDEFGHIkjIjIj") [va];
    c=r<'a';
    r&=~(one<<one<<one<<one<<one<<one);
    o=minus_one(o);
    res[o]=to_zero(r);

    if (len_a) len_a = minus_one (len_a);
    if (len_b) len_b = minus_one (len_b);
  }
  if(c)
  {
    o=minus_one(o);
    res[o]=to_zero('B');
  }
  printf("%s\n",&res[o]);
  free (res);
}

VBA - No +/-, 7 tie-breakers
+,-,/,*,,,.,0-9 = 0
( = 3 (3 total pairs)
) = 3
= = 1
Function a(b)
    For Each c In b
        a = a & Space(c)
    Next
    MsgBox Len(a)
End Function

Takes an array of natural numbers as an argument. This will actually add more than just 2 values, if provided, as well as return the value of a single argument.
Older versions

+,-,/,*,=,.,0-9 = 0
( = 4 (4 total pairs)
) = 4
, = 1
Function a(b, c)
MsgBox Len(Space(b) & Space(c))
End Function

+,-,/,*,=,.,0-9 = 0
( = 4 (4 total pairs)
) = 4
, = 3
Sub a(b,c)
MsgBox Len(String(b," ") & String(c," "))
End Sub

+,-,/,*,. = 0
= = 4
( = 2 (2 total pairs)
) = 2
0-9 = 2
, = 1
Sub d(e,f)
For g=1 To e:h=h & " ":Next
For g=1 To f:h=h & " ":Next
MsgBox Len(h)
End Sub

Character count technically doesn't matter in this challenge. You have no -+, and you have 11 tie breakers. This puts you above any solution that has a -+ character, and below any solution with no -+ with fewer tie breakers.

So, I am tied with (as one example) Uri Goren's answer, correct? He has no +/-, but 11 tie-breakers.

Yes, you are tied with him.

C #, 26 tiebreakers

+/- : 0
=   : 2
.   : 6
()  : 18

using System;
using System.Linq;
class P
{
    static void Main()
    {
        Func<int[]> f=()=>new int[int.Parse(Console.ReadLine())];
        Console.Write(f().Concat(f()).Count());
    }
}

PHP, 22 chars
echo array_sum($argv);

Documentation: array_sum() and $argv
Usage: php -r 'echo array_sum($argv);' 5 6 will output 11.

+/- and above mentioned tiebreakers are interesting, not chars.

APL (10, 3 tie-breakers)
⎕←⍴(⍳⎕),⍳⎕

10x +/-?  Chars arn't interesting, just +/- and the tie-breakers.

Python 3 - 159 characters | ().,*/= count: 39
A little long, but I felt like doing it HDL-style.
a,b,c,d=int(input()),int(input()),0,0;l=max(a,b,key=int.bit_length)
for i in range(len(bin(l<<1)[2:])):
 e=a>>i&1;f=b>>i&1;c|=(e^f^d)<<i;d=e&f|d&(e^f)
print(c)

+/- tiebreakers are interesting, not characters.

@userunknown: What's wrong with characters?

Characters are counted in CodeGolf tagged questions. If a reader doesn't read the question again, he will get the impression that character count is important and probably make a misguided vote based on that assumption. So the rules say: No (+|-). In Tiebreak digits, ().,*/= are important. You should include that number in your answer, so that not every visitor has to count them himself.

@userunknown: Oh, right.

C# 141 characters 27 tiebreakers
+/- : 0
=   : 0
.   : 9
()  : 18

Console.WriteLine(Enumerable.Range(1,int.Parse(Console.ReadLine()))
.Concat(Enumerable.Range(1,int.Parse(Console.ReadLine())))
.Count());

Python 42
a,b=input()
print eval("~-"*a+"~-"*b+"0")

Seven tie breakers, but those are string operations

C#, 12 tiebreakers (), 3 tiebreakers .
using System;
using System.Data;

class Program {
  static string ReadLine { get { return Console.ReadLine(); } }
  static void Main(string[] args) {
    Console.Out.Write(
     new DataTable().Compute(string.Join("\u002b",
     ReadLine,
     ReadLine), "")
    );
  }
}

JavaScript 69
My attempt, using bitwise operators
for(x=(z=prompt().split(" "))[0],y=z[1];y;)x^=y,y=(y&x^y)<<1;alert(x)

R, 44 bytes
nchar(paste(strrep(" ",scan()),collapse=""))

Try it online!
Converts the two inputs to unary and "sums" via concatenation. Check out the other R answers:

Using sequence
Using dot product

C, score 0 with 8 tie-breakers
f(a,b) { return b ? f(a^b, a<<1 & b<<1) : a; }
 ^ ^ ^               ^   ^    ^      ^^

I've highlighted the tie-break chars.
Negative numbers are assumed to be 2s-complement.

Javascript (ES6) - 8 Tie-breaker characters
add: {
    let a = prompt``|false;
    let b = prompt``|false;
    while (a & b) {
        a = a ^ b;
        b = [b & ~a][false|false] << true
    }
    alert(a | b);
}

2 * (
2 * )
4 * =

Gol><>, 12 bytes
IITM:{P}?trh

Thanks to JoKing for reminding me there was a Teleport Pad!!
1st version, 25 bytes
II!/M:{P}?\rh
   \     :/

Try it online!
This was alot easier than I thought it would be!!! I will be golfing this alot more!!!

12 bytes using teleports, 10 bytes using put. Or 13 bytes without tie breaker characters

@JoKing Wow. Those use strategies I wasn't even thinking of!!!, nice!

Runic Enchantments, (no +/-, 1 tie-breaker, 11 bytes)
'V2,k!$wi|;

Try it online!
Not allowed to have + characters? Fine, I'll create them myself with math and reflection. V has the byte value 86, which gets divided by 2 (the , and only tie-breaker character) converted to a character, and finally, reflectively written into the program under the instruction pointer. It then reads input, hits a reflector (|), reads input again, then reaches the space originally containing a w and adds them together before printing. The IP then performs an illegal action at , and is silently terminated.
Is this cheating? Probably. But the challenge says "don't use + characters" and the source code contains 0 of them.
Alternate method, (no +/-, 3 tie-breakers, 16 bytes)
"ab"1,i*}i*qul$;

Try it online!
Makes two strings, one of length x and one of length y, concatenates them together, then computes the length of the string. Does this count as a "sum-like function"? Perhaps. + on two strings does do the same thing.

APL (Dyalog Unicode), 4 bytesSBCS, 0 +/-, 0 tie breakers
Can sum any number of non-negative integers.
≢⎕⌿#

Try it online!
# reference to the root object
⎕/ replicate by the number(s) from STDIN
for each number, we get that many copies of the corresponding element on the right, but since there is only one, all numbers get paired up with that one, forming a single list of N1+N2+…+Nn references
≢ tally
Output is implicitly to STDOUT.

Befunge-98 (FBBI), 4 bytes, one +.
&&+.

Try it online!

Surely you could use p to place a + command?

@negativeseven I just made it for my Seed answer below.

MathGolf, 3 bytes, 0 +/-
α▓∞

Try it online!
While perhaps violating the spirit of the "no sum" rule, this solution wraps the inputs into an array, calculates the average of the values in that array, and duplicates the result. Of course, the avg operator uses a sum internally, but its behavior is inherently different compared to the sum operator Σ.
The output is printed as a float, with .0 at the end. If this is not acceptable, just add i to the end to convert it back into an integer.
Explanation
α     wrap last two elements in array
 ▓    get average of list
  ∞   pop a, push 2*a

Befunge-98 (PyFunge), 0 +/- characters, 0 tiebreaker characters, 47 bytes
brqzzzzzzzzzzzzzzzzzzzpyadgyacpyappyacybyabybay

Try it online!
Made all out letters, because why not?
More readable variant that does pretty much the same thing:
b<@                               &&pyapyabybay

Abuses the y GetSysInfo command, which can be used to retrieve the instruction pointer's current X coordinate. This is used to push the ASCII codes for + (add) and . (output), which later get put onto the field.

C (gcc), 3 tiebreakers
I take no credit for this, as this is not an original answer, but merely an amalgamation of the following answers to this same challenge:
https://codegolf.stackexchange.com/a/5701/97511, https://codegolf.stackexchange.com/a/4613/97511
#include <stdio.h>

#define OP (
#define CP )
#define CO ,

int main OP ac CO av CP int ac; typeof OP "" CP av; {
    scanf OP "%d\n%d" CO &ac CO &av CP;
    return printf OP "%d\n" CO &av[ac] CP;
}

Try it online!

Raku, 0 tie-breaker characters
say ½−½−$_ given ½−½−get−get

Try it online!
− here is the Unicode character MINUS SIGN at codepoint 8722, rather than the ASCII/Unicode character -, HYPHEN-MINUS, at codepoint 45.  The two are synonymous in Raku, but the former is by no stretch the "standard" subtraction operator.
½−½− is how I'm negating numbers without using any of the tiebreaking characters.  It could be done with just a single leading MINUS SIGN, but that could arguably be considered a "negation function."

Julia 1.0, no +/-, 1 tiebreaker
import Base:Meta.parse
["a"^[readline|>map|>parse][] "b"^[readline|>map|>parse][]]|>join|>length|>show

Try it online!

"a"^N creates a string of length N
x|>f is equivalent to f(x)
f|>map calls f with no argument (f())
[...][] is equivalent to parenthesis
we join both strings and check for the total length

Julia 1.0 (function), no +/-, no tiebreaker
x->["a"^[x|>first][] "b"^[x|>last][]]|>join|>length

Try it online!

source: Stack Exchange

license: 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/

sort: votes


text:
BWInf 2011, question 5: Twin towns
This is a challenge that was originally a tas for the German Bundeswettbewerb Informatik (federal competition of computer science [?]), a competition for highschool students. As opposed to the original question, where you have to find a good solution and write some documentation, I want you to golf this. I try to replicate the question as good as possible:
Challenge
Many towns in Europe have so-called twin towns. This year, there is a special Jubilee where each pair of twin-towns in the EU organizes a festival to celebrate their partnership. To ensure that no city has to organize too many festivals, each city has a limit of festivals it can organize. Is it possible to distribute the festivals among the twin-towns in a way, such that each pair of twin-towns organizes one festival in one the two towns and no town organizes more festivals than it is allowed to? If yes, explain how.
This is a map of some towns, their partnerships and their limits of festivals.

Requirements

Your program must terminate the problem in one minute each for both testcases. (See below)

Refer to the testcases for the input format.

The output should be empty iff no solution exists and should have the following format otherwise: One line for each pair of twin towns, a if city1 organizes the festival, b otherwise.
  <city1>, <city2>, <a/b>

The solution with the least number of characters that satisfies the requirements wins. In case of a tie, the program that was submitted first wins.

Usual code-golf rules apply.

Testcases
The original task had two testcases. I have uploaded them on github.

Hint: there's a simple reduction to integer max-flow.

@Peter what about the bipartite matching?

The reduction is a slight extension of the standard bipartite matching reduction and should be more efficient than a reduction via bipartite matching (which would require turning each city into n nodes, where n is the budget limit of the city).

Link to map is dead.

@pppery Fixed!  Sorry for the inconvenience.

Python, 380 chars
import sys
N={};H={};X={}
for L in open(sys.argv[1]):n,x,y=L.split('"');N[x]=int(n);H[x]=0;X[x]=[]
for L in open(sys.argv[2]):s,t=eval(L);X[s]+=[t]
p=1
while p:
 p=0
 for x in N:
  if len(X[x])>N[x]:
   p=1;S=[y for y in X[x]if H[y]<H[x]]
   if S:X[x].remove(S[0]);X[S[0]]+=[x]
   else:H[x]+=1
   if H[x]>2*len(N):sys.exit(0)
for x in N:
 for y in X[x]:print'"%s", "%s", a'%(x,y)

This code uses a push-relabel-style maximum flow algorithm.  N[x] is the number of parties allowed at x, X[x] is the list of partner cities currently scheduled to host at x (which may be longer than N[x] during the algorithm), and H[x] is the labelled height of x.  For any oversubscribed city, we either push one of its scheduled parties to a lower partner city, or raise its height.

C#, 1016 992 916 chars
Takes 4 seconds for me on the large test set; performance can easily be improved a lot by making X a HashSet<s> rather than a List<s>.
using System;using System.Collections.Generic;using System.IO;using System.Linq;using
s=System.String;class D<T>:Dictionary<s,T>{}class E:D<int>{static void Main(s[]x){s
S="",T=">",l;s[]b;D<E>R=new D<E>(),P=new D<E>();R[S]=new E();R[T]=new E();foreach(s L in
File.ReadAllLines(x[0])){b=L.Split('"');s f=b[1];R[T][f]=0;R[f]=new E();P[f]=new
E();R[f][T]=int.Parse(b[0].Trim());}foreach(s L in File.ReadAllLines(x[1])){b=L.Split('"');s
f=b[1],t=b[3],v=f+t;R[v]=new
E();R[v][S]=R[f][v]=R[t][v]=0;P[f][t]=R[S][v]=R[v][f]=R[v][t]=1;}for(;;){List<s>X=new
s[]{S}.ToList(),A=X.ToList();w:while((l=A.Last())!=T){foreach(s t in
R[l].Keys){if(!X.Contains(t)&R[l][t]>0){X.Add(t);A.Add(t);goto
w;}}A.RemoveAt(A.Count-1);if(!A.Any())goto q;}l=S;foreach(s n in
A.Skip(1)){R[l][n]--;R[n][l]++;l=n;}}q:if(R[S].Values.Contains(1))return;foreach(s
f in P.Keys)foreach(s t in P[f].Keys)Console.WriteLine(f+", "+t+", "+"ba"[R[f][f+t]]);}}

This uses the reduction to max flow which I hinted at earlier in comments. The vertices are

A newly generated source S and sink T.
The partnerships.
The cities.

The edges are

From the source to each partnership with flow capacity 1.
From each partnership to each city in the partnership with flow capacity 1.
From each city to the sink with flow capacity equal to that city's budget.

The algorithm is Ford-Fulkerson with DFS. It is obvious a priori that each augmenting path will increase the flow by 1, so the golfing optimisation of removing the computation of the path's flow has no negative effect on performance.
There are other possible optimisations by making assumptions such as "The names of the input files will never be the same as the names of the cities", but that's a bit iffy IMO.

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

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


text:
Write a third order quine
This challenge is an extension of 'Golf a mutual quine'.
Using three languages of your choice, create a third order Ouroboros program.
That is, in language A, write a program pA which outputs program pB in language B. Program pB should output program pC in language C, which in turn outputs the original program pA in language A.
No two languages in A, B, and C can be the same or subsets or supersets of each other. None of pA, pB or pC may be identical.
For example, a Haskell program outputs a Perl program which outputs a java program which outputs the original Haskell program would be valid.
On the other hand, a C# 4 program which outputs a C# 3 program which outputs a C# 2 program is invalid. Even a Perl -> Ruby -> Bash combination would be invalid if, say, the Perl program and the Ruby program were identical.
This is code golf, so the shortest program pA wins.

For the interested: A mutual quine generator where you can specify the sequence of languages.

Python -> Perl -> Ruby, 48 characters
Adaption of my previous answer. Running
s='print q<puts %%q{s=%r;print s%%s}>';print s%s

with Python generates this Perl snippet
print q<puts %q{s='print q<puts %%q{s=%r;print s%%s}>';print s%s}>

which generates the following Ruby code
puts %q{s='print q<puts %%q{s=%r;print s%%s}>';print s%s}

which then prints the original Python snippet:
diff -s <(ruby <(perl <(python thirdorderquine.py))) thirdorderquine.py
Files /dev/fd/63 and thirdorderquine.py are identical

Perl -> PHP -> HTML + JavaScript, 105 chars
I wanted to make the chain of languages somehow meaningful, so I figured I'd write a PHP script that generates a HTML page containing JavaScript.  For the third language I chose Perl, just because I like Perl. :)
Some might consider this four languages, but I don't really count HTML as separate from JavaScript here — it's a markup language, not a programming language.  Anyway, here are the three versions:
Perl (105 chars):
printf+(q(<script>alert(unescape("<?=urlencode(<<<E%sprintf+(q(%s),$/)x2,$/%sE%s)?>"))</script>),$/)x2,$/

PHP (165 chars):
<script>alert(unescape("<?=urlencode(<<<E
printf+(q(<script>alert(unescape("<?=urlencode(<<<E%sprintf+(q(%s),$/)x2,$/%sE%s)?>"))</script>),$/)x2,$/
E
)?>"))</script>

HTML + JavaScript (235 chars):
<script>alert(unescape("printf%2B%28q%28%3Cscript%3Ealert%28unescape%28%22%3C%3F%3Durlencode%28%3C%3C%3CE%25sprintf%2B%28q%28%25s%29%2C%24%2F%29x2%2C%24%2F%25sE%25s%29%3F%3E%22%29%29%3C%2Fscript%3E%29%2C%24%2F%29x2%2C%24%2F"))</script>

(Ps. Yes, I know I could've made the PHP step an almost-noop, e.g. just generating HTML + JS code in Perl and appending <?php to it, but that felt too much like cheating.  In this solution, the code is actually processed in PHP instead of just being copied verbatim.)

Underload → sed → Perl, 23 bytes
Can probably get this down lower with better choices of languages. Arguably noncompeting because the rule "sed programs can take an empty line as argument" postdates the contest.
The Underload program:
((iprint+q)Sa(:^)*aS):^

generates the sed program:
iprint+q(((iprint+q)Sa(:^)*aS):^)

which generates the Perl program:

print+q(((print+q)Sa(:^)*aS):^)

(note: there are two trailing newlines here), which generates the original Underload program again:
((iprint+q)Sa(:^)*aS):^

The main aim here is to find languages in which strings are nestable (i.e. you can just quote a string by enclosing it in delimiters, rather than having to escape it); Underload has (), Perl has q(), and in sed a string continues until whitespace (which is implicitly nestable if there's no whitespace in the program). There's probably an esolang or golfing language out there with a "print the rest of the current line, not followed by newlines" instruction, which would be ideal here, but I haven't spent all that much time looking for one; you could save 8 bytes minus the length of the instruction in that case. (Jelly almost works but its “ instruction doesn't quote itself. Besides, it postdates the challenge.)
You can reduce this to 22 bytes like this:

((csay+q)Sa(:^)*aS):^

(with one trailing newline, like a regular text file, rather than the zero you normally get in golf). However, this requires an Underload interpreter that's OK with treating newline as a no-op. Try It Online!'s does, but I think it postdates the challenge.