text:
Print an alphabet wave
You are to print this exact text:
ABABABABABABABABABABABABAB
BCBCBCBCBCBCBCBCBCBCBCBCBC
CDCDCDCDCDCDCDCDCDCDCDCDCD
DEDEDEDEDEDEDEDEDEDEDEDEDE
EFEFEFEFEFEFEFEFEFEFEFEFEF
FGFGFGFGFGFGFGFGFGFGFGFGFG
GHGHGHGHGHGHGHGHGHGHGHGHGH
HIHIHIHIHIHIHIHIHIHIHIHIHI
IJIJIJIJIJIJIJIJIJIJIJIJIJ
JKJKJKJKJKJKJKJKJKJKJKJKJK
KLKLKLKLKLKLKLKLKLKLKLKLKL
LMLMLMLMLMLMLMLMLMLMLMLMLM
MNMNMNMNMNMNMNMNMNMNMNMNMN
NONONONONONONONONONONONONO
OPOPOPOPOPOPOPOPOPOPOPOPOP
PQPQPQPQPQPQPQPQPQPQPQPQPQ
QRQRQRQRQRQRQRQRQRQRQRQRQR
RSRSRSRSRSRSRSRSRSRSRSRSRS
STSTSTSTSTSTSTSTSTSTSTSTST
TUTUTUTUTUTUTUTUTUTUTUTUTU
UVUVUVUVUVUVUVUVUVUVUVUVUV
VWVWVWVWVWVWVWVWVWVWVWVWVW
WXWXWXWXWXWXWXWXWXWXWXWXWX
XYXYXYXYXYXYXYXYXYXYXYXYXY
YZYZYZYZYZYZYZYZYZYZYZYZYZ
ZAZAZAZAZAZAZAZAZAZAZAZAZA

Specs

You can print all lowercase instead of all uppercase. However, case must be consistent throughout the output.
You may print one extra trailing linefeed.

Scoring
Since this is an alphabet wave that fluctuates to a small extent, your code should also be small in terms of byte-count. In fact, the smallest code in terms of byte-count wins.

Seriously, another alphabet challenge?

@NathanMerrill As numerous as they are, I don't think they are worthy of downvotes. (I do not imply you downvoted, I am merely saying.)

As long as the patterns are sufficiently different, I don't think it matters if we use the alphabet, decimal digits, asterisks and underscore, etc.

Can I use function return?

@ConorO'Brien No, the same with the other alphabet challenges.

@Dennis regardless of the characters used, its these type of "pattern" challenges that are getting overused, IMO.  I don't think its offtopic, but I would enjoy some fresh air.

Merely generating the alphabet makes for overlapping code in Python for all these challenges.

It's clear there's no more demand for alphabet challenges - only 39 people answered in the first 15 hours...

These challenges instantly go HNQ and the result is a massive amount of votes for an otherwise meh challenge

@Insane If it is a meh challenge it would not have gone HNQ

@LeakyNun Lots of meh challenges go to HNQ. The HNQ algorithm favors answers. On our site, that doesn't work so well, because the number of answers to a challenge is proportional to the triviality of the challenge.

This might not be a Programming Puzzle, but it´s definitely Code Golf. Four answers with different approaches for some languages - I like the diversity.

Can I use a leading linebreak instead of a trailing one?

C, 60 bytes
main(i){for(;i<703;)putchar(i++%27?65+(i/27+i%27%2)%26:10);}

This is genius.

Nice to see C in a code golf challenge.

@MichealJohnson "see C", I C what you did there. ;) And I agree with Leaky Nun. Sometimes I wonder how people come up with some of these ingenious answers.

@KevinCruijssen That was unintentional lol.

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

Practically the same size as Hello World. Impressive!

@phyrfox Actually...

Convex, 10 bytes
U_(+]D*zN*

Try it online!
U               Predefined Variable: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 _(+            Push a copy with the 'A at the end.
    ]           Add both strings to an array.
     D*         Repeat array 13 times. D defaults to 13.
       z        Transpose.
        N*      Join by newlines. N defaults to "\n"

Pyth, 11 10 bytes
jC*13.<BG1

Try it here.
        G   the alphabet
       B    bifurcate over
     .<  1  left shift by 1
  *13       repeat 13 times
 C          transpose
j           join on newlines

Ruby, 42 39 38 37 bytes
-3 bytes thanks to @user81655
-1 byte thanks to @manatwork
-1 byte thanks to @NotthatCharles
?A.upto(?Z){|a|puts (a+a.next[0])*13}

See it on repl.it: https://repl.it/CmOJ

Nowdays with Ruby 2.7 you can use _1 and you can go down to 36 bytes.
?A.upto(?Z){puts (_1+_1.next[0])*13}

Vim, 85 83 bytes
:h<_<cr><cr><cr>YZZP:s/./\0\r/g<cr><c+v>ggy25Pqqlxj:let @a='xkPjj'<cr>25@akia<esc>25klq11@qh<ctrl+v>25jylpl<c+v>25jdGdd

I know this can be golfed more, but my head hurts so I gotta stop for now.
<cr> is the enter key, <c+v> is ctrl+v, and <esc> is the escape key. Those were all counted as one byte.
I recorded a gif of this, but it got screwed up. The video is fine though: http://recordit.co/ldLKvho9Gi

Cheddar, 48 bytes
print(65|>90).map(l->@"[l,l>89?65:l+1]*13).vfuse

Cheddar is good with strings :D
Try it online!
Explanation
print
  (65|>90)            // Range from 65 (A) to 90 (Z)
  .map(l->            // Map through range
    @"                // Convert following array of char codes to string
      [l,             // The character
       l>89?65:l+1]   // See below for explanation
      *13             // Repeat 13 times
  ).vfuse             // Vertically fuse

What does l>89?65:l+1 do? Well 89 is the char code for Y. Basically, l>89 is checking if the letter is Z, that means we should be returning A. If l>89 is false. I'll return l+1, the next char

I thought you can insert @" between them.

Doesn't this use a function return?

@ConorO'Brien yeah?

http://codegolf.stackexchange.com/questions/89283/print-an-alphabet-wave/89286?noredirect=1#comment217722_89283

@ConorO'Brien oh, didn't see in challenge spec. will fix

@Downgoat it isn't in spec >_< just in comments

Haskell, 60 58 bytes
mapM putStrLn[[0..12]>>[a,b]|a:b:_<-scanr(:)"A"['A'..'Z']]

Starting with "A" scanr(:) builds the a list from the chars of ['A'..'Z'] from the right. (->  ["ABCDE...A", "BCDEF..A", ...,  "XYZA", "YZA", "ZA", "A"]). (a:b:_) matches the first two chars of each sublists (with at least two chars) and makes 13 copies of it.

Considering some of the cheats used by other languages on a regular basis I consider it only fair to not include the actual printing. In this case you could replace it with "(++"\n")=<<" and save 2 bytes. Possibly more.

@MarLinn: No, I don't think so. Golfing languages are designed with implicit printing in mind and most other answers do have some sort of printing command. Btw, unlines is even shorter than (++"\n")=<<.

Jelly, 10 bytes
26ḶḂØAṙZj⁷

Try it online!
How it works
26ḶḂØAṙZj⁷  Main link. No arguments.

26Ḷ         Yield [0, ..., 25].
   Ḃ        Bit; compute the parity of each intger.
    ØAṙ     Rotate the alphabet by these amounts.
       Z    Zip; transpose rows and columns.
        j⁷  Join, separating by linefeeds.

Didn't Y exist back then? Also congrats for 100k rep!!

Thanks! I checked and, sadly, Y was added two days after the challenge was posted.

Because you could have golfed it further down to 26ḶḂØAṙZY. But, as it is right now, it's still good.

PowerShell, 49 43 bytes
TimmyD's remix:
65..89|%{-join[char[]]($_,++$_)*13};"ZA"*13

was, 49 bytes:
0..25|%{(""+[char]($_+++65)+[char]($_%26+65))*13}

Python 2, 70 68 54 bytes
List based solution:
L=map(chr,range(65,91))
for i in range(-26,0):print(L[i]+L[i+1])*13

But why create a list? Thanks LeakyNun:
for i in range(26):print(chr(i+65)+chr(-~i%26+65))*13

R, 72 67 60 56 bytes
write(matrix(LETTERS[c(1:26,2:26,1)],26,26,T),"",26,,"")

Thanks to @Giuseppe for the extra 4 bytes off!
Old rep-based solution at 60 bytes:
for(i in 1:26)cat(rep(LETTERS[c(i,i%%26+1)],13),"\n",sep="")

See here on an online interpreter. Thanks to @user5957401 for the extra 7 bytes off!
Old matrix-based solution at 72 bytes:
for(i in 1:26)cat(matrix(LETTERS[c(1:26,2:26,1)],26,26)[i,],"\n",sep="")

See here on an online interpreter.

if you change the indext to i in 1:26 and then the letter selection to LETTERS[c(i,i%%26+1)] you can drop like 6 or 7 bytes

@user5957401 arf I was so stubbornly doing (i+1)%%26 that it didn't occur to me to do the opposite! Thanks!

56 bytes using matrices again :)

Jellyfish, 26 bytes
P
+'A
~
| S
+$ r2
 ,'
r'

Note the trailing unprintable characters on the last two lines.
Try it online!
Explanation
This is basically an arithmetic manipulation approach: make a 26×26 grid with alternating 0-1 pattern, add the index of each row to every element of the row, reduce mod 26, and add the ASCII value of A.
Characters in Jellyfish are just numbers with a special flag, and all arithmetic works on them as expected.
From bottom to top:

The 's are character literals; they are followed by unprintables with ASCII code 26, and stand for those characters.
The lower r computes the character range from 0 to 25.
The , forms a pair from the two unprintable chars.
The higher r is given argument 2, and forms the range [0 1].
The $ takes that range, and reshapes it into the shape given by its other argument, which is the pair of unprintables. This gives a 26×26 matrix of alternating rows 0 1 0 1 0 1 ...
The lower + adds the char range 0-25 to this matrix. The addition distributes on the rows, so row i is incremented by i. It's also converted to a char matrix, since the south argument consists of chars.
The ~| is modulus with flipped arguments: the south argument (the above char matrix) is reduced modulo the east argument (the S turns the argument-seeking process south, so this is the unprintable literal 26).
The higher + adds the literal A to every coordinate of the resulting matrix.
The P prints the result in matrix format, that is, each row on its own line without quotes.

I wanted to try to golf but then I saw the name of him who wrote the code.

@LeakyNun You can still try! Although 26 bytes is fitting for this challenge.

Perl, 26 bytes
Solution from @Dom Hastings. (12 bytes shorter than mine!)
-1 byte thanks to @Ton Hospel
say+($_++,chop)x13for A..Z

Run with -M5.010 or -E :
perl -E 'say+($_++,chop)x13for A..Z'

Managed to get this down to 33: say+($_++,$_--=~/^./g)x13for A..Z, but I'm sure there's a way to get a shorter one from: say+($_++,$_--)x13for A..Z...

Not sure why I have the -- in there, it's not needed! O_o. 27: say+($_++,/^./g)x13for A..Z

@DomHastings Nicely done! I tried say+($_,$_++)x13for A..Z at first which didn't work, but it seems I should have push further into that direction!

say+($_++,chop)x13for A..Z saves one more byte

@TonHospel great, thanks for that.

MATL, 13 bytes
1Y2tn:!to~!+)

Try it online!
1Y2    % Predefined string literal: 'AB···Z'
tn:    % Duplicate, number of elements, range: gives [1, 2, ···, 26]
!      % Transpose into a column vector
to~!   % Duplicate and transform into [0, 1, 0, 1, ···, 1] using modulo 2
+      % Addition with broadcast. Gives 2D numeric array
)      % Index (modularly) into string. Implicitly display.

T-SQL 133 Bytes (Golfed by : @t-clausen.dk)
SELECT REPLICATE(Char(number+65)+IIF(number=25,'A',Char(number+66)),13)FROM spt_values WHERE number<26and'P'=TYPE

T-SQL , 151 Bytes
Using CTE to generate sequence of number
;WITH n(a,v) AS(SELECT CHAR(65)+CHAR(66), 66 UNION ALL SELECT CHAR(v)+CHAR(v+1), v+1 FROM n WHERE v < 91)SELECT REPLICATE(REPLACE(a,'[','A'),13) FROM n

T-SQL, 155 Bytes
SELECT REPLICATE(Char(number+65)+ CASE WHEN number=25 THEN 'A' ELSE Char(number+66) END, 13) FROM master.dbo.spt_values  WHERE name IS NULL AND number < 26

I have golfed your answer down to 113 characters.
I provided a very different answer in TSQL

@t-Clausen.dk That is excellent. Please post your answer. I would delete mine.

no reason to delete your answer, you can just use my fiddle to improve your answer. I already posted 1 hour ago ago, if you enjoy TSQL , you should take a look at my other answers. I made Fiddles for most of them

Vim, 31 bytes
:h<_↵↵↵YZZPJra0qqy2l13Plr↵25@qD

Where ↵ is the Return key.

Julia, 46 bytes
[println("$c$(c+1-26(c>89))"^13)for c='A':'Z']

Try it online!

Pyth, 10 bytes
jCm.<G~!ZG

Demonstration
Explanation:
jCm.<G~!ZG
  m      G    Map over G, predefined to the lowercase alphabet.
              This will give 26 columns.
   .<G        Left shift (cyclically) G by
        Z     Z elements. Z is initialized to 0.
      ~!      After using its value, logical not Z. (0 -> 1, 1 -> 0)
 C            Transpose
j             Join on newlines

Nice, wish I knew as much as you do about Pyth

Brainfuck, 88 86 bytes
++[[+>]<+<++]+>-[[->+>+<<]>>-]++++++++[<[++++++++<+<]>[>]<-]<<++<[>+++[->.<<.>]<<++.<]

Requires an interpreter with 8-bit cells and a tape not bounded on the left. Try it online!

Lua, 80 65 Bytes.
s = string c = s.char for i=1,26 do print(s.rep(c(64+i)..c((65+(i%26))),13)) end

With help from Leaky Nun
c=("").char for i=1,26 do print((c(64+i)..c(65+i%26)):rep(13))end

Lua is a pretty inefficent language in regards to handling of strings and such, so this is the best I can narrow it down.

Welcome to PPCG! Nice first post! You can save 5 bytes if you remove some unnecessary whitespace: s=string c=s.char for i=1,26 do print(s.rep(c(64+i)..c((65+(i%26))),13))end

for i=1,26 do print(((64+i):char()..(65+(i%26)):char()):rep(13))end (not tested)

Because string.rep(x,13) is basically x:rep(13)

Right! I forgot the string metatable defaultly indexes to the string library.

Although good, numbers such as 65+(i%26) don't count as strings unless stored as such. I'll work on a way to make that work for the hell of it.

Brachylog v1, 30 24 20 bytes

@Ab:"a"c:@Arz:{:12jc:@Nc.}a:wa
@Ab:"a"c:@Arze:12jcw@Nw\
@A$(:@Arze:12jcw@Nw\

Try it online!

05AB1E, 12 bytes
ADÀ)øvyJ5Ø×,

Explanation
AD            # push 2 copies of the alphabet
  À           # rotate the 2nd one left by 1
   )ø         # add to list and zip
     v        # for each
      yJ      # join the pair
        5Ø×   # repeat it 13 times
           ,  # print with newline

Try it online

I know this is an old question but i just can't help myself. ADÀ)ø13×» works as well with 9 bytes.

@Datboi: That does indeed work now, but unfortunately it didn't work at the time this question was posted :(

TSQL, 111 bytes
DECLARE @o varchar(702)='',@ int=1WHILE @<702SELECT @o+=CHAR(IIF(@%27=0,10,65+(@/27+1-@%27%2)%26)),@+=1PRINT @o

Fiddle

Golfed even further to 99 bytes http://codegolf.stackexchange.com/a/90659/58577

Mathematica, 82 75 67 66 bytes
Print@FromCharacterCode@PadLeft[{},26,{i-1,i}~Mod~26+65]~Do~{i,26}

Technically shorter, although it prints in lowercase instead of uppercase:
Mathematica, 64 bytes
Print[""<>FromLetterNumber@Table[{i-1,i}~Mod~26+1,13]]~Do~{i,26}

Nice trick using PadLeft.

APL (Dyalog Unicode), 12 bytes
⍉↑26⍴⌽∘⎕A¨⍳2

Try it online!
Requires ⎕IO←0, so that ⍳2 evaluates to 0 1.
How it works
⍳2     ⍝ 0 1
⌽∘⎕A¨  ⍝ Rotate the uppercase alphabet 0 and 1 times,
       ⍝ giving ["ABC..Z", "BCD..ZA"]
26⍴    ⍝ Cycle the two strings to the length of 26
⍉↑     ⍝ Promote to a matrix and transpose

Bunch of 13- and 14-byte solutions
⍉↑26⍴⎕A(1⌽⎕A)
⍉↑26⍴0 1⌽¨⊂⎕A
(26⍴⍳2)⊖∘.⊣⍨⎕A
∪⍉↑26⍴↓2 27⍴⎕A
∪26⍴⍤1⍉2 27⍴⎕A

These are included in the TIO link above.

J, 20 19 bytes
1 byte thanks to miles.
u:65+26|(+/2&|)i.26

Online interpreter
This is actually the program I used to generate the text in the challenge.

You can remove the @

u:65+(|i.+/2|i.)26

Oracle SQL 11.2, 141 138 bytes
SELECT LISTAGG(CHR(l+64)||CHR(MOD(l,26)+65))WITHIN GROUP(ORDER BY l)FROM(SELECT CEIL(LEVEL/13)l FROM DUAL CONNECT BY LEVEL<339)GROUP BY l;

Un-golfed
SELECT LISTAGG(CHR(l+64)||CHR(MOD(l,26)+65))WITHIN GROUP(ORDER BY l)
FROM   (
         SELECT CEIL(LEVEL/13)l
         FROM   DUAL
         CONNECT BY LEVEL<339  -- 26*13+1
       )
GROUP BY l

T-SQL 99 90 bytes
Saved 9 bytes thanks to @t-clausen.dk
DECLARE @ INT=65z:PRINT REPLICATE(CHAR(@)+CHAR(IIF(@=90,65,@+1)),13)SET @+=1IF @<=90GOTO z
Ungolfed:
DECLARE @CurrCharacter INT = 65; --ASCII decimal for 'A'
WHILE (@CurrCharacter <=90) --ASCII decimal for 'Z'
BEGIN
   PRINT REPLICATE(
    REPLACE(CHAR(@CurrCharacter)+CHAR(@CurrCharacter+1),'[','A')
    ,13); --Replicate the current character and its neighbor 13 times. If the neighbor is '[' (ASCII code 91) then replace it with 'A'.
   SET @CurrCharacter+=1; --Go to the next letter
END

That is very nice, you can save another 9 bytes like this

05AB1E, 11 9 bytes
AuDÀø13×»

Try it online!
Posting because it beats the other 05AB1E answer and kinda uses a different method
-2 with vectorisation
Explained
Au          # Push the uppercase alphabet. STACK = [A-Z]
  D         # Duplicate that. STACK = [A-Z, A-Z]
   À        # Rotate the alphabet left. STACK = [A-Z, Rotate_Left(A-Z)]
    ø       # Zip those two alphabets. STACK = ["AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ", "JK", "KL", "LM", "MN", "NO", "OP", "PQ", "QR", "RS", "ST", "TU", "UV", "VW", "WX", "XY", "YZ", "ZA"]
     13×»   # Repeat each 13 times and join with newline

jq -nr, 41 bytes
range(26)|[(.+range(26)%2)%26+65]|implode

Try it online!

JavaScript (ES6), 88 83 bytes
_=>[..."ABCDEFGHIJKLMNOPQRSTUVWXYZ"].map((c,i,a)=>(c+a[-~i%26]).repeat(13)).join`\n`

Where \n represents the literal newline character. Writing the alphabet out saved me three bytes today, but @LeakyNun saved me another five bytes.

Did it save you four bytes yesterday?

_=>[...s="ABCDEFGHIJKLMNOPQRSTUVWXYZ"].map((c,i)=>(c+s[-~i%26]).repeat(13)).join\\n``

@LeakyNun No, just two, I'm afraid: http://codegolf.stackexchange.com/a/89297/17602

The (c,i,a) is watching you.

MATLAB, 47 38 bytes
a=(65:90)';char(repmat([a a([2:end 1])],1,13))

char(repmat([65:90;[66:90 65]]',1,13))

The first makes a column array of the alphabet in ASCII, appends a shifted copy as a column to its right, replicates the resulting 26*2 array 13 times columnwise, casts to a character array and prints by default.
The second makes a 2*26 array of alphabet and shifted alphabet, transposes it then continues as above.

You can save one byte using [... ''] instead of char(...).

And you can use simply [65:90;66:90 65] saving two bytes.

Neoscript, 59 bytes
a=('A:[]:'Z)+'Aeach n=0:[]:25console:log((a[n]+a[n+1])*13);

Javascript (using external library Enumerable) (84 bytes)
    n=>(w=_.Range(0,26)).WriteLine(x=>w.Write("",y=>String.fromCharCode((x+y%2)%26+65)))

Link to lib: https://github.com/mvegh1/Enumerable/
Code explanation: Create a range of ints starting at 0 for count of 26. Store into global variable w. For each, write a new line according to predicate. Predicate states to take "w" and write a joined string based off the passed predicate to Write. Predicate to Write uses an empty string as the join delimiter, and uses the current integer value from WriteLine ("x") and the current integer value from Write ("y") to calculate the correct string at that position
Edit: Removed extra parens to save 2 bytes

PHP, 102 bytes
<?php $a='ABCDEFGHIJKLMNOPQRSTUVWXYZA';$i=-1;while($i++<25){echo str_repeat(substr($a,$i,2),13)."\n";}

You can remove the quotes from the Alphabet string. Replace \n with an actual enter instead of \n. Stole that idea from @insertusernamehere. So check his answer for what I mean. Edit: Also use the short-tag notation <?.  You also do not need a space after <?. So <?$a='ABC' also works.

Ruby, 41 bytes
26.times{|i|puts [*?A..?Z,?A][i,2]*''*13}

C (86 bytes):
for(int c=-11,n=-26;++n<1;){while(c++){printf("%c%c",90+n,n?91+n:65);}c=-11;puts("");}

My first attempt on a Code Golf challenge.
Some answers are really impressive!

PHP, 65 bytes
Well, this is pretty straight forward:
for(;$i<26;)echo str_repeat(chr(65+$i).chr(65+(++$i%26)),13)."
";

C#, 107 bytes
My first attempt at a submission to PPCG
Golfed:
var l="";int i=0,j=0;for(;i<26;i++){for(;j<26;j++)l+=(char)(((j%2)+i)%26+65);Console.WriteLine(l);l="";j=0;}

Ungolfed:
var l="";
int i=0,j=0;
for(;i<26;i++){
    for(;j<26;j++)l+=(char)(((j%2)+i)%26+65);
        Console.WriteLine(l);
    l="";j=0;
}

Pretty sure this adheres to standards! Would love to hear any potential improvements.

Java 7, 87 bytes
void c(){for(int i=0;i<703;)System.out.print((char)(i++%27>0?65+(i/27+i%27%2)%26:10));}

Based on @orlp's amazing answer.
Ungolfed & test code:
Try it here.
class Main {
  public static void main(String[]a){
    c();
  }

  static void c(){
    for(int i=0; i<703;){
        System.out.print((char)(i++%27 > 0
                                  ? 65 + (i/27+i%27%2)%26
                                  :10));
    }
  }
}

Python 2 53 bytes
i=0;exec'print(chr(i+65)+chr(-~i%26+65))*13;i+=1;'*26

Common Lisp, SBCL, 86 bytes
(dotimes(i 26)(format t"~13@{~a~:*~}~%"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZA"i(+ i 2))))

Explanation
(dotimes(i 26);loop from i=0 to i=25
(format t"~13@{~a~:*~}~%"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZA"i(+ i 2))))
;print 13 times pairs of "AB", "BC", ... , "ZA"

c64 basic v2, 95 93 85 83 77 bytes
0fOy=65to90:l$="":a$=cH(y)+cH(y+1+(y=90)*26)
1fOx=0to12:l$=l$+a$:nE:?l$:nE

Screenshot:

Trial instructions are in my previous answer.

can you switch out 0..25 for 65..90 in the first line? e.g. 0fOy=65to90:l$="":a$=chr$(y):b$=chr$(1+y):ify=90tHb$="a" for -3 bytes?

@streetster Thanks! And I switched to conditional operator to avoid the if-then! :-) It is already 85. Screenshot follows.

SOGL V0.12, 8 bytes
Z«Z¹'⁰∙I

Try it Here!
Explanation:
Z         push the uppercase alphabet
 «        put its first letter at the end
  Z       push the alphabet once again
   ¹      wrap in array: ["BCDEFGHIJKLMNOPQRSTUVWXYZA", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
    '⁰∙   multiply vertically 13 times
       I  rotate clockwise

Bash, 64 bytes
f()(tr A-Z B-ZA|tee >(((i++<25))&&f);echo)
printf ZA%.s {a..m}|f

Credit to seshoumara's sed answer for the idea of translating A-Z to B-ZA.
Try it online!

Visual Basic .NET (Mono), 140 bytes
Module M
Sub Main
Dim I,J,S
For I=1To 26
S=""
For J=0To 11
S+=Chr$(I+64)+Chr$(I Mod 26+65)
Next
Console.WriteLine(S)
Next
End Sub
End Module

Try it online!

MY-BASIC, 77 bytes
For I=1 To 26
For J=0 To 12
Print Chr(I+64)+Chr(I Mod 26+65)
Next
Print;
Next

Try it online!

PHP, 78, 72, 67 bytes
<?php $s='A';while($s!='AA')echo str_repeat($s++.(--$s)[0],13)."
";

Try it online!

Instead of striking out old answers, just keep their bytecount in the header and strike those out. The revision history is sufficient in case you want to see older solutions.

@Timtech good point, thank you, Sir :)

Glad to help you out @Link, keep it up:)

APL (Dyalog Unicode), 13 bytesSBCS
⍉(⎕a⌽⍨2|⊢)⌸⎕a
Try it online!

Charcoal, 15 bytes
Ｅ²⁶⎇﹪ι²α⁺ΦαμA⟲⁶

Link is to verbose version of code.
Try it online!

Knight, 34 bytes
;=a 65;W>90aO*+AaA=a+1a 13O*"ZA"13

Try it online!
Expanded code:
;=a 65
;WHILE > 90 a
  OUTPUT * (+(ASCII a) (ASCII (= a(+ 1 a)))) 13
OUTPUT (* "ZA" 13)

There's probably a better way to deal with the last row, but I don't know it.
Another 34-byte solution:
;=a 0W>26aO*+A+65aA+65%=a+1a 26 13

Julia, 51 bytes
!()=join(["$x$(x+1-26(x>89))"^13for x='A':'Z'],"
")

Initial golfing.

C, 77 74 71 bytes
Basically the same as the Python answer inspired by LeakyNun, Thanks to owacoder for puts
:
f(i,j){for(i=0;++i<27;puts(""))for(j=13;--j;printf("%c%c",i+64,i%26+65));}

Usage:
f();

While  mathematically (26-n)%26 == (-n)%26, this is not true for C, otherwise these two bytes can be shaved off. Using a count up loop for i resolves the problem

You can save two bytes by counting from 64: f(i,j){for(i=64;++i<91;printf("\n"))for(j=13;--j;printf("%c%c",i,i%91+65));}

Use puts("") instead of printf("\n") for printing a newline.

@Advancid no you can't. that i%95 does not work

@owacoder Ah, good old puts. Only had putchar in mind.

Java 8, 139 137 bytes
()->{for(int i=65,j=1;;j++){if(j>25){j=++i<91?1:0;System.out.println();
if(j==0)break;}System.out.print((char)i+""+(char)(i>89?65:i+1));}}

chaning j==26 to j>25 allow you to save 1 byte. using multiple print statements when you are golfing in java cost you badly, and you could refactor it to use single print statement

Javascript(ES5), 107 99 bytes
for(var s="",i=-1;++i<676;)i&&!(i%26)&&(s+="\n"),s+=String.fromCharCode((i/26+i%2)%26+65);alert(s);

console.log => alert.

Thanks for pointing that out! Made another small change as well. This is the part I'd really like to change "i&&!(i%26)", surely there's a better way of doing both checks here at once, or at least in a more concise way! I'd love any suggestions here!

RETURN, 23 bytes
'A'[␊'B'[␊'A␈13␋␄'␊°␇␂,

Try it here.
NOTE: Use the "Insert String" button and paste the above code in.
Explanation
Basically generates A-Z and B-Z and A at the end on the stack. Then the stack is duplicated 13 times, transposed, joined with a newline, and outputted.
Due to a bug that I just can't fix, 'A'[␊${25@}13␋␄'␊°␇␂, does not work.

A language using ␊ instead of a literal newline is weird...

No, I'm just putting it there to avoid confusion; newlines are range commands, so having ␊ there emphasizes that. It's the same with the other unprintables.

C# - 159 138 bytes
var a="ABCDEFGHIJKLMNOPQRSTUVWXYZA";for(int i=0;i<26;i++){for(int j=0;j<14;j++){Console.Write("{0}{1}",a[i],a[i+1]);}Console.WriteLine();}

If you add A at the end of the alphabet you can change (i+1)%26 to i+1

The alphabet can also be var and you don't need the .ToCharArray() as a string is already just that.

Oh, thank you! This was my first time code golfing, so I'm happy to learn more.

Creating the row in a variable and replacing the inner for with a while saves at least 13 additional bytes.

You can save a few bytes by using string interpolation like this: Console.Write($"{a[i]}{a[i+1]}") which makes it 135 bytes

JAVA 9, 103 97 bytes
it works on JShell, provided by Java9 SDK.
for(int c=64,i;++c<91;)for(i=0;i<26;)System.out.print((char)((c-13+i%2)%26+65)+(i++<25?"":"\n"))

Pyke, 13 bytes
GGt\a+]w-*,_X

Try it here!

ListSharp, 236 bytes
ROWS x=ROWSPLIT "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,T,S,U,V,W,X,Y,Z,A" BY [","]
[FOREACH NUMB IN 1 TO 26 AS i]
{
STRG t =""
[FOREACH NUMB IN 1 TO 13 AS j]
{
STRG e=GETLINE x [i]
STRG r=GETLINE x [i+1]
STRG t=t+e+r
}
ROWS s=s+t
}
SHOW=s

Feel free to comment if you want anything to be explained to you
Execution screenshot:

Perl 6, 50 bytes
say .join x 13 for flat('A'..'Z','A').rotor(2=>-1)

EXCEL: 53 bytes
=REPT(CHAR(ROW(A1)+64)&CHAR(MOD(ROW(A1),26)+65),13)

Place in A1 and drag to desired length of wave (in this case, 26, one cell for each letter).

Improving on @gabe3886's answer (new account and not able to comment)
PHP 94 92 Bytes
<?php for($i=0;$i<26;)echo str_repeat(substr('ABCDEFGHIJKLMNOPQRSTUVWXYZA',$i++,2),13)."\n";

However if you suppress notices, it's 92 90 bytes
<?php for(;@$i<26;)echo str_repeat(substr('ABCDEFGHIJKLMNOPQRSTUVWXYZA',@$i++,2),13)."\n";

Welcome to PPCG. You can golf this down to 79 bytes: for(;$i<26;)echo str_repeat(substr(ABCDEFGHIJKLMNOPQRSTUVWXYZA,$i++,2),13)."↵";. Replace ↵ with an actual line break. As an additional note: You don't need to include the PHP opening tag and you don't need to handle notices.

You can even save another 6 bytes, with a total of 73 bytes: for(;$i<26;)echo str_repeat(substr(implode(range(A,Z)).A,$i++,2),13)."↵";

@insertusernamehere: Thanks! I wasn't too clear on the rules for this exchange (IE: does it include just functional code (no <?php tag) and/or would warnings be considered part of the output). I noticed in your second comment that range(A,Z) don't have the A and Z characters quoted. Is that abusing another PHP "feature"?

Yes, I've removed the quotes in both suggestions. When you run a string without quotes it should prompt something like Notice: Use of undefined constant which is fine here. But be careful, this won't work on strings with whitespaces or special characters etc.

Right. I remember now. PHP will assume it's the literal character "A"(or "Z" or whatever), which is the same reason "foo $bar[baz]" interpolation works without the curly braces.

Logo, 93 bytes
Here's a non-graphical Logo solution.  Try it online with Calormen.com's interpreter.
to m:c type char 65+modulo:c 26end
to b:a repeat 13[m:a-1 m:a] pr" end
repeat 26[b repcount]

JavaScript, Z (90) bytes
for(i=65,b=66;i<91;++i,b=b<90?++b:65)console.log(Array(14).join(String.fromCharCode(i,b)))

To learn:
var start = 65,
    end = 90;

for (var i = start, b = i+1; i <= end; ++i) {
    var chars = String.fromCharCode(i, b);
    /* repeat chars 14 times */
    console.log(Array(14).join(chars));
}

What is that Z?

@EriktheGolfer You know, Z in ASCII is 90 bytes (\x5a)

VIM, 42
:h<_↵↵↵YZZP:s/./&\r/g↵^25↑y↑pG2↑aa↓^ggy13P

where:

↵ is return,
^ is ctrl + v
↑ is the up arrow
↓ is escape

I'm sure this can be golfed more. I'm new to VIM so any suggestions are appreciated.

Vitsy, 29 bytes
So, instead of doing the typical thing, I used my two-dimensional stacking to generate the alphabets and then offset them by one from each other, alternating back and forth between them.
9a*d5*Hd\[:{:}]Y?y\[y\[O?]aO]

9a*d5*H                        Push an alphabet to the stack.
9a*                                 Push 90 to the stack (character code 'Z')
   d5*                              Push 65 to the stack (character code 'A')
      H                             Pop a, b, push range (a, b)

       d\[:{:}]                Establish the other stacks, while alternating.
       d\[    ]                     Do the bracketed code 13 times.
          : :                       Clone the stack.
           {                        Put the top item of the stack on the bottom.
             }                      Put the bottom item of the stack on the top.
               Y                    Discard a stack. (13*2+1-1 = 26)
                ?                   Rotate right a stack (we start on 'A' now)
                 y\[y\[O?]aO]  Output.
                 y\[        ]       Repeat the code in brackets number of stacks times (26).
                    y\[  ]          Repeat the code in brackets number of stack times (26).
                       O            Pop a, print a as a character.
                        ?           Go right a stack.
                          aO        Output a newline.

Try it online!

PHP, 70 66 64 Bytes
<?$a=A;$b=B;while($a!=AA)echo str_repeat($a++.($b++)[0],13)."
";

3 bytes short (if I would remove the <? as well) from @insertusernamehere answer. So close!
EDIT:
Actually got it to 66 bytes (64 without the <?)! Doing A and B without quotes actually seem to work. Seems to be the shortest PHP one as time of write :D
EDIT 2:
Also removed " " from AA. Still seems to be working.

python 3, 92 90 bytes
a=65
b=66
for i in range(312):
    if a>89:b=65
    print(chr(a)+chr(b),end="")
    if (i+1)%12<1:
        a+=1
        b+=1
        print()

python 2, 80 bytes
a=65
b=66
for i in range(312):
    if a>89:b=65
    print chr(a)+chr(b),
    if (i+1)%12<1:
        a+=1
        b+=1
        print

This program outputs AB AB AB AB... rather than ABABABAB... I'm not sure if this is allowed, but it's the best I can come up with.
EDIT:
Thanks @User902383 for you comment on @TAsk's post allowing me to shave off 2 bytes.
And thanks @NoOneIsHere for suggesting that I move to python 2 instead of 3, I've included a second program in python 2 with a new byte count.

You can remove the soace before b=65.

Thanks, I think I already had mentally omitted that when I counted it, just not taken it out of the code. Thanks anyway though.

If you switch to python 2, you can replace print() with print, and print(...,end='') to print ..., (trailing comma).

Scala, 64 bytes
Can anyone improve on this?
(('A'to'Z'):+'A').sliding(2).map(_.mkString*13).foreach(println)

Python 2.7, 65 bytes
Python 2 alternative using a recursive function
def l(a=0):
 print(chr(a+65)+chr(-~a%26+65))*13
 if a<25:l(-~a)

Bash, 149, 115, 111, 106 bytes
for i in {0..25};{
printf $(printf %b%b \\`printf %o $[i+65]` \\`printf %o $[-~i%26+65]`)%.s {a..m};echo
}

(thanks @manatwork, saved 34, 4 more bytes)
Bash, 140 bytes
(thanks @steeldriver)
for i in {0..25}; do printf "$(printf '%b%b' \\$(printf '%03o' $((i+65))) \\$(printf '%03o' $((-~i%26+65))))%.0s" {1..13}; printf \\n; done

Save to <file> and run as: /bin/bash <file>

$((…)) → $[…], '%b%b' → %b%b, printf \\n → echo, inner $(…) → \…`, do … done→{ … }, %.0s→%.s, {1..13}→{a..m}`. (Some of those you may find in Tips for golfing in Bash.)

Sorry, but { and } need separators around them. But there are still single quotes to remove around printf's format strings and what I forgot earlier, no need for the double quotes either. http://pastebin.com/s1h75e5i

One more thing: 65..90 in octal is 101..132, so they take 3 digits anyway, so %03o → %o.

Sorry, seems I not explained the error well enough. As the code you posted failed with “line 1: syntax error near unexpected token `{printf'”, I edited it. Feel free to revert if you disagree.

@manatwork copy-paste error on my part, thanks (-:

GNU sed, 95 bytes
s,^,@@@@@@@@@@@@@,;s,@,AB,g
:;p
y,ABCDEFGHIJKLMNOPQRSTUVWXYZ,BCDEFGHIJKLMNOPQRSTUVWXYZA,
/^Z/!b

I wish the 'y' command had this syntax: y,A-Z,B-ZA,.

Python, 56
for k in range(26):print(chr(k+65)+chr((k+1)%26+65))*13

Ah, I had a look at your answer, @Karl Napf. You used a sneaky method of golfing two bits away from my solution. Thank you for teaching me something new :]

PHP, 52 bytes
for($a=A;$a!=AA;)echo str_pad("\n",27,$a++.$a[0],0);

Can JavaScript beat this? Run with -r.

Javascript, 98 Bytes
for(var j=371,s="";j<1333;j+=37){for(i=0;i<13;i++)s+=j.toString(36).replace("100","za");s+="<br>"}

Try it here

Is that a typo? This doesn't look like 12 bytes to me. (I think it's 98 bytes.)

tcl, 80
time {puts [string repe [format %c%c [expr [incr i]+64] [expr $i%26+65]] 13]} 26

demo

tcl, 86
while {[incr i]<27} {puts [string repe [format %c%c [expr $i+64] [expr $i%26+65]] 13]}

demo

Bash + Unix utilities, 53 52 bytes
dc "-e65[d257*1+16 52^65535/*POP1+d91>x]dsxx"|tr [ A

Try it online!
Test run:
dc "-e65[d257*1+16 52^65535/*POP1+d91>x]dsxx"|tr [ A
ABABABABABABABABABABABABAB
BCBCBCBCBCBCBCBCBCBCBCBCBC
CDCDCDCDCDCDCDCDCDCDCDCDCD
DEDEDEDEDEDEDEDEDEDEDEDEDE
EFEFEFEFEFEFEFEFEFEFEFEFEF
FGFGFGFGFGFGFGFGFGFGFGFGFG
GHGHGHGHGHGHGHGHGHGHGHGHGH
HIHIHIHIHIHIHIHIHIHIHIHIHI
IJIJIJIJIJIJIJIJIJIJIJIJIJ
JKJKJKJKJKJKJKJKJKJKJKJKJK
KLKLKLKLKLKLKLKLKLKLKLKLKL
LMLMLMLMLMLMLMLMLMLMLMLMLM
MNMNMNMNMNMNMNMNMNMNMNMNMN
NONONONONONONONONONONONONO
OPOPOPOPOPOPOPOPOPOPOPOPOP
PQPQPQPQPQPQPQPQPQPQPQPQPQ
QRQRQRQRQRQRQRQRQRQRQRQRQR
RSRSRSRSRSRSRSRSRSRSRSRSRS
STSTSTSTSTSTSTSTSTSTSTSTST
TUTUTUTUTUTUTUTUTUTUTUTUTU
UVUVUVUVUVUVUVUVUVUVUVUVUV
VWVWVWVWVWVWVWVWVWVWVWVWVW
WXWXWXWXWXWXWXWXWXWXWXWXWX
XYXYXYXYXYXYXYXYXYXYXYXYXY
YZYZYZYZYZYZYZYZYZYZYZYZYZ
ZAZAZAZAZAZAZAZAZAZAZAZAZA

Windows batch, 155 bytes
@set s=ABCDEFGHIJKLMNOPQRSTUVWXYZA
@set/ac=-1
:L
@set/ac+=1
@call set t=%%s:~%c%,2%%
@for /l %%i in (1,1,13) do @cd|set/p=%t%
@echo(
@if %t% neq ZA @goto l

Excel VBA, 50 Bytes
Anonymous VBE immediate window function that takes no input and outputs a wave to the range [A1:Z26] on the ActiveSheet object
[A1:Z26]="=Char(Mod(Row()+IsEven(Column()),26)+64)

Recursiva, 19 bytes
{B26'P*13Z~}+(C65;}

Try it online!

Pyth, 12 bytes
I haven't been there
VG*13+N@G=hZ

Explanation:
VG       In the lowercase alphabet...
  *13     13 times...
  +N@G=hZ The current item concatenated with alphabet[++Z]

Try it online!

K (oK), 23 bytes
Solution:
`c$65+26#'a,'1_27#a:!26

Try it online!
Explanation:
`c$65+26#'a,'1_27#a:!26 / solution
                    !26 / range 0..25
                  a:    / save as 'a'
               27#      / 27 take, wraps to make ABC...XYZA
             1_         / 1 drop, take off leading A
          a,'           / concatenate each element with each of a (AB,BC,etc)
      26#'              / 26 take each, wraps to get ABABAB... BCBCBC... etc
   65+                  / add 65, vectorised (65=A in ASCII)
`c$                     / cast to characters

Bonus:
Here are a couple of other ways to get the result:
24 chars: Try it online!
`c$65++26#(!26;1_27#!26)

27 chars: Try it online!
26#'+0 1_'26 27#\:`c$65+!26

q/kdb+, 19 bytes
Solution:
26#'.Q.A,'1_27#.Q.A

Explanation:
Shorter and different to my oK solutions as we have a shortcut to the uppercase alphabet by means of .Q.A. As always, interpreted right-to-left
26#'.Q.A,'1_27#.Q.A / solution
               .Q.A / shortcut to uppercase alphabet, ABC..XYZ
            27#     / 27 take, wraps to get ABC...XYZA
          1_        / 1 drop, drop first element to give BCD...XYZA
    .Q.A,'          / concatenate each left/right lists, so AB, BC, CD etc
26#'                / 26 take each, gives ABABA.. BCBCB... etc

Mathematica, 52 bytes
Column[""<>#~Table~13&/@Partition[Alphabet[],2,1,1]]

-1 byte from Martin Ender

Infix notation for Table saves a byte.

Yabasic, 69 bytes
For I=1To 26
For J=0To 12
?Chr$(I+64)+Chr$(Mod(I,26)+65);
Next
?
Next

Try it online!

uBASIC, 83 bytes
0ForI=1To26:ForJ=0To12:?Left$(Chr$(I+64),1)+Left$(Chr$(IMod26+65),1);:NextJ:?:NextI

Try it online!

Pip -n, 18 bytes
(z.z)@>_@<2X13M,26

Pip doesn't have transpose, so I just took two letter substrings and repeated them.
-n joins lists with newlines.
Try it online!

Jelly, 10 bytes
ØA,Ɲẋ€13j⁷

Try it online!
Noncompeting probably because some of the atoms are new.

Vyxal j, 10 bytes
kA:ǓZv∑13*

Try it Online!
kA         # Uppercase alphabet
  :ǓZ      # Zip with a copy  rotated one to the left
     v∑    # Sum each
       13* # Repeat each 13x

Japt -R, 11 bytes
;B¬£BéÓYvÃy

Test it

Python 2, 78 bytes
a="abcdefghijklmnopqrstuvwxyz"
for i in range(len(a)):print(a[i]+a[-~i%26])*13

Try it online!

Is this a valid -2 shave: a="abcdefghijklmnopqrstuvwxyza"\nfor i in range(len(a)):print(a[i]+a[-~i])*13? it errors, but iirc the meta consensus is to ignore error output

Zsh, 46 bytes
p=A
for c ({B..Z} A)<<<${(el:52::$p$c:)}&&p=$c
Attempt This Online!

Vyxal 3 j, 8 bytes
mmṘZṠ13×

Try it Online!


text:
Do my maths homework!
For all you American folk out there, remove the "s" in "maths".
Ugh, my maths teacher gave me so much algebra to do. There's just lines and lines of meaningless junk like Expand (x+1)(x+6) and Factorise x^2+2x+1.
My hands are literally dying from the inside.
So I figured out a way to hack the system - why not write a program in my book (and tell the teacher to run it)? It's genius!
Your task is to either expand or factorise the function listed. My hand's already dying, so I need to write as small a program as possible to save my fingers.
Input:

The input is either Expand {insert algebra here} or Factorise {insert algebra here}.
When the first word is Expand, you must expand the algebraic terms. You are guaranteed there won't be more than 5 terms.

In the example shown in the intro, the output is x^2+7x+6.
Some more inputs:

Expand (x+1)(x-1) = x^2-1
Expand x(x-1)(x+1) = x^3-x (notice the x on its own - your program must work for that.)
Expand (x+1)^2 = x^2+2x+1 (notice the ^2 on the outside of x+1 - your program must work for that.)

When the first word is Factorise, you must factorise the algebraic term.

In the example shown in the intro, the output is (x+1)^2.
Some more inputs:

Factorise x^2+3x+2 = (x+1)(x+2)
Factorise x^2+x = x(x+1) (if x alone is one of the factors, you must leave it outside the brackets.)
Factorise x^3+9x^2+26x+24 = (x+2)(x+3)(x+4) (there are more than 2 terms here - you are guaranteed that the maximum amount of terms is 5.)
Factorise x^2+2x+1 = (x+1)^2 (if there are multiple repeating terms, group them together - so no (x+1)(x+1), but (x+1)^2.

Specs:

The pronumeral will always be x.
The terms in the Expand bit always contain whole numbers from 1 to 20.
You are guaranteed that the algebra bit in the Factorise part will always be factorised into 5 or less terms, and all the numbers in each term will be whole, and from 1 to 20.
You are not allowed to use any built-in functions.

This is code-golf, so shortest program in bytes wins.
Just as a side-note: it would be appreciated if a pretty-printed output (i.e. With nice-looking exponents)  - I'm looking at you, Mathematica - was included in an answer. You don't have to do it.

Just use WolframAlpha to help you. I think you can use the exact same syntax.

@LeakyNun Well, not anymore... no builtins. Also, is there anything that's vague or unclear about this challenge?

Half of this is a dupe of Factor a polynomial. The other half is close enough to count as a dupe of Multiply polynomials (it just wraps a loop). So there's not really anything new here, unless it's supposed to handle non-polynomials too (which isn't actually clear).

source: Stack Exchange

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

sort: votes


text:
Multiplify a number
Challenge description
Multiplification (totally not a made-up word) is a process in which you take two positive integers: a and b, and produce another integer which is equal to a repeated ("glued together") b times. For example, multiplifying 3 by 7 gives 3333333. Similarly, 103 multiplified by 5 is 103103103103103.
In this challenge, given two positive integers a and b, output a multiplified by b. The catch is, you can't use string operations to generate the number - it has to be done in a purely mathematical way. You may only use operators for addition (+), subtraction (-), multiplication (*), integer division (/, //, div), modulo operation (%, mod) and binary operations (&, ^, |, <<, >> etc.). It's not possible to do in every language, since it has to support arbitrary precision integers.
Sample inputs / outputs
10, 4   | 10101010
3, 9    | 333333333
3737, 2 | 37373737
993, 1  | 993
8888, 8 | 88888888888888888888888888888888

Can I convert to digit list, then concatenate, then convert back to number?

Yes, but you can't directly concatenate digits, like [3, 2] -> 32 unless you do it mathematically, that is for example 3*10 + 2. The point is not to use string operations.

Is this your ideal solution?

Yes, it doesn't use string operations and is therefore valid. Doing something like f=lambda a,b:int(str(a)*b) would be cheating.

Can I compute the length of the number as a string?

No, that counts as a string operation.

I wanted to do this in V but the string restriction makes it impossible. :(

If I want to use a language that doesn't have arbitrary precision integers, am I still allowed a non-competing solution that works for the first four test cases?

Can I print a as many times as b?

@LeakyNun Sounds like a string operation to me.

@Neil Totally, it's still better than nothing. Support for arbitrary precision integers is not a strict requirement, but it won't work for many simple cases, like 102 and 4 (assuming 32-bit integers), that's why I put it there.

@LeakyNun: No, you may not. The number needs to be produced at some point which is the purpose of the challenge.

"[...] Support for arbitrary precision integers is not a strict requirement [...]" vs "[...] it has to support arbitrary precision integers [...]" What should we do now?

@Frozn: Submit your solution and add only works within <range>. It's not a complete solution, but a solution nonetheless.

This falls into one of the classic traps of Do X without Y: it's written assuming that all languages are C-like and so prohibits other languages unnecessarily. E.g. CJam is banned because it would require a duplication operator to have one copy of a to count its length and another to multiply by the corresponding g.p.

This challenge seems to have a number of contradictions between the body and the comments. Consensus is that any changes made in the comments should be edited into the body of the challenge. Until that happens it is unclear which rules apply.

Unfortunately, although the intentions of this challenge are good, I'd like to point out that in general "Do X without Y" challenges are hard to get right. Golfing often invites one to find loopholes in the rules, but in this case the line between what is and what isn't allowed can get a bit fuzzy.

It's still unclear if things like for loops are allowed - they aren't one of the mathematical operators. If they can't it's just a competition with who can find the shortest language that can express this formula

it has to be done in a purely mathematical way says it all, doesn´t it? You have to compute the result using only basic numkerical operations. Loops are no loophole imo (as long as you don´t use them to simply print a b times). btw: what is //?

Python 2, 48 bytes
c,n=input();a=1
while n/a:a*=10
print a**c/~-a*n

Arithmetic!
Take number n and repetition count c. First, computes a=10**num_digits(n) as the smallest power of 10 above a. Then, the floor division a**c/(a-1) gives a number of the form 1001001001001 with c ones, spaced apart by the digit-length of n. Multiplying by n then replaces each 1 with n, giving c concatenated copies of n.
A same-length recursive version:
f=lambda c,n,a=10:a**c/~-a*n*(a>n)or f(c,n,a*10)

This one has to start at a=10 because a=1 causes a division-by-zero error.

Nice, pretty much the same what I came up with, except I wasn't sure how to go about golfing log10(a)

Brachylog, 9 bytes
jL,?h:.cL

Try it online!
Explanation
The j operator concatenates the first thing in an array to itself as many times as the second thing in the array.
In other words, [10:2] would produce 101010.
This operator uses integer in the implementation so is completely usable.
However, it is one concatenation too many.
Therefore, we use the ability of Brachylog to prove things to deal with this:
jL,?h:.cL
jL          input after being treated by the j operator yields L
  ,         and
   ?h:.cL   first element of input concatenated with output is L

Why the downvotes?

Java 8 lambda, 268 characters
Arbitrary precision ruins everything, here are the BigIntegers:
import static java.math.BigInteger.*;import java.math.BigInteger;(a,b)->{BigInteger r=ZERO;int d=(int)(Math.log(2)/Math.log(10)*a.bitLength()+1);if(TEN.pow(d-1).compareTo(a)>0)d--;while((b=b.subtract(ONE)).compareTo(ZERO)>=0)r=r.multiply(TEN.pow(d)).add(a);return r;}

And here the ungolfed version:
import java.math.BigInteger;

import static java.math.BigInteger.*;

public class Q89322 {

    static BigInteger expand(BigInteger a, BigInteger b) {
        BigInteger result = ZERO;

        int digitCount = (int) (Math.log(2) / Math.log(10) * a.bitLength() + 1);
        if (TEN.pow(digitCount - 1).compareTo(a) > 0) {
            digitCount--;
        }
        while ((b = b.subtract(ONE)).compareTo(ZERO) >= 0) {
            result = result.multiply(TEN.pow(digitCount)).add(a);
        }
        return result;
    }
}

I hope that logarithm is also counted as a valid mathematical operation :)
Getting the digits of the BigIntegers powered by this guy. With only int or long this could be way shorter :/

PHP, 105 139 136 134 bytes
function m($a,$b){$s=$x=$a;for($f=10;$x>9;$x=bcdiv($x,10))$f=bcmul($f,10);for(;$b=bcsub($b,1);)$s=bcadd($s,$a=bcmul($a,$f));return$s;}

arbitrary precision needs some room in PHP, but I´ll look if I can shrink this a bit.

I'm quite sure log10 doesn't have arbitrary precision.

@LeakyNun: log10 does not, true. But a=1e+xx is sufficient to get an exact length of a unless xx is greater than INT_MAX. I assume that a does not have that many digits, so I spare the code to implement bclog10 or add a bcmul or bcdiv loop.

oh ... no log, no pow allowed ... back to the editor.

Haskell, 38 bytes
n%c|a<-until(>n)(*10)1=n*div(a^c)(a-1)

Everyone forgets about until!

Python, 65 bytes
f=lambda x,n,p=1:p<=x and f(x,n,p*10)or n and f(x,n-1,p)*p+x or 0

Ideone it!
First recursion to find the power, second recursion to complete the "concatenation".

Pyth, 7 bytes
i*jQTET

Test suite.
Convert to digit list, repeat for that many times, then convert to number.
i*jQTET  Q: first input, E: second input
  jQT    convert Q to base T (10) as a digit list
 *   E   repeat for E many times
i     T  convert from digit list to number

Why the downvotes?

@VTCAKAVSMoACE Salt-votes lol

JavaScript (ES7), 43 bytes
f=(a,b,c=1)=>c>a?(c**b-1)/~-c*a:f(a,b,c*10)

Works up to f(9000,4). (Looks like I rediscovered @xnor's formula.) 56-byte ES6 version or 52-byte ES6 version with an even smaller range:
f=(a,b,c=0,d=0)=>c<a?f(a,b,c*10+9,d*(b='1e'+b)+--b):d/c*a
f=(a,b,c=1,d=1)=>c>a?~-d/~-c*a:f(a,b,c*10,d*='1e'+b)

Jelly, 3 bytes
DẋḌ

Try it online!
DẋḌ  Main chain, argument: x,y
D    Convert x to list of digits
 ẋ   repeat y times
  Ḍ  Convert back to number

Common Lisp, 73 bytes
(lambda(a b)(loop for x below b sum(*(expt 10(*(ceiling(log a 10))x))a)))

k, 20 bytes
Same idea as Pyth solution.
Only supports up to 64 bit signed int range.
{10/:(y*#d)#d:10\:x}

Example
k){10/:(y*#d)#d:10\:x}[103;2]
103103

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


text:
Is it truthy or falsy?
There are so many different ways to express whether something is true or not! The goal of this challenge is to produce a standardized output of truthy or falsy for various input truthy and falsy values.
For the purposes of this challenge, the following inputs are considered truthy:

A string representing a signed integer with a non-zero value (contains only the digits [0-9], with an optional - at the beginning). Note that the string -0 will never be given as input. A non-zero integer will never be preceded by a 0 (i.e. 01 will never be given as input, similarly -01 will never be gien as input).
The case-insensitive strings equivalent to one of defined, found, nonnil, non-nil, on, success, t, true, y, and yes

For the purposes of this challenge, the following inputs are considered falsy:

The string 0. Repeated zeros (00, 00...) will never be given as input.
An empty string
The case-insensitive strings equivalent to one of f, failure, false, n, nan, nil, no, notfound, not-found, null, nullptr, off, and undefined

Input
The input is a string representing a truthy/falsy value. The string may come from any source desired (stdio, function parameter, etc.). There is no leading/trailing whitespace.
The input is guaranteed to match one of the allowed truthy/falsy values above (i.e. you do not need to provide any error handling).
Output
Your program/function must output a truthy/falsy value which represents the "truthy-ness" or "falsy-ness" of the input.
You are only allowed to specify exactly 1 truthy and 1 falsy value which your output must convert the input to (these are your "standardized" truthy/falsy value). The output may be written to any sink desired (stdio, return value, output parameter, etc.).
Please specify what truthy and falsy value you chose in your answer.
Ex.: If you choose the string true as a truthy value, you cannot also have the integer 1 for truthy.
Test Cases
Test cases are formatted as the first line is the input, and the second line is the output.
-1
true

1
true

1234
true

-4321
true

defined
true

deFined
true

Found
true

nonnil
true

non-nil
true

ON
true

SuCCess
true

T
true

true
true

y
true

YeS
true

0
false

'' (empty string)
false

faLSE
false

f
false

Failure
false

n
false

NaN
false

nil
false

no
false

notfound
false

not-Found
false

NULL
false

nullptr
false

OFF
false

unDefined
false

Scoring
This is code-golf; shortest code in bytes wins. Standard loopholes apply. You may use any built-ins desired.

Can a positive integer begin with 0?

Are repeated zeros like 00 truthy, or are they even valid inputs? (I suppose they are not valid, but just checking)

What about FileNotFound? ;)

@feersum a non-zero input will never have preceding zeros.

@Zgarb they are not valid inputs

@TRIG I would have added that if there were fewer answer already given for the current set of inputs.

MATL, 20 bytes
U|sG36ZA13\[BID1]m+g

Input is a string enclosed in single quotes. Output is 1 for truthy or 0 for falsy.
Try it online! Or verify all test cases.
How it works
U|s      % Take input implicitly. Interpret as number, absolute value, sum
G36ZA    % Push input again. Convert from base-36
13\      % Modulo 13
[BID1]   % Push array [6 3 8 1]
m        % True if member: gives 1 iff the result from modulo 13 is in the array
+g       % Add, convert to logical. Display implicitly

This performs two tests on the input:

Try to interpret the input as a number, and detect if it is nonzero. The function used to interpret a string as a number outputs an empty array if it's not possible; and the sum of the entries of an empty array is 0. So it suffices to try the conversion, take the absolute value, and sum. This gives a positive value if the input contains a nonzero number, and 0 otherwise.
Assuming the input string doesn't represent a number, we need to classify it into one of the two given sets. To do this, the input is interpreted as the digits of a number expressed in base-36, using alphabet '01...9ab...z'. The base conversion function is case-insensitive and ignores digits not present in the alphabet (in our case, '-'). It turns out that the modulo 13 of the resulting number is 1, 3, 6 or 8 for the truthy strings, and doesn't give any of those values for the falsy strings. So it can be used as a signature. We thus perform modulo 13 and see if the result is any of those four values. This gives 1 if it is, or 0 otherwise.

The final result should be truthy if any of the two conditions is met, and falsy otherwise. So we add the two numbers resulting from 1 and 2 above and convert to logical, which gives 1 or 0 as standardized truthy/falsy values.

Retina, 22 24 23 bytes
Saved 1 byte thanks to edc65
i`^([-1-9sdty]|fo|n?on)

The whole code is just a regex. The i` at the start makes the regex case insensitive.
Outputs 1 for truthy, 0 for falsey.
Try it online!

The n?on is great, I'm going to use it. I think you don't need the first \\

@edc65: You're right, I don't, oddly enough.

Nice trick with n?on.

Batch, 142 bytes
@goto l%1 2>nul
:l
:l0
:lfailure
:lfalse
:ln
:lnan
:lnil
:lno
:lnotfound
:lnot-found
:lnull
:lnullptr
:loff
:lundefined
@echo 1

Outputs 1 for falsy, nothing for truthy.

Answers like this make me want to write an automated script that posts questions on Code Review seeded with Code Golf content. wipes tear

This is amazing. Even if there might be shorter solutions, I don't care, this is the clear winner.

JavaScript (ES6), 35 39
Edit using the n?on trick, stolen from BusinessCat's answer
Edit 2 OP clarified, no leading 0s, saved 4 bytes
v=>/^([-1-9dsty]|fo|n?on)/i.test(v)

Simply returns true or false
Test

f=v=>/^([-1-9dsty]|fo|n?on)/i.test(v)

trues=[-1,1,1234,-4321,'defined','deFined','Found',
'nonnil','non-nil','ON','SuCCess','T','true','y','YeS']
falses=[0,'','faLSE','f','Failure','n','NaN','nil',
'no','notfound','not-Found','NULL','nullptr','OFF','unDefined']

console.log('TRUE: '+trues.map(x=>f(x)))

console.log('FALSE:' +falses.map(x=>f(x)))

Does removing the \d from the regexp and changing to |v!=0 work?

How about swapping the \d for 1-9? Provided that feersum's question is accurate, ^([-1-9dsty]|on|fo|non) should suffice.

Python, 129 79 78 bytes
Gotta submit fast!
lambda n:n.lower()[:3]in" 0 f n no nil fai fal nan not nul off und".split(" ")

True is false and false is true; I have a nice rhyme for this, I really do (not)

Why the downvote? It seems to work, just true is false and false is true, that's allowed

You can shorten the string array be writing ' 0 f failure false n nan nil no notfound not-found null nullptr off undefined'.split(' ')

@KarlKastor You can actually use .split() instead, because the default separator for split is whitespace.

@Skyler I know, but then there's the empty string missing somehow.

Python, 111 bytes
def b(s):s=s.lower();return s!='no'and not sum(map(ord,s))in[0,48,323,744,523,877,110,785,443,922,315,317,946]

Tests on sum of ASCII values, extra check for no since on has the same value.

Edit1: forgot to test on integer values. Now checking for false inputs

@edc65 the first answer didn't, now checking for false and including ord('0') does

lambda s:s.lower()!='no'and sum(map(ord,s.lower()))in[0,48,323,744,523,877,110,785,443,922,315,317,946]>1 I haven't tested it though.

Python, 83 75 bytes
import re
def f(s):return re.search(r'^([-1-9dsty]|fo|n?on)',s.lower()).pos

Returns 0 on success, AttributeError on failure.
Now using edc85's regex to save 8 bytes.

Ah yes, the good old "explode the program when it fails the test" approach. I love seeing comments like "we couldn't have reached here with invalid arguments" :-)

PowerShell v2+, 39 37 bytes
$args[0]-match'^([-1-9dsty]|fo|n?on)'

Presumes that the answer to @feersum's question is "No, truthy integers may not start with a 0."
Port of @edc65's regex JavaScript answer, with my own 1-9 substitution instead of \d. Uses @BusinessCat's n?on trick to golf further.
Outputs literal Boolean $true or $false values, which when left on the pipeline and sent through an implicit Write-Output at the end of execution results in True or False being printed to the console.

If the answer is "Yes, truthy integers can start with 0," then the following changes need to be made for 51 49 bytes
param($n)$n-ne0-and$n-match'^([-\ddsty]|fo|n?on)'

If you don't like regex, go for PowerShell v3+ and the following at 107 bytes
param($n)$n-and$n-notin-split'0 f failure false n nan nil no notfound not-found null nullptr off undefined'

This takes the string of falsey values, -splits them on whitespace, and uses the -notin operator to check the input $n against that array of strings (which is, by default, case-insensitive). Requires the $n-and to check against the empty string.

You don't need parentheses to use alternation in regex: '^[-1-9dsty]|fo|n?on'  :)

@briantist Without the parens, it matches notfound and not-found because of the fo.

D'oh, you're right. You could do ^[-1-9dsty]|^fo|^n?on but that's the same number of chars and less clear.

PHP, 50 bytes
<?=preg_match('%^([-1-9dsty]|fo|n?on)%i',$argv[1])

prints 1 for truthy, nothing for falsy
tried to come up with a different solution, but the shortest regex for falsy is 3 bytes longer than that for truthy: %^(0|fa|f?$|n(?!on)|of|u)%i

Zsh, 32 bytes
grep -Pi '^([-1-9dsty]|fo|n?on)'

Try it online!
Outputs via exit code; 0 is truthy, 1 is falsey

Python, 83 bytes
lambda x:x.lower()[:3]in['fou','non','on']or x[:1].lower()in'dsty-123456789'and''<x

https://repl.it/ClgO/1

Don´t the ins include non-empty?

@Titus I'm not sure what you mean.

What is x[:1] for an empty string? Does in return false in that case? If so, you should be able to drop the and''<x

@Titus, I see what you mean. I had the same thought at first, but ''[:1] in 'abc' evaluates to true.

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


text:
Concise Grading
Write a program or a function in your favorite programming language that will take as input a number n (integer or non-integer) between 0 and 100 inclusive, and output the corresponding grade as outlined below:

If 0 < n <= 40, then output E.
If 40 < n <= 55, then output D.
If 55 < n <= 65, then output C.
If 65 < n <= 70, then output C+.
If 70 < n <= 75, then output B-.
if 75 < n <= 80, then output B.
If 80 < n <= 85, then output B+.
If 85 < n <= 90, then output A-.
If 90 < n <= 95, then output A.
If 95 < n <= 100, then output A+.

You are guaranteed that there are no other cases to test, and that n is guaranteed to be within 0 and 100.
The input n can be provided via stdin or as an argument to the program.
Lines in the output are not allowed to have trailing spaces and/or newlines. You must output exactly the corresponding grade, nothing else.
Shortest code in bytes wins!

Odd, I've never received an E grade before... Is that for ease of coding, or did you intend F?

@StevenH. I actually do mean E there (that's how my university denotes failing grades).

Some education systems use E as the absolute lowest without an F

I think we've already had a challenge to convert numbers grades to letters.

Python, 74 66 73 bytes
lambda n,l="E "*8+"D D D C C C+ B- B B+ A- A A+ A+":l.split()[int(n-1)/5]

Unnamed lambda, uses a list of all grades in groups of 5. (I'm sure there's a way to handle n=100 without adding the extra 'A+' at the end, I'm just not sure how)
Edit: Thanks to @LeakyNun for 8 bytes

Question says n could be non-integer?

Logically you shouldn't have to add an extra A+ at the end. This gives wrong output for 95.1

Instead of doing (n-1)/5, you can do 20-n/5 which shifts thing correctly

@LeakyNun Could you post a fuller example of what you mean? Because substituting 20-n/5 still gives a bunch of weird behavior at "edge-numbers"

@Theo Have a look at Neil's answer.

@LeakyNun Yes, but he uses some fancy 'or' tricks to return 'E' when the index is outside the list bounds. I'm sure there is a way, but I don't know of a way to do this in python.

lambda n,l="A+ A A- B+ B B- C+ C C D D D"+" E"*8:l.split()[int(20-n/5)]

@LeakyNun That gives 'D' for 40, when it should be 'E' and so on

It gives me 'E' for 40 in both Python 2 and 3, although it doesn't work for other values in Python 2 because / is integer division. *.2 works though.

@Neil Could you post the code you used? Because Leaky Nun's code doesn't run at all for values below 5, and mine gives wrong outputs for some values.

@LeakyNun's code worked for me in Python 3  for non-zero numbers; to make it work with zero I had to change *8 to *9.

JavaScript (ES6), 57 bytes
n=>`A+ A A- B+ B B- C+ C C D D D`.split` `[20-n/5|0]||`E`

Pyth, 36 bytes
?<Q41\E+C/-1075Q15?<Q66k-@"-+ "/_Q5d

Test suite.
Explanation
Here is the equivalent program in Python 3.
lambda Q:[chr(int(1075-Q)//15)+["-+ "[int(99-Q/5)%3],""][Q<66],"E"][Q<41].split()[0]

Ideone it!


text:
Fun with strings and string lengths
Introduction
Inspired by Dyalog Ltd.'s 2016 student competition. The challenge there is to write good APL code, but this is a code-golf and it is open to all languages. Derived from this closed challenge.
The real challenge here is to combine the various (quite trivial) parts of the problem in a byte-efficient way by reusing values and/or algorithms.
If you find this challenge interesting and you use Dyalog APL (free download here), you may also want to participate in the original competition, but note that the objective there is to submit quality code – not necessarily short code. If you are a student, you can win USD 100 for Phase I. Phase II (not related to this code golf challenge) can win you up to USD 2000 and a free trip to Scotland!
Task
Take two strings (of any 7-bit ASCII characters) by any means and order (but please include input format in your answer). You may take them as separate arguments/inputs or as a single list of strings. One string contains the delimiters in the other. E.g. given ',;/' and 'hello,hello;there;my/yes/my/dear,blue,world', the sub-strings are ['hello', 'hello', 'there', 'my', 'yes', 'my', 'dear', 'blue', and 'world'].
You will do some statistics and ordering based on the lengths of those sub-strings that are not duplicated in the input. (You may chose to consider casing or not.) In the example given, those are ['there', 'yes', 'dear', 'blue', 'world'].
Give (by any means) a list of four elements in the overall structure [Number_1, Number_2, [List_3], [[List_4_1], [List_4_2]]]:

The mean of the lengths of the non-duplicated strings. In our example, that is 4.2
The median of the lengths of the non-duplicated strings. In our example, that is 4.
The mode(s) of the lengths of the non-duplicated strings. In our example, that is [4, 5].
The original sub-strings (including duplicates), divided into two lists; the first are those that are not one of the above mode lengths, and the second are those that are. In our example: [['my', 'my', 'yes'], ['dear', 'blue', 'hello', 'hello', 'there', 'world']]

The combined final answer of our example case is: [4.2, 4, [4, 5], [['my', 'my', 'yes'], ['dear', 'blue', 'hello', 'hello', 'there', 'world']]]
Considerations

Don't forget to reuse code and values. E.g. the median is the average of the 1 or 2 middle elements, and you'll need the mode(s) to reorder the original list.

Watch out for division by zero; an empty input means one string with length zero, so the mean length is zero. If there are no non-unique sub-strings, return zero for both mean and median, an empty list for modes, and put all original sub-strings onto the non-mode list.

The list of modes, and the sub-lists of non-mode-length strings, and mode-length strings, do not need to be sorted in any way.

If all non-duplicated sub-strings have different lengths, then all the lengths are considered modes.

Wherever the term list is used, you may use any collection of multiple data pieces that your language supports, e.g. tuples, arrays, dictionaries, etc.

The numeric values only need to be within 1% of the actual value.

Example cases
Example A
',;/' 'hello,hello;there;my/yes/my/dear,blue,world'
gives
[4.2, 4, [4, 5], [['my', 'my', 'yes'], ['dear', 'blue', 'hello', 'hello', 'there', 'world']]
Example B
'+|' ''
gives
[0, 0, [0], [[], ['']]]
Note: while there are two delimiter characters, none of them occur in the data string, so this is just one empty string. Mean, median, and mode are therefore zero There are no strings in the non-mode list and just the single empty string in the mode list.
Example C
'' 'ppcg.se.com'
gives
[11, 11, [11], [[], ['ppcg.se.com']]]
Note: no delimiters, so the entire input is one string.
Example D
',;' ',math,,math;'
gives
[0, 0, [], [['', 'math', '', 'math', ''], []]]
Note: there are three empty sub-strings, and since all sub-strings have at least one duplicate, the mean and median default to zero, as per Considerations, above.
Example E
',;' 'new,math,math;!;'
gives
[1.333, 1, [0,1,3], [['math', 'math'], ['new', '!', '']]]
Note: there is only one of each length among the non-duplicated sub-strings, so all three lengths are modes.

You can verify my explicit permission to post this challenge here by contacting the author of the original competition.

I presume the delimiters are always single characters? And that when you say "list" you also include tuples, in particular for the sake of strongly typed languages which require all elements of a list to have the same type?

@PeterTaylor The inputs are two plain strings, so the delimiters can only be single characters. I'm not sure I understand what the problem about tuples vs lists. But if you want to use tuples instead of lists, go ahead.

Ugh. The additional handling required for supporting empty substrings (like Example D) is brutal. :-/

The first number of Example A should be 4

@TimmyD It is 2 not 3

@TimmyD It is 'oh' not 'yes'

@LeakyNun Thanks, fixed. It was supposed to be the same as in the walk-through, but I changed the walk-through and forgot to update the example.

Could ^, ], - or \  be delimiters?

@Neil any 7-bit ASCII. I've edited that in. Thanks.

PowerShell v4+, 453 455 435 427 417 bytes
param([char[]]$a,$b)if(!$b){0;0;0;'','';exit}$a|%{$b=$b-split$_};$c=@{};if($z=($b|group|?{$_.count-eq1}).Name){$z|%{$m+=$c[$_]=$_.length}}if($l=$c.count){$c=$c.GetEnumerator()|sort v}else{$l=2}$m/$l;if($l%2){$c[[math]::Floor($l/2)].Value}else{($c[$l/2].value+$c[$l/2-1].value)/2}if($x=($c|group value|sort c -des)|%{if($_.count-ge$i){$i=$_.count;$_.name}}){$m=$b|?{$_.length-in$x}}else{$m=@()}$x;($b|?{$_-notin$m}),$m

(Saved 7 bytes by eliminating $d and reusing $c instead. Saved 13 21 31 bytes thanks to @Joey)
What a mess. Below is a slightly more readable version, broken down into sections. I also included -join on the two potentially-array outputs to make the output more clear visually, as well as surrounding the last one in distinct delimiters #-> and <-# to indicate the sub-arrays. I did this since PowerShell's Write-Output for multiple array return values can get a little confusing when just looking at them on the console.
param([char[]]$a,$b)if(!$b){0;0;0;'','';exit}$a|%{$b=$b-split$_}
$c=@{}
if($z=($b|group|?{$_.count-eq1}).Name){$z|%{$m+=$c[$_]=$_.length}}
if($l=$c.count){$c=$c.GetEnumerator()|sort v}else{$l=2}
$m/$l
if($l%2){$c[[math]::Floor($l/2)].Value}else{($c[$l/2].value+$c[$l/2-1].value)/2}
if($x=($c|group value|sort c -des)|%{if($_.count-ge$i){$i=$_.count;$_.name}}){$m=$b|?{$_.length-in$x}}else{$m=@()}
$x-join','
"#->" + ((($b|?{$_-notin$m})-join','),($m-join',')-join'<-# #->') + "<-#"

Takes input $a and $b (separators and string), and explicitly casts $a right away as a char-array. The if(!$b) clause handles the special case where $b is an empty string - it dumps zeros and empty strings onto the pipeline and exits. Otherwise we loop through $a with $a|%{...}, each loop -splitting $b by the current character and re-saving into $b.
The next line sets $c as an empty hashtable. This is used as the temporary storage location for the non-duplicated values in $b and their corresponding lengths.
That's the next line. We take $b, pump it through Group-Object to put like words together, pipe that to Where-Object to select only those where the .count is -equal to 1. We then take the .Name of those (here's where the v4+ requirement comes into play), and store those .Names (i.e., the words) into $z. We then take the .count of that, and that number forms our if clause -- so long as it's non-zero (i.e., we have at least one unique word), we pump those words through a loop. Each iteration we accumulate $m by, and also store into $c, the corresponding word's .length.
Next line sorts $c on lengths (that's the |sort value in the middle) and stores that back to $c, but we need to have some logic to account for cases where $z was empty (i.e., every word is a duplicate). If that's the situation, $c is already an empty hashtable, but we set $l equal to 2 to handle the mean calculation later.
Now, we're to our outputs. The first $m/$l just calculates the average length. The next line calculates the median based on either taking the exact middle value of $c, or taking the two above and below the middle and splitting the difference.
The next line is very complicated, and was where the longest troubleshooting was. It's calculating the mode. We start by Grouping $c based on value (i.e., the word lengths), then Sort-Object them by their count in -descending order (i.e., the most-common lengths will be first). That list is fed into a loop. Each iteration, if the current item's $_.count is greater-than-or-equal-to $i (which initializes to $null or 0, here), meaning that we've got a length that's the most-common, set $i equal to how many of that length there are, and add the length ($_.name) to the pipeline. That resulting array of most-common lengths is stored into $x.
Provided that we have at least one most-common length, the if triggers and we pipe $b through another Where-Object. This time, we're selecting all of the words where the .length is -in $x (i.e., all of the words that have a length that's in the mode), and store them into $m (yes, I reused a variable name). Else, we don't have a most-common length, so the strings of the mode is empty.
The next line $x-join',' outputs the lengths of the mode. Then, the words in $b that aren't in $m and the words in $m, as two sub-arrays.

Test suite
PS C:\Tools\Scripts\golfing> @(@(',;/','hello,hello;there;my/yes/my/dear,blue,world'),@('+|',''),@('','ppcg.se.com'),@(',;',',math,,math;'),@(',;','new,math,math;!;'))|%{"Testing: '"+$_[0]+"' '"+$_[1]+"'";.\fun-with-strings.ps1 $_[0] $_[1];"---------------------------------------------------------------------------------------"}
Testing: ',;/' 'hello,hello;there;my/yes/my/dear,blue,world'
4.2
5
4,5
#->my,yes,my<-# #->hello,hello,there,dear,blue,world<-#
---------------------------------------------------------------------------------------
Testing: '+|' ''
0
0
0

---------------------------------------------------------------------------------------
Testing: '' 'ppcg.se.com'
11
11
11
#-><-# #->ppcg.se.com<-#
---------------------------------------------------------------------------------------
Testing: ',;' ',math,,math;'
0
0

#->,math,,math,<-# #-><-#
---------------------------------------------------------------------------------------
Testing: ',;' 'new,math,math;!;'
1.33333333333333
1
3,1,0
#->math,math<-# #->new,!,<-#
---------------------------------------------------------------------------------------

I can't really tell the structure from your output. Does the output have four or five parts?

Give (by any means) a list of four elements: The fifth point on that list was supposed to be under Considerations (fixed now), but your 4th and 5th need to be two elements of one list in order to be fully compliant with the specs.

@Adám Easy enough to fix, at the cost of two parens and changing a ; to a ,. Updated.

@Joey Oh yeah. But don't need the * since it's unambiguous anyway.

You do, since neither c nor v match a property; the wildcards do.

@Joey Works for me without the *. PowerShell v4 ISE on Win 8.1

Your tests give different results for me. PowerShell v5, Win 10. In any case, that behaviour for Sort-Object has been that way for ages. It takes a string[] of property names which can also contain wildcards.

Pyth, 63 bytes
Ju.ncRHGQ]E.OKlMfq1/JTJ.O<.<S*2KtlK2=N
S{.x.M/KZKY=Y
f}lTNJ.-JY

Test suite.

I can't really tell the structure from your output. Does the output have four or five parts?

Denote your format to be [A, B, C, [D, E]]. My output is A↵B↵C↵D↵E

Done, but I'd accept A↵B↵C↵DE if that's a natural list format for Pyth. However, A↵B↵C↵D↵E doesn't quite follow the specs.

@Adám Oh, so you moved the goalpost

How so? According to the revision history, the very first version said Give (by any means) a list of four elements:.

Python 3, 341 chars, 343 bytes
from statistics import*
def f(d,s,l=len):
 w=sorted(''.join(x if not x in d else'ÿ'for x in s).split('ÿ'),key=l)
 L=[l(x)for x in w if w.count(x)<2]
 if L==[]:return 0,0,L,[s,L]
 a,q=mean(L),median(L)
 D={x:L.count(x)for x in L}
 m=[x for x in D if D[x]==max(D.values())]
 i=[l(x)for x in w].index(m[0])
 return a,q,m,[w[:i],w[i:]]

As built-ins are not forbidden, using the statistics module is fine for mean and median, but its mode does not allow multiples.

Edit1: check for non-uniqueness
Edit2: shorter list comprehension on m
Edit3: l=len and L==[]
Edit4: for the empty L case, use it instead of []
Edit5: figured empty strings were not handled well, introduced non-7-bit-ASCII sentinel ÿ

JavaScript (ES2017), 346 bytes
f=(p,q,a=p?q.split(p[0]):[q])=>p[1]?f(p.slice(1),a.join(p[1])):(s=a.filter(e=>a.indexOf(e)==a.lastIndexOf(e)).map(e=>e.length).sort((a,b)=>a-b),t=l=0,r=[],s.map(e=>r[t+=e,l++,e]=-~r[e]),[l&&t/l,l&&(s[l>>1]+s[l-1>>1])/2,[...m=new Set(s.filter(e=>r[e]==Math.max(...Object.values(r))))],[a.filter(e=>!m.has(e.length)),a.filter(e=>m.has(e.length))]])

For ES6 replace Object.values(r) with Object.keys(r).map(k=>r[k]) at a cost of 11 bytes. Explanation:
f=(p,q,a=p?q.split(p[0]):[q])=>         split on first seprator
 p[1]?f(p.slice(1),a.join(p[1])):       recurse for each separator
  (s=a.filter(e=>                       search through list for
     a.indexOf(e)==a.lastIndexOf(e))    unique strings only
    .map(e=>e.length)                   get lengths of each string
    .sort((a,b)=>a-b),                  sort lengths into order
   t=l=0,                               total and length
   r=[],                                frequency table
   s.map(e=>r[t+=e,l++,e]=-~r[e]),      build frequency table and total
   [l&&t/l                              mean = total / length
   ,l&&(s[l>>1]+s[l-1>>1])/2            median = mean of middle elements
   ,[...m=new Set(s.filter(e=>r[e]==    unique elements matching
    Math.max(...Object.values(r))))]    maximum length frequency
   ,[a.filter(e=>!m.has(e.length))      filter on non-modal length
    ,a.filter(e=>m.has(e.length))]])    filter on modal length

q/kdb+, 134 bytes
Solution:
{(avg;med;{:M::(&)m=max m:(#:)@/:(=)x};{(y(&)(~)C;y(&)C:((#:)@/:y)in M)}[;a])@\:(#:)@/:(&)1=(#:)@/:(=)a:"\000"vs?[any y=/:x;"\000";y]}

Examples:
q)/assign function to 'f' to make this tidier
q)f:{(avg;med;{:M::(&)m=max m:(#:)@/:(=)x};{(y(&)(~)C;y(&)C:((#:)@/:y)in M)}[;a])@\:(#:)@/:(&)1=(#:)@/:(=)a:"\000"vs?[any y=/:x;"\000";y]}
q)f[",;/";"hello,hello;there;my/yes/my/dear,blue,world"]
4.2
4f
5 4
(("my";"yes";"my");("hello";"hello";"there";"dear";"blue";"world"))
q)f["+|";""]
0f
0f
,0
(();,"")
q)f["";"ppcg.se.com"]
11f
11f
,11
(();,"ppcg.se.com")
q)f[",;";",math,,math;"]
()
()
()
(("";"math";"";"math";"");())
q)f[",;";"new,math,math;!;"]
1.333333
1f
3 1 0
(("math";"math");("new";,"!";""))

Explanation:
Ungolfed version. Can likely be golfed down a fair bit more.
f:{(avg;                                           / built-in average
    med;                                           / built-in median
    {:M::where m=max m:count each group x};        / get max counts for group, save to global M
    {
     (y where not C;                               / y is original list,
      y where C:(count each y) in M)               / so these are ones that match the modes (M)
    }[;a]                                          / pass parameter a to the function
    )
    @\:                                            / apply each-left with items on the right
    count each                                     / get the lengths of each string
    where 1=count each group                       / remove the duplicates
    a:"\000" vs                                    / split on NUL and save in a
    ?[any y=/:x;"\000";y]}                         / replace any occurance of delimiter with NUL