text:
Row of natural numbers
Definition
There is infinite row of concatenated natural numbers (positive integers, starting with 1):
1234567891011121314151617181920212223...
Challenge

Write program in any language, that accepts position number as an input, and outputs digit from that position in the row defined above.
Position number is arbitrary size positive integer. That is first position is 1, yielding output digit '1'
Input is either in decimal (eg. 13498573249827349823740000191), or e-notation (eg. 1.2e789) corresponding to positive integer.
Program has to end in reasonable time (10 seconds on modern PC/Mac), given very large index as an input (eg. 1e123456 - that is 1 with 123456 zeroes). So, simple iteration loop is not acceptable.
Program has to terminate with an error in 1 s, if given any invalid input. Eg. 1.23e (invalid), or 1.23e1 (equals to 12.3 - not an integer)
It's ok to use public BigNum library to parse/store numbers and do simple mathematical operations on them (+-*/ exp). No byte-penalty applied.
Shortest code wins.

TL;DR

Input: bignum integer
Output: digit at that position in infinite row 123456789101112131415...

Some acceptance test cases
in notation "Input: Output". All of them should pass.

1: 1
999: 9
10000000: 7
1e7: 7  (same as row above)
13498573249827349823740000191: 6
1.1e10001: 5
1e23456: 5
1.23456e123456: 4
1e1000000: 0
1.23e: error (invalid syntax)
0: error (out of bounds)
1.23e1: error (not an integer)

Bonus!
Output digit position number inside the number, and output number itself.
For example:

13498573249827349823740000191: 6 24 504062383738461516105596714

That's digit '6' at position 24 of number '504062383738461516105596714'

1e1000000: 0 61111 1000006111141666819445...933335777790000

Digit '0' at position 61111 of 999995-digit long number I'm not going to include here.

If you fulfill the bonus task, multiply size of your code by 0.75
Credit
This task was given at one of devclub.eu gatherings in year 2012, without large number requirement. Hence, most answers submitted were trivial loops.
Have fun!

I really don't get what the challenge is. Are we supposed to take the input and output the number at that position?

Input: integer (in decimal or e-notation). Output: digit at that position in infinite row of natural numbers (concatenated).

What is the highest index our program needs to understand? How are we supposed to interpret numbers in scientific notation?

Considering bonus task involves outputting the number itself, I'd set the limit at position 1e1000000 (1 followed by million zeroes), as the number at that point is megabyte long. "How to interpret scientific notation" - common sense applied. https://en.wikipedia.org/wiki/Scientific_notation#E_notation

This is OEIS sequence 33307.

Thanks for the info. Does it make outputting the number easier?

@metalim 1e1000000 seems absurdly large, most languages won't be able to calculate that high to due major precision errors. A more reasonable limit would be 2^64-1 or even 1e256. If we are required to supply this colossal numbers, can we use a BigInt library with no byte penalty?

@vihan Using some public bignum library is acceptable. No penalty. Of course including the solution into library and using the library in one-liner is considering cheating. Common sense applies here.

Do we have to accept both e-notation and number-notation, or do we have the option to only support one or the other?

@Claudiu Both notations should be accepted.

Do the numbers in the output have to be separated by spaces or would, e.g., newlines be acceptable?

Just wanted to show off a surprisingly concise F# solution, clocking in at 44 bytes. Granted, it can only handle indices up to 2^31-1 (and its still trying to compute that value as I write this). I'm not posting this though because it does indeed break the rules, but I'd say its pretty good for F#!

The requirements to handle inputs like 1.23456e123456 arbitrarily punishes languages that cannot process such values natively and requires them to do string processing that is tangential to the challenge.

@Dennis any readable output in decimal notation is acceptable, as long as it is clearly distinguished by a human. Outputting number as number of dots printed is not ok.

@xnor parsing is part of the challenge. Entering the input is meant to be done by a human. Hence, there's room for error or unusual input.

@metalim Would this way of presenting the output be acceptable? I think it's readable, but it contains a quote (which indicates that we're printing a character, not a number) and the order of the last two integers has been swapped.

@Dennis sure. It is readable and clearly separated.

https://en.wikipedia.org/wiki/Champernowne_constant

CJam, 78 bytes
r_A,s-" e . .e"S/\a#[SSS"'./~'e/~i1$,-'e\]s"0]=~~_i:Q\Q=Qg&/
s,:L{;QAL(:L#9L*(*)9/-_1<}g(L)md_)p\AL#+_ps=

The program is 104 bytes long and qualifies for the bonus.
The newline is purely cosmetic. The first line parses the input, the second generates the output.
Try it online!
Idea
For any positive integer k, there are 9×10k-1 positive integers of exactly k digits (not counting leading zeroes). Thus, if we concatenate all of them, we obtain an integer of 9×n×10k-1.
Now, concatenating all integers of n or less digits yields an integer of

digits.
For a given input q, we try determine the highest n such that the above expression is smaller than q. We set n := ⌈log10q⌉-1, then n := ⌈log10q⌉-2, etc. until the desired expression becomes smaller than q, subtract the resulting expression from q (yielding r) and save the last value of n in l.
r now specifies the index in the concatenation of all positive integers of l+1 digits, which means that the desired output is the r%(l+1)th digit of the r/(l+1)th integer of l+1 digits.
Code (input parsing)
r_          e# Read from STDIN and duplicate.
A,s-        e# Remove all digits.
" e . .e"S/ e# Push ["" "e" "." ".e"].
\a#         e# Compute the index of the non-digit part in this array.

[SSS"'./~'e/~i1$,-'e\]s"0]

            e# Each element corresponds to a form of input parsing:
            e#   0 (only digits): noop
            e#   1 (digits and one 'e'): noop
            e#   2 (digits and one '.'): noop
            e#   3 (digits, one '.' then one 'e'):
            e#     './~    Split at dots and dump the chunks on the stack.
            e#     'e/~    Split the and chunks at e's and dump.
            e#     i       Cast the last chunk (exponent) to integer.
            e#     1$      Copy the chunk between '.' and 'e' (fractional part).
            e#     ,-      Subtract its length from the exponent.
            e#     'e\     Place an 'e' between fractional part and exponent.
            e#     ]s      Collect everything in a string.
            e#   -1 (none of the above): push 0

~           e# For s string, this evaluates. For 0, it pushes -1.
~           e# For s string, this evaluates. For -1, it pushes 0.
            e# Causes a runtime exception for some sorts of invalid input.
_i:Q        e# Push a copy, cast to Long and save in Q.
\Q=         e# Check if Q is numerically equal to the original.
Qg          e# Compute the sign of Q.
&           e# Logical AND. Pushes 1 for valid input, 0 otherwise.
/           e# Divide by Q the resulting Boolean.
            e# Causes an arithmetic exception for invalid input.

Code (output generation)
s,:L     e# Compute the number of digits of Q and save in L.
{        e# Do:
  ;      e#   Discard the integer on the stack.
  Q      e#   Push Q.
  AL(:L# e#   Push 10^(L=-1).
  9L*(   e#   Push 9L-1.
  *)     e#   Multiply and increment.
  9/     e#   Divide by 9.
  -      e#   Subtract from Q.
  _1<    e#   Check if the difference is non-positive.
}g       e# If so, repeat the loop.
(        e# Subtract 1 to account for 1-based indexing.
L)md     e# Push quotient and residue of the division by L+1.
_)p      e# Copy, increment (for 1-based indexing) and print.
\AL#+    e# Add 10^L to the quotient.
_p       e# Print a copy.
s        e# Convert to string.
2$=      e# Retrieve the character that corresponds to the residue.

CJam, 75 * 0.75 = 56.25
This is quite fast, one iteration per digit of the number that contains the desired position. I'm sure it can be golfed a lot more, it's quite crude as it is.
q~_i_@<{0/}&:V9{VT>}{T:U;_X*T+:T;A*X):X;}w;U-(_X(:X/\X%10X(#@+s_2$\=S+@)S+@

Give the position as input, the output is:
<digit> <position> <full number>

Try it online.

@Dennis Working with all inputs now :)

This still doesn't raise an error (as it should) for 1.23e1. It errors, however, for 1.23456e123456, since the input cannot represented by a Double. Also, the last test cases takes 3 minutes.

@Dennis Now raises the error. As for the big test case... Damn. I may have to rewrite the whole thing.


text:
ASCII connected hexagons
Overview
Given a number of hexagons, arrange them into a connected shape within the confines of a 50 by 50 ASCII art image. The shape you choose can be arbitrary - whatever you find most amenable to golfing - as long as it is connected. It may have holes provided they are larger than one hexagon (otherwise the number of hexagons will be ambiguous).

Layout
All hexagons must be in the following form (only this size and orientation is valid):
 __
/  \
\__/    Note there are 2 underscores per horizontal edge.

Two hexagons are directly connected if they share an edge:
 __               __
/  \__           /  \
\__/  \          \__/
   \__/    or    /  \
                 \__/

Two hexagons are not connected if they only share a vertex:
 __  __
/  \/  \
\__/\__/

Sharing half an edge also does not count as connected:
 __
/  \
\__/
 /  \
 \__/

A collection of hexagons is connected if there exists a path from any hexagon to any other using only directly connected hexagons.
Holes
A hexagon sized hole in a connected collection of hexagons counts as a hexagon, so that any given piece of ASCII art has an unambiguous hexagon count.
This does not count as a hole since the prospective hole is a single hexagon:
    __
 __/  \__
/  \__/  \
\__/  \__/
/  \__/  \
\__/  \__/
   \__/      7 hexagons (not 6 with a hole)

This does count as a hole since it does not correspond to a single hexagon:
    __
 __/  \__
/  \__/  \__
\__/  \__/  \
/  \__   \__/
\__/  \__/  \
   \__/  \__/
      \__/      8 hexagons with a hole

Input and output
Input
An integer from 1 to 255.
Output
An ASCII art string representing the input number of connected hexagons as described above.

The number of rows (newline separated substrings) is at most 50, plus an additional optional trailing newline.
The rows need not be the same length, but each must be of length at most 50.
Zero length rows can exist above or below the connected shape provided the total number of rows does not exceed 50.
Space-only rows can exist above or below the connected shape provided the total number of rows does not exceed 50.
Spaces can appear to the left of the shape provided the row lengths do not exceed 50 (the shape does not need to be aligned to the left).
Spaces can appear to the right of the shape provided the row lengths do not exceed 50.
Any characters that do not form part of the connected shape must be either spaces or newlines.

Provided the output is correct, it is not required to be consistent from one run to the next.
Examples
Input: 6
Valid Outputs:
 __    __    __
/  \__/  \__/  \__
\__/  \__/  \__/  \
   \__/  \__/  \__/

 __    __
/  \__/  \
\__/  \__/
/  \__/  \
\__/  \__/
   \__/

          __
 __      /  \
/  \__   \__/
\__/  \__/  \
   \__/  \__/
      \__/
      /  \
      \__/

Invalid Outputs:
    __
 __/  \__
/  \__/  \
\__/  \__/
/  \__/  \
\__/  \__/
   \__/      Invalid for 6 as the centre hole counts as a 7th hexagon.

 __    __    __      __
/  \__/  \__/  \    /  \
\__/  \__/  \__/    \__/
   \__/  \__/                Invalid as the 6 hexagons are not connected.

 __    __    __  __
/  \__/  \__/  \/  \
\__/  \__/  \__/\__/
   \__/  \__/           Invalid as vertex touching does not count as connected.

 __    __       __
/  \__/  \     /  \
\__/  \__/     \__/
/  \__/  \
\__/  \__/
   \__/       Invalid as the 6 connected hexagons are not the only visible characters.

Winning
The shortest valid answer in bytes wins.

Leaderboard
(using Martin's leaderboard snippet)

var QUESTION_ID=54277;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function shouldHaveHeading(e){var a=!1,r=e.body_markdown.split("\n");try{a|=/^#/.test(e.body_markdown),a|=["-","="].indexOf(r[1][0])>-1,a&=LANGUAGE_REG.test(e.body_markdown)}catch(n){}return a}function shouldHaveScore(e){var a=!1;try{a|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(r){}return a}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.sort(function(e,a){var r=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0],n=+(a.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0];return r-n});var e={},a=1,r=null,n=1;answers.forEach(function(s){var t=s.body_markdown.split("\n")[0],o=jQuery("#answer-template").html(),l=(t.match(NUMBER_REG)[0],(t.match(SIZE_REG)||[0])[0]),c=t.match(LANGUAGE_REG)[1],i=getAuthorName(s);l!=r&&(n=a),r=l,++a,o=o.replace("{{PLACE}}",n+".").replace("{{NAME}}",i).replace("{{LANGUAGE}}",c).replace("{{SIZE}}",l).replace("{{LINK}}",s.share_link),o=jQuery(o),jQuery("#answers").append(o),e[c]=e[c]||{lang:c,user:i,size:l,link:s.share_link}});var s=[];for(var t in e)e.hasOwnProperty(t)&&s.push(e[t]);s.sort(function(e,a){return e.lang>a.lang?1:e.lang<a.lang?-1:0});for(var o=0;o<s.length;++o){var l=jQuery("#language-template").html(),t=s[o];l=l.replace("{{LANGUAGE}}",t.lang).replace("{{NAME}}",t.user).replace("{{SIZE}}",t.size).replace("{{LINK}}",t.link),l=jQuery(l),jQuery("#languages").append(l)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:<(?:s>[^&]*<\/s>|[^&]+>)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

I fear everyone will use the first example output pattern as it's probably the easiest to implement.

@Fatalize my examples only work for an input of 6. For an input of 255 a horizontal row of hexagons won't fit in a 50 by 50 ASCII art.

You could still simply loop back and fill the lines below every time you reach the 50 chars limit

@Fatalize The challenge is to minimise the number of bytes in the code. I don't mind if the patterns are simple, it will just be interesting to see what people try and what suits different languages.

@Fatalize: I dunno if it would be short or not, but a more "interesting" answer might do an actual search to see where it can place hexagons and thus get a more interesting output.

CJam, 64 57 55 bytes
" __
/  \
\__/"N/{_SS/\+_47>S3*f{\+}_2>\@?}q~(*]:..e>N*

Test it here.
This will generate the following pattern, column-wise:
 __    __    __    __    __    __
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/

Explanation
This is based on Dennis's excellent tip, using .e> to assemble an ASCII art output from several pieces. As he says, .e> takes the element-wise maximum of two arrays (or strings), and since spaces have the lowest character code, we can use this to impose any other characters on a string grid. Furthermore, if the two arrays don't have the same length, the extraneous elements of the longer array are simply copied unchanged. This means that the different patterns don't even need to be the same size. To apply this to two-dimensional arrays (because we don't want to insert the newlines until the very end), we apply .e> pairwise to lines, which gives ..e>.
The basic idea of the code is to generate N copies of a single hexagon moved to the right position. We "move" the hexagon vertically by prepending empty lines and horizontally by prepending spaces. Once we're done, we fold all of the copies together, using the beautiful :..e> (probably the longest operator I've ever used in a CJam program).
Here is the code:
" __
/  \
\__/"N/    e# Get a 2D character grid of the hexagon.
{          e# Read input N, repeat this block N-1 times.
  _        e#   Make a copy, so we leave the last hexagon on the stack.
  SS/\+    e#   Prepend two empty lines.
  _47>     e#   Make a copy and discard the first 47 lines.
  S3*f{\+} e#   Prepend 3 spaces to each line. This copy has been moved back to
           e#   the top and one column to the right.
  _2>      e#   Make a copy and discard another two lines.
  \@?      e#   If any lines were left after that, pick the copy in the next column,
           e#   otherwise, stay in the same column.
}q~(*
]:..e>     e# Wrap all the hexagons in an array and fold them into a single grid.
N*         e# Join them with newline characters.

Man, I really ought to learn one of these golfing languages.

@AlexVanLiew You should! :) But not because it improves your chances of winning code golf, but because CJam is a beautiful language which is fun to program in, and I don't know any other language in which the above solution (which I think is quite elegant) would have made sense. ;)

I'd probably learn Pyth or both; are they both pretty much the same thing or is one better than the rest?

@AlexVanLiew I don't know much Pyth, but I know that they are far from the same thing. CJam is a stack-based language, while Pyth originated as a shorthand for Python (but now has its own set of built-ins). Pyth might slightly have the upper hand when it comes to golfing, but I personally really enjoy programming in a different paradigm, so I'll stick with CJam.

Aha, I see. I know Python pretty well, which is why I'd like to learn Pyth, but if I get the time maybe I'll give CJam a try too!

Python 2, 219 207 chars
b=bytearray(' ');h=['__ ','/  \\','\\__/'];k=range;x=input();g=[b*50for _ in k(50)]
for i in k(x):
 c=i*3%48+1;r=(i*3+1)/48*2+i%2
 for m in k(i>15,3):n=m==0;g[r+m][c+n:c+4-n]=h[m]
print"\n".join(map(str,g))

Takes input on stdin.
Pretty much just creates a 50x50 grid of spaces of and plops the hexagons in where appropriate. After the 16th hexagon, I don't need the first row of h (the hexagon as a 2D array) so I use i>15 to start the range at 1 instead of 0. c=i*3%48+1;r=(i*3+1)/48*2+i%2 calculates the column and row I need to start at. n is a boolean but is used as an integer to fix up the bounds (since h[0] is only 3 characters to avoid overwriting stuff).
I'm pretty happy with this one, I shaved off about 50 bytes since the initial version, especially when I remembered the a[x:y]=b syntax.
Output (n=30):
  __    __    __    __    __    __    __    __
 /  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__
 \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
 /  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
 \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
    \__/  \__/  \__/  \__/  \__/  \__/  \__/
(plus 44 lines of spaces each 50 wide)

Since trailing lines of whitespace are allowed I changed the creation of g to just create 50 bytearrays instead of 3+(x>1)+x/16*2, which is the exact number of rows required, shaving off 12 bytes.

Swift 2.0, 601 591 bytes
import Cocoa
var a=Int(Process.arguments[1])!,b="/  \\__".join([String](count:9,repeatedValue:""))+"/",c="\\__/  ".join([String](count:9,repeatedValue:""))+"\\",d=c.startIndex,e=c.endIndex,j=[c.stringByReplacingOccurencesOfString("\\",withString:" ").stringByReplacingOccurencesOfString("/",withString:" ").substringToIndex(advance(d,3*a,e)),b.substringToIndex(advance(d,3*a+a%2,advance(e,-1)))]
while a>0{j+=[c.substringToIndex(advance(d,3*a+1,e)),b.substringToIndex(advance(d,3*a+(a+1)%2,e)]
a<=16 ?j+=[" "+j.removeLast().substringFromIndex(advance(d,1))]:()
a-=16}
for l in j{print(l)}

To run: swift hexagons.swift 21
Output:
 __    __    __    __    __    __    __    __
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/
   \__/  \__/

Swift's substringToIndex and stringByReplacingOccurencesOfString take up so many characters...

I don't know Swift at all, but isn't there a way to construct that repetitive string with less code?

The only way I know of to repeat a string is with stringByPaddingToLength, however in this case it would be 11 characters longer than typing out the full string.

I see Apple really likes overly verbose string concatenation. Not as bad as stringByAppendingString in Objective-C but still...

Outside of code golf this is really nice though as it makes searching for a method so much easier.

C, 238 bytes
#define h(A) c[m+A/4][n+A%4]
i,m,n;
f(a)
{
    char c[50][51];
    for(i=0;i<50;i++)for(m=0;m<51;m++)c[i][m]=m-50?32:0;
    for(;a;)
        m=a/12*2,n=a%12*3,a--%2?m=a/12*2+1,n=a%12*3+3:0,
        h(1)=h(2)=h(9)=h(10)=95,h(4)=h(11)=47,h(7)=h(8)=92;
    for(;i;)puts(c-i--+50);
}

Only necessary spaces and newlines considered for character count.
It simply creates a matrix of characters, fills them in reverse order, and then prints the whole thing.

233 bytes

JavaScript (ES6), 265 bytes
A=Array;f='forEach';U=x=1;y=0;a=A.from(A(51),_=>A.from(A(51),_=>' '));d=h=>(` __
/  \\
\\__/`.split`
`[f]((l,i)=>[...l][f]((c,j)=>{if('_/\\'.indexOf(a[x+i][y+j])<0)a[x+i][y+j]=c})),(x+=U*-2+1),(U=!U),(C-y<=3?((U=x+=2),y=0):y+=3),--h?d(h):a.map(d=>d.join``).join`
`)

Tessellates hexagons in a row, from left to right, alternating up and down—like a  honeycomb—until the end of a row is reached.
Ungolfed with description (works in firefox):

'use strict';
const CAP = 51;
var a = Array.from(Array(51), () => Array.from(Array(51),() => ' '))

function draw (hexagons, x, y, a, up) {
  // x, y (row, col) represents the current position of the cursor
  /*

    Here's a map of the first three iterations:

            01234567
     0        __
     1     __/  \__
     2    /  \__/  \
     3    \__/  \__/

    For the first 17 iterations, the cursor will be at:

      # | x | y
      ----------
      1 | 1 | 0
      2 | 0 | 3
      3 | 1 | 6
      4 | 0 | 9
      5 | 1 | 12
      6 | 0 | 15
      7 | 1 | 18
      8 | 0 | 21
      9 | 1 | 24
     10 | 0 | 27
     11 | 1 | 30
     12 | 0 | 33
     13 | 1 | 36
     14 | 0 | 39
     15 | 1 | 42
     16 | 0 | 45
     17 | 3 | 0      <- moves back to the first row

  */
` __
/  \\
\\__/`
  // split the hexagon into three lines
  .split('\n').forEach((line, index) => {
    // and for each line
    ;[...line].forEach((char, j) => {
      // if the cursor position (x, y) translated
      // by (index, j) is not already part of a hexagon
      // then replace it with the current (index, j) piece
      // of the hexagon
      /*
         0123
       0  __
       1 /  \
       2 \__/

      */
      if ('_/\\'.indexOf(a[x + index][y + j]) < 0)
        a[x + index][y + j] = char
    })
  })

  // `up` represents the next hexagon
  // if true, the next hexagon will be drawn attached to
  // the top right edge of the current hexagon
  if (up) {
    x -= 1
  // otherwise, it'll be drawn attached to the bottom right edge
  } else {
    x += 1
  }

  // move three columns to the right
  y += 3
  // change directions
  up = !up

  // if within the right boundary of the 51x51 matrix,
  // move back to the left edge and down 2 rows
  // and draw the next hexagon as an `up` hexagon
  if (51 - y <= 3) {
    y = 0
    x += 2
    up = true
  }

  // if hexagons > 0, then recurse and draw the next hexagon
  // otherwise, return the array (join the columns in each row, then join each row
  // by a new line)
  return --hexagons ?
    draw(hexagons, x, y, a, up)
    : a.map(d => d.join('')).join('\n')
}

var n = parseInt(prompt('Number to draw:'))
var r = draw(n, 1, 0, a, true)
document.write('
' + r.replace(/\n/g, '
') + '
')

Ruby, 120
->n{a=(1..50).map{' '*50}
n.times{|i|x=i%16*3
3.times{|j|a[47-i/16*2-x/3+j][x..x+3]=[' __ ','/  \\','\__/'][j]}}
puts a}

creates an array of 50 strings of 50 spaces, then substitutes 4 characters in 3 lines to add the hexagons:
" __ "
"/  \"
"\__/"

As the first line contains spaces, once a hexagon has been plotted we cannot plot another one below it, because the spaces would overwrite the previous hexagons.
Therefore the hexagons are added in the form of a 16x16 rhombus (distorted rectangle) from bottom to top, and slanting from bottom left to top right.
The string " __ " will then be overwritten with additional \ and / where neccessary.
Ungolfed in test program
g=->n{
  a=(1..50).map{' '*50}              #make an array of 50 strings of 50 spaces
  n.times{|i|                        #loop through all hexagons
    x=i%16*3                         #x coordinate of top left corner of hexagon, 16 per row
    3.times{|j|                      #loop through 3 lines to print hexagon.
      a[47-i/16*2-x/3+j][x..x+3]=    #47-i/16*2 : start at the bottom and work up. each row is 2 lines high and contains 16 hexagons. x/3 : slant upwards as the row moves right.
       [' __ ','/  \\','\__/'][j]    #These are the symbols for each of the 3 lines required for a hexagon. [x..x+3] defines which characters have to be replaced in each string.
    }
  }
  puts a                             #print to stdout
}

N=gets.to_i
g.call(N)

Typical output (n=250)
There should be a few more rows of whitespace at the top here, to make a total of 50, but I don't know if there is a way to get Stackexchange to format to include them.
                                              __
                                           __/  \
                                        __/  \__/
                                     __/  \__/  \
                            __    __/  \__/  \__/
                         __/  \__/  \__/  \__/  \
                      __/  \__/  \__/  \__/  \__/
                   __/  \__/  \__/  \__/  \__/  \
                __/  \__/  \__/  \__/  \__/  \__/
             __/  \__/  \__/  \__/  \__/  \__/  \
          __/  \__/  \__/  \__/  \__/  \__/  \__/
       __/  \__/  \__/  \__/  \__/  \__/  \__/  \
    __/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
 __/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/  \__/
/  \__/  \__/  \__/  \__/
\__/  \__/  \__/  \__/
/  \__/  \__/  \__/
\__/  \__/  \__/
/  \__/  \__/
\__/  \__/
/  \__/
\__/

source: Stack Exchange

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

sort: votes


text:
Reflections in Water
Take a string as input. This string can be as long as you'd like, however, it may only include letters and spaces––no numbers, punctuation, etc. When a word is passed into your function, an image will be made out of it. This image is the input word written out using only these characters: –, /, \, and |. You do not need to use all of these characters, but you may not use any others. Only words are inputed; no numbers or any other characters.
Here are a couple examples:
Input : "String"

Return :

 –––    –––    –––   –––  |\    |   –––
|        |    |   |   |   | \   |  |
 –––     |    |–––    |   |  \  |  | ––
    |    |    |   \   |   |   \ |  |   |
 –––     |    |    \ –––  |    \|   –––     //uppercase string written out
––––––––––––––––––––––––––––––––––––––––    //bar
                                            //line break
 –––     |    |    / –––  |    /|   –––
    |    |    |   /   |   |   / |  |   |
 –––     |    |–––    |   |  /  |  | ––
|        |    |   |   |   | /   |  |
 –––    –––    –––   –––  |/    |   –––     //uppercase string written upside-down (reflected)

After the all caps string written out, there is a bar and then a line break. After that, there is the same string, just mirrored/upside-down. The bar under the word spelled out should be the length of the written out string. The upside down word––the reflection––goes one line beneath the line break.
Here is another example:
Input : "hi"

Return :

|  |  –––
|  |   |
|––|   |
|  |   |
|  |  –––
–––––––––

|  |  –––
|  |   |
|––|   |
|  |   |
|  |  -––

A bonus challenge/addition:
Add a ripple effect. Have something like a random indent between 0 and 3 spaces before each line in the reflection. Here's an example of what it could look like:
Input : "hi"

Return :

|  |  –––
|  |   |
|––|   |
|  |   |
|  |  –––
–––––––––

 |  |  –––
 |  |   |
  |––|   |
 |  |   |
  |  |  -––

Your code should be in the following form:
function createAwesomeness(string) -> string {
    let s = //your code that creates the 'image'
    return s
}

print createAwesomeness("string")
print createAwesomeness("bananas")

A couple notes:

Every language is valid
Suggestion: Do not copy the font-set as a dictionary or array because that adds a lot to your code's size. Both as a challenge and to lower your code's size, try to use a function of sorts to create the letters
Along with your code, have:

The size in bytes of your function
The number of characters of your function
The two examples

Shortest, working code wins
There is currently no deadline

If any further explanation is needed, please tell me in the comments!
Any response is welcome and greatly appreciated!

Could you please show the complete fontset that we are supposed to use in this challange?

@Loovjo – You mean the characters, yes?

Yes, all the characters.

Anyway, instead of showing how the answer should be in a function, I would suggest just saying "You should create a function named createAwesomeness that takes the string as the only argument" or something similar.

@Loovjo - My only hesitation connected to writing font-set is that part of the challenge was writing the letters using the specific characters, not just plugging in prewritten shapes

So you're saying that the code can use any shape of characters as long as the characters looks like the Input? If so, you might want to specify that.

@Loovjo - I said that the words should be "written out using these characters: –, /, ****, and |" and that "each letter should be five characters in height. The width does not matter but it should a) be uniform wherever that same letter appears and b) should be in proportion to the height so that it resembles the letter."

@Loovjo - Whoops, part of my comment was poorly reformatted; The words should be "written out using these characters: -, /, </b>, and |"

Okay. Will the Input only consist of letters? Or both letters and numbers? All printable ascii characters? You should specify that in the question.

@Loovjo - OK. I specified in the beginning

Are letter representations for "S", "T", "R", "I", "N" and "G" other than the ones shown above also valid, or are the ones from above a fixed part of the font set to be used?

@Chiru - Yes. As I said in the instructions: All letter representations are valid provided that a) they are 5 characters high, and that b) they reasonably resemble the letter.

@Chiru - Sorry––Yes, they can be in the font-set but no, they do not have to.

Thanks. Two more questions though: (1) Must all of the characters -, /, , and | be used in the alphabet? (2) Does the input contain one word only or could it also contain more than one word (separated by a space character)?

@Chiru - Thanks for asking. (1) No. The only thing is that you can only use those four characters. No others. (2) The input can be as long as you'd like, just that it can only have letters and spaces––No numbers or other characters.

In order to avoid disputes over whether letter representations "reasonably resemble" the letter, you should mandate specific representations. (That's also probably the only way you'll get letter representations which use more than one character). With respect to the deadline: deadlines are a Bad Thing™. By all means wait a week before awarding the accepted answer, but a) there's no need to say that you will do that; b) if someone comes along later with a better answer, accept that one instead.

@PeterTaylor - (a) There is now no deadline (b) I did mandate that letters must be at least 5 chars in height. The width simply has to be proportionate to the height. The letter is valid if it follows those two size criteria and if it is obvious which letter it represents.

I'm voting to close as unclear what you're asking, since, without predefined ASCII art representations of all characters, there's no objective way to determine if a given submission is valid or not. A code golf competition like this one needs a tight specification. Otherwise, the shortest answer is just the one that generates the ugliest font.

@Dennis - I must disagree with you and I have my evidence.  Chiru has successfully answered my question. He has followed my criteria: 5 characters in height, a proportional width. He has also followed the second piece of criteria, that states that he can only use these characters: / \ - | . He has chosen to use - .

@Dennis - The only reason that I am not writing my own font-set for you all to use is that that is part of the challenge. Chiru has successfully overcome that challenge quite intelligently. Now all he has to do is start thinning it.

@Dopapp Has he? One could argue that his B, J, M, Q and W don't look like the letters should. I'm not saying his answer is invalid, but it's certainly debatable. My point is that an answer's validity shouldn't be debatable.

@Dennis - If I were to add a character set, the challenge would just be who can append characters with the least characters/bytes. That would be fairly boring/simple I think.

@Dennis I've just edited my solution to make the letter B (for starters) look as it should while still keeping the code at its length. I did indeed find it challenging enough to create an "optimal" alphabet for this purpose, and I'd love to see other alphabets and approaches than my own.

@Dopapp The issue with this question might be resolved if the community decides whose code wins, since their votes will criticize the letters' readability but reward proper esthetics, both letter- and program-wise. Readability is, by person, subjective, but if measured in a large enough set of people, becomes quite a reliable metric.

@Chiru So, you're saying it should be a [tag:popularity-contest]?

@wizzwizz4 Yes, that's the word I'm looking for. Thanks!

This would make a poor popcon (it would be an art contest) and should not be a [tag:code-golf] without a truly objective way to determine if an answer is valid.

popcon and code-golf are mutually exclusive winning criteria, by the way.

JavaScript (ECMAScript 6) (580 characters/bytes)
Probably not the best/shortest way to do this, but here's my two cents' worth:

a=x=>{l=["#####","#   #","#","  #","    #","# #","#  ##","####",""],g=[0,1,1],t=[8,8,8,8,8,0,1,...g,7,1,0,1,7,0,2,2,2,0,7,1,1,1,7,0,2,0,2,0,0,2,0,2,2,0,2,0,1,...g,...g,0,3,3,3,0,0,4,4,4,...g,5,5,1,2,2,2,2,0,0,...g,1,1,1,1,6,1,...g,1,0,0,1,0,2,2,...g,6,0,0,1,0,5,1,0,2,0,4,0,0,3,3,3,3,1,1,1,1,...g,1,1,3,1,1,1,0,...g,3,1,1,1,1,0,3,3,0,4,0,2,0],s=(n,r)=>l[t[5*n+r]].padRight(8),y=Array(10).fill("");for(r=-1,z=0;++r<5&z<x.length;r==4&&++z?r=-1:0){c=x[z].charCodeAt()&31;y[r]+=s(c,r),y[9-r]+=s(c,r)}return`${y.slice(0,5).join`
`}
${"-".repeat(y[0].length-3)}

${y.slice(5).join`
`}`}
console.log(a("string"))
console.log(a("bananas"))

Note that although this is standard ES6, this strictly requires sloppy mode (heh, get it?) which hasn't landed in all of the JS engines/transpilers yet; it'll probably be ready this winter. If anyone knows a way to run this code in a sloppy environment as of today, feel free to edit.
Well, since people still need to reproduce my output, I'll just give you the strict version that only differs in the way that it uses "let" to declare variables instead of making them globals by omitting it. Feel free to verify that I only added "let" in four places and changed nothing further. Here's the strict version that you can run today already using babel:
let a=x=>{let l=["#####","#   #","#","  #","    #","# #","#  ##","####",""],g=[0,1,1],t=[8,8,8,8,8,0,1,...g,7,1,0,1,7,0,2,2,2,0,7,1,1,1,7,0,2,0,2,0,0,2,0,2,2,0,2,0,1,...g,...g,0,3,3,3,0,0,4,4,4,...g,5,5,1,2,2,2,2,0,0,...g,1,1,1,1,6,1,...g,1,0,0,1,0,2,2,...g,6,0,0,1,0,5,1,0,2,0,4,0,0,3,3,3,3,1,1,1,1,...g,1,1,3,1,1,1,0,...g,3,1,1,1,1,0,3,3,0,4,0,2,0],s=(n,r)=>l[t[5*n+r]].rpad(8),y=Array(10).fill("");for(let r=-1,z=0;++r<5&z<x.length;r==4&&++z?r=-1:0){let c=x[z].charCodeAt()&31;y[r]+=s(c,r),y[9-r]+=s(c,r)}return`${y.slice(0,5).join`
`}
${"-".repeat(y[0].length-3)}

${y.slice(5).join`
`}`}
console.log(a("string"))
console.log(a("bananas"))

Output
The first console.log yields STRING:
#####   #####   #####   #####   #   #   #####
#         #     #   #     #     #   #   #
#####     #     #####     #     #   #   #####
    #     #     # #       #     #  ##   #   #
#####     #     #   #   #####   #   #   #####
---------------------------------------------

#####     #     #   #   #####   #   #   #####
    #     #     # #       #     #  ##   #   #
#####     #     #####     #     #   #   #####
#         #     #   #     #     #   #   #
#####   #####   #####   #####   #   #   #####

and the second console.log yields BANANAS:
####    #####   #   #   #####   #   #   #####   #####
#   #   #   #   #   #   #   #   #   #   #   #   #
#####   #####   #   #   #####   #   #   #####   #####
#   #   #   #   #  ##   #   #   #  ##   #   #       #
####    #   #   #   #   #   #   #   #   #   #   #####
-----------------------------------------------------

####    #   #   #   #   #   #   #   #   #   #   #####
#   #   #   #   #  ##   #   #   #  ##   #   #       #
#####   #####   #   #   #####   #   #   #####   #####
#   #   #   #   #   #   #   #   #   #   #   #   #
####    #####   #   #   #####   #   #   #####   #####

How it works:
My idea was to generate the the alphabet by compressing letters with respect to similar lines. Thus, every letter in the alphabet can be represented as a 5-dimensional vector of numbers that correspond to a string that again corresponds to a row in a letter.
This approach is made a lot easier when every letter has the same width, as this enables us to re-use some string patterns more effectively. With this idea in mind, I then designed a font that is optimized for similar-looking lines in letters, so that it compresses well:
#####
#   #
#####
#   #
#   #

####
#   #
#####
#   #
####

#####
#
#
#
#####

####
#   #
#   #
#   #
####

#####
#
#####
#
#####

#####
#
#####
#
#

#####
#
#####
#   #
#####

#   #
#   #
#####
#   #
#   #

#####
  #
  #
  #
#####

#####
    #
    #
    #
#####

#   #
#   #
# #
# #
#   #

#
#
#
#
#####

#####
#####
#   #
#   #
#   #

#   #
#   #
#   #
#  ##
#   #

#####
#   #
#   #
#   #
#####

#####
#   #
#####
#
#

#####
#   #
#   #
#  ##
#####

#####
#   #
#####
# #
#   #

#####
#
#####
    #
#####

#####
  #
  #
  #
  #

#   #
#   #
#   #
#   #
#####

#   #
#   #
#   #
#   #
  #

#   #
#   #
#   #
#####
#####

#   #
#   #
  #
#   #
#   #

#   #
#   #
#####
  #
  #

#####
    #
#####
#
#####

=========================================

0: #####
1: #   #
2: #
3:   #
4:     #
5: # #
6: #  ##
7: ####
8:

A = [0, 1, 0, 1, 1]
B = [7, 1, 0, 1, 7]
C = [0, 2, 2, 2, 0]
D = [7, 1, 1, 1, 7]
E = [0, 2, 0, 2 ,0]
F = [0, 2, 0, 2, 2]
G = [0, 2, 0, 1, 0]
H = [1, 1, 0, 1, 1]
I = [0, 3, 3, 3, 0]
J = [0, 4, 4, 4, 0]
K = [1, 1, 5, 5, 1]
L = [2, 2, 2, 2, 0]
M = [0, 0, 1, 1, 1]
N = [1, 1, 1, 6, 1]
O = [0, 1, 1, 1, 0]
P = [0, 1, 0, 2, 2]
Q = [0, 1, 1, 6, 0]
R = [0, 1, 0, 5, 1]
S = [0, 2, 0, 4, 0]
T = [0, 3, 3, 3, 3]
U = [1, 1, 1, 1, 0]
V = [1, 1, 1, 1, 3]
W = [1, 1, 1, 0, 0]
X = [1, 1, 3, 1, 1]
Y = [1, 1, 0, 3, 3]
Z = [0, 4, 0, 2, 0]

To further assist compression, I decided to only use number signs (#) to form letters, resulting in better compression. Another great thing about this approach is that it allows me to do a very simple reflection logic, since I'm not required to transform "\" to "/". The resulting font is exceptionally ugly, but as long as it compresses well, I really don't mind about its looks.
In the end, I managed to represent every single letter of the alphabet by using eight different patterns in total (plus one additional dummy pattern for spaces). It was in my best interest to use no more than 10 different patterns (or else I'd have to pay the price of requiring two characters to write down some numbers in the code). I then serialized all letter information in an array, added a little bit of letter selection/concatenation logic, and voilà.

Would using # work better?

Yes, # looks much nicer than -. Edited, thanks!

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


text:
Summation under Zeckendorf Representation
Zeckendorf's theorem shows that every positive integer can be uniquely represented as a sum of non-adjacent Fibonacci numbers. In this challenge, you have to compute the sum of two numbers in Zeckendorf representation.

Let Fn be the n-th Fibonacci number where

F1 = 1,
  F2 = 2  and
  for all k > 2, Fk = Fk - 1 + Fk - 2.

The Zeckendorf representation Z(n) of a non-negative integer n is a set of positive integers such that

n = Σi ∈ Z(n) Fi  and
  ∀i ∈ Z(n) i + 1 ∉ Z(n).

(in prosa: the Zeckendorf representation of a number n is a set of positive integers such that the Fibonacci numbers for these indices sum up to n and no two adjacent integers are part of that set)
Notably, the Zeckendorf representation is unique. Here are some examples for Zeckendorf representations:

Z(0) = ∅ (the empty set)
  Z(1) = {1}
  Z(2) = {2}
  Z(3) = {3} ({1, 2} is not the Zeckendorf representation of 3)
  Z(10) = {5, 2}
  Z(100) = {3, 5, 10}

In this challenge, Zeckendorf representations are encoded as bit sets where the least significant bit represents if 1 is part of the set, etc. You may assume that the Zeckendorf representations of both input and output fit into 31 bits.
Your task is to compute Z(n + m) given Z(n) and Z(m). The solution with the shortest length in octets wins.
You can find a reference implementation written in ANSI C here. It can also be used to generate Zeckendorf representations or compute a number from its Zeckendorf representation.
Here are some pairs of sample input and output, where the first two columns contain the input and the third column contains the output:
73865           9077257         9478805
139808          287648018       287965250
34              279004309       279004425
139940          68437025        69241105
272794768       1051152         273846948
16405           78284865        83888256
9576577         4718601         19013770
269128740       591914          270574722
8410276         2768969         11184785
16384           340             16724

Could you please elaborate the Input/Output?

@flawr Please have a look at the provided reference implementation. You can use it to generate your own sample input.

I'd be happy if you could document here exactly what you want and provide some examples, as I am, and perhaps others are too, not fluent in C.

I disagree with the uniqueness argument. Since the Fibonacci sequence starts with 1, 1, 2 you can clearly decompose 3 into F0 + F2 = 1 + 2 = 3. F0 and F2 are not adjacent.

@orlp The Fibonacci sequence defined here starts with F1=1 and F2=2. So the way I read it, F0 from your definition is not part of the sequence used here.

@RetoKoradi F(0) follows from the formula F(k) = F(k - 1) + F(k - 2) when evaluating for k = 2. If the sequence doesn't start with 1 1 2, then the sequence isn't the Fibonacci sequence anyway.

@orlp The Fibonacci numbers with indices smaller than 1 are not considered in this representation.

@flawr Let me add some test cases just for you.

@orlp Compare the sentence “The Zeckendorf representation Z(n) of a non-negative integer n is a set of positive integers such that...”

@FUZxxl I don't understand. Either your sequence starts with 1, 1, 2, or you shouldn't call it the Fibonacci sequence. A sequence that starts with 1, 2 is similar to the Fibonacci sequence, but not actually the sequence itself. I would be ok with 'any number bigger than 3 has a unique representation', but I do not agree with calling this a result over the Fibonacci sequence, when it is clearly not. In fact, in my example above F(0) is an abomination. By definition F(1) = 1 and F(2) = 1 for the Fibonacci sequence.

@orlp The series does “start” with 1, 1, just at different indices which are not considered for the Zeckendorf representation.

@FUZxxl A core property of the Fibonacci sequence is that F(n) = (phi^n - (1 - phi)^n) / sqrt(5). This property fails for your sequence, because it is not the Fibonacci sequence. The indices matter.

K (ngn/k), 45 43 42 41 bytes
{2/<':(+/F@&+/'|2\x){y!x}\|F:64(+':1,)/0}

Try it online!
@Bubbler's algorithm
{ } function with argument x
64( )/0 do 64 times, using 0 as initial value:

1, prepend 1
+': add each prior (leave the first element intact)

F: assign to F for "fibonacci sequence"
| reverse
(..){y!x}\.. starting with the value on the left, compute cumulative remainders (left-to-right) for the list on the right. the value on the left is the plain sum of the inputs without zeckendorf representation:

2\x binary encode the inputs. this will be an nbits-by-2 matrix
| reverse
+/' sum each
& where are the 1s? - list of indices. if there are any 2s, the corresponding index is repeated twice.
F@ array indexing into F
+/ sum

<': less than each prior (the first of the result will always be falsey)
2/ binary decode

APL (Dyalog Extended), 39 bytes
⊥1↓⍧|/⌽(+/g[⍸⌽+/⊤⎕]),↑,\⌽g←(2+/,)⍣38⍨⍳2

Try it online!
Changed into a full program taking one argument of length 2, and also changed the Fibonacci generator. Thanks to @ngn for lots of ideas.
Uses ⎕IO←0 so that ⍳2 evaluates to 0 1.
Fibonacci generator (new)
Note that the last two numbers are inaccurate, but it doesn't change the output of the program.
(2+/,)⍣38⍨⍳2
→ 0 1 ((2+/,)⍣38) 0 1

Step 1
0 1 (2+/,) 0 1
→ 2+/ 0 1 0 1
→ (0+1) (1+0) (0+1) ⍝ 2+/ evaluates sums for moving window of length 2
→ 1 1 1

Step 2
0 1 (2+/,) 1 1 1
→ 2+/ 0 1 1 1 1
→ 1 2 2 2

Step 3
0 1 (2+/,) 1 2 2 2
→ 2+/ 0 1 1 2 2 2
→ 1 2 3 4 4

Zeckendorf to plain (partial)
⍸⌽+/⊤⎕
     ⎕  ⍝ Take input from stdin, must be an array of 2 numbers
    ⊤   ⍝ Convert each number to base 2; each number is mapped to a column
  +/    ⍝ Sum in row direction; add up the counts at each digit position
 ⌽      ⍝ Reverse
⍸       ⍝ Convert each number n at index i to n copies of i

APL (Dyalog Extended), 47 bytes
g←1↓(1,+\⍤,)⍣20⍨1
{⊥1↓⍧|/⌽⍵,↑,\⌽g}+⍥{+/g[⍸⌽⊤⍵]}

Try it online!
Changed Part 1 of the previous answer to reuse the Fibonacci numbers. Also, drop the duplicate 1 to save some bytes in other places.
Part 1 (new)
{+/g[⍸⌽⊤⍵]}
       ⊤⍵    ⍝ Argument to binary digits
     ⍸⌽      ⍝ Reverse and convert to indices of ones
   g[    ]   ⍝ Index into the Fibonacci array of 1,2,3,5,...
 +/          ⍝ Sum

APL (Dyalog Extended), 52 bytes
{⊥1↓¯1↓⍧|/⌽⍵,↑,\⌽(1,+\⍤,)⍣20⍨1}+⍥({+∘÷⍣(⌽⍳≢⊤⍵)⍨1}⊥⊤)

Try it online!
How it works
No fancy algorithm to do addition in Zeckendorf because APL isn't known for operation on individual elements in an array. Instead, I went ahead to convert the two inputs from Zeckendorf to plain integers, add them, and convert it back.
Part 1: Zeckendorf to plain integer
{+∘÷⍣(⌽⍳≢⊤⍵)⍨1}⊥⊤  ⍝ Zeckendorf to plain integer
                ⊤  ⍝ Convert the input to array of binary digits (X)
{    (  ≢⊤⍵)  }    ⍝ Take the length L of the binary digits and
      ⌽⍳           ⍝   generate 1,2..L backwards, so L..2,1
{+∘÷⍣(     )⍨1}    ⍝ Apply "Inverse and add 1" L..2,1 times to 1
                   ⍝ The result looks like ..8÷5 5÷3 3÷2 2 (Y)
               ⊥   ⍝ Mixed base conversion of X into base Y

Base |             Digit value
-------------------------------
13÷8 | (8÷5)×(5÷3)×(3÷2)×2 = 8
 8÷5 |       (5÷3)×(3÷2)×2 = 5
 5÷3 |             (3÷2)×2 = 3
 3÷2 |                   2 = 2
 2÷1 |                   1 = 1

Part 2: Add two plain integers
+⍥z2i  ⍝ Given left and right arguments,
       ⍝   apply z2i to each of them and add the two

Part 3: Convert the sum back to Zeckendorf
"You may assume that the Zeckendorf representations of both input and output fit into 31 bits" was pretty handy.
{⊥1↓¯1↓⍧|/⌽⍵,↑,\⌽(1,+\⍤,)⍣20⍨1}  ⍝ Convert plain integer N to Zeckendorf
                 (1,+\⍤,)⍣20⍨1   ⍝ First 41 Fibonacci numbers starting with two 1's
                ⌽                ⍝ Reverse
             ↑,\                 ⍝ Matrix of prefixes, filling empty spaces with 0's
          ⌽⍵,                    ⍝ Prepend N to each row and reverse horizontally
        |/                       ⍝ Reduce by | (residue) on each row (see below)
       ⍧                         ⍝ Nub sieve; 1 at first appearance of each number, 0 otherwise
  1↓¯1↓                          ⍝ Remove first and last item
 ⊥                               ⍝ Convert from binary digits to integer

The Fibonacci generator
(1,+\⍤,)⍣20⍨1
→ 1 ((1,+\⍤,)⍣20) 1  ⍝ Expand ⍨
→ Apply 1 (1,+\⍤,) x 20 times to 1

First iteration
1(1,+\⍤,)1
→ 1,+\1,1  ⍝ Expand the train
→ 1,1 2    ⍝ +\ is cumulative sum
→ 1 1 2    ⍝ First three Fibonacci numbers

Second iteration
1(1,+\⍤,)1 1 2
→ 1,+\1,1 1 2  ⍝ Expand the train
→ 1 1 2 3 5    ⍝ First five Fibonacci numbers

⍣20  ⍝ ... Repeat 20 times

This follows from the property of Fibonacci numbers: if Fibonacci is defined as
$$
F_0 = F_1 = 1; \forall n \ge 0, F_{n+2} = F_{n+1} + F_n
$$
then
$$
\forall n \ge 0, \sum_{i=0}^{n} F_i = F_{n+2} - 1
$$
So cumulative sum of \$ 1,F_0, \cdots, F_n \$ (Fibonacci array prepended with a 1) becomes \$ F_1, \cdots, F_{n+2} \$. Then I prepend a 1 again to get the usual Fibonacci array starting with index 0.
Fibonacci to Zeckendorf digits
Input: 7, Fibonacci: 1 1 2 3 5 8 13

Matrix
0 0 0 0 0 0 13 7
0 0 0 0 0 8 13 7
0 0 0 0 5 8 13 7
0 0 0 3 5 8 13 7
0 0 2 3 5 8 13 7
0 1 2 3 5 8 13 7
1 1 2 3 5 8 13 7

Reduction by residue (|/)
- Right side always binds first.
- x|y is equivalent to y%x in other languages.
- 0|y is defined as y, so leading zeros are ignored.
- So we're effectively doing cumulative scan from the right.
0 0 0 0 0 0 13 7 → 13|7 = 7
0 0 0 0 0 8 13 7 →  8|7 = 7
0 0 0 0 5 8 13 7 →  5|7 = 2
0 0 0 3 5 8 13 7 →  3|2 = 2
0 0 2 3 5 8 13 7 →  2|2 = 0
0 1 2 3 5 8 13 7 →  1|0 = 0
1 1 2 3 5 8 13 7 →  1|0 = 0
Result: 7 7 2 2 0 0 0

Nub sieve (⍧): 1 0 1 0 1 0 0
1's in the middle are produced when divisor ≤ dividend
(so it contributes to a Zeckendorf digit).
But the first 1 and last 0 are meaningless.

Drop first and last (1↓¯1↓): 0 1 0 1 0
Finally, we apply base 2 to integer (⊥) to match the output format.

CJam, 76 74 70 63 59 bytes
2q~{32{2\#I&},}fI+32_,*{WUer$Kf-[UU]/[-2X]*2,/2a*Kf+}fKf#1b

Try it online in the CJam interpreter or verify all test cases at once.
Idea
We start by defining a minor variation of the sequence in the question:

G-2 = 0
G-1 = 1
Gk = Gk-1 + Gk-2 whenever k is a non-negative integer

This way, the bit 0 (LSB) of the bit arrays input or output corresponds to the Fibonacci number G0 and, in general, the bit k to Gk.
Now, we replace each set bit in Z(n) and Z(m) by the index it encodes.
For example, the input 53210 = 10000101002 gets transformed into [2 4 9].
This yields two arrays of integers, which we can concatenate to form a single one.
For example, if n = m = 100, the result is A := [2 4 9 2 4 9].
If we replace each k in A by Gk and add the results, we obtain n + m = 200, so A is a way to decompose 200 into Fibonacci numbers, but certainly not the one from Zeckendorf's theorem.
Keeping in mind that Gk + Gk+1 = Gk+2 and Gk + Gk = Gk + Gk-1 + Gk-2 = Gk+1 + Gk-2, we can substitute consecutive and duplicated indexes by others (namely, (k, k + 1) by k + 2 and (k, k) by (k + 1, k - 2)), repeating those substitutions over and over until the Zeckendorf representation is reached.1
Special case has to be taken for resulting negative indexes. Since G-2 = 0, index -2 can simply be ignored. Also, G-1 = 0 = G0, so any resulting -1 has to be replaced by 0.
For our example A, we obtain the following (sorted) representations, the last being the Zeckendorf representation.
[2 2 4 4 9 9] → [0 3 4 4 9 9] → [0 5 4 9 9] → [0 6 9 9] → [0 6 7 10] → [0 8 10]
Finally, we convert back from array of integers to bit array.
Code
2             e# Push a 2 we'll need later.
q~            e# Read and evaluate the input.
{             e# For each integer I in the input:
  32{         e#   Filter [0 ... 31]; for each J:
    2\#       e#     Compute 2**J.
    I&        e#     Compute its logical AND with I.
  },          e#   Keep J if the result in truthy (non-zero).
}fI           e#
+             e# Concatenate the resulting arrays.
32_,*         e# Repeat [0 ... 31] 32 times.
{             e# For each K:
  WUer        e#   Replace -1's with 0's.
  $           e#   Sort.
  Kf-         e#   Subtract K from each element.
  [UU]/[-2X]* e#   Replace subarrays [0 0] with [-2 1].
  2,/2a*      e#   Replace subarrays [0 1] with [2].
  Kf+         e#   Add K to each element.
}fK           e#
f#            e# Replace each K with 2**K.
1b            e# Cast all to integer (discards 2**-2) and sum.

1 The implementation attempts substituting 32 times and does not check if the Zeckendorf representation has in fact been reached. I do not have a formal proof that this is sufficient, but I've tested all possible sums of 15-bit representations (whose sums' representations require up to 17 bits) and 6 repetitions was enough for all of them. In any case, augmenting the number of repetitions to 99 is possible without incrementing the byte count, but it would cripple performance.

Haskell, 325 396 bytes
EDIT: new version:
s f[]=[]
s f l=f l
x((a:b):(c:d):(e:r))=x(b:d:(a:e):r)
x(a:b:((c:d:e):r))=x((c:a):b:e:((d:s head r):s tail r))
x[]=[]
x(a:r)=a:x r
w l|x l/=l=w.x$l|True=l
l=length
t n x=take n$repeat x
j 0=[]
j n=t(mod(n)2)1:j(div(n)2)
i n=[[],[]]++j n++t(32-(l$j n))[]
u[]=0
u(a:r)=2*u r+l a
o(_:a:r)=u r+l a
z a b=o$w$zipWith(++)(i a)(i b)

z does the job.

Some stuff can get shortened straight away - for example function has the highest precedence, so you can gut rid of parents around function applications, and also guards don't need parents either - guards stop where the = is, so parents there aren't needed, and so on and so forth, and note that : associates to the right and you can cut some there.                     But, anyways, congrats! Looks greatly complicated. Can't wait to figure out how this works!

@proudhaskeller Uselessly complicated, though, see my edit. Shall I explain the basic idea? It might be better another way, but I tried to do as much pattern matching as possible at first. Ah, by parents you mean parentheses: golf'd that!

chillax, it's on of your first times here. If you stay long, you will grow much better. Be sure to check the Haskell golfing tips question for some insight http://codegolf.stackexchange.com/questions/19255/tips-for-golfing-in-haskell

@proudhaskeller edit arrived...

ES6, 130 bytes
(n,m)=>{for(a={},s=0,i=x=y=1;i<<1;i+=i,z=y,y=x,x+=z)s+=((n&i)+(m&i))/i*(a[i]=x);for(r=0;i;i>>>=1)s>=a[i]?(s-=a[i],r|=i):0;return r}

I originally tried to compute the sum in-place (effectively along the lines of the CJam implementation) but I kept running out of temporaries, so I just converted the numbers to and back from real integers.
(Yes, I can probably save a byte by using eval.)

Ruby, 85 73 65 bytes
->*a{r=(0..2*a.sum).select{|r|r^r*2==r*3};r[a.sum{|w|r.index w}]}

Try it online!
How?
First get an upper bound for the encoded sum: (a+b)*2 is ok.
Now filter out all non-zeckendorf numbers from (0..limit).
We have a lookup table, it's downhill from here.

Python 3, 207 bytes
def s(n):
 p=1
 while n>=2*p:
  p*=2
 return n if n<=p else s(n+p//2)if n>=3*p/2 else s(m)if (m:=s(n-p)+p)!= n else n
a=lambda n,m:(b:=n&m)>-1 and s(a(a(a(s((n|m)-b%4),b//4*2),b//4),b%4*2+b%4//2))if m else n

Try it Online! (Verify all test cases)
Explanation
This program directly manipulates the binary translations of the Zeckendorf representations. The function a(n,m) performs the main calculations, and s(n) is a helper function that gets rid of adjacent numbers contained in the Zeckendorf representation.
Let's start with the function s(n) (expanded for clarity):
def s(n):
    p=1                  #This finds the highest digit of the binary form of n.
    while n>=2*p:
        p*=2
    if n<=p:             #If n is a power of two (i.e, our number is already a Fibonnaci number)...
        return n         #Then return it normally.  This also works for zero. (A)
    if n>=3*p/2:         #If n's first digit is followed by a 1 (i.e, it starts with 11X)
        return s(n+p//2) #Then replace that with 100X (B)
    m = s(n-p)+p         #Otherwise, apply s to the rest of the number (C)
    if m==n:             #If this is out final result, we're done! (D)
        return n
    return s(m)          #Otherwise, reapply it. (E)

For example, the number 107 (1101011 in binary, representing 1+2+5+13+21=42), undergoes the following process:
1+2+5+13+21 [1101011] -> 1+2+5+34 [10001011] (B)
1+2+5+34 [10001011] (C)
 1+2+5 [1011] (C)
  1+2 [11] -> 3 [100] (B)
 ->3+5 [1100] (A/E)
 (E):  3+5 [1100] -> 8 [10000] (B)
->8+34 [10010000] (A/E)
(E): 8+34 [10010000] (C)
->8+34 [10010000] (A/E)

Try it Online!  (s with detailed output)
Here is an expanded version of a(n,m):
def a(n,m):
    if m==0:
        return n
    b=n&m
    t=s((n|m)-b%4)              #(A)
    t=a(t,b//4*2)               #(B)
    t=a(t,b//4)                 #(C)
    return s(a(t,b%4*2+b%4//2)) #(D)

This function converts the two Zeckendorf representations into four  binary numbers which are easier to combine.  Line (A) is the bitwise OR of the two binary Zeckendorf representations--these correspond to one copy of each Fibonacci number in either group. (B) and (C) are the bitwise AND of the two numbers right-shifted 1 and 2 times, respectively. We know that when the corresponding Fibonacci numbers for (B) and (C) are added together, they will be equivalent to the bitwise AND of our n and m because  F(n)=F(n-1)+F(n-2).
For example, let's say that we have the binary numbers n=101001 (corresponding to 1+5+13) and m=110110 (2+3+8+13).  Then we will have (A)=111111 (1+2+3+5+8+13), which is converted to 1010100 (3+8+21) by our function s, (B)=10000 (8), and (C)=1000 (5).  We can check that (1+5+13)+(2+3+8+13)=(3+8+21)+(8)+(5)=45.  This process repeats with ((3+8+21)+(8))+(5)=((3+8+21)+(5)+(3))+(5), etc.
The one difficulty with this system is that it doesn't work for the Fibonacci numbers 1 and 2, since they don't obey the property F(n)=F(n-1)+F(n-2) (they're the lowest two numbers)!  Because of that, whenever 1 or 2 is contained in both n and m, they are removed from A, B, and C, then their sum placed in D under the property that 1+1=2 and 2+2=1+3.  For example, if we add 1+3 (101) + 1+3+5 (1101), we get:
(A): 3+5 (1100) = 8 (10000)
(B): 2 (10)
(C): 1 (1)
(D): 2 (10)
Notice that the 3 and 5 were placed into A, the duplicate 3 was split into 2+1 in B and C, and duplicate 1s were removed from A, B, and C, added together, and put into D.  Similarly, if we add 2+3 (110) + 2+3+5 (1110), we get:
(A): 3+5 (1100) = 8 (10000)
(B): 2 (10)
(C): 1 (1)
(D): 1+3 (101)
Try it online! (a with detailed output)

Wolfram Language (Mathematica), 218 bytes
Fold[#+##&,Total@PadLeft@IntegerDigits[#,2]//.{{p=n_/;n>1,r=y___}:>{0,n,y},{q=x___,i_,p,j_,k_,r}:>{x,i+1,n-2,j,k+1,y},{q,i_,p,j_}:>{x,i+1,n-2,j+1},{q,i_,p}:>{x,i+1,n-2},{1,1,r}:>{1,0,0,y},{q,i_,1,1,r}:>{x,i+1,0,0,y}}]&

Try it online!
Simply pattern matching.
Ungolfed:
FromDigits[Total@PadLeft@IntegerDigits[#, 2] //.
   {{n_ /; n > 1, y___} :> {0, n, y},
    {x___, i_, n_ /; n > 1, j_, k_, y___} :> {x, i + 1, n - 2, j, k + 1, y},
    {x___, i_, n_ /; n > 1, j_} :> {x, i + 1, n - 2, j + 1},
    {x___, i_, n_ /; n > 1} :> {x, i + 1, n - 2},
    {1, 1, y___} :> {1, 0, 0, y},
    {x___, i_, 1, 1, y___} :> {x, i + 1, 0, 0, y}}, 2] &

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


text:
Brainf*** code golf challenge - write a Brainf*** program that searches for the first non-zero cell
The challenge is to write a brainf*** program that searches sequentially through memory for the first NON-zero cell.
The program should start somewhere in fairly low memory (there will probably be some overhead/counters/etc.). Once the program starts checking cells, it should continue to the right, checking every cell in sequence until it reaches the first non-zero cell, then stop.
Testing will be performed for several random cells and values. Examples might look like: m(13) = 1, or m(144) = 137, or m(983) = 231. The actual values will be randomly generated once and used for all entries. The cell values of 1 and 255 will also be tested.
Scoring - different from the usual
- code golf, lowest score wins
- in the case of a tie, earlier entry wins
- any continuous series of identical commands that changes pointer position or cell value counts as 1 point.
>                           1 point
> >                         1 point
> > > > > > > > > > > > > > > > > > > > > > > > > > 1 point
< < < < < < < < < < <       1 point
+ + + + + +                 1 point
- -                         1 point

[       opening a loop = 1 point

]       closing a loop required, so 0 points

one point for EACH input or output
. .             2 points
. . . . . .     6 points
,               1 point
, ,             2 points (not that anyone would ever do this)

The python 3 program I will use for scoring is found here:
http://pastebin.com/RJi72BHa

Welcome to PPCG. We tend to prefer challenges that are not language specific. The language restriction means this challenge has a most definite shortest answer, which is rather limiting. Also I'm a little confused by the idea of a brainfuck program searching memory. Brainfuck is normally run as a virtual machine whose memory is set to all zeroes at the start. Do you have or know of a brainfuck interpreter that allows data to be poked into the memory before running? also, where in the memory can the submitted brainfuck program store its own variables?

Thanks for your questions. I knew this one would be a confusing one to ask. So I will try to clarify. This question only makes sense for BF, any other language and it wouldn't be an issue. What got me wondering about this is: you have probably seen the simple example of BF code [>] that is go through memory and stop on the first zero cell. Well I wanted to write the opposite version. Go through memory with an unknown series of zero cells and stop on the first non-zero cell. As for testing programs, I will place a random value (1-255) somewhere in a random cell. All of the cells before it ...

...will be zero. So a valid program will start at the first available cell (to the right of the program itself) and if zero, continue checking to the right, maybe for hundreds of cells, until the first non-zero cell is found.

Also, this is regular vanilla BF, so where you store your variables? That's what BF is all about.

Do you want it to output the first non-zero cell, or just find it? Can it change the value there, or must it remain the same? Does the state of the tape at the end matter at all, or is the position of the pointer the only thing that matters?

@BrainSteel the location of the first non-zero cell would be more relevant, but that's a way, way more difficult problem. And it would need some boundaries on how long the memory was.

@vihan  Consensus is that we do not censor language names. Brainfuck is the correct name for this language, and it is only profane if you insist on viewing it that way. In any case the profane part of the name is not insulting to any particular group, so should not cause offence among adults.  http://meta.codegolf.stackexchange.com/q/1136/15599 . This type of censorship makes the questions less searchable. Anyway I have decided not to roll back your edit as it would be yet another pointless edit, but please bear this in mind in future.

@steveverrill Although it is not offensive for humans, entreprises' proxies (word blacklist) happen to find it offensive, which means the page can't be accessed without overpassing security...

@Thrax that point was mentioned in one of the answers to the meta question I linked. I'm still against censoring it. You shouldn't be using your work computer to access Programming Puzzles and Code Golf anyway. I never do ;-)

Do we just have to move the pointer to the first non-zero cell, or do we have to do something special to it?

11 24 Points
Edit: Now, we do not change the value that is there and do not output it. This now behaves as expected for 255 as well.
+[-[[-<<+>>]<<+>>-<]>+]-<<[->>+<<]>>

This program searches for the first non-zero byte and exits. We expect the first value pointed at to be 0, and we require that the pointer be at least at cell 1 to begin with ("The program should start somewhere in fairly low memory").
Here's a little test, no funky interpreter required:
[ Search for the first non-zero cell            ]
[ http://codegolf.stackexchange.com/q/54432/31054   ]

[We require moving one cell to the right from the left end ] >

[Testing code: ]
>>>>>>>>> [... any number of > ...] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
[ASCII code '0'] ++++++[-<++++++++>]
<<<<<<<<< [... the same number of < ...] <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

[Find it and stop:  ]
+[-[[-<<+>>]<<+>>-<]>+]-<<[->>+<<]>>

>[Output, for checking: ]<
.

Example run:
~ Me$ bf f.bf
0

It's not entirely clear from the spec whether or not you can guarantee that the head starts at a 0-byte, but this solution will output nothing if the head starts at a 255 byte.

@ymbirtt Yeah, I noticed that. I'm still not entirely sure what should be output (if anything) anyway, so I decided to leave it unless a62 told me it was broken. I may make a longer solution for all the edge cases when I have time.

Nothing needs to be output or input, just find. The description in the code section is just to explain how the scoring works.

The value should not change the value once it is found.

The location of the pointer will be examined when the program ends, it should be on the cell with the non-zero value.

Boundaries - there should be no inherent limit for how far it can search.

@a62 Is there a guarantee that the initial value pointed to is 0?

@BrainSteel and ymbirtt, sorry, I misunderstood, Ideally the program would stop immediately if it started actually on a cell with a non-zero value, but it is acceptable if the program requires at least one zero cell.

@a62 regarding "the value shound not change the value once it is found": this was not stated anywhere when this answer was posted, and still isn't edited into the question. This very clever answer was valid according to the rules at the time. Changing or adding rules is considered bad form. This actually makes writing a challenge very hard. You can post your next one at http://meta.codegolf.stackexchange.com/q/2140/15599 to try to get some feedback before posting.

@a62 Please edit the question to clarify these rules. Since I have the only answer, I will happily edit the answer to comply with these new rules, so little damage is done.

I did not specify in the original description that something should be printed or that the value can change, and yet these are points of confusion. It is difficult to anticipate how things will be interpreted. I expected that most of the confusion would be about my unique scoring method, but no problem there. In the event that I create another challenge, I will certainly make use of that link to get feedback.

Since it is bad form to change the rules after submitting a challenge I'm going to have to go with not changing the original spec. This reverses a couple of the 'clarifications' I made. Result: If you wrote a program that you feel covers the specs, then it will be acceptable.

Command count:  12
Golf score:  10
+[-[<-<]>+]>
This is my first attempt for a Brainfuck program
This seems to work fine. the program was inspired from the answer of Brainsteel(Though seems to be highly optimized and hardly the same program)
My first attempt(Without brainsteels answer also it solves the negative 1 problem in brainsteel and my answer) was:
+[>[[<+>-]>]<[->+<]>]<<[->+<]>-
With Command count:  31
Golf score:  25

18 bytes, 15 points
>+[>[<-]<[->+<]>]>

Code requires to have at least two 0s before searched value.
It finds any number, even -1 and doesn't change it.

12 bytes, 8 points
+[-->>[<]<+]

Does not change the non-0 cell value
Does not work if the non-0 cell is the 1st or 2nd cell
Stops on the second cell before the non-0 cell (e.g. [][][pointer][][non-0][][])

or...
+[-->>[<]<+]>> (14b 9pts) which will stop on the non-0 cell

Here is my attempt. After doing it, I see that it is similar to other entries.
+[-[[-]>-<]>+]<   has 15 commands not including part that puts number in memory

             does not maintain original value
             stops at P for value 1~254
             stops at P-1 for value = 255