text:
Markov Chain Quine
A simple Markov Model will be used in this question. For more information about Markov Chains, see http://setosa.io/ev/markov-chains/.
Take a string. For this example, we will use the word:
reader

Now, for each character, take the characters that appear after each occurence of the character in the string. (`^` represents the start of the string and `$` represents the end)
`^` -> {'r'}       # After the start of the string, there is an `r`.
'r' -> {'e', `$`}  # After the first `r` (*r*eader), there is an `e`
                   # after the second (reade*r*), there is the end of the string.
'e' -> {'a', 'r'}
'a' -> {'d'}
'd' -> {'e'}

Now, starting from the start of the string, pick randomly from one of the characters in the next set. Append this character and then pick from the characters in its next set, and so on until you get to the end. Here are some example words:
r
rereader
rer
readereader

If a character appears after another character multiple times, it is more likely to be chosen. For example, in cocoa can, after a c, there is a two thirds of a chance of getting an o and a one thirds chance of getting an a.
'c' -> {'o', 'o', 'a'}

Challenge
Create a program that takes no input and outputs a random string generated using a Markov Chain, like above, where the input to the chain is the program's source.

The program must have at least two characters, two of which must be the same (To prevent "boring" chains that only have one output)
You can modify the model to use bytes instead of characters if you wish, but change "characters" to "bytes" in rule 1
The program should output strings randomly with the expected frequency in theory

This is code-golf, so the shortest program wins!

@mbomb007 all the information is in the question, the link is just extra if you get interested (This is a very basic implementation)

Why are the ^ and $ in quotes? it might make it more clear to take it out of quotes, or put them in backquotes.

Pip, 64 bytes
This was fun.
t:V Y\"m:"Yt@0T9=A OyY@>RC(t(Xy).'.)"ST["t:V Y"RPy";Vm"C9]\";Vm<tab>

<tab> represents a literal tab character (0x09). Try it online!
How?
TL;DR: escaped-string syntax, repr, and eval.
For strings that need to contain literal " characters, Pip has escaped strings, using \" as the delimiter. A standard quine using escaped strings would look like this:
V Y\""V Y".RPy\"

That is: Yank (storing as y) a string containing "V Y".RPy and eVal it. RPy takes the repr of y, to which we prepend the literal string V Y. Finally, output the result of the eval.
The structure of the Markov quine is similar, except that we want to save the code instead of outputting it and then do some stuff with it afterwards. t:V Y\"...\" assigns the eval result to t. Inside the eval'd code, m:"..." assigns a string of code to m, which we will evaluate at the end with Vm.
ST["t:V Y"RPy";Vm"C9] builds a list containing
"t:V Y"  Literal string
RPy      Repr(y)
";Vm"    Literal string
C9       Tab character

and converts it to a string, which by default concatenates all the items. This section is equivalent to "V Y".RPy in the original quine. Since it is the last expression in the big eval string, its value is what the V operator returns, and thus what gets assigned to t.
Thus, after the eval and assignment, t is equal to the full code, and m contains
Yt@0T9=A OyY@>RC(t(Xy).'.)

Now Vm evaluates that as code. Let's break down what happens.
                            We'll use y to hold the current character in the chain
Yt@0                        Yank first character of t into y (chain always starts there)
         Oy                 Output y without newline each time we...
    T9=A                    Loop till ASCII code of y equals 9 (tab)
                            Since there's only one literal tab, at the end of the program,
                              this satisfies the Markov chain ending requirement
                   Xy       Generate a regex that matches y
                  (  ).'.   Concatenate . to regex: now matches y followed by any character
                (t       )  Find all matches in t (returns a list)
              RC            Random choice from that list
           Y@>              Slice off the first character and yank the remaining one into y

A couple notes:

Ending the code with a literal tab was shorter than doing a regex test for "next character or end of string."
The regex I used does not work properly if there are doubled characters in the code; for instance, applying it to xxy would return only xx and not xy in the matches. Fortunately, however, there are no doubled characters in this code, so it doesn't matter.

JavaScript, 217 215 bytes

a="a=q;a=a.replace('q',uneval(a));for(b=c='a';d=a.split(c),c=d[Math.random()*~-d.length+1|0][0];b+=c);alert(b)";a=a.replace('q',uneval(a));for(b=c='a';d=a.split(c),c=d[Math.random()*~-d.length+1|0][0];b+=c);alert(b)

Note that this uses uneval, which is only supported by Firefox. Sample runs:
a=ale(a.lend[Ma=d[Macepla.ler(b+=c)b=q;fom(a=q;a=dort(b+1|0],c);a.lit(a)
at(c=c;d[0],c=q;ath+1|0][0];dorerac=ac=d[Ma),c;)*~-d[Ma=alenepl(b+=ac=c;a=c;d[2];d.re(c;fom()
a="a[0],und=d=a)
angt(b),und=d.l(b=a)
a)
ale(a.rth.revanepleplit(b)
ac);fore(b)*~-d.r(b+1|0];fora';a)*~-d.splalith+=dorth+=c=";ath+=a.length+=';ale(b)
a.r(b=c=a)b+1|0],und[0][0];d.splerath.spleneva)";ath.r(ceneplith+=d=aceple(c;)*~-d=';ala';)b='ac;fom(b=c;a.ler(b=d=d[Ma.rt(c=cendor()*~-d='a=";ac;a.spla)b=ceva=';a=d.rt(angt(alength+1|0],c;angt()
al(ac=dorth+1|0][0][0][0][Ma.split()

As you can see, it's mostly gibberish, but that is to be expected ;) The OP has created a JSFiddle which demonstrates that the chance of an output being syntactically valid JS is  about 6.3%.

If self-reading functions were allowed, this could be 78 bytes of ES6:
f=(c="f",p=("f="+f).split(c),q=p[Math.random()*~-p.length+1|0][0])=>q?c+f(q):c

Very, very rarely, this outputs syntactically valid JS:
f=>e?c+f():c
f=>e?c=>engt():c
f=>e?c=(e):c
f=>e?c=>e=>ength.split():c
f=p=>q?c+f():c
f(q).sp=",p[Mat(q?c=(),plith.lith.sp.sp[0]).lendom().lith+f=>q=p.lendom(",p=p=>q?c+f():c
f(q),q?c=(c=(q)*~-p[0]):c
f().random(),q?c=(c=p[0]):c
f=>q?c=(q="+f"+f).rath.split(c):c
f="+1|0])=().lith.rat()*~-p=>q?c=p[Mat(c=",q?c=p.rath.splendom()*~-plength.splith.lendom(c):c

My favorite of the function names it's created is .splendom() (split + length + random)

I wonder what the probability of this generating valid JavaScript is. (Nerd snipe warning)

@DanTheMan Certainly very, very low. Just the probability of all parentheses and brackets being balanced is incredibly low. Although one time I got a.splerength.r(), which could be valid ;)

Might want to note this is FF only due to the use of uneval

@ShaunH Thanks, I forgot that only FF supports uneval.

Shouldn't uneval(a) and a+'' work the same?

@DanTheMan uneval(a) on a string returns a wrapped in quotation marks. e.g. uneval("Hi!") -> "\"Hi!\""

@ETHproductions Duh.

The second self-reading function isn't valid (http://meta.codegolf.stackexchange.com/a/4878/48878 "a quine must not access its own source, directly or indirectly."), and @DanTheMan, according to https://jsfiddle.net/kabkfLak/1/, the chance should be around 6.3%.

@Artyer I didn't figure they were; that's why I didn't remove the full program. And that JSFiddle is awesome :)

@Artyer Apparently the function has around a 0.02% chance of generating valid JS: https://jsfiddle.net/hbzasbg8/2/

I really enjoy the function/variable names in this too! Perl is just so much punctuation, but this and Ruby generate some great new words!

MS-DOS machine code (.COM file), 126 bytes
(A 63-byte variant would be possible if the program was allowed to read its own code.)
The first half (63 bytes) of the program are code and look like this:
FC BE<3F>01 AC 50 88 C2 B4 02 CD 21 E8 1A 00 59
4E AC 81 FE<7E>01 7C 03 BE<3F>01 38 C1 75 F2 FE
CA 75 EE 81 FE<3F>01 75 DB 8A 16 00 80 31 C0 8E
D8 31 C9 AC 00 C2 E2 FB 0E 1F 88 16 00 80 C3

The second half (63 bytes) are data and are a 1:1 copy of the code.
(In the 63-byte variant reading its own code, the bytes marked with "<>" have different values and the second half of the program is not present.)
I'm also not sure about the random generator's probability distribution:
The program uses the fact that the clock counters and other information modified by interrupts are stored in segment 0 to generate random numbers.
Converted to assembly code the program looks like this:
# 0x100:
    cld                # Ensure SI is being incremented
    mov si, programEnd # Move SI to the first byte of the copy of the program
nextOutput:
    lodsb              # Load one byte of the program ...
    push ax            # ... save it to the stack ...
    mov dl, al         # ... and output it!
    mov ah, 2
    int 0x21
    call pseudoRandom  # Create a random number (in DL)
    pop cx             # Take the stored byte from the stack
    dec si             # Go back to the last byte loaded
nextSearch:
    lodsb              # Load the next byte
                       # If we loaded the last byte ...
    cmp si, 2*programEnd-0x100
    jl notEndOfProgram # ... the next byte to be loaded ...
    mov si, programEnd # ... is the first byte of the program.
notEndOfProgram:
    cmp cl, al         # If the byte loaded is not equal to ...
                       # ... the last byte written then ...
    jne nextSearch     # ... continue at nextSearch!
    dec dl             # Decrement the random number and ...
    jnz nextSearch     # ... continue at nextSearch until the ...
                       # ... originally random number becomes zero.
    cmp si, programEnd # If the last byte read was not the last byte ...
    jnz nextOutput     # ... of the program then output the next ...
                       # ... byte!

    # Otherwise fall through to the random number generator
    # whose "RET" instruction will cause the program to stop.

    # The random number generator:
pseudoRandom:
    mov dl, [0x8000]   # Load the last random number generated
                       # (Note that this is uninitialized when
                       # this function is called the first time)
    xor ax, ax         # We use segment 0 which contains the ...
    mov ax, ds         # ... clock information and other data ...
                       # ... modified by interrupts!
    xor cx, cx         # Prepare for 0x10000 loops so ...
                       # ... all bytes in the segment are processed ...
                       # ... once and the value of SI will be ...
                       # ... unchanged in the end!
randomNext:
    lodsb              # Load one byte
    add dl, al         # Add that byte to the next random number
    loop randomNext    # Iterate over all bytes
    push cs            # Restore the segment
    pop ds
    mov [0x8000], dl   # Remember the random number
    ret                # Exit sub-routine

programEnd:
    ## Place a copy of the code as data here ##

Non-competing is reserved for answers that meet the challenge criteria but are using a language or feature newer than the challenge. Either post the variant that doesn't read its own source, or delete the answer.

Non-competing is a (now obsolete) note relating to submissions being in languages that postdate the challenge; we do require all submissions to be valid, and non-competing doesn't bypass that. As such, I am removing this answer as per our policy for handling invalid submissions. Feel free to edit to a valid solution and flag for undeletion.

C, 306 328 585 611 615 623 673 707 bytes
Source code:

p[256][256]={0};char*X="p[256][256]={0};char*X=%c%s%c,Y[999],c,j,*a;main(){sprintf(Y,X,34,X,34);for(a=Y;*a;a++)p[*a][*(a+1)]++;for(j=*Y;putchar(c=j);)while(p[c][++j]<<16<rand());}",Y[999],c,j,*a;main(){sprintf(Y,X,34,X,34);for(a=Y;*a;a++)p[*a][*(a+1)]++;for(j=*Y;putchar(c=j);)while(p[c][++j]<<16<rand());}

With newlines and whitespace added for legibility/explanation:
01  p[256][256]={0};
02  char*X="p[256][256]={0};char*X=%c%s%c,Y[999],c,j,*a;main(){sprintf(Y,X,34,X,34);for(a=Y;*a;a++)p[*a][*(a+1)]++;for(j=*Y;putchar(c=j);)while(p[c][++j]<<16<rand());}",
03  Y[999],c,j,*a;
04  main(){
05      sprintf(Y,X,34,X,34);
06      for(a=Y;*a;a++)p[*a][*(a+1)]++;
07      for(j=*Y;putchar(c=j);)
08          while(p[c][++j]<<16<rand());
09  }

Explanation
Line 01: p[][] holds the counts of one character following another.
Line 02: X contains the program's source, escaped with %c%s%c.
Line 03: Y will contain the program's literal source. c, j, *a are counting variables.
Line 05: Set Y to contain the quine.
Line 06: Count letter occurrences in p[][].
Line 07: Print the current state.
Line 08: Find the next character randomly, proportional to the counts in p[][].
Sample output:
p[++);p[99]=Y;putfor(aind(a++j,*a+j=j,c][c,*an(arile(pr*Y,Y[256]<<1);)][*Y,Y;)wha+++j=*aintfor*Y;prin(a+j]=j][256<1)pr(a;a;f(p[char(Y;for());};a;ma;ma=%s%chain(Y;ar(j][256<<<1)p[256<<raile(cha][9]<rin(j,34,34,Y[256]+j,Y,34,Y,c=Y,*a;*a;for(){0}

Can you add a version without newlines and whitespace so we can verify the byte count?

Yes, I've added the single line version at the top.

Perl 5, 81 bytes
Based on the standard quine and my answer to this question:
$_=q{@$=a^E;@$="\$_=q{$_};eval"=~/(?<=\Q$@\E).?/g,print$@while$@=$$[rand@$]};eval

Try it online!
As with the faux source code answer, this sometimes produces valid Perl, but very infrequently (<2%):
$$$_=al
$_=a^E;eval
$_=al
$$=q{$$]};eval
$@=a^E;@whil
$_=q{@\E;e$]};evaleva^E;eval
$$=q{@\$_=a^E;evant$@$="=$$]};evaleval
$_=q{@whind@$_=$]};eval
$_=q{@\$@=~/(?<=\$[rilevale$=ant$[rint$_};evaleval
$_=aleval
$_=q{@$_};@whil
$$=q{@$=q{@$=\E;evand@whint$_};eva^E).?<=$=~/g,prand@$_=al"\E;e$@\E).?/g,prant$_};evaleval
$_=\$_=~/g,prind@=q{$]};@$@\Q$$$_};e$@$_=q{@$_=~/g,pril
$_=q{$=aleval"\E;evaleva^E;eva^E).?/g,pra^E;eva^E).?/(?/g,print$@$_};eval
$@=q{$_=~/(?<="\$_};eval

If you told me the first example was valid Perl I would believe you.

@dohaqatar7 I misunderstood your comment at first and thought you wouldn't believe me if I said the main code was valid Perl... :D http://www.zoitz.com/comics/perl_small.png

@ankh-morpork: it's clearly invalid, q{ is the start of a string literal and there's no } to close it. Perl's actually fairly bad at running random sequences of bytes (and when it does, it's normally due to an early string literal or comment).

Rust, 564 bytes (not competitive)
extern crate rand;fn main(){let t=("extern crate rand;fn main(){let t=", ";let mut s=format!(\"{}{:?}{}\",t.0,t,t.1).into_bytes();s.push(0);let mut r=rand::thread_rng();let mut c=s[0];while c!=0{print!(\"{}\",c as char);let u=s.windows(2);c=rand::sample(&mut r,u.filter(|x|x[0]==c),1)[0][1];}}");let mut s=format!("{}{:?}{}",t.0,t,t.1).into_bytes();s.push(0);let mut r=rand::thread_rng();let mut c=s[0];while c!=0{print!("{}",c as char);let u=s.windows(2);c=rand::sample(&mut r,u.filter(|x|x[0]==c),1)[0][1];}}

Since I already had written a pretty neat Rust quine for another question, I thought I'd adapt it for this, since it seemed simple enough. While the original was small, though, for this I have made very little attempt to minimize size. Here's an expanded version to explain what's going on:
// Random numbers are removed from the standard library in Rust,
// I had to make a cargo project to even compile this...
// Rust is hardly a golfing language.
extern crate rand;

fn main(){

    // The quine is fairly simple, we just make a tuple with
    // "everything before this tuple" as first element, and
    // "everything after this tuple" with any quotes escaped
    // as second. That makes it really easy to print.
    let t=("[...before...]", "[...after...]");

    // Instead of printing it, we save it as a byte vector
    // and append 0
    let mut s=format!("{}{:?}{}",t.0,t,t.1).into_bytes();
    s.push(0);

    // Start with the first character
    let mut c=s[0];
    let mut r=rand::thread_rng();

    while c!=0 {
        print!("{}",c as char);

        // We slide a 2 wide window over it to save a vector
        // of all bigrams.
        let u=s.windows(2);

        // Filter it to only those which have the current character
        // as first. Take one at random, its second is our next
        // character.
        c=rand::sample(&mut r, u.filter(|x|x[0]==c), 1)[0][1];

        // Keep at it until the 0 byte is generated.
    }
}

Sample output 1:
eran(),0{ller=samarin chas c).pr,teteran mut madoletet manthilaplerng().wind_byt.wit();let.u.0][*s=[*s.plleas.wshit, rnd:Vec<_byte mputextet ut t leat=r,t rant!=r().filllet rng();lar("{}{let.ind_byt.what amusarando_ramut!=st ct!(\").0]=colet!(&lec<_ret.plec=s.whrararandormpr=saile ret=r,0]=r);le(\"),t und;fint.prilt!();ler(2).forap(&ler=s(),t ut rat mu:t=ramund:Ve s.putec==[0];wst and_byt sh(\"et c s[1), munwhras[0];c=s=s="etornws(2)[0, ain(|x|x[0,0,0];fowile c ct(&l=",tes().co_byt().wrmat ash(|x|x[*s.lethrant.wrarmu.file(\"et, r==[1);uterile().0,t ando_rinwhas=[0{}"ect.wilant!("{ple mut, mut mamprmant,0];le(&lec=s.1),t co_>=fin mamustec!(\",c=[0];}}",0];leteteat.ust(",ternwhashrarmut ler("erat,0]==file and_reter==s.utet an letet.ut=", ras.1);fin("{:?}"et t letes[*sado_bytet rnd::Verain s[0];whant(){}{}\"echin s(2);lerad;wst reth(\",t u.iletermat c 1];}{}

Sample output 2:
et!().0][0][0{}

Ruby, 152 bytes
0;s="0;s=%p<<33
0until putc($/=Hash[[*(s%%s).chars.each_cons(2)].shuffle][$/])==?"<<33
0until putc($/=Hash[[*(s%s).chars.each_cons(2)].shuffle][$/])==?!

Sample output:
0;s.c($/=Has(s).ears(2).ch[*(2)=Hacontc(2).ears.eas=Has==Hars%putc($/]).ears%sh_chuffl puns=Hachach[$/==?!

or
0;s.ch[*($/=%pufl puns($/=%s.shas($/=Harsh_chutilears)])].e]).s)=Hac($/=="<<33\ntile].chufffle][[$/=Hars%sh_c(2)=%p<<<<<33
0;s)].ears)=Hars).c(s).eacon0un0;sh_c($/][*(s.s=Hacons=?!

Quines using string formatting via "s%s", and does the Markov chaining by taking all two-character slices, shuffling them, and turning them into a Hash dictionary, where for duplicate keys the last appearance defines the value. To avoid adding extra logic for the beginning, I track the most recently output character using $/, which is automatically initialized to a newline, and ensure that newlines are always followed in the code by 0, the same character the code starts with. For the end, I manipulate the source code so that there's only one ! so we always end after the bang, using <<33 to add it without the literal. This could be golfed further using an unprintable single-digit character instead of ASCII 33, but that seemed too annoying.

p<<<<<33 The super-super-super-concat operator? ;-)

That's the "waaaay less than" operator.

I love the words this generates! The fact the first example is so concerns if the object Has(s).ears(2) makes me chuckle!

Python 2, 211 bytes
Outputs the result to stderr.
import random;X='q=[(list(t)+["$$"])[i+1]for i in range(len(t))if t[i]==c];c=random.choice(q)\nif c=="$$":exit(o)\no+=c\nexec X';s='import random;X=%r;s=%r;q=t=s%%(s,X);o=c="i";exec X';q=t=s%(s,X);o=c="i";exec X

Try it online
Sample output:
i+[(s,X)));exenit(or;q=rt(t(t(t);o='ic\n(q)+1]=c\ndor randort))\ngeno));X)\nge(st))ic]=";oic=%ran(s%%(s%rt(q)\ngexe(s=st(t[(s=[if X=%(ompoiforanom;e(t X="$"$"ic="$"i";X=c rt X

Brief Explanation:

This program uses the s='s=%r;print s%%s';print s%s quine format. I create a string s, which will contain the entire program.
The string X contains the procedure to execute recursively.
The procedure builds the output string o, which will be printed to stderr upon reaching the end of the Markov chain.
The end of the chain is represented by the string $$, using two characters so that the program will work for all strings. I could have used a character not in my program like chr(0), but I think that's longer.
The character chosen each execution is placed in c, which (along with o) is initialized to the first character of the program.
The list of characters that follow each occurrence of choice c in the string t (the variable holding the quine of the source code) is q, which will be chosen from for the next selection of c.

PHP, 144 135 130 120 272 220 212 bytes
<?$e='$p=$n="";foreach(str_split($s)as$w)$p=$m[$p][]=$w;do echo$n=$m[$n][array_rand($m[$n])];while("\n"!=$n);
';$s='<?$e=%c%s%1$c;$s=%1$c%s%1$c;$s=sprintf($s,39,$e,$s);eval($e);';$s=sprintf($s,39,$e,$s);eval($e);

Or, formatted for readability:
<?$e='$p = $n = "";
foreach (str_split($s) as $w) {
    $p = $m[$p][] = $w;
}
do {
    echo $n = $m[$n][array_rand($m[$n])];
} while ("\n" != $n);
';$s='<?$e=%c%s%1$c;$s=%1$c%s%1$c;$s=sprintf($s,39,$e,$s);eval($e);';$s=sprintf($s,39,$e,$s);eval($e);

Sample output:
<?p=')ay_r_gecorr_splililen]=$p=$w;

and:
<?p=$n=$ntststs$m[$n=$m[ay_r_chondo$n=$ph(s$nt(fitstr_r_geantentr_s('m[$n=$n"!=$p etstsp][$w;d(fililile(s$w)$nt(sphor_str_getrarast(''''m[$n='m[$m';

and:
<?p=$who eay_re($n=$n=$nt(')];d(fililileando et($m[]=$pleay_ch(')aray_ren='''))ay_st_r_s($m[$m[asp])ay_co$m[$p $phorentechitr_rean)][$n=$nd("\n"!=$n=$wh(filend('')ay_gen=$ndo$nt_rasp=$n][$p=$whp=$n='m[$n"\n)))))][$w;dorechph(';dorracho$ple_s$w;fil

and:
<?ph($n);

PHP Cheating, 117
For the curious, if we cheat by reading our own source, we can do 117:
<?=$p=$n='';foreach(str_split(file('m')[0])as$w)$p=$m[$p][]=$w;do echo$n=$m[$n][array_rand($m[$n])];while("\n"!=$n);

Welcome to the site! Unfortunately we have some rules about what counts as a proper Quine for challenges like this and unfortunately reading from your own source is forbidden.

Oh, good, thank you.  I was looking for the rules.  I'll have to revise this.

Vyxal D, 18 bytes
`{Ȯq‛DĖ+$/Ḣ℅h:₴`DĖ

Try it Online!
Sample outputs:
`{Ȯq‛DĖ
`DĖ
`{Ȯq‛DĖ+$/Ḣ℅h:₴`{Ȯq‛DĖ
`DĖ+$/Ḣ℅h:₴`{Ȯq‛DĖ+$/Ḣ℅h:₴`DĖ+$/Ḣ℅h:₴`{Ȯq‛DĖ+$/Ḣ℅h:₴`DĖ
`DĖ+$/Ḣ℅h:₴`{Ȯq‛DĖ

Explanation:
`              `D  # push this string to the stack and triplicate => [ <code> , <code> , <code> ]
                 Ė # Execute the top => [ <code>, <code> ]
 {                 # While true
  Ȯ                # push the second to last item on the stack => [ <code> , <code> , <code> ]
   q‛DĖ+           # quote and add ‛DĖ => [ <code> , <code> , `<code>`DĖ ]
        $          # swap => [ <code> , `<code>`DĖ , <code> ]
         /Ḣ        # split and discard the first element => [ <code> , [`DĖ] ]
           ℅h      # choose at random an element and get it's first element => [ <code> , ` ]
             :₴    # duplicate and print without a newline => [ <code> , ` ]
## on loop ##
 {                 # While true
  Ȯ                # push the second to last item on the stack => [ <code> , ` , <code> ]
   q‛DĖ+           # quote and add ‛DĖ => [ <code> , ` , `<code>`DĖ ]
        $          # swap => [ <code> , `<code>`DĖ , ` ]
         /Ḣ        # split and discard the first element => [ <code> , [<code>, DĖ] ]
           ℅h      # choose at random an element and get it's first element (or error and stop the program) => [ <code> , <char> ]
             :₴    # duplicate and print without a newline => [ <code> , <char> ]

Also 18 bytes
`q‛:Ė+:{h~/$₴Ḣ℅`:Ė

Try it Online!

Julia 1.7, 103 bytes
(c='(';a=:((c = (q = "(c='(';a=:($(a)))|>eval")[(print(c) != 1) + rand(findall(c, q))]):eval(a)))|>eval

Try it online!
All those spaces are painful but necessary because the code is stored in an Expr (AST), which will add spaces when interpolated. Replace print(c) with println(q) to check the validity of the quine.
based on this quine:
(a=:(print("(a=:($(a)))|>eval")))|>eval Try it online!

Python 3.8 (pre-release), 103 102 bytes
exec(s:="from random import*;c='e'\nwhile c:print(end=c);c=choice(f'exec(s:={s!r})'.split(c)[1:])[0]")

Try it online!
the program stops by crashing due to an IndexError. To avoid crashing, [0] must be replaced by [:1] for the cost of 1 byte
How it works?

I started from the quine exec(s:="print('exec(s:=%r)'%s)")

then the core program is the following :
from random import*
c='e'
while c:
  print(end=c)
  c=choice('<the quine string>'.split(c)[1:])[0]

I assign c to the first letter of our quine (e).

while c is not the empty string :

I print c
I randomly choose a successor of c beween all possible successor

to choose a successor :

let say our string is "abacbdeb" and I want a successor of 'b':
I split the string using 'b' as separator : ['a','ac','de','']
I remove the first substing which corresponds to the char before the first occurence of b : ['ac','de','']
I take up to 1 char of these substring : ['a','d','']

If the char is at the end of a string, it will have the empty string as potential successor and will crash the program when atempting to get its first character. It only works beacuse no char is repeated twice.


text:
Produce Dürer's magic square
The challenge
Output an array or string representation of Dürer's famous magic square:

that is,
16  3  2 13
 5 10 11  8
 9  6  7 12
 4 15 14  1

Some properties of this square, which can perhaps be exploited, are:

It contains each integer from 1 to 16 exactly once
The sum of each column or row, as well as the the sum of each of the two diagonals, is the same. This is the defining property of a magic square. The sum is the magic constant of the square.
In addition, for this particular square, the sum of each of the four quadrants also equals the magic constant, as do the sum of the center four squares and the sum of the corner four squares.

Rules
Bultins that generate magic squares are not allowed (such as Matlab's magic or Mathematica's MagicSquare). Any other builtin can be used.
The code can be a program or a function.
There is no input.
The numbers must be in base 10. The output format is flexible as usual. Some possibilities are:

A nested array (either function output, or its string representation, with or without separators, any type of matching brackets):
[[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]]

A 2D array:
{16, 3, 2, 13; 5, 10, 11, 8; 9, 6, 7, 12; 4, 15, 14, 1}

An array of four strings, or a string consisting of four lines. The numbers may be right-aligned
16  3  2 13
 5 10 11  8
 9  6  7 12
 4 15 14  1

or left-aligned
16 3  2  13
5  10 11  8
9  6  7  12
4  15 14  1

A string with two different separators for row and column, such as
16,3,2,13|5,10,11,8|9,6,7,12|4,15,14,1

The output format should clearly differentiate rows and columns. For example, it is not allowed to output a flat array, or a string with all numbers separated by spaces.
Code golf. Shortest wins.

Related

Interestingly, the numbers 5, 8, 9 and 12 are in their (1-indexed) positions, 6, 7, 10 and 11 have been reflected vertically, 2, 3, 14 and 15 have been reflected horizontally and 1, 4, 13 and 16 have been rotated 180°. I doubt that will help anyone though.

Possibly useful observation: if you decrement 1 from each number, you can generate the square by starting with the array [15], then repeatedly concatenating it with its reverse with each item XORed by 13, 3, 8, and 15, respectively.

This seems rather hard to compress in non-golfing languages. i think a larger magic square would have done better.

I'm waiting for the Mathematic answer: Print[Dirac]

"Interger", heh...

@carusocomputing Thanks, corrected :-)

I wonder if anyone will try the "Generate a 4x4 grid of randomly generated numbers until it's a magic square" approach and win.

@Caruso With that approach you may produce a different magic square. But perhaps the other conditions do ensure uniqueness

I'm fairly certain each rotation or reflection of the square would have the same properties.

@LuisMendo Could check to see that [0,0] = 16 ;)

Is there a performance requirement of the solutions?

@Emigna No. If it theoretically works it's fine even if it takes a long time or a lot of memory

-1 because you banned magic =(

Jelly, 15 bytes
“¡6ṡƘ[²Ḳi<’ḃ⁴s4

TryItOnline!
Pretty boring, sorry:
Prep: Took the square, read it by rows, converted from bijective base 16, convert that to base 250, looked up the code page indexes for those "digits" (¡6ṡƘ[²Ḳi<).
Jelly then reads the indexes to make a base 250 number, converts to bijective base 16 (ḃ⁴) and splits into chunks of size 4 (s4).

If we are allowed to output a different orientation, upside-down is possible in 14:
“#⁷ƙ¤ṆWȷỤ’ḃ⁴s4

Test

In theory, given enough memory for 16! integers the following would give us the correct orientation in 14:
⁴Œ!“ŒCġŀḌ;’ịs4

This would create all permutations of [1,16] with ⁴Œ! and pick the value at index 19800593106060 (1-based) with ị using the base 250 representation ŒCġŀḌ; and split it into chunks of length 4 with s4.

Since then I have added four new atoms (Œ?, Œ¿, œ?, and œ¿) to Jelly to address such situations.
The monad Œ? takes an integer (or iterable of integers) and returns the shortest possible permutation of running natural numbers which would have the given index (or indexes) in a list of lexicographically sorted list of all permutations of those numbers.
...and it does so without creating any permutation lists.
As such the following would now work for 12 (obviously non-competing):
“ŒCġŀḌ;’Œ?s4

Give It A Go!

This should be shorter in your Jelly fork (which I had forgotten about until right now, sorry).

Oh? How do you think?

Pyth, 18 bytes
c4.PC"H#ût"_S16

Run the code.
c4.PC"H#ût"_S16

    C"H#ût"       Convert the packed string to the number 1122196781940
  .P       _S16   Take that-numbered permutation of the reversed range [16,15,...,1]
c4                Chop into piece of length 4

Reversing the range was meant to lower the permutation index, since the output starts with 16, but I think it only broke even.
This beat out a more boring strategy of converting the table directly to base 17 and then a string (link) for 20 bytes:
c4jC"úz(ás¸H"17

Jelly, 16 15 bytes
4Œ!.ịm0µZḂÞ’×4+

Try it online!
Background
If we subtract 1 from the numbers in the square and divide them by 4 (computing quotient and remainder), a pattern becomes apparent.
quotients and remainders    quotients    remainders

   3 3  0 2  0 1  3 0        3 0 0 3      3 2 1 0
   1 0  2 1  2 2  1 3        1 2 2 1      0 1 2 3
   2 0  1 1  1 2  2 3        2 1 1 2      0 1 2 3
   0 3  3 2  3 1  0 0        0 3 3 0      3 2 1 0

The remainder matrix follows an obvious pattern and is easy to generate. The quotient matrix can be obtained by transposing the remainder matrix and swapping the middle rows.
How it works
4Œ!.ịm0µZḂÞ’×4+  Main link. No arguments.

4Œ!              Compute the array of all permutations of [1, 2, 3, 4], in
                 lexicographical order.
   .ị            Take the permutations at the indices adjacent to 0.5, i.e., the
                 ones at indices 0 ([4, 3, 2, 1]) and 1 ([1, 2, 3, 4]).
     m0          Concatenate the resulting [[4, 3, 2, 1], [1, 2, 3, 4]] with a
                 reversed copy, yielding the matrix
                 M := [[4, 3, 2, 1], [1, 2, 3, 4], [1, 2, 3, 4], [4, 3, 2, 1]].
       µ         Begin a new, monadic chain. Argument: M
        Z        Zip/transpose M, yielding the matrix
                 [[4, 1, 1, 4], [3, 2, 2, 3], [2, 3, 3, 2], [1, 4, 4, 1]].
         ḂÞ      Sort the rows by the lexicographical order of their parities,
                 yielding [[4, 1, 1, 4], [2, 3, 3, 2], [3, 2, 2, 3], [1, 4, 4, 1]].
           ’     Subtract 1 to yield the matrix of quotients, i.e.,
                 [[3, 0, 0, 3], [1, 2, 2, 1], [2, 1, 1, 2], [0, 3, 3, 0]].
            ×4+  Multiply the quotient by 4 and add the result to M (remainders).

Ruby, 49 bytes (shorter than the naive solution!)
It took quite a few attempts to write a snippet for this challenge in a mainstream language that was shorter than what it evaluated to! Per usual rules I've made a program out of it by adding a p  to output it.
p [15,4,8,3].map{|i|[1+i,1+i^=13,1+i^=3,1+i^=13]}

It outputs (the string representation of) an array of arrays. It's longer than wat's Ruby solution that outputs a differently-formatted string, but one byte shorter than the naive program below that simply returns the literal array.
p [[16,3,2,13],[5,10,11,8],[9,6,7,12],[4,15,14,1]] #naive solution, 50 bytes
p [15,4,8,3].map{|i|[1+i,1+i^=13,1+i^=3,1+i^=13]}  #submission, 49 bytes

Explanation: start with numbers 0..15 (38 bytes!)
This is where I started and it´s much easier. If we convert the 0..15 square into binary, we note that each cell contains the value at the bottom of its column XORed with the value at the right hand side of its row:
15 2  1  12            1111 0010 0001 1100
4  9  10 7             0100 1001 1010 0111
8  5  6  11            1000 0101 0110 1011
3  14 13 0             0011 1110 1101 0000

From this we derive the code below. But by using the first column instead of the last column, we save one byte, as shown.
p [12,7,11,0].map{|i|[i^3,i^14,i^13,i]}            #0..15 square, 39 bytes
p [15,4,8,3].map{|i|[i,i^13,i^14,i^3]}             #0..15 square, 38 bytes

The required 1..16 version was more difficult. In the end I realised the way to do it was to add 1 to each cell of the 0..15 square. But as ^ has lower priority than + I needed a lot of parentheses, which ate bytes. Finally I hit on the idea of using ^=. The new value of i is calculated by augmented assignment ^= before the 1 is added to it, so the calculation is done in the correct order.

Nice characterization! A simple realization in Python is 6 chars above hardcode: for a in 12,7,11,0:print[(a^b)+1for b in 3,14,13,0]. It would win if we could do 0 to 15 with for a in 12,7,11,0:print[a^3,a^14,a^13,a].

J, 37 27 bytes
Saved 10 bytes thanks to miles!
4 4$1+19800593106059 A.i.16

Now with less boring! This takes the 19800593106059 permutation of the list i.16, which is 15 2 1 12 4 9 10 7 8 5 6 11 3 14 13 0. Then, that is incremented, then is shaped into a 4 by 4 list.
Alternate version, with no whitespace:
_4]\1+19800593106059&A.i.16

Output, for posterity:
   _4]\1+19800593106059&A.i.16
16  3  2 13
 5 10 11  8
 9  6  7 12
 4 15 14  1
   4 4$1+19800593106059 A.i.16
16  3  2 13
 5 10 11  8
 9  6  7 12
 4 15 14  1

I think _4]\1+19800593106059&A.i.16 works but it could be made shorter possibly

@miles oo, nice use of A..  How did you fin that number?

Monadic A. finds the permutation index of a zero-indexed permutation

@miles huh. I guess I should learn a little more about those functions then.

05AB1E, 18 17 bytes
Thanks to Emigna for saving a byte!
•3øÑ¼ž·Üý;•hSH>4ô

Uses the CP-1252 encoding. Try it online!

Incrementing before chunking saves a byte (>4ô).

@Emigna Ahh, of course! Thanks! :)

JavaScript (ES6), 43 bytes
_=>`16,3,2,13
5,10,11,8
9,6,7,12
4,15,14,1`

Separated by newlines, then commas. I doubt there's any shorter way...

Yeah, this is probably the shortest possible.

sed 39 bytes
c16,3,2,13|5,10,11,8|9,6,7,12|4,15,14,1

Try it Online!
It can't get much simpler than this. And, unfortunately, I don't think it can get any shorter either.

Jelly, 20 bytes
“Ñ¤£Æ¦½¿®µ©¬€¥ÐÇ¢‘s4

Try it online!
This simply looks up the Jelly code point of each character, then slices into subarrays of length 4 with s4.

Javascript ES6, 66 65 55 bytes
Yes, it isn't the shortest one. And yes, it can be reduced.
_=>`f21c
49a7
856b
3ed0`.replace(/./g,_=>'0x'+_-~0+' ')

For now, it isn't perfect. But is something!

Thanks to @Neil's suggestion that could save 5-8 bytes, and that inspired @ETHproductions suggestion that saves 10 bytes!
This makes the answer only 12 bytes longer than his 43 bytes solution.

You could use g instead of 0 and parseInt(c,17) instead, which I think saves you 4 bytes, or you could use +0x${c}||16, which I think saves you 5 bytes, and you could then subtract 1 from all of the digits and add it back later, which I think saves you another byte.

Building on @Neil's suggestions, you can save at least 10 bytes in total.

@Neil Thank you a lot for the idea. Using base17 really does save a few bytes. It really is something I didnt think about.

@ETHproductions Thank you a lot for the suggestion! I'm still trying to understand how it works. But I think I will get there. Now, just need to shorten 13 bytes to beat you. But it does seem your answer is the shortest possible in Javascript

DASH, 24 bytes
<|>4tc"................"

Replace the periods with the characters of charcodes 16, 3, 2, 13, 5, 10, 11, 8, 9, 6, 7, 12, 4, 15, 14, and 1 respectively.
Explanation
Simply converts the characters to an array of charcodes and chunks by 4.

Actually, 22 bytes
4"►♥☻♪♣◙♂◘○♠•♀♦☼♫☺"♂┘╪

Try it online!
Explanation:
4"►♥☻♪♣◙♂◘○♠•♀♦☼♫☺"♂┘╪
 "►♥☻♪♣◙♂◘○♠•♀♦☼♫☺"     push a string containing the numbers in the magic square, encoded as CP437 characters
                   ♂┘   convert to ordinals
4                    ╪  chunk into length-4 slices

Groovy, 57 bytes / 46 bytes
"F21C49A7856B3ED0".collect{Eval.me("0x$it")+1}.collate(4)

Parse each as hexidecimal digit and add 1, collate by 4 into a 2D array.
[[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]]

Shorter, but also lamer:
print '16,3,2,13|5,10,11,8|9,6,7,12|4,15,14,1'

Scala, 52 bytes
()=>Seq(15,4,8,3)map(x=>Seq(x,x^13,x^14,x^3)map(1+))

Ungolfed:
()=>
  Seq(15, 4, 8, 3)
  .map(x=>
    Seq(x, x^13, x^14, x^3)
    .map(1+)
  )

Inspired by Level River St's ruby answer.

PowerShell v2+, 40 bytes
'16,3,2,13
5,10,11,8
9,6,7,12
4,15,14,1'

A literal multiline string, left on the pipeline. Output via implicit Write-Output happens at program completion. Nice and boring.

Constructed version, 77 bytes
'f21c59a7856b3dc0'-split'(....)'-ne''|%{([char[]]$_|%{"0x$_+1"|iex})-join','}

Takes the string, -splits it every four elements, loops on them, changes each to a hex 0x$_ and adds 1, pipes that to iex (short for Invoke-Expression and similar to eval), then -joins the result into a string with , as the separator. Outputs four strings onto the pipeline, with implicit printing.

Ruby, 60 bytes - first attempt
%w(f21c 49a7 856b 3ed0).map{|i|i.chars.map{|i|i.to_i(16)+1}}

Ruby, 45 bytes - cheap
puts '16,3,2,13|5,10,11,8|9,6,7,12|4,15,14,1'

Pyth - 17 bytes
Base conversion. This unfortunately beats @xnor's approach
c4jC"úz(ás¸H"17

Try it online here.

Matlab, 38 35 bytes
Anonymous function:
@()['pcbm';'ejkh';'ifgl';'dnoa']-96

Direct printing (38 bytes):
disp(['pcbm';'ejkh';'ifgl';'dnoa']-96)

In Matlab best way to produce an array of integers is though a string.

Using an anonymous function would save a few bytes: @()['pcbm';'ejkh';'ifgl';'dnoa']-96

@LuisMendo I didn't notice that returning value is also acceptable, thanks!

05AB1E, 15 bytes
16Lœ•iPNÍš¯•è4ä

Explanation
16L              # range [1 ... 16]
   œ             # compute all permutations of the range
    •iPNÍš¯•è    # take the permutation at index 19800593106059
             4ä  # split the permutation into 4 parts

The index of the permutation was found using the formula:
a*15! + b*14! + c*13!+ ... + o*1! + p*0!
Where the variables are replaced with the number of succeeding elements which are smaller than the number at the current index for each number in the target list
[16, 3, 2, 13, 5, 10, 11, 8, 9, 6, 7, 12, 4, 15, 14, 1]
which for our sought after permutation is
a=15, b=2, c=1, d=10, e=2, f=6, g=6, h=4, i=4, j=2, k=2, l=2, m=1, n=2 o=1, p=0
This gives us the formula:
15*15!+2*14!+1*13!+10*12!+2*11!+6*10!+6*9!+4*8!+4*7!+2*6!+2*5!+2*4!+1*3!+2*2!+1*1!+0*0!
which is equal to 19800593106059.

Python 3, 51 47 bytes
print("16,3,2,13|5,10,11,8|9,6,7,12|4,15,14,1")

Try it online!
Some solutions @xnor mentioned in the comments.
Python 3, 54 bytes (construction)
for a in 12,7,11,0:print([(a^b)+1for b in[3,14,13,0]])

Try it online!
Python 3, 43 41 bytes (0 to 15)
for a in 12,7,11,0:print(a^3,a^14,a^13,a)

Try it online!
-2 thx to @Steffan

For the last one you can probably remove the [] right? It should be a valid output

source: Stack Exchange

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

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

sort: votes


text:
Decode Baby-talk!
When babies open their mouths, they're not just spewing gibberish. They're actually talking in a highly advanced, adult-proof cipher...
The Baby-talk Cipher
When a baby talks, it could look something like gogooa gagooook aagaaoooy
Each single-space separated section represents a character (so the example above represents 3 characters).
To decipher a section, we must count number of As and Os it contains. However, we only count those which are adjacent to another vowel. For example, the A in 'gag' would not count, but both the A and O in 'gaog' would.
Counting the example above would look like this:
Section    | Num Os | Num As

gogooa     | 2      | 1
gagooook   | 4      | 0
aagaaoooy  | 3      | 4

We then use these values to convert the input into plaintext on a Polybius square. This is a 5x5 representation of the English alphabet, omitting 'J' (please note that, in baby-talk, 0-counting rules apply to the table):
  0 1 2 3 4
0 A B C D E
1 F G H I K
2 L M N O P
3 Q R S T U
4 V W X Y Z

Using the number of Os as the column, and number of As as the row, we find which character each section represents:
Section    | Num Os | Num As | Character

gogooa     | 2      | 1      | (2,1) -> H
gagooook   | 4      | 0      | (4,0) -> E
aagaaoooy  | 3      | 4      | (3,4) -> Y

Which tells us that the baby was just saying "HEY".
Notes:
- If a section representing a character has more than 4 As or Os, ignore the extras, because 4 is the maximum value on the table.
- For this task, Y is not a vowel - only A, E, I, O and U.
The Challenge
Your task is to create a full program which takes one input, a word in baby-speak, and prints it in plaintext.

Your program must be able to take input in uppercase, lowercase, and a mix of both.
The input will only contain ASCII alphabet letters (A-Z and a-z), with single spaces to seperate the baby words.
The output text can be in any case.
You should the take the input from STDIN and print the plaintext on STDOUT. If your language does not have these, use the nearest equivalent.
This is code-golf, so the shortest code in bytes wins - but any solution is welcome.

Test Cases
'GLOOG KAKAAOOO ARGOOO OOOOOGUGUU' -> CODE
'oaka pooopaa gaau augu' -> GOLF
'Aoao U oOOAoa oaoAoo aoAoAOa' -> NAPPY
'GUG gAGaA gOougOou' -> ALE
'OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI' -> HELLO

'GUG gAGaA gOougOou' -> 'ALE' Babies drink ale? :D

only the finest :D @KritixiLithos

How do babies say "FAB"?

The case requirement seems unnecessary, right? All you're doing is adding a .toUpperCase() or similar function call, not an actually stimulating challenge

@MayorMonty not necessarily, I would try to avoid something so verbose

@edc65 "If a section representing a character has more than 4 As or Os, ignore the extras, because 4 is the maximum value on the table." Therefore, OOOOOGUGUU is (4,0), which is E.

How does gogooa have 2 o's? And how does gagooook have 0 a's?

@ETHproductions uh... thanks clear now

@carusocomputing Read the paragraph starting with "To decipher a section..."

@Neil Well, here it is: guag gag goag.

@EriktheGolfer Yeah, I had overlooked the bit where you could use other vowels.

Actually, @EriktheGolfer , that's FAG :P

@Flp.Tkc Yeah, typo. It should have been goug instead.

Finally we know their language ... now the only challenge is to find out how many vowels they actually speak!

So babies cannot say "Java", "Javascript" and "Jelly"?

@GB they are too young to know such things.

05AB1E, 46 bytes
lð¡vyžNvyð:}ð¡D€g1›ÏJ©'a¢4‚W5*®'o¢4‚Ws\+A'j-è?

Try it online!
Explanation in steps

split on spaces to form words
replace konsonants in words with spaces
split words on spaces to form groups of vowels
remove vowel groups with a length shorter than 2
get min of count(a) and 4, multiply by 5
get min of count(o) and 4
add counts
get letter at that index of alphabet (excluding "j")

Good job, congrats on winning

I like the approach of splitting by consonants, I didn't think of that

Perl, 82 bytes
Includes +1 for -a
Give input on STDIN:
perl -M5.010 baby.pl <<< "OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI"

baby.pl:
#!/usr/bin/perl -a
say map{$A=$O=$_=uc;y/AEIOU/@/c;s/(\B.|.\B)/$$1+=$$1<4/eg;(A..I,K..Z)[5*$A+$O]}@F

This assumes a recent enough perl version where -a implies -n. If your perl is too old you will need to add an explicit -n option.
It also assumes babies can't say general ASCII strings that start with digits like 1 this will not work

that's a correct assumption. I'll make sure to specify that in the question

JavaScript (ES6), 145 bytes
alert(prompt().replace(/\S+ ?/g,x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)))

Replaces each word (and the following space) with its corresponding letter.
s.split` `.map().join`` is 3 bytes longer:
alert(prompt().split` `.map(x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)).join``)

The challenge currently states that you should write "a full program which takes input [from STDIN] and prints it [to STDOUT]." This means that as currently written function answers aren't allowed.

Nice submission, but as CAD said, it has to be a full program. I'm not very familiar with JavaScript but I think prompt and alert are the best equivalents to STDIN/OUT, right?

@Flp.Tkc Yeah, unless you're using Node or some other environment. I'll update my code.

the question does say or the nearest equivalent. For js in the browser, a prompt and alert are close enough

brainfuck, 656 bytes
+[[>>>,[>++++[<-------->-]]<]<<[>]<-[+[<+>>+<-]----[>>+<<----]>>+[<[-<]<[>]>>-]-<[[-]>+<]>[[-[->]<<+>]<->>>]<<<[>>>+<<<-]<<-]>>>>>[[<+>>+<-]----[>-<----]>--[----<]<[>]>[----<]<[>]>[------<]<[>]>[------<]<[>]><+>[[-]<->]>>]<<<[>->]<[<]>[>[<<<<<+>>>>>>+<-]<<<<]<[-]>>>>[<[>[>+<-]<-]>[-]->[<+>-]>>]<<<[-<----[>-<----]>[>+>+<<-]+>[<->[-]<]<[<]>[[<<<]<+>>>>[>>>]<<<-]>+>--------------[<->[-]]<[-<<<<[<<<]>+>>[>>>]>]<<<<]<[<+<+>>-]>++++[<<[->]>[<]>-]+<<[[-]++++<[-]>>]>[<]<<[>+<-]>>+>->[>+>+<<-]<++++[>>[-<]<[>]<-]>>[[-]++++>[-]]<<<[>]<->>>>[<+>-]<[<<<+>>>-]<<<<[>+++++<-]>[>+>+<<-]<++++++++[>>[-<]<[>]<-]>>[[-]>+<]----[>+<----]>++.[-]+>>>,[<++++[>--------<-]]>]

This was a pretty good way to kill a couple of hours.
Requires a brainfuck interpreter that uses 8-bit wrapping cells, allows you to go left from cell 0 and returns 0 if , is used when stdin is empty. In my experience, these are the most common settings.
This program does not consider Y a vowel, but if OP wants it to it's an easy fix.
It seems like writing this would be a daunting task but if you have some familiarity with the language there's nothing surprising or new in the code. Standard brainfuck tactics: Read the input but make sure you leave a couple of empty cells between each byte, use those empty cells to store data about the input, use the data you stored to decide how to transform it and spit something out at the end. In this case it was get the input, set it all to uppercase, figure out which cells are vowels, throw that information away after using it to determine which cells are next to vowels, set everything that isn't next to a vowel to some value that will never be relevant so they're not in the way later, and you're basically done. From there you just have to count your As and Os, multiply As by 5 and add the number of Os, special case anything above 8 to avoid J and output. I did choose to handle this one word at a time, rather than taking the whole input at once, so I had to set up the part of the code that reads stdin to break at 0 or 32, but that's not too big of a problem (just wrap the subtraction by 32 in a conditional so it doesn't happen if the value is already 0, then correct for any < or > instructions you missed later).
I don't know how helpful it will be because I wrote it mostly to keep my thoughts straight rather than as a real explanation, but here's the code with my comments and its original indentation:
+[[>>>,[>++++[<-------->-]]<]get an entire word of input
                            each character lowered by 32
                            two empty cells between characters
                            stops when reaching a space or null byte

any lowercase letters have become uppercase; anything with a value below 65 used
to be an uppercase character; fix it

<<[>]<-[+                for each character until hitting 1:
  [<+>>+<-]              make a backup
  subtract 64 from the character but stop if it hits 0
  ----[>>+<<----]>>+     generate the number 64
  [                      64 times:
    <[                     if the character is not 0:
      -                    subtract 1
      <                    go to a guaranteed 0 cell to break the loop
    ]

    we're either on the character or to the left of it; sync up
    <[>]

  >>-]
  -<[[-]>+<]>            logical NOT of character

  [                      if logical NOT returns true:
    [-[->]<<+>]<-          add 32 to backup of character
  >>>]

  <<<[>>>+<<<-]          move copy over to make room
<<-]
  >>>>>[                 for each character:
  [<+>>+<-]              make copies
  ----[>-<----]>--       check if it's A
  [----<]<[>]>           check if it's E
  [----<]<[>]>           check if it's I
  [------<]<[>]>         check if it's O
  [------<]<[>]>         check if it's U

  IF YOU NEED TO ADD Y; THIS IS THE PLACE

  <+>[[-]<->]            logical NOT to complete vowel check
>>]

<<<[                if the last char is a vowel; prevent a side effect
  >->
]

<[<]>[                 for each character:
  >[                     if it's a vowel:
    <<<<<+>>>>>>+<-          leave a flag to the left and right to show that a
  ]                          vowel is adjacent
<<<<]

<[-]>                  clean up a side effect left behind if first char is vowel

>>>[                   for each char:
  <[                     if it's adjacent to a vowel:
    >[>+<-]<-              move it to the side
  ]
  >[-]-                otherwise; destroy it
  >[<+>-]              move backup over if it exists (subtracting 1)
>>]

all characters without a vowel beside them have been set to 255
all characters with a vowel beside them are set to itself minus 1

notable charaters are: 'A' minus 1 = 64
                       'O' minus 1 = 78

<<<[                 for each character:
  -<----[>-<----]      subtract 64
  >[>+>+<<-]           make a copy
  +>[<->[-]<]<[<]>     logical NOT

  [[<<<]<+>>>>[>>>]<<<-] if NOT returns true; record an A

  >+>--------------  subtract 14 from backup

  [<->[-]]<          logical NOT
  [-<<<<[<<<]>+>>[>>>]>] if NOT returns true; record an O
<<<<]

<[<+<+>>-]           make a backup of A count
>++++[<<[->]>[<]>-]  subtract 4 but don't go below 0
+<<[                   if the char was greater than 3:
  [-]++++<[-]>>          put 4 there
]
>[<]                  resynchronise
<<[>+<-]              if there were fewer than 4 As put the number back

same thing but for the O count

>>+>->[>+>+<<-]       make a backup of O count
<++++[>>[-<]<[>]<-]   subtract 4 but don't go below 0
>>[                     if the char was greater than 3:
  [-]++++>[-]             put 4 there
]
<<<[>]                resynchronise
<->>>>[<+>-]          if there were fewer than 4 Os put the number back

<[<<<+>>>-]<<<<[>+++++<-] A*5 plus B = index of character to output

>[>+>+<<-]            make a backup
<++++++++[>>[-<]<[>]<-] subtract 8 but don't go below 0
>>[[-]>+<]            if the result is nonzero it is late enough in the alphabet
                      that it must be increased by 1 to exclude J as a possible
                      output
----[>+<----]>++      add 65 to make it a letter
.[-]+>>>,             output and get new input
[<++++[>--------<-]]> sub 32 if not 0
]

This is amazing... and yes, by vowels I meant a,e,i,o,u :)

Perl, 159 +1 = 160 bytes
+1 byte for -n flag.  Whitespace is not part of the code and is only provided for readability.
for(split$",lc){
    $b=0;
    @a=sort/([ao](?=[aeiou])|(?<=[aeiou])[ao])/g;
    $b++until$b>$#a||$a[$b]eq o;
    $c=($d=$#a-$b+1)>4?4:$d;
    $b=$b>4?4:$b;
    print+(a..i,k..z)[5*$b+$c];
}

The code splits the input by spaces and converts each baby word to lowercase before proceeding.  The regex finds all a or o vowels that are followed by another vowel, or are preceeded by a vowel, and sorts them, a's at the start, o's at the end, then finds the index of the first 'o'.  If the remaining number of matches (aka, the number of 'a's) is greater than 4, then we care about 4 a's, and if there are more than 4 o's, we care about 4 o's.  Then it pulls the appropriate letter out of the matrix and prints it, then moves onto the next baby word.

Brainfuck, 283 bytes
,[[<[>-[>>>-<<<----[----[>+<------[>-<------[<[-]>>>>[-]->>[-]<<<<<-]]]]]>[>>>>+
<<<<-]>>+<[>[>+<-]>>[>+<-]<<<-]<,<<[>>>+<<<-]>]>+[<+>[-<<]>[[-]+++++[<++++++>-]<
+<]>>>]<]>>[-]>+>>+[[-]>[<+>-[<+>-[<+>-[<+>[-]]]]]<<<]>->[>+<-[[>+<-]>>+>]>[+>--
--[->]]]+[-<+]>>+++++++++++++[>+++++<-]>.,]

Formatted:
,
[
  [
    <
    [
      >-
      [
        not a
        >>>-<<<
        ----
        [
          not e
          ----
          [
            not i
            >+<
            ------
            [
              not o
              >-<
              ------
              [
                consonant
                <[-]>
                >>>[-]->>[-]<<<<<-
              ]
            ]
          ]
        ]
      ]
      >[>>>>+<<<<-]> >+<
      [
        prev was vowel
        >[>+<-]>>[>+<-]<<<-
      ]
      <,<<[>>>+<<<-]
      >
    ]
    >+
    [
      <+>[-<<]
      >[[-]+++++[<++++++>-]<+<]
      >>>
    ]
    <
  ]
  >>[-]>+>>+
  [
    [-]
    >[<+>-[<+>-[<+>-[<+>[-]]]]]<
    <<
  ]
  >->
  [
    >+<-
    [
      [>+<-]
      >>+>
    ]
    >
    [
      +>----[->]
    ]
  ]
  +[-<+]
  >>+++++++++++++[>+++++<-]
  >.,
]

This works with or without a trailing newline in the input.
Try it online.
Each character is processed mod 32 (with control flow such that the code implementing the mod operation only occurs once in the program). This enables case insensitivity, as well as collapsing the space character and EOF into a single case. A trailing newline is treated the same as J, which doesn't affect the output.
Sketch of memory layout:
0 x C c y a A b B
where c is the input character, C is the char mod 32, x is whether it is a vowel, y is whether the previous char was a vowel, A and B are the counts of valid (next to vowels) a and o chars respectively, and a and b are their respective buffers that get copied or cleared depending on whether there is an adjacent vowel.
When a space or EOF is reached, some juggling is done to reduce counts greater than 4 and to skip the letter J, and then the decoded character is printed.

this is very close to the java implementation in byte count ... hats off to you

it's a crime that this has less points than my trivial solution that's over twice as long

@undergroundmonorail That makes me an accomplice!

PHP, 163 bytes
<?php for(;$c=preg_replace('/(?<![AEIOU]).(?![AEIOU])/','',strtoupper($argv[++$i]));$j=min($d[79],4)+5*min($d[65],4),print range(A,Z)[$j+($j>8)])$d=count_chars($c);

More readable version:
<?php
for (
    ;
    $c = preg_replace(
        '/(?<![AEIOU]).(?![AEIOU])/',
        '',
        strtoupper($argv[++$i])
    );
    $j = min($d[79], 4) + 5 * min($d[65], 4),
    print range(A, Z)[$j + ($j > 8)]
)
    $d = count_chars($c);

Tests:
$ php babytalk.php GLOOG KAKAAOOO ARGOOO OOOOOGUGUU
CODE
$ php babytalk.php oaka pooopaa gaau augu
GOLF
$ php babytalk.php Aoao U oOOAoa oaoAoo aoAoAOa
NAPPY
$ php babytalk.php GUG gAGaA gOougOou
ALE
$ php babytalk.php OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI
HELLO

Java 8, 272 266 251 249 bytes
interface M{static void main(String[]i){String z="(?=[AEIOU])|(?<=[AEIOU])";for(String s:i[0].split(" ")){int a=s.split("(?i)A"+z+"A",-1).length-1,o=s.split("(?i)O"+z+"O",-1).length-1,t=(a>4?4:a)*5+(o>4?4:o);System.out.printf("%c",t>9?t+66:t+65);}}}

-6 bytes thanks to @Joba.
-1 byte converting from Java 7 to 8, and 14 16 additional bytes saved by changing the print-part.
Explanation:
Try it here.
interface M{                   // Class:
  static void main(String[]i){ //  Main method:
    String z="(?=[AEIOU])|(?<=[AEIOU])";
                               //   Regex-part for look-ahead or look-behind of vowels
    for(String s:i[0].split(" ")){
                               //    Loop over the program-arguments
      int a=s.split("(?i)A"+z+"A",-1).length-1,
                               //     The amount of A's with adjacent vowels
          o=s.split("(?i)O"+z+"O",-1).length-1,
                               //     The amount of O's with adjacent vowels
          t=(a>4?4:a)          //     If `a` is larger than 4, just take 4, else take `a`
            *5                 //     Multiply it by 5
            +(o>4?4:o);        //     And add 4 if `o` is larger than 4, else take `o`
       System.out.printf("%c", //     Print a character:
        t>9?                   //      If `t` is larger than 9 (index of J)
         t+66                  //       Take character unicode (skipping J)
        :                      //      Else:
         t+65);                //       Take character unicode (prior to J)
    }                          //   End of loop
  }                            //  End of main-method
}                              // End of program

The challenge currently states that you should write "a full program which takes input [from STDIN] and prints it [to STDOUT]." This means that as currently written function answers aren't allowed.

@CAD97 Thanks, read past that somehow. I've edited my answer accordingly.

Instead of using the upper case string, add the case invariant regex flag (?i) at the beginning of the s.split

Python 3, 163 162 157 146 bytes
import re
for W in input().upper().split():S=''.join(re.findall("[AEIOU]{2,}",W)).count;I=min(S('A'),4)*5+min(S('O'),4);print(end=chr(65+I+(I>9)))

Uses regex to find all string of vowels larger than 2, counts As and Os with maximum of 4, and then prints.

APL, 60
{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶

Note that ⎕IO←0 and ⎕ML←3
Example:
fn←{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶
fn 'Aoao U oOOAoa oaoAoo aoAoAOa'
NAPPY

Works in Dyalog 15.0, since it's the version in which 819⌶ was introduced to lowercase a string.

Are you sure you dropped the J and not the K?

Pyth, 64 bytes
Can probably be golfed further. Try it here !
L?<b5b4DebK+ds:rbZ"[aeiou]{2,}"1J+*/K\a5y/K\oR@G?<J9JhJu+GeHcQd"

R, 261 bytes
I think I spent way too much time just to get this working and I believe this is an unnecessarily complicated solution, although it works. Takes input from stdin, it's important that the string is enclosed in quotes.
x=el(strsplit(toupper(scan(,""))," "))
cat(apply(sapply(c("A","O"),function(y)sapply(sapply(regmatches(x,gregexpr("[AEIOU]{2,}",x,)),paste,collapse=""),function(s)min(sum(el(strsplit(s,""))%in%y),4)))+1,1,function(z)t(matrix(LETTERS[-10],5))[z[1],z[2]]),sep="")

The use of four nested apply-family could theoretically be reduced to only two by making use of mapply instead. But because inputs to mapply will not be of the same length, the shorter one is recycled which complicates things and I couldn't figure out a working solution.
If anyone is interested I'll add an ungolfed explanation later.
Try all the test cases on R-fiddle
Please note that this version takes input as a function argument instead from stdin because scan doesn't work on R-fiddle. Furthermore, added a newline to make it easier to read.

Python 3, 262 bytes
import re;f,b,v,n,r,l,t,g,a,o=re.findall,input().lower(),'aeiou',list(range(26)),'[aeiou]','abcdefghiklmnopqrstuvwxyz','',len,'a','o';del n[9],
for w in b.split():
 O,A=g(f(o+r,w))+g(f(r+o,w)),g(f(a+r,w))+g(f(r+a,w))
 if O>4:O=4
 if A>4:A=4
 t+=l[A*5+O]
print(t)

Less Golfed (The comments are the variables in the shortened code):
import re
findAll = re.findall #f
babyTalk = input('Baby Talk: ').lower() #b
vowels = 'aeiou' #v
numbers = list(range(26)) #n
del numbers[9]
letters = 'abcdefghiklmnopqrstuvwxyz' #l
finalText = '' #t
length = len #g
regex = '[aeiou]' #r
o = 'o' #o
a = 'a' #a
for word in babyTalk.split(): #w in b
 Os = len(findAll('o[aeiou]', word)) + len(findAll('[aeiou]o', word)) #O
 As = len(findAll('a[aeiou]', word)) + len(findAll('[aeiou]a', word)) #A
 if Os > 4: Os = 4
 if As > 4: As = 4
 print(As, Os)
 finalText += letters[As*5+Os]
 print(finalText)

Try it online!

This doesn't work for a word blaoaoaog: the interlaced vowels are counted more than once, giving z when it should be t (though it does work on just aaaooo, though I cannot figure out why....)

@CAD97 Are you saying that aooa should be p, not n?

not on purpose; aooa == (2,2) == n, aoaoao == (3,3) == t

just tested it and CAD is correct, gaoaoaog prints Z instead of T. I think it's because your regex is picking up [ao,oa,ao,oa,ao], which counts 5,5, then constricts it to 4,4, printing Z.

@Flp.Tkc Do you know how to fix it? I am very new to regex.

take a look at my solution

Kotlin, 221 209 bytes
Now much more ugly and slow, all in the name of 11 bytes
readLine()!!.toLowerCase().split(" ").map{fun
c(c:Char)=Regex("([aeiou]{2,})").findAll(it).fold(0){a,b->a+b.value.count{it==c}}.let{if(it>4)4 else it}
(('A'..'I')+('K'..'Z'))[c('a')*5+c('o')]}.forEach(::print)

Save it to a file (ex. BabyTalk.kts) to run as a script. Or, the above code can be prepended with fun main(z:Array<String>)= and compiled normally for a cost of 26 more bytes.
Try it online!
Indented:
readLine()!!
    .toLowerCase()
    .split(" ")
    .map {
        fun c(c: Char) =
            Regex("([aeiou]{2,})")
                .findAll(it)
                .fold(0) {
                    a, b ->
                    a + b.value.count { it == c }
                }
                .let { if (it > 4) 4 else it }
        (('A'..'I') + ('K'..'Z'))[c('a') * 5 + c('o')]
    }
    .forEach(::print)

PHP, 124 129 121 120 125 bytes
for(;$s=$argv[++$i];print chr((8<$O+=5*$A)+$O+65))for($k=$A=$O=0;$c=_&$s[$k++];$p=$c)$$c+=$$c<4&!trim($p.$s[$k]&__,AEIOU)[1];

Takes input from command line arguments. Run with -nr or try it online.
breakdown
for(;$s=$argv[++$i];            # loop $s through arguments
    print chr((8<$O+=5*$A)+$O+65)   # 3. map A and O counts to letter, print
)
    for($k=$A=$O=0;                 # 1. reset A and O counters
        $c=$s[$k++]&_;              # 2. loop $c through characters:
        $p=$c)                          # 2. remember current character as previous
        $$c+=                           # 1. increment counter for $c, if ...
            $$c<4&                          # it is < 4 and ...
            !trim($p.$s[$k]&__,AEIOU)[1];   # ... previous or next char is vowel

J, 109 bytes
echo{&(u:97+i.26)(+8<[)5#.4<.'AO'+/@e."1 0/~(;@#~1<#@>)@(</.~0+/\@,}.~:&(e.&'AEOUI')}:);._1' ',toupper 1!:1]3

Try it online!

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


text:
Animate Adve the Adventurer
The challenge
Your task is to animate Adve the Adventurer moving through a creepy (i.e. Halloween) maze. Adve is a •; he's character fluid, though, so he does not mind being represented by a different character.
To animate Adve, you print out each frame; a frame is the map with his current location in it. Adve moves one space forward every turn and never backtracks. He starts in the first row and ends in the last.
Input
Any reasonable format like a string with a delimiter or string array. You can assume the input will be a map greater than 3*3, containing only one possible path. The only characters present will be # and .
Output
The frames.
Example maze (ok... labyrinth)
Here is a map without Adve in it; the first and last frames are this empty map (this map is 9x15):
### #####
##  #####
## ######
##      #
####### #
#   ### #
# # #   #
# #   ###
# #######
#    ####
#### ####
####  ###
##### ###
##### ###
##### ###

This is code-golf, so shortest code in bytes wins!
The exact output for this can be found here (37 frames).
This is code-golf, so shortest code in bytes wins!

Will the first and last rows always have a single empty cell? Will there always be a single possible path (no bifurcations)?

@LuisMendo, yes, and there is "only one possible path"

Will the entrance always be at the top?

@DestructibleWatermelon, yes, and the exit will be at the bottom.

His real name is Dave, but he's all mixed up.

Maybe I am being a bit stupid and missing something but I thought that the idea was to take the input and generate a maze and then animate Adve through it. From the answers so far, is it OK to just take the maze (labrynth) above and ignore the input and just animate that?

@ElPedro, the input is the maze. You have to find the path and print each frame of Adve moving through it

Ah, so I can input the maze above and my program only has to work for that maze? "You can assume the input will be a map greater than 3*3, containing only one possible path." kinda confused me. Sorry :)

So @Dopapp, Please, to clarify. The input is an (array or whatever) of characters that is the maze. Not just a pair of integers that define the size of the maze?

@ElPedro, yes that is correct.

My mistake for not reading your challenge carefully enough. Nice question. Animated ASCII is my kind of thing. (Upvote) Will give it a go tomorrow now that I fully understand the challenge. Thanks for your explanation :)

Perl, 84 bytes
Thanks @Ton Hospel for guiding me to the right direction to golf out around 30 bytes!
Bytecount includes 82 bytes of code and -0p flags.
/.*/;say y/A/ /r;s/&(.{@{+}})? /A$1&/s||s/ (.{@{+}})?&/&$1A/s||s/ /&/?redo:y;A&;

Note that there are two final spaces, and no final newline (it won't work otherwise).
Takes the maze as input as outputs all the needed frames for Adve to get out of it. Note that Adve is a & rather than a •, since the latter isn't utf8 (and perl doesn't use utf8 by default). Run it with -0pE flags :
perl -0pE '/.*/;say y/A/ /r;s/&(.{@{+}})? /A$1&/s||s/ (.{@{+}})?&/&$1A/s||s/ /&/?redo:y;A&;  ' <<< "### #####
##  #####
## ######
##      #
####### #
#   ### #
# # #   #
# #   ###
# #######
#    ####
#### ####
####  ###
##### ###
##### ###"

Just for the eyes, I also made this animated version, that is a little bit longer, but will clear the terminal between each print and sleep 0.15 sec, so it will look like Adve is actually moving :
perl -0nE 'system(clear);/.*/;say y/A/ /r;select($,,$,,$,,0.15);s/&(.{@{+}})? /A$1&/s||s/ (.{@{+}})?&/&$1A/s||s/ /&/?redo:say"\e[H",y/A&/  /r' <<< "### #####
##  #####
## ######
##      #
####### #
#   ### #
# # #   #
# #   ###
# #######
#    ####
#### ####
####  ###
##### ###
##### ###"

I think it's the best algorithm but it can still be golfed down by more than 20 bytes...

@TonHospel -9 bytes so far (I removed the $s="@+", I hadn't realize earlier that @+ is only changed if a successful regex occurs. And redo instead of while saved one or two bytes). Any hint about how to golf it more? I'm guessing I have to get rid of those y/// somehow, or make the s/// shorter... but either way I don't know how.

@TonHospel (but if you worked on a solution and want to post it, don't hold it because it's the same algorithm or something, I won't mind at all ;) )

How regex variables are or aren't kept in loops is very subtle. The y/// is fine since you need something to indicate direction (but notice you get to choose on which side)  But the main improvement will come from combining substitutions

@TonHospel Indeed, I should've seen it, but I was trying too hard to combine s/ &/&A/ and s/& /A&/ together (and the next to together) to see that those weren't the regex I needed to combine! Thanks a lot! (And thanks for letting me find out how to golf it! )

JavaScript (ES6), 137
(1 byte saved thx @ETHproductions)
m=>(o=>{for(p=m.search` `-o,r=[m];[d,o/d,-o/d].some(q=>1/m[d=q,q+=p]?p=q:0);r.push(q.join``))(q=[...m])[p]=0})(d=1+m.search`
`)||[...r,m]

Less golfed
m=>{
  d = o = 1+m.search`\n`; // offset to next row and starting direction
  p = m.search` `-o; // starting position, 1 row above the first
  for( r=[m]; // r is the output array, start with empty maze
       // try moving in 3 directions (no back)
       // if no empty cell found, we have exit the maze
       [d,o/d,-o/d].some(q => 1/m[d=q,q+=p]? p=q : 0);
       r.push(q.join``) // add current frame
     )
     q=[...m], q[p] = 0; // build frame, '0' used to mark Adve position
  return [...r,m] // add last frame with maze empty again
}

Test

F=
m=>(o=>{for(p=m.search` `-o,r=[m];[d,o/d,-o/d].some(q=>1/m[d=q,q+=p]?p=q:0);r.push(q.join``))(q=[...m])[p]=0})(d=1+m.search`\n`)||[...r,m]

function go() {
  var i=I.value,r=F(i),
      frame=x=>(x=r.shift())&&(O.textContent=x,setTimeout(frame,100))
  frame()
}

go()
#I { width:10em; height: 19em; font-size:10px}
#O { white-space:pre; font-family: monospace; font-size:10px; vertical-align: top; padding: 4px}

<textarea id=I>### #####
##  #####
## ######
##      #
####### #
#   ### #
# # #   #
# #   ###
# #######
#    ####
#### ####
####  ###
##### ###
##### ###
##### ###
</textarea><button onclick='go()'>go</button>

Uh, silly me, thanks @ETHproductions

Great work. I probably would've ended up around 160 bytes


text:
Generate antsy permutations
Introduction
I defined the class of antsy permutations in an earlier challenge.
As a reminder, a permutation p of the numbers from 0 to r-1 is antsy, if for every entry p[i] except the first, there is some earlier entry p[i-k] such that p[i] == p[i-k] ± 1.
As a fun fact, I also stated that for r ≥ 1, there are exactly 2r-1 antsy permutations of length r.
This means that there is a one-to-one correspondence between the antsy permutations of length r and the binary vectors of length r-1.
In this challenge, your task is to implement such a correspondence.
The task
Your task is to write a program or function that takes in a binary vector of length 1 ≤ n ≤ 99, and outputs an antsy permutation of length n + 1.
The permutation can be either 0-based of 1-based (but this must be consistent), and the input and output can be in any reasonable format.
Furthermore, different inputs must always give different outputs; other than that, you are free to return whichever antsy permutation you want.
The lowest byte count wins.
Example
The (0-based) antsy permutations of length 4 are
0 1 2 3
1 0 2 3
1 2 0 3
1 2 3 0
2 1 0 3
2 1 3 0
2 3 1 0
3 2 1 0

and your program should return one of them for each of the eight bit vectors of length 3:
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

Can the program take the integer representation of each binary vector instead?

@mbomb007 No, because the leading zeros are significant. 0 1 and 0 0 1 should give outputs of different lengths.

Jelly, 12 11 10 bytes
ḟẋLṭ+
0;ç/

Try it online! or generate all permutations of length 4.
How it works
0;ç/   Main link. Argument: B (bit array)

0;     Prepend a 0 to B.
  ç/   Reduce [0] + B by the helper link.

ḟẋLṭ+  Helper link. Left argument: A (array or 0). Right argument: b (bit)

 ẋ     Repeat A b times, yielding A or [].
ḟ      Filter false; remove the elements of A or [] from A.
  L    Get the length of the resulting array.
       This yield len(A) if b = 0 and 0 if b = 1.
    +  Add b to all elements of A.
   ṭ   Tack; append the result to the left to the result to the right.

Python 2, 62 60 bytes
x=0,
for n in input():x=[t-n+1for t in x]+[n*len(x)]
print x

Thanks to @xnor for golfing off 2 bytes!
Test it on Ideone.

Do you need the comma in x=0,?

0, is a tuple. Without the comma, mapping over x would fail.

I think you can flip n to do [n*len(x)] and change the map to a list comp.

@xnor Indeed. Thanks!

JavaScript (ES6), 48 47 45 bytes
a=>[h=l=0,...a.map(c=>c?--l:++h)].map(e=>e-l)

This turned out to be similar to @ETHproductions' method, except I had started by directly calculating the first element and then using the binary vector to determine whether each digit is a new high or a new low. Edit: Saved 1 byte thanks to @ETHproductions. Saved 2 bytes by starting with zero and adjusting afterwards. My previous method turned out to be similar to @Dennis's method, but took 54 bytes:
a=>a.reduce((r,b)=>[...r.map(e=>b+e),r.length*!b],[0])

Python, 54 bytes
lambda l:[i-i*x+sum(l[i:])for i,x in enumerate([1]+l)]

Uses the following procedure:

Prepend a 1 to the list.
For each 0 entry, write its position in the 0-indexed list.
For each entry, write the number of 1's to its right, not counting itself.
Add the results of steps 2 and 3 entrywise.

For example, l=[1,0,1,0] gives f(l) == [2,1,3,0,4]
List with prepended 1         1 1 0 1 0

0-indexed position for 0's        2   4
Number of 1's to right        2 1 1 0 0
Sum of above two              2 1 3 0 4

Prepending a 0 would also give the same result. The enumerate is clunky, I'll see if it can done better recursively.

Clever technique! It's fascinating how different techniques are best in each language. I tried porting this to JS, but it ended up at 57 due to the lack of sum and slicing syntax.

JavaScript (ES6), 52 bytes
v=>[...v,l=0].map(x=>x?l++:h--,h=v.length).reverse()

Test it out:

f=v=>[...v,l=0].map(x=>x?l++:h--,h=v.length).reverse()
g=v=>console.log(f((v.match(/[01]/g)||[]).map(x=>+x)))
<input oninput="g(this.value)" value="010">

Explanation
This takes advantage of the fact that when an antsy permutation is reversed, each item is either 1 more than the maximum of the previous low entries, or 1 less than the minimum of the previous high entries. By denoting a higher item as a 0 and a lower item as a 1, we can create an exact one-to-one correspondance between the antsy permutations of length n and the binary vectors of length n - 1.
The best I could do with Dennis' technique is 57 51 bytes:
v=>v.reduce((x,n)=>[...x.map(i=>i+n),!n*++j],[j=0])
v=>v.map(n=>x=[...x.map(i=>i+n),!n*++j],x=[j=0])&&x

xnor's solution is 56 (saved 1 byte thanks to @Neil):
l=>[1,...l].map((x,i)=>i*!x+eval(l.slice(i).join`+`||0))

i-i*x could be i*!x.

@Neil Ah yes, thanks.

Perl, 33 bytes
Includes +1 for -p
Give vector as string without spaces on STDIN:
antsy.pl <<< 110

antsy.pl:
#!/usr/bin/perl -p
s%^|.%y/0//+($&?++$a:$b--).$"%eg

Batch, 127 bytes
@set s=%*
@set/an=h=l=%s: =+%
@for %%b in (%*)do @call:%%b
:0
@echo %n%
@set/an=h+=1
@exit/b
:1
@echo %n%
@set/an=l-=1

Takes input as command-line parameters, output is line-separated. (It's possible to input as space-separated on STDIN for no extra cost.)

Haskell, 40 bytes
foldl(\r a->map(+0^a)r++[a*length r])[0]

Dennis's Python solution golfs wonderfully in Haskell with map and fold. It's shorter than my attempts to port my direct entrywise construction:

f l=[i*0^x+sum(drop i l)|(i,x)<-zip[0..]$0:l]
f l=[a+c-b*c|(a,c,b)<-zip3(scanr(+)0l)[0..]$0:l]


text:
Pairable strings
A string is pairable if it can be split into subtrings, each of which is a string repeated twice consecutively. For example, aabaaababbbaba is pairable as:
aaba aaba
b b
ba ba

Given a non-empty string of a's and b's, output a Truthy value if it's pairable and a Falsey value if it isn't.
Pairable:
aa
abaaba
bbababbb
aabaaababbbaba
babababa
bbbbbbbbbbbb
aaababbabbabbbababbaabaabaababaaba
aaaabaab

Not pairable:
a
ba
baab
abaabaaba
bbbbbbbbbbbbbbb
baababbabaaaab
aaaaabbaaaaa

I encourage you to come up with non-regex-based solutions even when there's already a shorter regex answer in your language. You can mark them as "no regex". By regex, I mean a built-in string pattern matching subsystem.

Leaderboard:

var QUESTION_ID=98252,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/98252/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://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

Can we use anything other than ab?

If bbababbb is pairable, why are baab and aaaaabbaaaaa not?

@rnso From my understanding, bbababbb can be spilt as 3 pairs: bb, abab and bb which concatenates in that order to form the original string, whereas the other two cannot.

By the question "each of which (substring) is a string repeated twice CONSECUTIVELY" and that is not satisfied with bbababbb. Otherwise, baab can also be split to b a a b, and aaaaabbaaaaa to aaaaa b b aaaaa.

@rnso Not sure what you mean there. By consecutively, I mean the two repetitions are next to each other. In "b a a b", the two b's are separated by a's, so that doesn't work.

@EriktheGolfer No, just ab.

Python 2, 68 63 bytes
f=lambda s,n=1:s==2*s[:n]or''<s[n:]>-f(s,n+1)<f(s[n:])*f(s[:n])

Returns True or False. Test it on Ideone.

That's a really clean recursion, using the index for both for the center of the double and the center to partition. It's funny that truthiness is checked as being less than something. I do see some improvements...

Retina, 11 bytes
^((.+)\2)+$

Try all the test cases. The first two bytes make it multi-line.
Pretty literal interpretation of the rules, obviously uses regex, like all Retina programs will.

Dangit, I had been waiting for 3 weeks to post this...

Martin had been waiting too.

Whoops! I only beat him by 10 seconds, too... Well I'm sure if I write a Hexagony answer he'll forgive me!

@FryAmTheEggman I'm looking forward to it. :)

@MartinEnder I don't promise I'll be able to deliver soon (I've been pretty swamped and strings in Hexagony...) but I do promise I have a sheet of paper that is already covered in drawings of hexagons ;)

It's exactly the same  with Perl : perl -pE '$_=/^((.+)\2)+$/'

Jelly, 10 bytes
ẆŒPẋ€€2F€ċ

Not exactly efficient... Try it online!
How it works
ẆŒPẋ€€2F€ċ  Main link. Argument: s (string)

Ẇ           Window, generate the array of all substrings of s.
 ŒP         Powerset; generate all subarrays of substrings of s.
   ẋ€€2     Repeat each substring in each subarray twice.
            For example, ["ab", "a", "b"] becomes ["abab", "aa", "bb"].
       F€   Flatten the subarrays by concatenating their strings.
         ċ  Count how many times s appears in the generated strings.

This ... seems inefficient. How long inputs can this handle in a reasonable time frame?

It's extremely unefficient (O(2^n^2), I think). I'd have to check locally. TIO runs out of memory for strings of length 6.

A string of length 6 takes 3:20 minutes on my machine and requires 6 GB of memory.

@Dennis Let's not do a length 100 input then, because everything will crash. Yes, even TIO.

@EriktheGolfer That's a good idea since it will unnecessarily slow down TIO for other uses, but it won't crash it. As soon as the system runs out of memory, the process simply gets killed by the OOM.

@Dennis Yeah, no-one likes slowed-down interpreters. Also, I was over-alarmed by "A string of length 6... 6 GB or memory."

Haskell, 72 69 bytes (no regex)
g(a:b:c)|a==b=g c
g x=x==[]
any(g.words.concat).mapM(\c->[[c],c:" "])

A brute-force approach. Try it on Ideone.
Thanks to BlackCap for -3 bytes.
Explanation
The helper function g takes a list of strings, and checks that it consists of pairs of identical strings, like ["aa","aa","bba","bba","ab","ab"].
The (anonymous) main function splits a string in all possible ways, and checks that at least one splitting results in a list that g accepts.
g(a:b:c)                                  g on list with elements a, b and tail c,
        |a==b                              in the case that a==b,
             =g c                          recurses to the tail c.
g x=                                      g on any other list x
    x==[]                                  checks that x is empty.
                                           This includes the case where a is not equal
                                           to b, resulting in False.
any(g.words.concat).mapM(\c->[[c],c:" "]) The main function:
                    mapM(\c->[[c],c:" "])  Replace each letter c with either "c" or "c "
                                           in all possible ways, return list of results.
any(              ).                       Check that at least one result satisfies this:
            concat                          Concatenate the 1- or 2-letter strings,
      words.                                split again at each space,
    g.                                      apply g.

You can replace or.map with any

@BlackCap Of course, thanks! I initially had any g.map(words.concat) and thought "hey, I can golf the any to or"...

Python 2, 60 bytes
f=lambda s,t='':''<s>f(s[1:],t+s[0])|f(t and s)*f(t)>-(s==t)

I hope this is correct. It runs pretty slowly and the and doesn't look optimal.

I tried using strings, but I couldn't get anywhere near my index-based score. That's one clever and you have there.

Congrats! Recursing on the partition was the trick I had in mind.

Jelly, 12 bytes
ŒṖµœs€2ZEµ€S

Two bytes longer than my other answer, but this approach is a lot more efficient and handles all but one of the test cases.
Try it online!
How it works
ŒṖµœs€2ZEµ€S  Main link. Argument: s (string)

ŒṖ            Generate all partitions of s.
  µ      µ€   Map the monadic chain between the µ's over the partitions.
   œs€2         Split each string in the partition into two chunks of equal length.
       Z        Zip/transpose, collecting the first halves in one array and the
                second halves in another.
        E       Test the arrays of halves for equality.
           S  Return the sum of the results, counting the number of different
              ways s can be paired.

Brachylog, 14 bytes (no regex)
lye~l:1j@2zcc?

Try it online!
This is too slow for some of the test cases
Explanation
ly                  The list [0, …, length(Input)]
  e~l               A list whose length is an element of the previous list
     :1j            Append itself to this list
        @2zc        Split in half, zip and concatenate so that the list contains pairs of
                      consecutive identical elements
            c?      The concatenation of that list must result in the Input

Pyth - No Regex - 13 12 bytes
Checks if any of the partitions are made up of all string that are  equals to each other when chopped in two.
sm.AqMcL2d./

Test Suite.

JavaScript (ES6), no regexp, 75 74 bytes
f=s=>!s|[...s].some((_,i)=>i&&s[e='slice'](0,i)==s[e](i,i+=i)&&f(s[e](i)))

Returns 1 for pairable otherwise 0. Edit: Saved 1 byte thanks to @edc65.

Nice! Same count using substr without modifying i. But with slice repeated 3 times you can save 1 byte aliasing it

@edc65 How do you get the same count without modifying i? I realise that s.substr(i,i+i) returns the same as s.slice(i,i+=i) but I then use the modified value of i later...

it's s.substr(i,i) 2 bytes less, then s.slice(i+i) 2 bytes more

@edc65 Oh of course it is, I must need more coffee...

Python, 58 bytes
f=lambda s,p='':s>''and(f(p)>-(s==p)<f(s))|f(s[1:],p+s[0])

This is based on the Dennis's recursive method. The Boolean negation trick is taken from there as well.
The new idea is to recurse over partitions (p,s) of the original string by starting with ('',s) and repeatedly moving the first character of s to be the last character of p. This allows for the parts to be referred to directly without string slicing. But, because the partition starts with p empty, we must be careful to avoid infinite loops of f(s) calling f(s).

JavaScript (ES6), 24 bytes
x=>/^((.+)\2)+$/.test(x)

Probably doesn't get shorter than this.

Shouldn't that be \2?

@Neil For some reason, I thought it worked with \1, but aab returns true... thanks for the fix.

PHP, 40 Bytes
prints 0 for false and 1 for true
<?=preg_match("#^((.+)\\2)+$#",$argv[1]);

Python, 66 64 bytes
Thanks @Zgarb for -1 byte!
f=lambda x,s=1:x>x[:s]and(x==2*x[:s])|f(x[:s])&f(x[s:])|f(x,s+1)

Returns True or False.
Try it online!
Any help golfing this would be appreciated.

Racket 230 bytes
(let((sl string-length)(ss substring))(if(odd?(sl s))(printf ".~n")(begin(let p((s s))(if(equal? s "")(printf "!")
(for((i(range 1(add1(/(sl s)2)))))(when(equal?(ss s 0 i)(ss s i(* 2 i)))(p(ss s(* 2 i)(sl s)))))))(printf ".~n"))))

Prints a '!' for each way in which the string is pairable. Prints a '.' at the end.
Ungolfed:
(define (f s)
  (let ((sl string-length)                              ; create short names of built-in fns
        (ss substring))
    (if (odd? (sl s))  (printf ".~n")                   ; odd length strings cannot be pairable; end here.
        (begin
          (let loop ((s s))                             ; start testing here
            (if (equal? s "") (printf "!")              ; if no remaining string, it must be pairable
                (for ((i (range 1 (add1 (/(sl s)2)))))  ; ch lengths varying from 1 to half of string length
                  (when (equal? (ss s 0 i)              ; ch if substrings are same
                                (ss s i (* 2 i)))
                    (loop (ss s (* 2 i) (sl s) ))))))   ; if yes, loop to check remaining string.
          (printf ".~n")))))                            ; End of testing.

Testing:
(println "Following should be pairable")
(f "bbaabbaa")            ; should produce 2 '!' since 2 ways are possible.
(f "aa")
(f "abaaba")
(f "bbababbb")
(f "aabaaababbbaba")
(f "babababa")                    ; should be pairable in 2 ways.
(f "bbbbbbbbbbbb")                ; should be pairable in many ways.
(f "aaababbabbabbbababbaabaabaababaaba")
(f "aaaabaab")
(println "Following should be unpairable")
; (f "a")
(f "ba")
(f "baab")
(f "abaabaaba")
(f "bbbbbbbbbbbbbbb")
(f "baababbabaaaab")
(f "aaaaabbaaaaa")

Output:
"Following should be pairable"
!!.
!.
!.
!.
!.
!!.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!.
!.
!.
"Following should be unpairable"
.
.
.
.
.
.

Perl, 16 +2 = 18 bytes (with regex)
Run with the -nl flags.  -E is free.
say/^((.+)\2)+$/

Run as:
perl -nlE 'say/^((.+)\2)+$/'

Returns a list of the capture groups (a truthy) if pairable, null string if not pairable.
Explanation
The -nl flags will run the code in a loop (-n), putting the input (with trailing newline removed because of -l) into the variable $_ each time, then evaluating the code each time input is entered, until the program is manually terminated.  The -E flag lets you evaluate code on the command line, and enables the say command.
say/^((.+)\2)+$/

   /^((.+)\2)+$/  #The regex engine
      (.+)\2      #Find any set of at least one character, followed by itself
     (      )+    #Do this at least one time
   /^         $/  #Make sure that this matches the entire string from start to end
say               #Output the result of the regex

If a match is found (e.g. if the string is pairable), then the regex returns a list of the capture groups, which evaluates to a truthy, which is then passed to say, and output.  If no match is found, then the regex returns the empty string, which evaluates to falsy, which is then passed to say, and output.
Sample:
$ perl -nlE 'say/^((.+)\2)+$/'
aaababbabbabbbababbaabaabaababaaba
baababaababaaba                      #Truthy
baababbabaaaab
                                     #Falsy
bbababbb
bbb                                  #Truthy
aabaaababbbaba
bababa                               #Truthy
abaabaaba
                                     #Falsy

GNU Prolog, 49 46 bytes
Probably works in other variants too, although they don't all represent strings the same way; GNU Prolog's representation is a useful one for this problem.
It's unclear whether this counts as using regex or not. It's not using any regex-like feature, but the entire semantics of the language are similar to those of regex.
New version (uses the recursion trick seen in some other answers):
s(X):-append(A,B,X),(A=B;A\=X,B\=X,s(A),s(B)).

Older version:
s(X):-X=[];append(A,B,X),B\=X,append(C,C,A),s(B).

This is a predicate (Prolog's equivalent of a function) called s, not a complete program. Use it like this:
| ?- s("aa").
true ?
yes
| ?- s("aaababbabbabbbababbaabaabaababaaba").
true ?
yes
| ?- s("baababbabaaaab").
no
| ?- s("bbbbbbbbbbbbbbb").
no

An interesting feature of the older solution is that if you ask the interpreter "are there more solutions?" via use of ; at the true ? prompt (rather than asking "is there any solution" via pressing return at the prompt, like I did above), it returns "true" a number of times equal to the number of different ways the string can be expressed in the given form (e.g. it returns "true" twice with s("aaaa")., as this can be parsed as (a a)(a a) or as (aa aa)).
Prolog programs are often reversible (allowing s to generate a list of strings with the given property). The older one isn't (it goes into an infinite loop), but that's because of the golfed method I used to ensure that C is nonempty; if you rewrite the program to specify C as nonempty explicitly, it generates strings of the form "aa", "aabb", "aabbcc", and so on (Prolog being Prolog, it doesn't specify identities for the characters that make them up, just a specification of which characters are the same). The newer one generates strings of the form "aa", "abab", "abcabc", and so on; this is an infinite loop in its own right, and thus never hits the point at which it'd get stuck due to failing to detect a zero-length string.

Brainfuck, 177 bytes
+[<<<<,]>>>>[>+[>+[[>>]<+<[<<]>+>-]<[>+<-]>>>,>>[>>]+<<[<+>>-<-]<[>+<-]>>[,>[-<<
<<]<[<<<<]>]<[[<<]>]>>]>>[[>+>>>]>>>[>]<<<<[>+[-<<<,<]<[<<<[[<<<<]>>]<]>]>>]<[[-
>>>>]>>[<]<]<<]<.

Formatted:
+[<<<<,]
>>>>
[
  >+
  [
    >+
    [
      [>>]
      <+<[<<]
      >+>-
    ]
    <[>+<-]>
    >>,>>[>>]
    +<<[<+> >-<-]
    <[>+<-]>
    >
    [
      not equal
      ,>[-<<<<]
      <[<<<<]
      >
    ]
    <
    [
      equal
      [<<]
      >
    ]
    >>
  ]
  >>
  [
    mismatch
    [>+>>>]
    >>>[>]
    <<<<
    [
      backtrack
      >+[-<<<,<]
      <
      [
        not done yet
        <<<
        [
          [<<<<]
          >>
        ]
        <
      ]
      >
    ]
    >>
  ]
  <
  [
    match
    [->>>>]
    >>[<]
    <
  ]
  <<
]
<.

Expects input without a trailing newline. Prints \x00 for false and \x01 for true.
Try it online.
This implements depth-first search. In particular: check for repeated prefixes of increasing length starting from the current suffix, then move to the next suffix if a match is found, otherwise backtrack.
At the beginning, the string is reversed and a sentinel \x01 is placed at the end.
The tape is divided into 4-cell nodes. The memory layout of a node is:
c h x 0
where c is the character, h is a flag for whether the character is in the first half of a repeated prefix, and x is a flag to keep track of the current pair of characters being compared. The h flags stay in place while the x flags form a moving window.
If the string is pairable, the pointer lands next to the sentinel at the end of the main loop; otherwise, the pointer falls off the left side of the string while backtracking.

R, 31 bytes
grepl("^((.+)\\2)+$",scan(,""))

Try it online!
Based on Retina answer.
R, 129 bytes
And here’s an original, non-regex answer:
o=(y=utf8ToInt(scan(,"")))<0;for(i in 2*1:(sum(y>0)/2))for(j in 1:(i/2)){w=i:(i-j+1);v=w-j;if(all(y[w]==y[v]))o[c(v,w)]=T};all(o)

Try it online!

Brachylog, 5 bytes
~c~jᵐ

Try it online!
Note that this algorithm can take a very long time, especially on falsey cases, since it checks every possible partition of the input string.
Explanation
~c     Reversed concatenate: find a list that, when concatenated, results in the input string
       This examines all partitions of the input
  ~jᵐ  Map reversed juxtapose: for each string in that list, is it the result of concatenating
       a string to itself?

For an input string like "ababcc", ~c tries different partitions until it comes to ["abab", "cc"], at which point ~j succeeds for both items of the list, ᵐ outputs ["ab", "c"], and the predicate succeeds.

Lithp, 57 characters
#S::((? (!= (null) (match S "^((.+)\\2)+$")) true false))

Sample usage:
% pairable_strings.lithp
(
    (def f #S::((? (!= (null) (match S "^((.+)\\2)+$")) true false)))
    (print (f "aa"))
    (print (f "aabaaababbbaba"))
    (print (f "aaababbabbabbbababbaabaabaababaaba"))
    (print (f "ba"))
)

# ./run.js pairable_strings.lithp
AtomValue { value: 2, type: 'Atom', name: 'true' }
AtomValue { value: 2, type: 'Atom', name: 'true' }
AtomValue { value: 2, type: 'Atom', name: 'true' }
AtomValue { value: 3, type: 'Atom', name: 'false' }