[Question]
  [
The goal is to produce a single line of R code that:
1. Does as little as possible
2. In as many characters as possible (max of 100 characters)
3. And is as ugly as possible (where "ugly" can be taken to mean inefficient computational strategies, extraneous characters such as a terminating semicolon, and so forth).
Do your worst, gentlefolk!
**Objective criteria for winning**
The winning answer will be judged according to the following point scale (the answer with the most points wins):
* Generate a sequence from 0 to 10 (*100 points)*
* In as many characters (N) as possible
	+ *0 points* if N=100
	+ *N-100 points* if N<100 (i.e. lose a point for every character under 100)
	+ *2(100-N) points* if N>100 (i.e. lose two points for every character over 100)
* Using as many negative examples from the [R Inferno](http://www.burns-stat.com/pages/Tutor/R_inferno.pdf) as possible
	+ *6 points* per cited example
	+ Each example only counts once. This is so because a "heretic imprisoned in [a] flaming tomb" can only be so imprisoned one time. Thus two global assignments in your line of code only net you 6 points.
  
[Answer]
## 72 96 characters.
```
`c`<-function(...){list(...)[[-1]];}->>`c`;`[`=0;`]`=10;c(c,c)(c,c)(c,invisible)(`[`[]:`]`[])[];
```
Ugliness:
* Reusing a standard function name
* Using symbols as variable names
* Global assignment
* Right assignment
* Self-redefinition of function
* Unnecessary trailing semicolon(s)
* Unnecessary sub-scripting numbers
* Unnecessary quoting of variable name
* Leaves the workspace in a state which will almost certainly break any subsequent code run
Generates the sequence 0-10 (thanks to Andrie for the idea to do that).
### output:
```
 [1]  0  1  2  3  4  5  6  7  8  9 10
```
[Answer]
Generate a sequence from 0 to 10.
**100 characters**
```
{.=0;for(`~1` in c(1,2,3,4,5,6,7,8,9,10)){.=c(., `~1`,recursive=F)};print(unname(.[drop=T]));rm(.)}
 [1]  0  1  2  3  4  5  6  7  8  9 10
```
[Answer]
**100 characters:** 
Generate a sequence from 1 to 10. 
Note that the numbers 2-10 are NOT in the code... - Bonus points? :-)
Also note that it uses `lapply` for maximum performance :)
```
unlist(lapply(LETTERS[-(11:26)],function(x) as.integer(charToRaw(x))-as.integer(charToRaw('A'))+1L))
#[1]  1  2  3  4  5  6  7  8  9 10 
```
[Answer]
### 100 characters
```
assign("a",1:10);b<<-paste(c(a),collapse=";");unlist(lapply(strsplit(b,";")[[1]],function(c)c[[1]]))
```
Not sure if `lapply` on `strsplit` is a negative example but it sure should be.
Returns as a character:
```
 [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"
```
[Answer]
```
I(cumsum(Reduce("sum", replicate(paste0(as.integer(T),as.integer(T)), T), accumulate=1-F) - T >0))
```
should have slightly less than 100 characters and somehow produce 0:10
]