text:
Iterative binary search
Binary search is an algorithm that looks for an element in a sorted data-structure by constantly dividing the search space in half.
Rosetta Code

A binary search divides a range of values into halves, and continues to narrow down the field of search until the unknown value is found. It is the classic example of a "divide and conquer" algorithm.

Wikipedia

In computer science, a binary search or half-interval search algorithm finds the position of a target value within a sorted array. The binary search algorithm can be classified as a dichotomic divide-and-conquer search algorithm and executes in logarithmic time.

Smallest # of bytes wins
Clarifications

Example of calling the function/lambda/macro should be included, but don't count those chars!
Output should be > -1 if found, and <=-1 otherwise
import binary_search (20 bytes) DOES NOT count!
Implementation should run in O(log n), as algorithm dictates

Also see the code-golf StackExchange FAQ.
Example
> binary_search([1,3,5,6,7,8,8,10], 5);
4
> binary_search([1,3,5,6,7,8,8,10], 543);
-1

Does our implementation have to be exactly as binary search does it? Does is have to be logarithmic time?

Can the list have repeats? Are the entries whole numbers? You should give an example that doesn't have all consecutive values.

@xnor: Thanks for your comments, clarified.

Regarding your comments on some of the answers: 1. That's not a FAQ; it's the code-golf tag wiki. Also, there are two ordered lists on that page, and both have a 5th item. 2. Have built-in-to-some-languages solutions excluded is a suggestion that you exclude built-ins when writing up your challenge. That's all it is: a suggestion, not a rule. Built-ins are not forbidden by default, and the second revision of your question doesn't include the word implementation.

Last but not least, please consider using less exclamation points, less bold text and a different tone when dealing with submissions to your challenge. It's a little off-putting, and certainly no incentive to participate in one of your challenges.

Why should the search be iterative ?

JavaScript (94 bytes)
(a,e)=>{u=a.length,m=0;for(l=0;l<=u;)e>a[m=(l+u)>>1]?l=m+1:u=e==a[m]?-2:m-1;return u==-2?m:-1}

Expanded out a little so you can see what's going on:
function binary_search(array, elem) {
    let u = array.length, m;
    for (let l = 0; l <= u;)
        if (elem > array[(m = (l + u) >> 1)]) l = m + 1;
        else u = (elem == array[m]) ? -2 : m - 1;
    return (u == -2) ? m : -1;
}

Example usage:
> a = [1,2,3,4,5,6,7,8,9,10]
> binary_search(a, 5)
4
> binary_search(a, 15)
-1

C – 119 115 bytes
Iterative solution at 119 bytes:
f(a,x,l,h)int*a,x,l,h;{while(l<h){int m=(h+l)/2;if(a[m]>x)h=m;else if(a[m]<x)l=m+1;else return m;}return a[l]==x?l:-1;}

Recursive solution at 115 bytes:
f(a,x,l,h)int*a,x,l,h;{if(l==h)return a[l]==x?l:-1;int m=(h+l)/2;return a[m]>x?f(a,x,l,m):(a[m]<x?f(a,x,m+1,h):m);}

You can precede with int  to prevent compiler warnings or if you're using gcc compile with -Wno-implicit-int. Sample:
#include <stdio.h>

f(a,x,l,h)int*a,x,l,h;{while(l<h){int m=(h+l)/2;if(a[m]>x)h=m;else if(a[m]<x)l=m+1;else return m;}return a[l]==x?l:-1;}

int main()
{
    int x, a[] = {-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10};

    for (x = -15; x <= 15; x++)
        printf("%d\t%d\n", x, f(a, x, 0, 10));

    return 0;
}

-Wno-implicit-int is our friend :) - Nice little solution you've written, but unfortunately it's recursive… if you get the chance an iterative equivalent would be great! - Otherwise I'll have to 1 up you with a C solution of my own :3

@AT – Added at a penalty of 4 additional bytes!

Looking good! - +1 - Though that initialization is a bit weird, I feel that a swap to C++ would save 4 bytes right off the bat :O

Python 112 bytes
def b(A,k):
 l,h=0,len(A)
 while l<h:
  m=(l+h)/2
  if A[m]>k:h=m
  elif A[m]<k:l=m+1
  else:return m
 return -1

Example:
print b([1,3,5,6,7,8,8,10], 5)
2

Rather neat! - I keep trying to improve it, but haven't saved a character yet >.< - +1

Prolog, 146 bytes
I made the assumption that a program returning easy to understand truthy/falsy values is OK, as adding code just to return -1/1 instead of true/false in a code-golf challenge seems counter-productive.
So the program returns true if the value is present in the list, otherwise false.
s(F,S,L):-append(F,S,L),length(F,G),length(S,T),T>=G,T-G<2.
c(L,X):-s(_,[X|_],L).
c(L,X):-s(_,[M|T],L),X>M,c(T,X).
c(L,X):-s(F,[_|_],L),c(F,X).

How it works
s(F,S,L):-append(F,S,L),length(F,G),length(S,T),T>=G,T-G<2.

Helper function that takes the list L and splits it in the middle into the lists F and S where F is the lower part of the list.
If L has an odd number of elements, S is one element larger than F.
c(L,X):-s(_,[X|_],L).

Succeeds if the sought after element X is in the middle of list L.
c(L,X):-s(_,[M|T],L),X>M,c(T,X).

Checks for X in the higher part of the list if X is bigger than the middle element of list L.
c(L,X):-s(F,[_|_],L),c(F,X).

Checks for X in the lower part of the list if X is smaller than the middle element of list L.
As the previous predicates are checked first we can save a few bytes by not doing a comparison here.
Examples:
> c([1,3,5,6,7,8,8,10],5).
true

> c([1,3,5,6,7,8,8,10],543).
false

Nice one. Sure, happy to relax the -1 condition. Haven't seen Prolog since college! :P

Common Lisp, 142 143 bytes
Having seen some of the comments about recursive vs iterative, I'd point out that in any implementation with tail-call optimization, the second (original) solution is iterative.
pure iterative, with do loop (143):
(lambda(a e)(do((l 0)(h(length a)))((<= h l)-1)(let*((m(ash(+ h l)-1))(x(aref a m)))(if(= x e)(return m)(if(< e x)(setf h m)(setf l(1+ m)))))))

(lambda (a e)
    (do ((l 0)
         (h (length a)))
        ((<= h l) -1)
      (let* ((m (ash (+ h l) -1))
             (x (aref a m)))
        (if (= x e)
            (return m)
            (if (< e x)
                (setf h m)
                (setf l (1+ m)))))))

recursive (142)
(defun b(a e &optional(l 0)(h(length a)))(if(<= h l)-1(let*((m(ash(+ h l)-1))(x(aref a m)))(if(= x e)m(if(< e x)(b a e l m)(b a e(1+ m)h))))))

(defun b (a e &optional (l 0) (h (length a)))
  (if (<= h l) -1
      (let* ((m (ash (+ h l) -1))
             (x (aref a m)))
        (if (= x e) m
            (if (< e x)
                (b a e l m)
                (b a e (1+ m) h))))))

CL-USER> (loop with array = #(1 3 5 6 7 8 8 10)
            for element in '(1 7 5 3 2 4 6)
            collect (b array element))
(0 4 2 1 -1 -1 3)

Nice work, haven't seen Lisp in ages! - Also find it amusing that the iterative vs recursive is 1 character apart… +1

AutoIt, 92 bytes
This function binary searches an array in-memory and replaces it with an integer holding the index (or -1 if not found). Array needs to be sorted to work with the binary search:
#include <Array.au3>
Func b(ByRef $a,$n)
_ArraySort($a)
$a=_ArrayBinarySearch($a,$n)
EndFunc

Testing:
Local $a = [1,2,3,4,5,6,7,8,9,10]
b($a,5)
ConsoleWrite($a & @LF)

Output: 4

I see no implementation! - See 5 in this site's FAQ. Also I've updated the question to [more] explicitly say that import binary_search doesn't count!!!

kaspersky declares autoit as a trojan unfortunately for developers

C++14, 87 85 bytes
#include<algorithm>
[](int i,auto v){return std::binary_search(begin(v),end(v),i)-1;}

Assumes a sorted data structure which has iterators as input.
Example:
#include<algorithm>
#include<iostream>

auto f = [](int i, auto v){ return std::binary_search(begin(v), end(v), i) - 1; };

int main()
{
    std::vector<int> v = { 1, 2, 3, 4, 5 };

    std::cout << f(3, v);
}

I see no implementation! - See 5 in this site's FAQ. Also I've updated the question to [more] explicitly say that import binary_search doesn't count!!!


text:
Find the Nth number whose only prime factors are 2, 3, 5, and/or 7 (humble numbers)
First post here! I recently participated in a small friendly competition and this was one of the questions:

A positive integer whose only prime factors are 2, 3, 5 or 7 is called a humble number.
The first 20 humble numbers are:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27

Write a program of function that when given a positive integer N, prints or returns the Nth humble number.
Examples
1 -> 1
11 -> 12
22 -> 30

This is code-golf so the shortest answer in bytes wins. I'm interested in seeing solutions that run in O(N) but this is not a requirement.

@Calvin'sHobbies: I thought that too, but the very last line was what made me wonder if this post was misplaced.

1 doesn't contain either one of the factors 2,3,5,7.

@mroman the linked OEIS page describes them less ambiguously as "Numbers whose prime divisors are all <= 7".

@mroman - 1 doesn't contain any prime factors that aren't 2, 3, 5, or 7. That it doesn't contain those four either isn't relevant.

source: Stack Exchange

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

sort: votes


text:
Rotate the anti-diagonals
Background
In most reasonable programming languages, it's very easy to rotate the rows or columns of a 2D array.
In this challenge, your task is to rotate the anti-diagonals instead.
Recall that the anti-diagonals of a 2D array are its 1D slices taken in the northeast direction ↗.
Input
A non-empty rectangular 2D array of single-digit numbers in any reasonable format.
Note that the array may not be a square.
Output
The same array, but with each anti-diagonal rotated one step to the right.
Example
Consider the 3x4 input array
0 1 2 3
4 5 6 7
8 9 0 1

The anti-diagonals of this array are
0
4 1
8 5 2
9 6 3
0 7
1

Their rotated versions are
0
1 4
2 8 5
3 9 6
7 0
1

Thus the correct output is
0 4 5 6
1 8 9 0
2 3 7 1

Rules and scoring
You can write a full program or a function.
It's also acceptable to write a function that modifies the input array in place, if your language allows that.
The lowest byte count wins, and standard loopholes are disallowed.
Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you want to include multiple numbers in your header (e.g. because your score is the sum of two files, or you want to list interpreter flag penalties separately, or you want to show old scores that you improved), make sure that the actual score is the last number in the header.

var QUESTION_ID=63755,OVERRIDE_USER=32014;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 commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
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

Additional test cases
Input:
4
Output:
4

Input:
5 6 1
Output:
5 6 1

Input:
0 1
6 2
Output:
0 6
1 2

Input:
6 3 0 8
4 6 1 4
6 2 3 3
9 3 0 3
Output:
6 4 6 1
3 6 2 3
0 9 3 0
8 4 3 3

Input:
5 8 2
6 7 3
2 6 1
6 0 6
6 4 1
Output:
5 6 7
8 2 6
2 6 0
3 6 4
1 6 1

Input:
9 9 4 0 6 2
2 3 2 6 4 7
1 5 9 3 1 5
0 2 6 0 4 7
Output:
9 2 3 2 6 4
9 1 5 9 3 1
4 0 2 6 0 4
0 6 2 7 5 7

CJam, 20
{z_)\zLa+(@+\.+s\,/}

Written as a function block. Try it online
Explanation:
The input can be viewed like this:

That is, we separate the top row and right column from the rest of the matrix, and consider those elements in the order shown by the arrow.
Then the output is like this:

The remaining rectangular block is moved diagonally as a whole, and the edge elements are rearranged in the order/positions showed by the new arrow.
The code does almost exactly that, except the output is first generated with the arrow going straight down (so the matrix has a tail, like the letter P), then corrected.
z      zip (transpose) the matrix
_      make a copy
)      take out the last row (right column before transposing)
\      swap with the rest of the matrix
z      transpose back
La+    append an empty row (needed for the single-column case,
        which leaves an empty matrix here)
(      take out the first row (top row without the corner)
@+     bring the right column to the top of the stack and concatenate
        obtaining an array of the edge elements (marked with the blue arrow)
\      swap with the remaining part (big white block in the diagrams)
.+     concatenate element by element
        each edge element is concatenated with a row of the white block
        after the white block runs out, the remaining elements form new rows
s      convert the whole thing to a string (concatenating all rows)
\      swap with the copy of the transposed matrix
,      get its length (number of original columns)
/      split the string into rows of that length

The Pyth answer is also 20 bytes, but yours was earlier, so I'm accepting it.

CJam, 44 43 42 40 bytes
qN/:ReeSf.*:sz1fm<{Rz,{(S-(o\}*~]{},No}h

Test it here.
Hmm, much better than my first attempt, but I have a feeling Dennis will solve this in much less anyway...
Input and output are as ASCII grids:
0123
4567
8901

gives
0456
1890
2371

Crossed out 44 is still regular 44 ;(

@TimmyD I should have waited until the end of the grace period to edit it from 47 right down to 43. :P

Yes! It's become a meme.

I FINALLY went and learned a golfing language so I could golf 4 bytes to 3 and join the link chain :)

J, 24 char
Function taking one argument.
$$<@(1&|.)/./:&;</.@i.@$

J has an operator /. called Oblique. It can't invert it, so reconstruction isn't trivial, but you can consider "listing obliques" as a permutation of the elements of the array. So we invert that permutation with /: (dyadic Sort), by putting the "listing obliques" permutation for that size (</.@i.@$) on the right and our new oblique values, rotated properly, on the left. Then we reshape this list into the old rectangular array using good old $$.
   3 4$i.10
0 1 2 3
4 5 6 7
8 9 0 1
   ($$<@(1&|.)/./:&;</.@i.@$) 3 4$i.10
0 4 5 6
1 8 9 0
2 3 7 1

Try it online.

This is peak J right here.  Well done.

J, 38 30 bytes
8 bytes saved thanks to @algorithmshark.
{./.((}.~#),~({.~#),.])}:"1@}.

The function collects the top and left edges into a list, cuts the list to two pieces of sufficient sizes and stitches them to the right and bottom of the core part.
Usage:
   ]input=.0 1 2 3, 4 5 6 7,: 8 9 0 1
0 1 2 3
4 5 6 7
8 9 0 1
   ({./.((}.~#),~({.~#),.])}:"1@}.) input
0 4 5 6
1 8 9 0
2 3 7 1

Try it online here.

Down to 30 char: {./. replaces }:@{.,{:"1, and you can save two tildes by flipping the train around: {./.((}.~#),~({.~#),.])}:"1@}..

Julia, 153 149 139 bytes
A->(length(A)>1&&((m,n)=size(A);r(X)=for i=1:n X[:,i]=reverse(X[:,i])end;r(A);for i=-m:m A[diagind(A,i)]=circshift(diag(A,i),1)end;r(A));A)

This creates an unnamed function that accepts an array and returns the input array modified in place.
Ungolfed:
# Create a function to reverse the columns of a matrix
function revcols!(X)
    for = 1:size(X, 2)
        X[:,i] = reverse(X[:,i])
    end
    return X
end

# Our main function
function zgarb!(A)
    # Only perform operations if the array isn't one element
    if length(A) > 1
        # Record the number of rows
        m = size(A, 1)

        # Reverse the columns in place
        revcols!(A)

        # Shift each diagonal
        for i = -m:m
            A[diagind(A, i)] = circshift(diag(A, i), 1)
        end

        # Reverse the columns back
        revcols!(A)
    end
    return A
end

Thanks to Martin Büttner for algorithmic advice and for saving 4 bytes!

Pyth, 20 bytes
J+PhQ.)MQ++L.(J0tQ]J

Uses Adistu's approach of removing the top row and right column, then sticking them on the left and bottom. But with mutable data structures, not transpositions.

ES6, 75 bytes
This accepts an array of arrays as a parameter and modifies it in place.
a=>{t=a.shift();a.map(r=>{t.push(r.pop());r.unshift(t.shift())});a.push(t)}

Ungolfed:
function anti_diagonal(array) {
    var temp = array.shift(); // strip off the first row
    array.forEach(row => temp.push(row.pop())); // strip off the last elements of each row
    array.forEach(row => row.unshift(temp.shift())); // distribute the elements to the beginning of each row
    array.push(temp); // the remaining elements become the last row
}

See @aditsu's diagram for further clarification.

You could save 2 bytes by changing {t.push(r.pop());r.unshift(t.shift())} to t.push(r.pop())+r.unshift(t.shift())

Octave, 85 bytes
@(a)[(b=[a(1,1:end),a(2:end,end)'])(1:(s=size(a)(1)))',[a(2:end,1:end-1);b(s+1:end)]]

I hope I could get rid of the ends.

Python 2, 113 104 94 bytes
f=lambda i,b=[]:i and[b and b[:1]+i[0][:-1]]+f(i[1:],b[1:]or i[0][:-1]+[l[-1]for l in i])or[b]

Try it online!
This is a fairly literal interpretation of @aditsu's method.
Python's syntax for treating empty lists as False helped save an extra 10 bytes.

saved 8 bytes by discarding rows as I go

More test cases

You probably don't need the 0 in [0:1]

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

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


text:
Gamma Function Golf
Given a real number t in (-10^9,13) (not including -10^9 or 13) as input, output Γ(t), also known as the Gamma function, which is defined as follows:

You may not use a built-in Gamma function to solve this task, nor may you use built-in numeric or symbolic integration functions. Your output should be accurate to 6 significant figures or within 10^-6 of the actual value, whichever is less restrictive for the given value. Python's built-in Gamma function will be used for determining the actual value. You may assume Γ(t) is defined - that is, t is either a positive real number or a non-integer negative real number - and that |Γ(t)| ≤ 10^9. Here is a reference program that you may use to get the actual values, using Python's built-in Gamma function.
Examples
1 -> 1.000000
-2.5 -> -0.945309
3.14159265 -> 2.288038
-2.71828182846 -> -0.952682
12 -> 39916800.000000
0.5 -> 1.772454
8.675309 -> 20248.386956
-10.1 -> -0.000002

Rules

This is code-golf, so shortest answer (in bytes) wins.
Standard loopholes are forbidden.
Input and output may be performed in whatever manner is considered standard for your language.
You may write a full program, a function, or anything that is normally considered a valid answer for your language

Leaderboard
The Stack Snippet at the bottom of this post generates the leaderboard from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

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

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

Please provide explicit bounds for t such that |gamma(t)|<10^9

The link is not a reference implementation,...

@sergiol Reworded it

Pyth, 21 bytes
As with my TI-BASIC answer, I haven't been able to test this with the full 8^10 iterations, but everything seems good with smaller cases.
cu*Gc^hc1HQhcQHS^8T1Q

Explanation:
                            [implicit: Q=input]
                ^8T         8**10
               S^8T         [1,2,3,...,8**10]
  *Gc^hc1HQhcQH             lambda G,H:G*(1+1/H)**Q/(1+Q/H)
                   1        Base case
 u*Gc^hc1HQhcQHS^8T1        Reduce with base case 1
c                   Q       Divide by Q

Try it here with 2000 iterations instead of 8^10.

C++14, 86 85 81 bytes
    [](auto t){auto v=1.;for(int x=1;x<1e9;++x)v*=pow(1+1./x,t)/(1+t/x);return v/t;};

I didn't spend much time on this one. I just looked an approximation that seemed the easiest to implement (in the manner of bytes). It will take some time to compute the value (since the loop is over all positive integers), but time limitation is not specified in the challenge. It is anonymous function (lambda), which takes any argument (convertible to  T on which pow(double, T) and operator/(T, int) can be called) and returns double.
Ungolfed with usage
    #include <iostream>
    int main()
    {
        auto r = [](auto t)
        {
            auto v = 1.;
            for (int x = 1; x < 1e9; ++x)
                v *= pow(1 + 1. / x, t) / (1 + t / x);
            return v / t;
        };
        std::cout << r(-2.71828182846); // outputs -0.952682
    }

@Mego Of course it is! Thanks.

So what value o you get for -10^9 and for 10^9? I first want to know how well your stuff works before you get my upvote.

@Mego Microsoft compiler does not need neither of theese includes.

@Mego Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23026 for x86

@flawr Mine program outputs 0 for gamma(-10e9) but OP stated, that only parameters, for which gamma function is defined, can be considered. gamma(10e9) returns inf, while Python's built-in Gamma function will be used for determining the actual value says OverflowError: math range error

@Mego I will do that, thanks. I changed that into 1e9, since computation time is not limited in the question.

What is the name of the approximation?

@TanMath Well, it actually is not an approximation, it's alternative definition (if the product were all the way up to the infinity). Take a look at this link

75 bytes

Minkolang 0.12, 35 34 25 bytes
n$zl8;dz;z$:r[i1+dz+$:*]N

This does halt with an error (on trying to divide by 0), but that is allowed as per Meta consensus. Add a . at the end for a program that halts normally. Try all test cases at once. (The loop iterates only 1e4 times so it would finish sooner rather than later.)
Explanation
Zereges used one of the alternative, infinite product definitions. As it turns out, the other is much more amenable to implement in Minkolang.

This is a limit as n goes to infinity, which means that I can calculate both n! and (t+n) as I go. So I take out 1/t (because 0!=1) and n^t because that one cannot be calculated sequentially without knowing the ending value of n. As it happens, because n is the limit, I can use it twice. Once as a factor in the calculation and once as the number of times to run the loop.
An sequential infinite product has to start with something, usually 1. In this case, it's n^t/t. In the body of the loop, I calculate k/(t+k) and multiply this with the product so far. At the end, the whole product has been calculated and output. This is essentially what my program does, with n high enough that the answer is precise enough.

n                            Take number from input
 $z                          Store it in the register (this is t; retrieved with z)
   l8;                       10^8 (this is n, the limit)
      d                      n,n
       z;                    n,n^t
         z$:                 n,n^t/t
            r                Reverse stack -> n^t/t,n
             [               For loop that runs n times
              i1+            k
                 d           k,k
                  z+         k,t+k
                    $:       k/(t+k)
                      *      Multiply
                       ]N    Close for loop and output as integer

As there is no ., it wraps around and starts over. However, n now produces -1 because the input is empty, which eventually leads to attempting to divide by 0, which halts the program.

Julia, 141 bytes
z->(z-=1;a=90;c(k)=(k=big(k);(-1)^(k-1)/factorial(k-1)*(a-k)^(k-.5)*exp(a-k));(z+a)^(z+.5)*exp(-z-a)*(√(2π)+sum([c(k)/(z+k)for k=1:a-1])))

This creates an unnamed lambda function that accepts a real number and returns a real number. It uses Spounge's approximation to compute Gamma.
Ungolfed:
function Γ(z::Real)
    # Spounge's approxmation is for Γ(z+1), so subtract 1
    z -= 1

    # Choose a number for the constant a, which determines the
    # bound on the error
    a = 90

    # Define a function for the sequence c_k
    function c(k::Integer)
        # Convert k to a BigInt
        k = big(k)
        return (-1)^(k-1) / factorial(k-1) * (a-k)^(k-1/2) * exp(a-k)
    end

    # Compute the approximation
    return (z+a)^(z+1/2) * exp(-z-a) * (√(2π) + sum([c(k)/(z+k) for k=1:a-1]))
end

Very, very late golf, but z->(z-=1;a=90;c(k)=(k=big(k);(-1)^~-k/factorial(k-1)*(a-k)^(k-.5)*exp(a-k));(z+a)^(z+.5)*exp(-z-a)*(√(2π)+sum(c(k)/(z+k)for k=1:a-1))) should work for 137 bytes (at least in Julia 0.6)

Python, 348 448 407 390 389 bytes
Special thanks to @Mego!
 A crossed out 448 is (almost) still a 448! :p
This is based on the Lanzcos approximation. Golfed from here
from cmath import*
C=[0.9999999999998099,676.5203681218851,-1259.1392167224028,771.3234287776531,-176.6150291621406,12.507343278686905,-0.13857109526572012,9.984369578019572e-6,1.5056327351493116e-7]
def g(z):
 z-=1;if z.real<0.5:return pi/(sin(pi*z)*gamma(1-z))
 else:
  x=C[0]
  for i in range(1,9):x+=C[i]/(z+i)
  t=z+7.5;return sqrt(2*pi)*t**(z+0.5)*exp(-t)*x

Please golf your submission by, at a minimum, removing whitespace (the spaces before and after -= and in import * for example) and using a one-character function name. Also note that you only need to support real input.

@ThomasKwa I have edited it. My original version did not work, here is a newer one.

@Mego edited...

This causes a recursion error - remove the z-=1; in the first line of gamma to fix it. You should also rename gamma to g for bytes saves and to avoid naming conflicts with cmath.gamma. Also drop the extraneous leading zeroes.

Japt, 45 bytes
Japt is a shortened version of JavaScript. Interpreter
$for(V=X=1;X<1e9;)$V*=(1+1/X pU /(1+U/X++;V/U

Of course, 1e9 = 1,000,000,000 iterations takes forever, so for testing, try replacing the 9 with a 6. (1e6 is accurate to ~5 significant figures. Using 1e8 on an input of 12 is enough to get the first six.)
Test-case results: (using 1e7 precision)
       1:  1
    -2.5: -0.9453083...
      pi:  2.2880370...
      -e: -0.9526812...
      12:  39916536.5...
     0.5:  1.7724538...
8.675309:  20248.319...
   -10.1: -0.0000022...

How it works
         // Implicit: U = input number
$for(    // Ordinary for loop.
V=X=1;   //  Set V and X to 1.
X<1e9;)$ //  Repeat while X is less than 1e9.
V*=      // Multiply V by:
(1+1/X   //  1 plus (1 over X),
pU /     //  to the power of U, divided by
(1+U/X++ //  1 plus (U over X). Increment X by 1.
;V/U     // Output the result of (V over U).

Python 3, 74 68 78 73 bytes
Thanks @Mego and @xnor
This is a translation of the C++ answer by Zereges. Basically, this is an alternate definition of the gamma function, hence more accurate (and what is great is that is uses less bytes!)
I am sorry for all the mistakes!
def g(z,v=1):
 for i in range(1,10**9):v*=(1+1/i)**z/(1+z/i)
 return v/z

The +1 on the range doesn't matter when you are dealing with billions. Also, you should specify that this is Python 3 - you'd need from __future__ import division for float division and a few terabytes of RAM to deal with the fact that range returns a list in Python 2. Plus, you can replace the 1.0s with 1s and shave off 4 bytes.

@TanMath: ^ is xor, didn't you mean ** as for exponentiation?

int(1e9) is just 10**9, and you don't need the parens around (1+1/i)**z.

TI-BASIC, 35 bytes
Input Z
1
For(I,1,ᴇ9
Ans(1+I⁻¹)^Z/(1+Z/I
End
Ans/Z

This uses the same algorithm as Zereges.
Caveat: I haven't actually tested this with the full 1e9 iterations; based on the time taken for smaller values, I expect the runtime to be on the order of months. However, it appears to converge, and there should be no problems with rounding errors. TI stores numbers as decimal floats with 14 digits of precision.

You didn't test it?!

@TanMath I would, but I need my calculator for a final exam next month.

APL (Dyalog Unicode), 13 bytes
1e8∘(*÷⊣!+)÷⊢

Try it online!
The above code uses the ! function, but it is used as generalized binomial coefficient, not factorial. A version without the ! symbol altogether:
APL (Dyalog Unicode), 20 bytes
1e8∘(*×(×/⊢÷+)∘⍳⍨)÷⊢

Try it online!
In both cases, 1e7 is used instead of 1e8 to show that the actual values calculated are close enough to the true values.
How it works: the math
Uses the formula used in TanMath's Python answer and therefore Zereges' C++ answer.
Basically, the solutions by TanMath/Zereges compute the following, which I developed further to suit better to APL:
$$
\begin{align}
\Gamma(x) &\approx \frac1x \prod_{i=1}^{n}{\Bigl(1+\frac{1}{i}\Bigr)^x \div \Bigl(1+\frac{x}{i}\Bigr)} \\
&= \frac1x \prod_{i=1}^{n}{\Bigl(\frac{i+1}{i}\Bigr)^x \times \Bigl(\frac{i}{x+i}\Bigr)} \\
&= \frac1x \Bigl(\prod_{i=1}^{n}{\frac{i+1}{i}}\Bigr)^x \times \prod_{i=1}^{n}{\Bigl(\frac{i}{x+i}\Bigr)} \\
&\approx \frac{n^x}x \times \prod_{i=1}^{n}{\Bigl(\frac{i}{x+i}\Bigr)} \tag{1}\label{eq1}\\
&= \frac{n^x}x \div \binom{x+n}{n} \tag{2}\label{eq2}\\
\end{align}
$$
The second solution uses equation \$\eqref{eq1}\$ while the first uses equation \$\eqref{eq2}\$, both using \$n=10^8\$ in order to get enough precision.
How it works: the code
1e8∘(*÷⊣!+)÷⊢  ⍝ Input←x; n←1e8
1e8∘(    +)    ⍝ n+x
       ⊣!      ⍝ binom(n+x, n)
     *÷        ⍝ n^x ÷ binom(n+x, n)
           ÷⊢  ⍝ Divide by x

1e8∘(*×(×/⊢÷+)∘⍳⍨)÷⊢  ⍝ Input←x; n←1e8
1e8∘(  (     )∘⍳⍨)    ⍝ Generate 1..n; for each i in 1..n,
          ⊢÷+         ⍝ i÷(x+i)
        ×/            ⍝ Product over all i
     *×               ⍝ Multiply n^x
                  ÷⊢  ⍝ Divide by x

Julia, 41 bytes
x->prod([(1+1/i)^x/(1+x/i)for i=1:1E7])/x

This is a translation of Zereges' C++ answer. While my other Julia answer finishes instantaneously, this is rather slow. It computes the test cases in a couple seconds each on my computer.
Ungolfed:
function f(x::Real)
    prod([(1 + 1/i)^x / (1 + x/i) for i = 1:1E7]) / x
end

Mathematica, 40 bytes
NProduct[(1+1/n)^#/(1+#/n),{n,1,∞}]/#&

Prolog, 114 bytes
This is a translation of Zereges' C++ answer.
q(F,F,V,Z):-X is V/Z,write(X).
q(F,T,V,Z):-W is(1+1/F)**Z/(1+Z/F)*V,I is F+1,q(I,T,W,Z).
p(N):-q(1.0,1e9,1,N),!.

Try it out online here
Run it with a query of the form:
p(12).

Running it with 1e9 recursions takes about 15 minutes.
If you decrease it to 1e6 it takes about 1 second which makes for easier (but less acurate) testing.
Running it in an interpreter on you computer/laptop is most likely faster for most people as well.


text:
Convert Brainfuck to another language!
The Task
Write the shortest program, that accepts script in brainfuck from STDIN (or equivalent) and outputs to STDOUT (or equivalent) a program written in the SAME language you're using.
For example, if you write in Java, with the input
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

The output can be
public class B {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Brainfuck, 5 bytes
+[,.]

This sentence circumvents the 30 char answer requirement.


text:
Pentomino Validator
As someone who can't be bothered to look at their pentominos to see if it makes a rectangular shape, I've decided to make you write a program that does it.
Your task
Given some input split by newlines containing 12 unique characters, decide if it is a valid solution.
A valid solution MUST

Have 5 of each character (except newlines)
Each set of characters must be fully connected
Each set of characters must have a unique shape
Be in a regular rectangular shape

If it is a valid solution, output a truthy value, otherwise output a falsy value.
Your program may be a function or a full program but must take the input from stdin and output to stdout.
Test cases
Valid solutions
000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!

00.@@@ccccF111//=---
0...@@c))FFF1//8===-
00.ttttt)))F1/8888=-

Invalid configurations
invalid (doesn't contain 12 unique characters)

111112222233333444445555566666
77777888889999900000qqqqqwwwww (Each set has the same shape)

1234567890qw
w1234567890q
qw1234567890
0qw123456789
90qw12345678 (None of the characters are connected)

1234567890qw (Not 5 characters in every set)

1111122222333334444455555666666
77777888889999900000qqqqqwwwwww (More than 5 characters in some sets)

00
0
00.@@@ccccF111//=---
 ...@@c))FFF1//8===-
  .ttttt)))F1/8888=- (Doesn't form a rectangular shape)

Does a reflection of a pentomino have the same shape as the original? 2. Can we assume the input will consist of printable ASCII characters and newlines?

@Dennis Yes and Yes

@DigitalTrauma It's not remotely a duplicate of that. BTW that was an awesome question, it's a shame I didn't have time to answer it when it was newly asked.

@steveverill you're right - I didn't read this question properly

JavaScript (ES6), 237 235 222 bytes
f=p=>(m=[],s=[],d=0,l=p.indexOf`
`+1,[...p].map((c,i)=>(i+1)%l&&!m[i]?g=d-2<s.indexOf((t=a=>m[a]|p[a]!=c?r=0:(m[a]=y.push(a),n=a<n?a:n,t(a+1)+t(a-1)+t(a+l)+t(a-l)+1))(n=i,y=[])!=5?g=0:s[d++]=y.map(a=>r+=a-n)|r):0),d==12&g)

2 bytes saved thanks to @DankMemes!
Usage
f(`000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!`);
=> true

Explanation
A couple of notes about this solution:

It's possible this answer is not valid. It does not actually check if rotated pentominoes are the same shape, however I tried but could not find a valid pentomino rectangle that meets the requirements in the rules and includes two or more of the same shape rotated. But I'm no pentomino expert so if you find a valid combination that this fails with, let me know.
The rules also require answers to use STDIN and STDOUT for input and output but prompt() is only designed for single line input and my (Windows) computer automatically puts \r\n characters at every new line when pasting so I made it a function that accepts a string.

f=p=>(
  m=[],                      // m = map of checked characters
  s=[],                      // s = list of shapes found (stored as integer)
  d=0,                       // d = number shapes found
  l=p.indexOf`
`+1,                         // l = length of each line (including newline character)
  [...p].map((c,i)=>         // iterate through each character of the input
    (i+1)%l&&                // skip newline characters
      !m[i]?                 // skip the character if it has already been mapped
        g=                   // g = pentomino is valid
          d-2<s.indexOf(     // check if shape already existed before just now
            (t=a=>           // t() checks if character is part of the shape then maps it
              m[a]|          // skip if character is already mapped
                p[a]!=c      //    or if the current character is part of the shape
              ?r=0:(
                m[a]=        // mark the character as mapped
                  y.push(a), // y = list of shape character indices
                n=a<n?a:n,   // n = minimum index of all characters in the shape
                t(a+1)+      // check and map adjacent characters
                t(a-1)+
                t(a+l)+
                t(a-l)+
                1
              )
          )(n=i,y=[])
            !=5?g=0:         // make sure there are only 5 characters in the shape
            s[d++]=          // add the shape to the list
              y.map(a=>      // sum of (index of each character in the shape - minimum
                r+=a-n)|r    //     index) = unique integer representing the shape
        ):0
  ),
  d==12&g                    // ensure there is 12 shapes and return the 'is valid' result
)

You can abuse tagged templates with l=p.indexOf\`` to save 2 bytes

@DankMemes Thanks for the catch! I was really tired when I wrote this and I haven't double checked it yet. :P


text:
Layout my tiles for me
I'm retiling my kitchen with different coloured tiles. In fact, it's going to have at least 2 colours - and 26 colours as a maximum.
But, I'm fussy. I want this wall to look random, but sometimes random isn't random enough.
So, when I lay out my tiles, I don't want to have any the same colour next to each other in the 4 Cartesian directions. Diagonally adjacent is (of course) fine.
Acceptable:
┌───┐
│ A │
└───┘

┌───┬───┬───┐
│ A │ B │ A │
├───┼───┼───┤
│ B │ A │ B │
└───┴───┴───┘

┌───┬───┬───┐
│ A │ B │ C │
├───┼───┼───┤
│ C │ A │ B │
└───┴───┴───┘

Unacceptable:
┌───┬───┬───┐
│ A │ B │ A │
├───┼───┼───┤
│ A │ A │ B │
└───┴───┴───┘

┌───┬───┬───┐
│ A │ C │ C │
├───┼───┼───┤
│ C │ A │ B │
└───┴───┴───┘

Given input in the form A B N where A is the width, B is the height and N is the number of colours - an integer from 2 to 26 - you need to output a grid like so:
Input:
5 6 4

Example output:
A B C D A
B A D A C
A D C D A
B C B A B
D A D C A
B C A D C

The input will be given as a) 3 arguments to a function or b) as 3 separate input statements or b) as A B N. Input will always be valid.
All colours have to be used and all valid tilings have to have a non-zero probability of being generated.
This is code-golf so the shortest code wins.

... come on, you're familiar with the SE network; you should know better than to delete and repost questions.

You deleted and then reposted this question (and you should know full well that's highly frowned upon on SE...).

There were no answers on the original question. If you want to prevent answers while you're working on a question, use the Sandbox.

You know you can undelete questions, right? (It's also recommended that you use the Sandbox anyway, even if you think there are no issues with your question, because there could still be (this question being a case in point).)

Let us continue this discussion in chat.

@Tim You can undelete and then edit quickly. Just paste this challenge over the old one.

@Calvin'sHobbies should I do that now it's been reposted?

Does each row have to be printed space-separated?

@Sp3000 yes it does.

What's the minimum for the width/height? Are they at least 2?

@RetoKoradi one of them is at least two, and the min is 1.

Should the output be formatted exactly as in the example, i.e., using the first N uppercase letters, with spaces in rows and newlines between columns?

@Dennis Space and newlines yes. No, the arrangment should not be fixed with A B C D ... Z.

Python 2, 151 149 bytes
from random import*
W,H,N=input()
L='x'*W
exec"M='';exec'M+=sample(set(map(chr,range(65,65+N)))-{L[len(M)],M[-1:]},1)[0];'*W;L=M;print' '.join(L);"*H

Takes input comma-separated via STDIN, e.g. 10, 10, 2.

CJam, 53 52 51 bytes
q~:L,'Af+a*a*{_::mR_:|,L<\_z:O|N*2ew::=|:|}g;OSf*N*

This will take a long time if AB is too large or N is too small.
Try it online in the CJam interpreter.

I wrote a solution earlier but haven't posted it, see if there's anything you can use: q~:K;\,a*{{;Kmr}f%{_2few:::=s\z}2*@@|'0-}g'Aff+N*

Python2, 177 bytes
from random import *
W,H,N=input()
A,l={chr(c)for c in range(65,65+N)},[" "*W]
for h in range(H):
 s=""
 for c in l[h]:s+=sample(A-{s[-1:],c},1)[0]
 l+=[s]
print"\n".join(l[1:])


text:
Output a sound of a certain frequency
This is a rather simple challenge, but I couldn't find any question that was really similar to it. The challenge is to take a frequency in using STDIN or an equivalent, and then output a tone that matches that frequency, in Hz, for 5 seconds. For example
Input: 400
Output: (a tone of 400 Hz with a duration of 5 seconds)

Rules

Input must be taken in through STDIN, or your language's equivalent
The answer must be a full program
Builtins may be used
The frequency will be anywhere from 50 - 5000 Hz
The output must be played for 5 seconds
The output must be in the form of a sine wave

Test cases
Input: 440
Output:

Input: 200
Output:

Input: 4000
Output:

This is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.
Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. Languages specifically written to submit a 0-byte answer to this challenge are fair game but not particularly interesting.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
Also note that languages do have to fullfil our usual criteria for programming languages.

Catalogue
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

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

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

Would a function be acceptable?

@quartata It should be a full program.

I see that a lot of people are using a beep() function. Is it guaranteed that that is a sine wave?

Windows' System.Console.Beep thing is a sine wave on my (modern, Windows 10) machine, so I think that counts. Solutions on PPCG generally needn't be portable.

Is printing out an audio file a valid way to "output a tone"?

@IlmariKaronen Yes, that is ok.

QBasic, 18 bytes (disqualified)
Like @pabouk mentioned, this uses the PC speaker, so it plays a square wave, not a sine wave like the problem asks. (This requirement was added to the problem after this answer was posted, hence the votes.) I'll leave it here for posterity anyway.

INPUT F
SOUND F,91

Play a sound at the inputted frequency for 91 ticks, which is equal to 5 seconds.

This program does not satisfy the last requirement: "The output must be in the form of a sine wave". SOUND command uses the PC speaker which as designed was driven by a timer chip 8254 which produces a square wave. --- Though in modern PCs 8254 could be missing correct emulation of the SOUND command should produce a square wave.

This requirement was added after I posted my answer. :/ I'll add a note, but I feel weird about deleting this answer when it's the one voted to the top.

Python2, 40 bytes
from winsound import*
Beep(input(),5000)

Only works on Windows.

Would 5e3 work?

@Mauris No, I had already tried that but it wants integers only.

Mathematica, 42 bytes
Well if we can use built-ins...
Input[]
EmitSound@Play[Sin[2t%Pi],{t,0,5}]

Thanks to the requirement for a full program, this was the first time I got to use my recently discovered golfing tip of using % (result of last evaluation) to save two bytes.
Mathematica also has a built-in Sound which takes a pitch and a duration as arguments, but unfortunately the pitch has to be given as a musical note. Specifying your own sound wave via Play seems to be the only way to work with a frequency.

MATLAB, 36 bytes
sound(sin(pi*input('')*(0:8^-4:10)))

Thanks to flawr for saving two bytes.

You can save one character by using 2^-12 instead of 1/4096.

Oh silly me, 8^-4 is even shorter!

C#, 80 bytes
class P{static void Main(string[]a){System.Console.Beep(int.Parse(a[0]),5000);}}

Do you know what is the alternative for Beeping in Java?

PowerShell, 32 bytes
[console]::beep((read-host),5kb)

Is the space really needed?

wow, sloppy of me

Bash + Linux utils, 95
bc -l<<<"obase=16;for(;t<5;t+=1/8000){a=s($1*t*6.3);scale=0;a*30/1+99;scale=9}"|xxd -p -r|aplay

This is a true sine wave.  No beeps.  Input frequency entered via the command-line:
./hz.sh 440

FakeASM, 12 bytes
RDA
BEEP 5e3

Works with the Windows reference implementation (download). It calls Windows' Beep function, which is a sine wave on modern platforms.

Where's the STDIN?

RDA reads a number from STDIN and puts it in register A.

I ended up reading the spec and noticing that but I forgot to delete my comment. thanks, though

Bash + X11, 27 20 bytes
xset b 9 $1 5;echo

This contains an unprintable, so here's a hexdump:
0000000: 7873 6574 2062 2039 2024 3120 353b 6563  xset b 9 $1 5;ec
0000010: 686f 2007                                ho .

This takes the frequency as a command-line argument and plays the appropriate beep at a volume of 9% (since no volume was specified).
(Note: I was unable to test this due to some issues with my computer, but I'm 99% sure it works.)

Is there a \x07 in there?

No, xset does all the beeping stuff.

@TheDoctor Oh I see what you mean... it does need a \x07 to make the actual noise. Fixing.

echo <BEL> where <BEL> is the actual character, saves 6 bytes.

@Dennis D'oh. Thanks!

I was going to do something like this. +1

JavaScript, 114 bytes
p=prompt();c=new AudioContext;with(c.createOscillator()){frequency.value=p;connect(c.destination);start();stop(5)}

Requires a somewhat cutting-edge browser, enter the frequency in the prompt.
JSFiddle

This won't play for 5 seconds because prompt() is called after the audio timer is started at new AudioContext(). I believe the shortest you can get this is 115 bytes with c=new AudioContext(p=prompt());with(c.createOscillator()){frequency.value=p;connect(c.destination);start();stop(5)}.

Thanks for the heads up, I appreciate the idea of using 'with' as well.

I've not seen


text:
Defeat SVGCaptcha
I came across SVGCaptcha, and immediately knew it was a bad idea.
I would like you to show just how bad an idea this is by extracting the validation code from the SVG images that code produces.

An example image looks like this:

Here is the source of the example image:
<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
        "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
    <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve"
             width="200" height="40"
    > <rect x="0" y="0" width="200" height="40"
        style="stroke: none; fill: none;" >
        </rect> <text style="fill: #4d9363;" x="5" y="34" font-size="20" transform="translate(5, 34) rotate(-17) translate(-5, -34)">8</text>
<text style="fill: #be8b33;" x="125" y="29" font-size="21" transform="translate(125, 29) rotate(17) translate(-125, -29)">f</text>
<text style="fill: #d561ff;" x="45" y="35" font-size="20" transform="translate(45, 35) rotate(-2) translate(-45, -35)">4</text>
<text style="fill: #3de754;" x="85" y="31" font-size="21" transform="translate(85, 31) rotate(-9) translate(-85, -31)">8</text>
<text style="fill: #5ed4bf;" x="25" y="33" font-size="22" transform="translate(25, 33) rotate(16) translate(-25, -33)">u</text>
<text style="fill: #894aee;" x="105" y="28" font-size="25" transform="translate(105, 28) rotate(9) translate(-105, -28)">1</text>
<text style="fill: #e4c437;" x="65" y="32" font-size="20" transform="translate(65, 32) rotate(17) translate(-65, -32)">x</text>
</svg>

The input is the SVG image, which is a textual format.
The only real restriction is that your code must produce the values in the correct order.
The input <text> elements are in random order so you have to pay attention to the x attribute in the <text> tag

Score is the number of bytes in the code

Since the code currently does two transforms that cancel each-other out you can ignore them, but if you do take them in consideration, go ahead and take a 30% reduction from your score.

You haven't actually stated explicitly what the input and output are: I'm presuming the SVG file and the letters contained therein? And it's not clear to me whether answers are required to actually implement the SVG spec or whether they can assume that the SVG is generated by the current version of SVGCaptcha and so the transforms can be ignored.

I suggest limiting the output to STDOUT or function return value, and making it [tag:code-golf]

@AlexA. So there can't be a criterion on quality that can't really be quantified? You can't qualify on how funny the code is, or how clear it is? I really want the answers to be so dead simple that people who don't even know a single language could eventually figure it out.

@PeterTaylor I totally didn't look to see if the translations actually did anything. I would prefer if it did take them into consideration, but since the code is even dumber than I thought, any answer could ignore them.

No, questions need an objective, quantifiable winning criterion to be on-topic for this site.

If you want the answers to be "simple", why don't you just make it codegolf so that the shortest possible answer wins? Then we can get this open again. Yes SVGCaptcha is a hilariously dumb idea (I suspect the inventors do in fact know that, though there isn't a trace of irony shown on the linked page.) And it's been good for a laugh, but the purpose of this site is to host challenges, with objective rules.

@steveverrill I really wanted them to be elegant. The shortest code in Perl 5&6 are very often not the simplest for example. (one of the reasons most people think that Perl is hard to read) But in the interest of opening it is now a golfing competition

I'm not sure how relevant [tag:image-processing] is here.

This question is now the 4th result when googling 'svgcaptcha' :)

It is the 3rd now!

the google result for svgcaptcha it self and the relevance of this OP to the keyword is the elegant and ironical proof of how bad the idea itself is. ;)

Can we output it as a list of characters instead of String? I.e. [8, u, 4, x, 8, 1, f] instead of 8u4x81f?

@KevinCruijssen In some languages there is no difference. So sure why not.

Bash, 63 56 39 bytes

cat<<_|grep -o 'x=.*>'|cut -c4-|sort -n|grep -o '>.</t'|cut -c2

grep -o 'x=.*>'|cut -c4-|sort -n|grep -o '>.</t'|cut -c2

grep -o 'x=.*<'|sort -k1.4n|rev|cut -c2

Note: requires cat, grep, sort, rev, and cut. Takes input from stdin. The output is separated by line breaks on stdout. Make sure to press CTRL+D (not COMMAND+D on Mac) when finished entering the CAPTCHA. Input must be followed by a newline and then '_'.
EDIT: Saved 13 bytes.
EDIT 2: Saved 20 bytes thanks to @manatwork!

GNU coreutils sort supports character position in the keydef: cut -c4-|sort -n → sort -k1.4n.

@manatwork Thanks, I updated the answer.

CJam, 26 bytes
q"x="/2>{'"/1=i}${'>/1=c}/

Try it online in the CJam interpreter.
How it works
q     e# Read all input from STDIN.
"x="/ e# Split it at occurrences of "x=".
2>    e# Discard the first two chunks (head and container).
{     e# Sort the remaining chunks by the following key:
  '"/ e#   Split at occurrences of '"'.
  1=  e#   Select the second chunk (digits of x="<digits>").
  i   e#   Cast to integer.
}$    e#
{     e# For each of the sorted chunks:
  '>/ e#   Split at occurrences of '>'.
  1=  e#   Select the second chunk.
  c   e#   Cast to character.
}/    e#

JavaScript, 95 93 91 bytes
l=[],r=/x="(\d*).*>(.)/g;while(e=r.exec(document.lastChild.innerHTML))l[e[1]]=e[2];l.join``

edit: -2 bytes changing documentRoot to lastChild; -2 bytes changing join('') to join``, thanks Vɪʜᴀɴ
Enter code in the browser console on a page containg the SVG in question, writes to console output.

document.rootElement is retuning undefined. I've tried Firefox and Safari

This was only tested in Chrome, I'll look into what could be changed.

It appears to work in Firefox, is SVG the only content of the file?

Okay, tried it in Chrome, now it worked. +1. You can also save two bytes by changing the ('') to two backticks: ``

This is 78: t=>(l=[],r=/x="(\d*).*?>(.)/g,eval("while(e=r.exec(t))l[e[1]]=e[2];l.join``")) (takes xml string as parameter, returns captcha text)

Perl, 40 bytes
39 bytes code + 1 for -n
$a[$1]=$2 for/x="(.+)".+(.)</g}{print@a

Example:
perl -ne '$a[$1]=$2 for/x="(.+)".+(.)</g}{print@a' <<< '<example from above>'
8u4x81f

Man that is just full of warnings if you turn them on. Excellent use of Perl's default lax nature.

@BradGilbertb2gills Yeah, I try not to test the warnings, I'm so surprised any golfed code even works sometimes!

Bash + GNU utilities, 53
grep -Po '(?<=x=").*(?=<)'|sort -n|grep -Po '(?<=>).'

Like this answer, output is one char per line.

Perl 6, 68 bytes
say [~] lines.map({/'x="'(\d+).*(.)\</??(+$0=>$1)!!()}).sort».value

Befunge, 79 bytes
It feels like it should be possible to golf at least one more byte off of this, but I've been working on it for a couple of days now, and this is as good as I could get it.
<%*:"~"*"~"_~&45*/99p1v-">":_|#`0:~<
#,:#g7-#:_@^-+*"x~=":+_~99g7p>999p#^_>>#1+

Try it online!
Explanation

 Make the execution direction right-to-left, and wrap around to start the main loop.
 Read a char from stdin, and test for the end-of-file value.
 If it's not end-of-file, check if it's a >.
 If it's not a >, add it to the value on the stack which tracks the last two characters, and check if the current pair matches x=.
 If not, multiply by 126 and mod with 1262 to drop the oldest value from the pair and make space for the next character.
 Wrap around again to repeat the main loop.
 When an x= pair is encountered, skip the next character (the quote), read an integer (the x value), and divide by 20. This becomes the current offset which is saved for later.
 When a > is encountered, read the next character (typically one of the captcha letters), and save that at the current offset in an "array". Reset the offset to 9, so the captcha letter won't be overwritten when later > characters are encountered.
 Finally, when then end-of-file is reached, iterate over the 7 values saved in the array and output them one by one. That should give you all the captcha letters in the correct order.
I'm glossing over some of the details here, since the code paths overlap each other in ways which are a little difficult to explain, but it should give you a general idea of how the algorithm works.

Python2, 129 bytes
import re,sys
print''.join(t[1] for t in sorted(re.findall(r'(\d+), -\d+\)"\>(.)\</t',sys.stdin.read()),key=lambda t:int(t[0])))

Takes the HTML source on stdin, produces code on stdout.

How does this sort the output? The <text> elements are in a random order, and the only real requirement is that you have to put them in the correct order. That means you have to use the x from the <text> and follow any transforms.

@BradGilbertb2gills I missed that the first time around, fixed now.

Mathematica, 106 bytes
""<>(v=ImportString[#~StringDrop~157,"XML"][[2,3,4;;;;2]])[[;;,3]][[Ordering[FromDigits/@v[[;;,2,2,2]]]]]&

Note: The input needs to be in exactly the format specified by the example.

QuadS, 49 bytes
∊c[⍋⊃x c←↓⍎¨@1⍉(⊢⍴⍨2,⍨.5×≢)3↓⍵]
x="(\d+)
>(.)<
\1

Try it online!
Finds x values (digit-runs after x=") and "letters" (pinned by closing and opening tags), then executes the following APL (where ⍵ is the list of found x values and letters, in order of appearance):
3↓⍵ drop the first three elements (spaces around <rect…/rect> and the <rect's  x value).
(…) apply the following tacit function on that:
 ≢ the number of remaining items
 .5× halve that
 2,⍨ append a two
 ⊢⍴⍨ reshape to that shape (i.e. an n×2 matrix)
⍉ transpose (to a 2×n matrix)
⍎¨@1 execute each string in the first row (turning them into numbers)
↓ split the matrix into two vectors (one per row)
x c← store those two in x (x values) and c (characters) respectively
⊃ pick the first (x)
⍋ grade up (the indices into x which would sort x)
c[…] use that to index into c
∊ ϵnlist (flatten) because each letter is a string by itself

The equivalent APL expression of the entire QuadS program is:
∊c[⍋⊃x c←↓⍎¨@1⍉(⊢⍴⍨2,⍨.5×≢)3↓'x="(\d+)"' '>(.)<'⎕S'\1'⊢⎕]

V, 28 26 25 24 bytes
d5jÍx=
ún
JÍ">
lH$dÍî

Try it online!
Explanation:
d5j              delete first 6 lines
   Í<0x81>x=     In every line, replace everything up to x=" (inclusive) by nothing
ún               Sort numerically
J                Join line (closing </svg>) with next line
 Í<0x81>">       In every line, replace everything up to "> by nothing
l␖H$d            Visual block around closing </text> tags, delete
     Íî          In every line, replace \n by nothing.

HexDump:
00000000: 6435 6acd 8178 3d0a fa6e 0a4a cd81 223e  d5j..x=..n.J..">
00000010: 0a6c 1648 2464 cdee                      .l.H$d..

Gema, 65 characters
x\="<D>*\>?=@set{$1;?}
?=
\Z=${5}${25}${45}${65}${85}${105}${125}

In Gema there is no sorting, but fortunately is not even needed.
Sample run:
bash-4.4$ gema 'x\="<D>*\>?=@set{$1;?};?=;\Z=${5}${25}${45}${65}${85}${105}${125}' < captcha.svg
8u4x81f

XMLStarlet, 46 characters
xmlstarlet sel -t -m //_:text -s A:N:U @x -v .

Hopefully this is valid solution as XMLStarlet is transpiler that generates and executes XSLT code, which is a Turing complete language.
Sample run:
bash-4.4$ xmlstarlet sel -t -m //_:text -s A:N:U @x -v . < captcha.svg
8u4x81f

PHP, 96 bytes
Given that $i is the input string
preg_match_all('|x="(\d+).*(.)\<|',$i,$m);$a=array_combine($m[1],$m[2]);ksort($a);echo join($a);

Instead of array_combine() + ksort() you could use array_multisort() like this: array_multisort($m[1],$m[2]);echo join($m[2]);. But please note that solutions are expected to handle input and output themselves (unless the language does it automatically), instead of expecting to find the input in a variable or just leave the result in a variable. See related meta.

Clean, 277 150 bytes
Yay pattern matching!
import StdEnv,StdLib
?s=map snd(sort(zip(map(toInt o toString)[takeWhile isDigit h\\['" x="':h]<-tails s],[c\\[c:t]<-tails s|take 7 t==['</text>']])))

Try it online!
Defines the function ?, taking [Char] and giving [Char].

Java 8, 197 173 bytes
import java.util*;s->{String a[]=s.split("x=\""),r="";Map m=new TreeMap();for(int i=2;i<a.length;m.put(new Long(a[i].split("\"")[0]),a[i++].split(">|<")[1]));return m.values();}

Outputs a java.util.Collection of characters.
Explanation:
Try it online.
import java.util*;            // Required import for Map and TreeMap
s->{                          // Method with String as both parameter and return-type
  String a[]=s.split("x=\""), //  Split the input by `x="`, and store it as String-array
         r="";                //  Result-String, starting empty
  Map m=new TreeMap();        //  Create a sorted key-value map
  for(int i=2;                //  Skip the first two items in the array,
      i<a.length;             //  and loop over the rest
    m.put(new Long(a[i].split("\"")[0]),
                              //   Split by `"` and use the first item as number-key
          a[i++].split(">|<")[1]));
                              //   Split by `>` AND `<`, and use the second item as value
    return m.values();}       //  Return the values of the sorted map as result


text:
Parenthifiable Binary Numbers
If you express some positive integer in binary with no leading zeros and replace every 1 with a ( and every 0 with a ), then will all the parentheses match?
In most cases they won't. For example, 9 is 1001 in binary, which becomes ())(, where only the first two parentheses match.
But sometimes they will match. For example, 44 is 101100 in binary, which becomes ()(()), where all the left parentheses have a matching right parenthesis.
Write a program or function that takes in a positive base ten integer and prints or returns a truthy value if the binary-parentheses version of the number has all matching parentheses. If it doesn't, print or return a falsy value.
The shortest code in bytes wins.
Related OEIS sequence.
Truthy examples below 100:
2, 10, 12, 42, 44, 50, 52, 56

Falsy examples below 100:
1, 3, 4, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 45, 46, 47, 48, 49, 51, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99

More OEIS

There's a sequence for everything...

TeaScript, 9 bytes 16 18 20 22 24
Saved 2 bytes thanks to @ETHproductions
!x÷W(n,¢)

Woah. That's short. Uses @xnor's approach. This will use the recursive replace function (W) which will replace all 10 equal to () with nothing. If the string is blank it is balanced.

Using a version of TeaScript made after this challenge was posted this could become 7 bytes:
!x÷W(n)

Ungolfed
!xT(2)W(n,``)

Explanation
!      // NOT, returns true if empty string, else false
 xT(2)   // To binary
 W(n,``) // n is 10, reclusive replaces 10 or (), with nothing.

Excellent! Two things that might help: 1) If it's falsy when going up, it's already been falsy going down, so you shouldn't need the first tilde. 2) I believe ~--c is falsy in exactly the same scenario as c--.

@ETHproductions awesome, thanks! Now I'm down to 16 bytes

My smartphone thinks the 16 18 20 22 24 in the post is a phone number!

Pyth, 10 bytes
!uscG`T.BQ

Try this test suite in the Pyth Compiler.
How it works
              (implicit) Store the evaluated input in Q.
       .BQ    Return the binary string representation of Q.
 u            Reduce w/base case; set G to .BQ and begin a loop:
     `T         Return str(10) = "10".
   cG           Split G (looping variable) at occurrences of "10".
  s             Join the pieces without separators.
              Set G to the returned string.
              If the value of G changed, repeat the loop.
              This will eventually result in either an empty string or a
              non-empty string without occurrences of "10".
!             Return (and print) the logical NOT of the resulting string.

I came up with the equivalent !u:G\Tk.BQ`. Arguably easier to understand.

Yes, that's certainly a more natural choice.

JavaScript (ES6), 55 54 51 bytes
n=>![...n.toString(d=2)].some(c=>(d+=c*2-1)<2)*d==2

Saved bytes thanks to @Vɪʜᴀɴ and @xsot!
Explanation
n=>
  ![...n.toString(    // convert the input to an array of binary digits
    d=2)]             // d = current depth (+2)
      .some(c=>       // iterate through the digits
        (d+=c*2-1)    // increment or decrement the parenthesis depth
          <2          // if the depth goes negative, return false
      )*
        d==2          // if we finished at a depth of 0, return true

You can save two bytes by removing the not needed f=. You can also use use +c instead of c|0 to case to an integer. You can also use (+c?d++:d--) which is even shorter

@Vɪʜᴀɴ OK. Is there some kind of guide as to when I need to use f=? Because a lot of other JavaScript answers on the site name their functions.

Typically you only need to give the function a name if the challenge requires you to do so. Otherwise it's safe to assume that unnamed functions are fine.

In Firefox, running this for 11, returns true when it should return false

@Vɪʜᴀɴ My bad I messed up an edit. I'll change it back.

I don't know javascript, but I attempted to cut a few bytes and it works in chrome: n=>![...n.toString(d=2)].some(c=>(d+=c*2-1)<2)*d==2

@xsot Nice optimisiation :)

@xsot wait Chrome supports Arrow functions??

@xsot now does Chrome support spread ... ?

51 n=>![...n.toString(d=2)].some(c=>(d-=1-c-c)<2)&d==2

@CᴏɴᴏʀO'Bʀɪᴇɴ I've been using Chrome since I came to this site and so far the only thing I've seen which hasn't worked is default arguments.

Python2, 87 bytes
try:exec"print 1,"+"".join(["],","["][int(c)]for c in bin(input())[2:])
except:print 0

A terrible implementation that abuses syntax errors.

This is code golf. Terrible is a compliment.

Python 2, 45 bytes
f=lambda n,i=1:i*n>0<f(n/2,i+(-1)**n)or n<i<2

A recursive function. Reads binary digits of n from the end, keeping a count i of the current nesting level of the parens. If it falls below 0, reject. When we reach the start, checks whether the count is 0.
Actually, we start the count at i=1 to make it easy to check if it has fallen to 0. The only terminal success case is n==0 and i==1, checked with n<i<2. We force this check to happen if n==0, or if i falls to 0, in which case it automatically fails.
feersum saved two bytes by restructuring the non-recursive cases with inequalities to short-circuit.

Needs more conditional abuse. f=lambda n,i=1:n>0<i*f(n/2,i+(-1)**n) or n<i<2, at least, saves 1.

CJam, 11 bytes
ri2b"}{"f=~

This is a tad unclean: For parenthifiable numbers, it will print one or more blocks. For non-parenthifiable numbers, it will crash without printing anything to STDOUT. If you try this online in the CJam interpreter, keep in mind that it doesn't distinguish between STDOUT and STDERR.
Since non-empty/empty strings are truthy/falsy in CJam and printed output is always a string, it arguably complies with the rules. At the added cost of 3 more bytes, for a total of 14 bytes, we can actually leaves a truthy or falsy string on the stack that will be printed:
Lri2b"}{"f=~]s

This still crashes for non-parenthifiable numbers, which is allowed by default.
Test runs
$ cjam <(echo 'ri2b"}{"f=~') <<< 52 2>&-; echo
{{}{}}
$ cjam <(echo 'ri2b"}{"f=~') <<< 53 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 54 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 55 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 56 2>&-; echo
{{{}}}

How it works
ri          e# Read an integer from STDIN.
  2b        e# Push the array of its binary digits.
    "}{"f=  e# Replace 0's with }'s and 1's with {'s.
          ~ e# Evaluate the resulting string.
            e# If the brackets match, this pushes one or more blocks.
            e# If the brackets do not match, the interpreter crashes.

CJam, 15 bytes
ri2bs_,{As/s}*!

Try this fiddle in the CJam interpreter or verify all test cases at once.
How it works
ri               Read an integer from STDIN.
  2b             Push the array of its binary digits.
    s            Cast to string.
     _,          Push the string's length.
       {    }*   Do that many times:
        As/        Split at occurrences of "10".
           s       Cast to string to flatten the array of strings.
              !  Push the logical NOT of the result.

darn, you barely beat me again....

Python, 51 bytes
lambda n:eval("'0b'==bin(n)"+".replace('10','')"*n)

An anonymous function. Evaluates to an expression that looks like
'0b'==bin(n).replace('10','').replace('10','').replace('10','')...

Each replacement removes all 10, which correspond to (). After all replacements have been made, the function returns whether what's left is just the binary prefix 0b. It more than suffices to make n replacements, since a k-digit number takes at most k/2 steps, and its value is most 2**k.

Ruby, 40
->i{n='%0b'%i;1while n.slice!'10';n<?0}

Simple string manipulation.  Drops '10' until there is none left.

Japt -!, 3 bytes
¤eA

Try it here
¤eA     :Implicit input of integer
¤       :To binary string
 e      :Recursively replace
  A     :  10
        :Implicit output of logical NOT of final string (the empty string is falsey, all others are truthy)

One question: how

Explanation added, @Razetime

Seriously, 17 bytes
,;2@¡@`""9u$(Æ`nY

Outputs 0 for false and 1 for true. Try it online.
Explanation:
,      get value from stdin
;      dupe top of stack
2@¡    pop a: push a string containing the binary representation of a (swapping to get order of operands correct)
@      swap top two elements to get original input back on top
`""9u$(Æ` define a function:
  ""     push empty string
  9u$    push "10" (push 9, add 1, stringify)
  (      rotate stack right by 1
  Æ      pop a,b,c: push a.replace(b,c) (replace all occurrences of "10" in the binary string with "")
n      pop f,a: call f a times
Y      pop a: push boolean negation of a (1 if a is falsey else 0)

Japt, 23 bytes
Japt is a shortened version of JavaScript. Interpreter
Us2 a e@+X?++P:P-- &&!P

This reminds me just how far Japt has yet to go compared to TeaScript. After revamping the interpreter in the next few days, I'd like to add in "shortcut" chars like Vɪʜᴀɴ's.
How it works
       // Implicit: U = input number, P = empty string
Us2 a  // Convert U to base 2, then split the digits into an array.
e@     // Assert that every item X in this array returns truthily to:
 +X?   //  If X = 1,
 ++P   //   ++P. ++(empty string) returns 1.
 :P--  //  Otherwise, P--. Returns false if P is now -1.
&&!P   // Return the final result && !P (true if P is 0; false otherwise).
       // Implicit: output final expression

Shortly after this challenge, @Vɪʜᴀɴ (now known as @Downgoat) helped me implement a recursive-replace feature, like W in the TeaScript answer. This means that this challenge can now be done in just 5 bytes:
!¢eAs  // Implicit: U = input integer, A = 10
 ¢     // Convert U to binary.
  eAs  // Recursively remove instances of A.toString().
!      // Return the logical NOT of the result (true only for the empty string).

Test it online!

JavaScript ES5, 118 87 85 82 77 bytes
Interesting technique in my opinion. Minus a whole heck of a lot, thanks to @ETHproductions, and @NotthatCharles
function p(x){x=x.toString(2);while(/10/.test(x))x=x.replace(10,"");return!x}

JavaScript ES6, 77 57 56 54 bytes
-21 bytes to ETHproductions.
x=>[...x=x.toString(2)].map(_=>x=x.replace(10,""))&&!x

I like the translation to parentheses. However, if you leave it as 1s and 0s, it's a good bit shorter: function p(x){x=x.toString(2);r=/10/;while(x.search(r)>=0){x=x.replace(r,"")}return!x}

@ETHproductions Good point! I think I'll leave the other code at the bottom, I really like the algorithm ^_^ Thanks mate!

The ES6 version can still be golfed a bunch: x=>([...x=x.toString(2)].map(_=>x=x.replace(/10/,"")),!x) The trick is to move the while loop into a .map, since there are never more '10's in an input than its length.

@ETHproductions Thanks again ^_^ Nice trick with map.

No problem :) BTW, another byte can be saved with a trick edc65 uses all the time: x=>[...x=x.toString(2)].map(_=>x=x.replace(/10/,""))&&!x IDK if it can get shorter though.

@ETHproductions I'm glad I posted this answer, I'm learning so much :D I love the short-circuit trick. I conjecture that 56 is the minimum in ES6 afaik. Can't wait until ES7, though.

One more for ES5: {x=x.replace(r,"")} can be replaced with x=x.replace(r,"");, the space in return !x can be removed, and I think >=0 can be replaced with +1.

@ETHproductions You are my endless fount of golfing. Thanks much!

Why not replace while(x.search(r=/10/)+1) with while((r=/10/).test(x))?

@NotthatCharles Thanks for showing me .test. +1 from me.

@CᴏɴᴏʀO'Bʀɪᴇɴ I also think that if you don't bother declaring r you actually save a byte.  And what about while(/10/.test(x=x.replace('10',''));?

@NotthatCharles Oh, right. Nice catch.

Think you could save a few more by replacing x=x.toString(2);while(/10/.test(x)) with for(i in x=x.toString(2))

Wolfram Language (Mathematica), 42 bytes
TrueQ[And@@#~IntegerDigits~2//.1&&0:>1>0]&

Try it online!

Wolfram Language (Mathematica), 49 bytes
(#~IntegerDigits~2//.{x___,1,0,y___}:>{x,y})=={}&

Try it online!

I can't read Mathematica. Explanation, please? :)

@CᴏɴᴏʀO'Bʀɪᴇɴ Convert the number into base 2 (as a list), then repeatedly remove 1,0 from the list, and test if the result is an empty list.

C++, 104 94 bytes
#include<iostream>
int n,c;int main(){for(std::cin>>n;n&c>=0;n>>=1)c+=n&1?-1:1;std::cout<<!c;}

Run with this compiler, must specify standard input before running.
Explanation

Declarations outside of main initialize to 0.
Reading a decimal implicitly converts to binary, because this is a computer.
We check bits/parenthesis right to left because of n>>=1.
c+=n&1?-1:1 keeps count of open parenthesis ).
n&c>=0 stops when only leading 0s remain or parenthesis close more than they open.

Python 2, 60 57 56 55 53 52 50 49 bytes
n=input()
i=1
while i*n:i+=1|n%-2;n/=2
print i==1

Thanks to xnor for saving two bytes and feersum for bringing the final byte count to 49!
Explanation
The input number, n, is processed from its least significant bit. i is a counter that keeps track of the number of 0's and 1's. Note that it is initialised to 1 to save a byte. The loop will abort before n reaches 0 if the number of 1's exceed the number of 0's (i<=0).
For the parentheses to be balanced, two conditions are required:

The number of 0's and 1's are equal (i.e. i==1)
The number of 1's never exceeds the number of 0's during this process
(i.e the loop doesn't abort prematurely so n==0). Edit: I realised that this condition isn't necessary as i must be non-positive if n!=0 so the previous condition is sufficient.

If i and n are nonnegative then i==n==0 is i+n==0.

i can be negative if the loop aborts prematurely.

Actually, i|n==0 should always work.

Great suggestion, that line looks better now.

while i*n should work

Good catch. I feel silly now.

1|n%-2 is shorter than 1-n%2*2.

Octave, 48 bytes
@(a)~((b=cumsum(2*dec2bin(a)-97))(end)|any(b<0))

Haskell, 49 46 bytes
0#l=l==1
_#0=2<1
n#l=div n 2#(l+(-1)^n)
f=(#1)

Usage example: f 13 -> False.
I'm keeping track of the nesting level l like many other answers. However, the "balanced" case is represented by 1, so the "more-)-than-(" case is 0.
PS: found the nesting level adjustment l+(-1)^n in xnor's answer.

The signum seems too complicated, how about just _#0=1<0?

@xnor: yes, thanks.

Why not l>0 instead of l==1?

@MichaelKlein: because only l==1 is balanced. If l>1, the parentheses are unbalanaced.

@nimi I see, I misinterpreted how it works

Vyxal, 8 bytes
k/τk/ṘǑǒ

Try it Online!
Fortunately, Vyxal has a remove-substring-until-fixed-point builtin. Unfortunately, it only works on strings.
k/τ         Convert input to base "/\". (only string constant of length 2)
      Ǒ     Until it is no longer present as a substring, remove
   k/       "/\"
     Ṙ      reversed.
       ǒ    Is the result empty?

Originally did some fancy dancing with stack rotations in Vyxal r, but it turned out the same length flagless to just use k/ twice. I'm not having the best luck putting a solution together without replacement, but it doesn't seem like it could come out shorter.

Vyxal, 6 5 bytes
Π₀øo¬

Try it Online!
Π     # push the binary of the input
 ₀    # push 10
  øo  # remove ^ until no change
    ¬ # logical NOT

D, 209 170 bytes
import std.stdio;import std.format;import std.conv;void main(char[][]a){string b=format("%b",to!int(a[1]));int i;foreach(c;b){i+=c=='1'?1:-1;if(i<0)break;}writeln(i==0);}

This does exactly what it is supposed to do without any additions or benefits.

C, 67 bytes
n;main(i){for(scanf("%d",&n);n*i;n/=2)i+=1-n%2*2;putchar(48+!~-i);}

Pretty much a port of my python submission.

Prolog, 147 bytes
b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).
q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.
p(X):-b(X,L),!,q(L,0).

How it works
b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).

Converts decimal number N to it's binary representation as a list (reversed). Meaning:
b(42,[0,1,0,1,0,1]) is true

Then:
q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.

Recurses over list [H|T] increasing N if head element is 0 otherwise decreasing it.
If N at any point becomes negative or if N in the end is not 0 return false, else true.
The cut in
p(X):-b(X,L),!,q(L,0).

Is there to prevent backtracking and finding non-binary solutions to b(N,[N])

Testing
Try it out online here
Run it with a query like:
p(42).

PowerShell, 106 Bytes
param($a)$b=[convert]::ToString($a,2);1..$b.Length|%{if($b[$_-1]%2){$c++}else{$c--}if($c-lt0){0;exit}};!$c

Not going to win any shortest-length competitions, that's for sure. But hey, at least it's beating Java?
Uses the very long .NET call [convert]::ToString($a,2) to convert our input number to a string representing the binary digits. We then for-loop through that string with 1..$b.length|%{..}. Each loop, if our digit is a 1 (evaluated with %2 rather than -eq1 to save a couple bytes), we increment our counter; else, we decrement it. If we ever reach negative, that means there were more ) than ( encountered so far, so we output 0 and exit. Once we're through the loop, $c is either 0 or some number >0, so we take the logical-not ! of it, which gets output.
This has the quirk of outputting 0 if the parens are mismatched because we have more ), but outputting False if the parens are mismatched because we have more (. Essentially functionally equivalent falsy statements, just interesting. If the parens all match, outputs True.

Okay, sure. (Well, if I can fix the nagging doubt that I'm solving the wrong problem, I will).

Jelly, 9 bytes
B-*ÄṀoṪƊ¬

Try it online!
B            Convert to binary.
 -*          Raise -1 to the power of each digit.
   Ä   Ɗ     For the cumulative sums of the resulting list:
     o  ¬    neither
    Ṁ        is its maximum non-zero
      Ṫ      nor is its last element.

Replacement came out a bit longer:
Jelly, 11 bytes
B¬œṣØ.Ẏ$ÐLṆ

Try it online!

PowerShell Core, 74 72 bytes
for($t=[convert]::ToString("$args",2);$r-ne($t=$t-replace10)){$r=$t}
!$t

Try it online!
Explanations
for(
    $t=[convert]::ToString("$args",2); # converts the given argument to a binary string
    $r-ne($t=$t-replace10)){$r=$t}     # Until we can't find occurences of 10, remove them from the string
!$t                                    # Returns a truthy value if empty string

-2 bytes thanks to mazzy!

72 bytes?

Java, 129 131 bytes
boolean T(int i){int j=0,k=0;for(char[]a=Integer.toString(i,2).toCharArray();j<a.length&&k>=0;j++){k+=a[j]=='1'?1:-1;}return k==0;}

Probably can be shortened. Explanation to come. Thanks to Geobits for 4 bytes off!

Is it possible to combine int k=0; with int j=0;?

No, j is an inner variable in the for loop and cannot be referenced outside it.

You should be able to combine the other way, though: int k=0,j=0;for(... Then you could put the char[] declaration inside the loop initializer to save a semicolon, too.

The bigger problem is that this gives false positives. It returns true for 9, 35, 37, 38, for example.

@Geobits oops, I didnt even realize that, will fix when I get a chance.

GNU Sed (with eval extension), 27
s/.*/dc -e2o&p/e
:
s/10//
t

Sed doesn't really have a defined idea of truthy and falsey, so here I am claiming that the empty string means truthy and all other strings mean falsey.
If this is not acceptable, then we can do the following:
GNU Sed (with eval extension), 44
s/.*/dc -e2o&p/e
:
s/10//
t
s/.\+/0/
s/^$/1/

This outputs 1 for truthy and 0 otherwise.

 (ESMin), 21 chars / 43 bytes
ô⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ)

Try it here (Firefox only).
Note that this uses variables predefined to numbers (specifically 2 and 0). There are predefined number variables from 0 to 256.
19 chars / 40 bytes, non-competitive
⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ

Try it here (Firefox only).
Decided to implement implicit output... However, previous output forms are still supported, so you get several output options!

because everyone measures by char count

 (very noncompetitve), 6 chars / 8 bytes
!ïⓑĦⅩ

Try it here (Firefox only).
I've decided to revisit this challenge after a very, very long time.  has gotten so much better.
The reason this is a separate answer is because the 2 versions are almost completely different.
Explanation
Converts input to binary, recursively replaces instances of 10, then checks if result is an empty string.

C++, 61 bytes
I think the current C++ answer is wrong: it returns a truthy value for all even numbers, e.g. 4. Disclaimer: I was not able to use the mentioned compiler, so I used g++ 4.8.4. The problem lies in the use of the binary AND operator instead of the logical AND which is used to break early when the number of closing parentheses exceed the number of opening parentheses. This approach could work if true is represented as a word with an all true bit pattern. On my system, and probably most other systems, true is equivalent to 1; only one bit is true. Also, n/=2 is shorter than n>>=1. Here is an improved version as a function:
int f(int n,int c=0){for(;c>=0&&n;n/=2)c+=n&1?-1:1;return c;}

Husk, 8 bytes
¬ωoσḋ2øḋ

Try it online! or Verify first 100 results

K (ngn/k), 22 18 bytes
-4 bytes by making things tacit
~#(""/"10"\)/,/$2\

Try it online!

2\ convert (implicit) input integer to base-2 representation
,/$ convert the base-2 representation to a string
(""/"10"\)/ run a converge-/, splitting on instances of "10", joining with "" (in effect replacing instances of "10" with "")
~# check if there are any unmatched parentheses left

Lua (96 bytes)
function g(n)function f(m)return m>0 and f(m//2)..m%2 or""end return f(n):gsub("%b10","")==""end

AWK, 56 bytes
{for(a=$++b;a;a=int(a/2))(d+=a%2?-1:1)<0?b=0:0}1,$0=b*!d

Try it online!
The general idea here is the code runs through all the binary bits of the number, from the least significant digit to the most significant digit.  At each point the parenthetical "depth" is calculated.  The result is truthy if the final depth after all the digits have been considered is 0 and as long as intermediate depth is never negative.
 for(a=$++b;a;a=int(a/2))

This loop processes each bit.  The initialization a=$++b is just a golfed version of a=$1; b=1 setting a to the number requested and the default result "are all interim depths OK" variable b to 1.
It stops when all the bits have been process, which is when a is falsy.
And the end of loop shifts the number we're working down on bit with a=int(a/2) since I can't think of a short way to do integer math in AWK...
                     (d+=a%2?-1:1)<0?b=0:0

The body of the loop is just one statement.  It either increments of decrements the "depth count" variable depending on whether or not the current bit is set using d+=a%2?-1:1.
And then it sets the "does the depth ever go negative" variable b to 0 if the depth dips below zero with, which is this part of the statement (...)<0?b=0:0.
One we've run through all the bits, the only thing left is to decide if the number met the two success factors for the test,
                                               1,$0=b*!d

If both tests pass, then b*!d will be 1.  Setting $0 to that means AWK will print 1 or 0 since the 1, bit at the front means the test will always evaluate to true.

05AB1E, 6 bytes
bTõ:õQ

Try it online or verify all test cases.
Explanation:
b       # Convert the (implicit) input-integer to a binary-string
 Tõ:    # Keep replacing 10 with "" as long as it's possible
    õQ  # Check if what remains is an empty string ""
        # (after which the result is output implicitly)

Java (JDK), 56 bytes
Not an innovative solution, but the previous Java answer really needed an outgolfing.

It converts the integer parameter in binary classically (using modulo and division by 2), and since we are converting from right to left, it considers 0 as a +1 and 1 as a -1 in a score variable.
The score gets "stuck" forever at -1 if it ever reaches this value (if a ( is encountered before having encountered its matching )), or can increase indefinitely if there are too many ) without their matching (.

So at the end, the only acceptable score is 0 if the binary is perfectly "balanced".
n->{int r=0;for(;n>0;n/=2)r+=r<0?0:1-n%2*2;return r==0;}

Try it online!

Really close alternative solution using inline Stream (61 bytes, requires an Integer as parameter for the trick of calling the static toString on n, which wouldn't work with a primitive int) :
n->n.toString(n,2).chars().reduce(0,(a,b)->a<0?a:a+b*2-97)==0

Thunno 2, 6 bytes
`)(BøB

Explanation
`)(BøB  # Implicit input
`)(     # Two character string ")("
   B    # Convert input to base ")("
    øB  # Are the brackets balanced?
        # Implicit output

Screenshot

Scala, 82 bytes
Golfed version. Try it online!
i=>{var b=i.toBinaryString;while(b.contains("10"))b=b.replaceFirst("10","");b<"0"}

Ungolfed version. Try it online!
object Main {
  def main(args: Array[String]): Unit = {
    (1 until 100).filter(x => isBinaryWithout10(x)).foreach(x=>println(s"$x true"))
  }

  def isBinaryWithout10(i: Int): Boolean = {
    var binary = i.toBinaryString
    while (binary.contains("10")) {
      binary = binary.replaceFirst("10", "")
    }
    binary < "0"
  }
}

C# 98 bytes
bool f(int m){int i=0;foreach(char s in Convert.ToString((m),2)){if(s=='1')i+=2;i--;}return i==0;}

open for any suggestions. i like this challange even tho it is old-ish

Nekomata + -e, 7 bytes
Ƃ£E∫Ɔž≥

Attempt This Online!
Ƃ£E∫Ɔž≥
Ƃ           Convert to base-2
 £E         Power of -1
   ∫        Cumsum
    Ɔ       Split into the initial part and the tail
     ž      Check if the tail is zero
      ≥     Check if the initial part is greater than or equal to the tail


text:
De-Parenthesizing a String
Given a properly-parenthesized string as input, output a list of all nonempty substrings within matching parentheses (or outside of all parentheses), with nested parentheses removed. Each substring should be the sequence of characters in exactly the same matching parentheses. Substrings should be listed in order of depth, and substrings of the same depth should be listed in the order they occur in the string. Assume the input is always correctly parenthesized.
You may assume that the input contains only lower-case ASCII letters and parentheses.
Your answer should be a function that, when given a string, returns a list of strings.
Examples:
                   'a(b)c(d)e' -> ['ace', 'b', 'd']
                   'a(b(c)d)e' -> ['ae', 'bd', 'c']
                  'a((((b))))' -> ['a', 'b']
                        'a()b' -> ['ab']
                            '' -> []
                           'a' -> ['a']
          '(((a(b)c(d)e)f)g)h' -> ['h', 'g', 'f', 'ace', 'b', 'd']
'ab(c(((d)ef()g)h()(i)j)kl)()' -> ['ab', 'ckl', 'hj', 'efg', 'i', 'd']

Fewest bytes wins.

Are 'i' and 'd' in the correct order in the last test case?

@Pietu1998 i is less deeply nested than d.

@feersum Oh, right.

Would you mind allowing the other standard submission types as well, in particular full programs? Not all languages have a concept of functions. For default consensus see http://meta.codegolf.stackexchange.com/a/2422/8478 and http://meta.codegolf.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods.

@MartinBüttner Sure. I'm pretty new to code golf; I didn't realize that was an issue.

@redstonerodent The wording I tend to use is "You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter." and in your case "The output may be in any convenient, unambiguous, flat list format."

JavaScript ES6, 91 93 104 133 148
Edit2 2 bytes saved thx user81655
Edit Using more strings and less arrays
Test running the snippet below in an EcmaScript 6 compliant browser

f=s=>[...s].map(c=>l+=c<')'||-(o[l]=(o[l]||'')+c,c<'a'),o=[],l=0)&&(o+'').match(/\w+/g)||[]

// Less golfed

u=s=>{
  o=[]; l=0;
  [...s].map(c=>{
    if (c>'(') // letters or close bracket
      o[l]=(o[l]||'')+c, // add letter or close bracket to current level string
      l-=c<'a' // if close bracket, decrement level
    else
      ++l // open bracket, increment level
  })
  o = o+'' // collapse array to comma separated string
  return o.match(/\w+/g)||[] // fetch non empty strings into an array
}

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[ 'a(b)c(d)e'                    // ['ace', 'b', 'd']
 , 'a(b(c)d)e'                    // ['ae', 'bd', 'c']
 , 'a((((b))))'                   // ['a', 'b']
 , 'a()b'                         // ['ab']
 , ''                             // []
 , 'a'                            // ['a']
 , '(((a(b)c(d)e)f)g)h'           // ['h', 'g', 'f', 'ace', 'b', 'd']
 , 'ab(c(((d)ef()g)h()(i)j)kl)()' // ['ab', 'ckl', 'hj', 'efg', 'i', 'd']
].forEach(t=>console.log(t +" -> " + f(t)))

Save 2 bytes with c=>l+=c<')'||-(o[l]=(o[l]||'')+c,c<'a'),.

@user81655 nice, thanks

Julia, 117 86 83 bytes
v->(while v!=(v=replace(v,r"(\(((?>\w|(?1))*)\))(.*)",s"\g<3> \g<2>"))end;split(v))

It's a regex solution.
Ungolfed:
function f(v)
  w=""
  while v!=w
    w=v
    v=replace(v,r"(\(((?>\w|(?1))*)\))(.*)",s"\g<3> \g<2>"))
  end
  split(v)
end

r"(\(((?>\w|(?1))*)\))(.*)" is a recursive ((?1) recurses group 1) regex that will match the first outermost balanced parentheses (that don't contain unbalanced/reversed parentheses), with the second group containing everything inside the parentheses (not including the parentheses themselves) and the third group containing everything after the parentheses (until the end of the string).
replace(v,r"...",s"\g<3> \g<2>") will then move the second group to the end of the string (after a space, to act as a delimiter), with the relevant parentheses removed. By iterating until v==w, it is ensured that the replace is repeated until there are no parentheses left. Because matches are moved to the end, and then the next match goes for the first parenthesis, the result will be the string broken down in order of depth.
Then split returns all of the non-whitespace components of the string in the form of an array of strings (that have no whitespace).
Note that w="" is used in the ungolfed code to make sure that the while loop runs at least once (except if the input string is empty, of course), and is not needed in the golfed form.
Thanks to Martin Büttner for assistance with saving 3 bytes.

Neat, I've arrived at the same solution independently in Retina. It's 44 bytes there, but as it stands full-program solutions are not allowed. :/

You can save three bytes by using \w instead of [^()].

@MartinBüttner - thanks. I'd actually considered that, but I was worried that I'd overlooked something and that it would fail on some edge case. If you say it's fine, though, then it's fine.

Python, 147 bytes
def f(s):
 d=0;r=[['']for c in s]
 for c in s:
  if c=='(':d+=1;r[d]+=['']
  elif c==')':d-=1
  else:r[d][-1]+=c
 return[i for i in sum(r,[])if i]

Unit tests:
assert f('a(b)c(d)e') == ['ace', 'b', 'd']
assert f('a(b(c)d)e') == ['ae', 'bd', 'c']
assert f('a((((b))))') == ['a', 'b']
assert f('a()b') == ['ab']
assert f('') == []
assert f('a') == ['a']
assert f('(((a(b)c(d)e)f)g)h') == ['h', 'g', 'f', 'ace', 'b', 'd']
assert f('ab(c(((d)ef()g)h()(i)j)kl)()') == ['ab', 'ckl', 'hj', 'efg', 'i', 'd']

I like this puzzle; it's very cute!

Pyth, 32 bytes
fTscR)uX0.<GJ-FqLH`()@[Hdk)Jzmkz

Test suite
Loosely based off of @Quuxplusone's approach. Builds up space separated lists of the characters at each depth, then splits them and filters out the empty groups. The working list is rotated to keep the current depth's list in front at all times.

Retina, 44 41 bytes
+`\(((\w|(\()|(?<-3>.))*).(.*)
$4 $1
S_`

Run with the -s flag. Notice the space at the end of the last line.
I came up with this solution independently of Glen O but it turns out to be identical. The idea is to match the first pair of parentheses, remove it, and insert its contents at the end of the output (repeatedly). Due to .NET's lack of recursion in regex, I had to use balancing groups which is four bytes longer.
If you don't understand the first regex, let me refer you to my SO answer about balancing groups. Since the input is guaranteed to be correctly parentheses, we can save two bytes by matching ) with . instead of \). Then we simply match the rest of the string with (.*). $4 $1 first writes back said rest of the string (omitting both the parentheses and their content), and then the content of the parentheses after a space. The +` tells Retina to repeat this step until the string stops changing (which only happens once all parentheses have been removed).
Empty parentheses will result in two consecutive spaces, so finally we split the entire string on spaces (S` activates split mode and the regex is a single space). The _ option tells Retina to omit empty parts of the split, so we don't include the empty results in the output.

Common Lisp, 160
(lambda(x)(labels((g(l)(cons(#1=format()"~(~{~A~}~)"(#2=remove-if'listp l))(mapcan #'g(#2#'atom l)))))(remove""(g(read-from-string(#1#()"(~A)"x))):test'equal))))

This could be four bytes less if the case conversion wasn't necessary.  The idea is to add left and right parenthesis to each side of the input string, treat it as a list, write the top level elements of the list to a string, and then process the sublists the same way.

Haskell, 114 112 111 bytes
')'%(h:i:t)=("":i):t++[h]
'('%l=last l:init l
c%((h:i):t)=((c:h):i):t
g x=[a|a<-id=<<foldr(%)(x>>[[""]])x,a>""]

Usage example: g "ab(c(((d)ef()g)h()(i)j)kl)()" -> ["ab","ckl","hj","efg","i","d"].
I'm going backward through the input string. The intermediate data structure is a list of list of strings. The outer list is per level and the inner list is per group within a level, e.g. [["ab"],["ckl"],["hj"],["efg","i"],["d"]] (note: the real list has a lot of empty strings in-between). It all starts with a number of empty strings equal to the length of the input - more than enough, but empty lists are filtered out anyway. The outer lists either rotates on (/) or adds the character to the front element. ) also starts a new group.
Edit: @Zgarb has found a byte to save.

You might want to add a Try it online! link

Sed, 90 bytes
:
s/^(\w*)\((.*)\n?(.*)/\1\n\3_\2/M
s/(\n\w*_)(\w*)\)(.*)/\3\1\2/M
t
s/[_\n]+/,/g
s/,$//

Uses extended regexes (-r flag), accounted for by +1 byte. Also, this uses a GNU Extension (the M flag on the s command).
Sample Usage:
$ echo 'ab(c(((d)ef()g)h()(i)j)kl)()' | sed -r -f deparenthesize.sed
ab,ckl,hj,efg,i,d

Explanation:
Since sed does not support stuff like recursive regexes, manual work is required. The expression is split up into multiple lines, each representing a level of nesting depth. The individual expressions on the same depth (and hence on the same line) are separated by an _. The script works through the input string one bracket at a time. The remaining input is always kept on the end of the line that corresponds to the current nesting level.

05AB1E, 23 21 17 16 bytes
Thanks to @ovs for -2
Thanks to @ovs for additional -4
ΣžuSQÆ®+©}'(¡')м

Try it online!
The program contains empty strings in the output, which should be ignored. In case that's not allowed it's +3 for ʒgĀ.

½ is a builtin for i¾}.

Checking both for both brackets at once and using the registers for counting the nesting level is a bit shorter: https://tio.run/##AT8AwP9vc2FiaWX//86jxb51U860UcOGwq4rwql9JyjCoScp0Lz//2FiKGMoKChkKWVmKClnKWgoKShpKWopa2wpKCk

That δ isn't needed

Python, 161 bytes
Here's what I came up with, a one-line functional python solution:
p=lambda s:filter(None,sum([''.join([s[i]for i in range(len(s))if s[:i+1].count('(')-s[:i+1].count(')')==d and s[i]!=')']).split('(')for d in range(len(s))],[]))

This challenge was inspired by https://github.com/samcoppini/Definition-book, which outputs a long string with word defined in parentheticals. I wanted to write code that would give me each sentence, with parenthesis removed. The functional solution is too slow to be effective on long strings, but imperative solutions (like @Quuxplusone's solution) are much faster.

APL (Dyalog Unicode), 56 bytes
{a←⍬⋄(×≢¨a)/a←a,⊂'\([^()]*\)'⎕R{''⊣a,←⊂⍵.Match~'()'}⍣≡⍵}

Try it online!
A dfn which uses repeated regex replacement, and returns a list of strings (unordered).

That's 86 bytes. It's 56 characters.

@CommandMaster APL uses a custom codepage, just like what your 05AB1E submissions use: SBCS