text:
As Easy as One-Two-Three
Write a program or function that takes in a positive integer. You can assume the input is valid and may take it as a string. If the number is any of
123
234
345
456
567
678
789

then output a truthy value. Otherwise, output a falsy value. For example, the inputs
1
2
3
12
122
124
132
321
457
777
890
900
1011
1230
1234

must all result in falsy output. (The input will not have leading zeroes so you needn't worry about things like 012.)
The shortest code in bytes wins.

Oh, strings are allowed? What about digit arrays?

@Dennis No. Let's keep it to plain strings or plain ints.

If I take string input, should I handle 012?

Does it have to return the same truth value? same false value?

@Lynn No. 012 would be falsy but you can assume it is not input.

@BradGilbertb2gills No. It should just satisfy the linked definition of truthy/falsy - http://meta.codegolf.stackexchange.com/questions/2190/interpretation-of-truthy-falsey/2194#2194

Python, 24 bytes
range(123,790,111).count

An anonymous function that outputs 0 or 1. It creates the list [123, 234, 345, 456, 567, 678, 789] and counts how many times the input appears.
f=range(123,790,111).count

f(123)
=> 1
f(258)
=> 0

Couldn't you remove a byte by making the start at 12 instead of 123?

It needs to not include 12.

But we can assume it wouldn't be input? I'm confused

If you're talking about the comments, they're saying that if you take input as a string (which this is not), you can expect numbers to not have leading zeroes, so 12 will be given as "12" and not "012".

Python, 24 bytes
lambda n:n%111==12<n<900

Just a lot of condition chaining.

Being able to compare a range that easily beats any language I already know. I had to look it up to see how it worked.

Wow, if it wasn't for the word lambda I wouldn't have even guessed that was Python. That's horrific.

Haskell, 22 bytes
(`elem`[123,234..789])

An anonymous function. Generates the evenly-spaced list [123, 234, 345, 456, 567, 678, 789] and checks if the input is an element.

No way! That's magic!

Brachylog, 9 bytes
h:2j:12+?

Try it online! or Verify all test-cases.
Credits to Dennis for the algorithm.
In English, "(prove that) the Input's first digit, concatenated to itself twice, add 12, is still the Input."

This is brilliant!

Python 2, 25 bytes
lambda n:`n-12`==`n`[0]*3

Test it on Ideone.

Brain-Flak 76 + 3 = 79 bytes
This answer is a golf of this answer.  I don't actually know quite how my answer works but DJMcMayhem gives a good explanation in his original answer and my answer is a modification of his.
([]<>)<>({}[({})]<>)<>(({}[({})()()()()()]<>{}{}<(())>)){{}{}(((<{}>)))}{}{}

It is run with the -a ascii flag adding 3 bytes.
Explanation (of sorts)
Starting with the original working solution:
([]<>)<>({}[({})]<>)<>({}[({})]<>)({}{}[()()])({}<({}[()()()])>)(({}{}<(())>)){{}{}(((<{}>)))}{}{}

I run this through a simple golfing algorithm I wrote and get:
([]<>)<>({}[({})]<>)<>(({}[({})]<>{}[()()]<({}[()()()])>{}<(())>)){{}{}(((<{}>)))}{}{}

From here I see the section <({}[()()()])>{} this essentially multiplies by one which makes it equal to {}[()()()] reduce the whole code to:
([]<>)<>({}[({})]<>)<>(({}[({})]<>{}[()()]{}[()()()]<(())>)){{}{}(((<{}>)))}{}{}

Lastly negatives can be combined:
([]<>)<>({}[({})]<>)<>(({}[({})()()()()()]<>{}{}<(())>)){{}{}(((<{}>)))}{}{}

"I don't actually know quite how my answer works" you win the internet

Nope.

@LeakyNun I don't believe Ascii mode works on try it online.  You are going to have to get the github version.

It works, I'm saying that the algorithm is wrong.

@WheatWizard ASCII mode definitely works on TIO. You can verify this by adding 48 ('0') to the top of the stack. Leaky nun is right, the algorithm (my algorithm) is wrong, because it just checks if the sum of the differences is 2 (which works if the difference is +3 and -1). Unfortunately, both of our answers are wrong.

@WheatWizard This answer does not appear to be valid. Try it online! (My original answer wasn't either)

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

Try it online!
Credits to Lynn for the core of the algorithm.

05AB1E, 5 bytes
¥XX‚Q

Explanation
¥      # deltas
    Q  # are equal to
 XX‚   # [1,1]

Try it online

I used 2Å1 instead of XX,, just for the heck of less commands (4 instead of 5).

@ErikGolferエリックゴルファー: and Å is writeable on my keyboard (as opposed to ‚) which is a benefit :)

‚ (not the , I used) doesn't have a compose-key sequence too, while Å is oA on an en-US keyboard.

Jelly, 6 bytes
DI⁼1,1

Try it online! or verify all test cases.
How it works
DI⁼1,1  Main link. Argument: n (integer)

D       Decimal; convert n to base 10.
 I      Increments; compute the differences of all pairs of adjacent digits.
   1,1  Yield [1, 1].
  ⁼     Test the results to both sides for equality.

012 doesn't return false, although it doesn't actually return anything...

The input has to be an integer. As far as ast.literal_eval is concerned, 012 doesn't represent an integer.

MATL, 8 bytes
d1=tn2=*

Try it online!
This will print 1 1 for a truthy input, and an array with a 0 in it for a falsy value, since that is falsy in MATL.
Explanation:
d           % Calculate the difference between consecutive digits
 1=         % Push an array of which elements equal one
   t        % Duplicate this array
    n       % Push the length of this array
     2=     % Push a one if the length is 2, and a zero otherwise
            % Now, if we have a truthy input, the stack looks like:
            %   [1 1]
            %   1
            % And if we have a falsy input, the stack looks something like this:
            %   [1 0]
            %   1
            % Or this:
            %   [1 1]
            %   0
       *    % Multiply the top two elements

Maybe d1=Ep4= (I haven't tested thoroughly)

Or dTTX= for 5 bytes

@luismendo whaaa? How does that even work? I can't find documentation on T

T is the literal true, and F is false. Neighbouring T and F stick together, so TT is [true true], which for these purposes is equivalent to [1 1]. See section 4.3 of the spec

Java 7, 46 bytes
boolean f(int a){return a>12&a<790&a%111==12;}

After trying several things with Leaky Nun in chat, this seems to be the shortest. Sometimes you just have to do things the straightforward way :/
Explanation:
boolean f(int a){
    return a>12         Is it more than 12? (stupid edge case)
           &
           a<790        Is it in range the other way?
           &
           a%111==12;   Is it 12 more than a multiple of 111?
}

Perl 6,  35 29 24 21  19 bytes
{.chars==3&&'0123456789'.index: $_}
{$_ (elem) (123,*+111...789)}
{$_∈(123,*+111...789)}
*∈(123,*+111...789)
*∈(123,234...789)
Explanation:
# Whatever lambda ( the parameter is ｢*｣ )
*

∈ # is it an element of:

# this sequence
(
  123,
  234,

  # deduce rest of sequence
  ...

  # stop when you generate this value
  789
)

Usage:
my &code = *∈(123,234...789);

say code 123; # True
say code 472; # False

say (  *∈(123,234...789)  )( 789 ); # True

Retina, 26
.
$*:
^(:+ ):\1::\1$

Outputs 1 for truthy and 0 for falsey.
Try it online (First line added to allow multiple testcases to be run).

Brain-Flak, 99 bytes
([{}]({})<>)<>([{}]{}<>)(({})<([{}]{})((){[()](<{}>)}{})>)([{}]{})((){[()](<{}>)}{})<>{{{}}<>{}}<>

Try it online!
This is 98 bytes of code +1 for the -a flag.
This prints 1 for truthy, and either 0 or nothing (which is equivalent to 0) for falsy

Try to get rid of push pop inefficiencies.  I can see a bunch in your code.  They look like ...)({} but vary.  If you push and pop without using the value you can condense it into one thing. I can link you to a version of your code with all of these golfed out if you want.

Here is my 76 byte golf of your program. I pretty much ran my brain-flak optimizer over your code with a few custom settings.

Nope.

Ruby -nl, 32 30 25 bytes
p"123456789"[$_]&.size==3

Attempt This Online!

Your tests show 12 going to true.

@xnor Oops. That'll teach me to golf after bedtime. Fixed!

I thought -a does a split, not chop? Also, what does the & do? I'm using an older Ruby which throws an error. Anyway, it works perfectly at 26 bytes without it.

Oops, I meant -l, not -a. &. is the "safe navigation" operator, added in Ruby 2.3. Without it inputs like 19, which aren't substrings if "123456789", will raise a NoMethodError.

@Jordan I'm not getting an error in 2.2. Maybe it's new in 2.3 too?

R, 30 22 bytes
scan()%in%(12+1:7*111)

Not particularly exciting; check if input is in the sequence given by 12 + 111k, where k is each of 1 to 7. Note that : precedes * so the multiplication happens after the sequence is generated.

Brain-Flak, 114 bytes
([((()()()){}){}]{})(((()()()){}())<>)<>{({}<(({}[(((((()()()){}()){}){}){}){}]())){(<{}>)<>({}[()])<>}{}>[()])}<>

Try it online!
Correct version (in the spirit of the question): takes the integer as input, output 0 for falsey and 1 for truthy.
This is not stack clean.
Algorithm
Let the input be n.
The output is truthy iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.
I computed those seven numbers by first subtracting 12 and then subtract 111 7 times, and then computed the logical double-NOT of those seven numbers and added them up.
For truthy results, the sum is 6; for falsey results, the sum is 7.
Then, I subtract the sum from 7 and output the answer.

I don't understand the code, but the algorithm is clever so have a +1.

C# (Visual C# Interactive Compiler), 41 30 23 bytes
First code-golf submission, be gentle :)
a=>{return a&gt12&&a&lt790?a%111==12:false;};
a=>a&gt12&&a&lt790?a%111==12:false
a=>a&gt12&a&lt790&a%111==12

Try it online!

-11 bytes thanks to Kirill L.
Another -7 bytes thanks to ASCII-only.

Welcome to PPCG! You can save some bytes by dropping the curly braces and return keyword: 30 bytes

23, also 23

Nice first submission!

CJam, 13 9 bytes
A,s3ewqe=

Try it online!
Explanation
A,s        e# Push "0123456789".
   3ew     e# Split it into contiguous length-3 chunks: ["012" "123" "234" ... "789"].
      q    e# Push the input.
       e=  e# Count the number of times the input appears in the array.

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

Bah, I'm no good at this. Outputs \x01 if the output is one of the strings 123, 234, …, 789; outputs \x00 otherwise.
(I beat Java 7, though…)
Try it online!

What's the point of [>>]<? Couldn't that just be >?

I want to veer the program into failure (by throwing it off-track) if the cell under the pointer isn't zero at that point.

42 bytes

@LeakyNun That looks completely different; feel free to post it as a separate answer

@Lynn Done.

You beat Java 7, yes, but not Java 8 :P

Excel - 62 57 35 31 bytes
Based on Anastasiya-Romanova's answer, but returning Excel's TRUE/FALSE values.
=AND(LEN(N)=3,MID(N,2,1)-MID(N,1,1)=1,MID(N,3,1)-MID(N,2,1)=1)

Further, we can get to
=AND(LEN(N)=3,MID(N,2,1)-LEFT(N)=1,RIGHT(N)-MID(N,2,1)=1)

since both RIGHT and LEFT return a single character by default.
And, inspired by some of the Python solutions:
=AND(LEN(N)=3,MOD(N,111)=12,N<>900)

Thanks to Neil for 4 more bytes...
=AND(N>99,MOD(N,111)=12,N<900)

Doesn't N<900 save you a byte, in which case you can also use N>99 instead of LEN(N)=3.

21 bytes: =REPT(LEFT(N),3)+12=N where N is the name of the reference cell.

JavaScript ES6, 26 bytes
n=>1>(n-12)%111&n>99&n<790
This takes advantage of the fact that I'm using bit-wise logic operators on what are essentially booleans (which are bit-based!)
Thanks to Titus for saving 2.

two bytes: (n-12) and n>99

@Titus Oh, very nice, +1 to you!

=> is ES6, not ES5.

@Neil well spotted, thanks

I believe it was decided in meta that you didn't have to count "f=" making this 26 bytes

Thanks @CharlieWynn, is that because the function's declaration and assignment are arbitrary?

@WallyWest I think it's because it's not necessary to have "f=" to use the function in every case, so why assume you need it for this case?  People smarted than me decided it's fine so I just go with it ;)

Guess I'll be going through all my previous answers!

Brachylog (2), 7 bytes
ẹ~⟦₂-_2

Try it online!
Explanation
ẹ~⟦₂-_2
ẹ        Split into digits
 ~⟦₂     Assert that this is an increasing range; take its endpoints
    -_2  Assert that the starting minus ending endpoint is -2

As a full program, we get a truthy return if all assertions hold, a falsey return if any fail.

Regex (ECMAScript), 20 bytes
The input n is in unary, as the length of a string of xs.
^x{12}(x{111}){1,7}$

Try it online!
This works by asserting that \$n-12\$ is of the form \$111k\$ where \$1\le k\le 7\$.

Vyxal, 4 bytes
¯k₁⁼

Try it Online!
Explained
¯k₁⁼
¯    # Deltas
 k₁  # [1,1]
   ⁼ # compare lists

K (ngn/k), 15 bytes
{($x-12)=3#*$x}

Try it online!
Port of Dennis' algorithm.
Explanation:
{($x-12)=3#*$x}  Main function. Takes x as input
            $x   Convert x to string
           *     Then get the first character
         3#      And duplicate it thrice
        =        Is it equal to
 ( x-12)         x - 12
  $              Converted to string?

ARM Machine Code, 18 bytes
Hex dump (little endian):
3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

This is a function that takes in a length, pointer pair for the string. The output is bash-style, it outputs 0 for true and a non-zero value for false. In C the function would be declared int oneTwoThree(size_t length, char* string). The instruction encoding is thumb-2, which has 2 and 4 byte instructions. Tested on a Raspberry Pi 3.
Ungolfed assembly:
.syntax unified
.text
.global oneTwoThree
.thumb_func
oneTwoThree:
    @Input: r0 - the number of characters in the string
    @r1 - A pointer to the (not necessarily NUL-terminated)
    @string representation of the number (char*)
    @Output: r1 - 0 if the number is in 123,234,...,789, else non-zero (bash-style)
    subs r0,r0,#3
    bne end @Return non-zero if r0!=3
    ldr r0,[r1] @Remember that this is little endian
    @So the first digit is the most siginificant byte
    @I.e. if the input was 123 then r0 contains 0xXY010203 where XY is garbage

    rsb r0,r0,r0,lsr #8 @r0=(r0>>8)-r0 (rsb is reverse subtract)
    uxth r0,r0 @r0&=((1<<16)-1) (mask off top half)
    @Now r0 is 0x0101 iff we have a matching number
    sub r0,r0,#0x101
    @Now r0 is 0 iff the string fit the specification

    end:
    bx lr @return

Testing script (also assembly):
.syntax unified
.text
.global main
.thumb_func
main:
    push {r4,lr}
    ldr r4,[r1,#4] @r0=argv[1]
    mov r0,r4
    bl strlen
    @Now r0 is the length of the string argv[1]
    mov r1,r4
    bl oneTwoThree @oneTwoThree(strlen(argv[1]),argv[1])
    cmp r0,#0
    it ne
    movne r0,#1 @Output through return code, 1 if false
    pop {r4,pc}

Excel - 104 bytes
=IF(LEN(N)<3,"Falsy",IF(AND(LEN(N)=3,MID(N,2,1)-MID(N,1,1)=1,MID(N,3,1)-MID(N,2,1)=1),"Truthy","Falsy"))

Explanation:
The syntax for the IF formula in Excel is:
IF( condition, [value_if_true], [value_if_false] )

If the length of input N, where it's a name of the reference cell, is less than 3, then it will return Falsy. Else, if the length of input N is 3 and both of the difference of second digit and first digit and the difference of third digit and second digit are equal to 1, then it will return Truthy.

21 bytes: =REPT(LEFT(N),3)+12=N where N is the name of the reference cell.

Pyth, 8 Bytes
qi>3SeQT

Try online!
Explanation:
q       Q  Is the input equal to:
  <3S       The last three digits of the range from 1 to
     eQ      The last digit of the input
 i     T      Concatenated together into an integer

Dyalog APL, 10 bytes
Takes string argument.
1 1≡¯2-/⍎¨

1 1≡ Is {1, 1} identical to
¯2-/ the reversed pair-wise difference of
⍎¨ each character taken as a number?
TryAPL online! (⍎ has been emulated with e for security reasons.)

Perl, 18 bytes
Includes +1 for -p
Run with the input on STDIN
123.pl <<< 123

123.pl:
#!/usr/bin/perl -p
$_=$_=/./.2==$_-$&x3

PHP, 31 bytes
<?=($n=$_GET[n])-12==$n[0]*111;

Check if first digit of (number minus 12) is multiple of 111

PowerShell v3+, 24 bytes
($args[0]-12)/111-in1..7

Uses the same "multiple of 111 plus 12" trick as some other answers, but goes the other direction. Takes input $args[0], subtracts 12, divides by 111, and checks whether that's -in the range 1..7. Outputs a Boolean true/false value. Requires v3+ for the -in operator.
Test Cases
PS C:\Tools\Scripts\golfing> 123,234,345,456,567,678,789|%{.\easy-as-one-two-three.ps1 $_}
True
True
True
True
True
True
True

PS C:\Tools\Scripts\golfing> 1,2,3,12,122,124,132,321,457,777,890,900,1011,1230,1234|%{.\easy-as-one-two-three.ps1 $_}
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False

JavaScript (ES6), 34 bytes
And one more option in JS. Takes input as a string and outputs 0 for false and 1 for true.
n=>++n[0]==n[1]&++n[1]==n[2]&!n[3]

See my other solutions here and here

Try it

f=
n=>++n[0]==n[1]&++n[1]==n[2]&!n[3]
i.addEventListener("input",_=>o.innerText=f(i.value))
<input id=i type=number><pre id=o>

Jelly, 5 bytes
9ṡ3Vċ

Try it online!

Yay outgolfed the Dennis with a perfectly competing answer.

Brachylog (v2), 4 bytes
~s₃Ị

Try it online!
Certainly not as creative as user62131's answer, but quite a bit shorter. Takes input as a string through the input variable and assumes the string has no leading zeroes (i.e. "012" is a false positive), outputting through success or failure, where success of a predicate run as a program prints true. and failure prints false.
        The input is a
~s₃     length-3 substring of
   Ị    "0123456789".

If input is allowed to be a bit less orthodox...
Brachylog, 3 bytes
Ịs₃

Try it online!
Outputs the same way and takes input in the same format, but takes it through the output variable. To run this as a program, the input is given as the first command-line argument on TIO, rather than through the Input box (which actually has to either be empty or contain "0123456789").

BRASCA, 15 bytes
Ci,:::SSL{+,SS=

Try it online!
Explanation
Ci                - Set implicit output to output numbers, and turn "0-9" into 0-9
  ,               - Reverse stack
   :::SSL{+       - First digit of input, concatenated to itself twice, + 12
           ,SS=   - Concatenate the digits of the original, then check if both numbers are equal
<implicit output> - Output 1 if truthy, 0 if falsy

Factor, 26 bytes
[ "123456789"3 clump in? ]

Try it online!

"123456789" 3 clump -> { "123" "234" "345" "456" "567" "678" "789" }
in? Is the input in this?

Javascript (ES5), 47 39 bytes
function(n){return(n-12)%111==0&&i<1e3}

Old solution with 47 did not work correctly.

Old one returns true for 1234

Brain-Flak, 118 + 3 = 121 bytes
([][()()()]<>)<>({}[({})()]<>)<>({}[{}()]<>)<>(<{{}}>)<>([]){{}{(<{}>)<>({}())<>}{}([])}<>{(<{}>)<>({}[()])<>}<>({}())

Try it online!
ASCII version: take code-points as input, output \x00 for falsey or \x01 for truthy.

Pyke, 9 bytes
~ut{3Qlq&

Try it here!
~ut{      -  input in "123456789"
        & - ^ and V
    3Qlq  -  len(input) == 3

Or 5 bytes if allowed sequence input
$1D]q

Try it here!
$     - delta(input)
 1D]q - ^ == [1,1]

Fish (><>), 14 bytes
With input from the command line/initial stack.
l3=?!;$:@---0=l1==n;

Explanation:
$:@              Swaps top two values on stack then duplicates topmost one, then swaps top three values
   ---             Each '-' subtracts the second most value on the stack from the topmost and pushes their result
      0=l1=          Checks if topmost value is 0, pushes 1 if true and 0 if false, then checks if length of stack is 1 (pushes 1 is true, 0 if false)
         =n;           Does the logical && of the top two truthy/falsy values pushed in previous step and outputs the result.

Try it here

This actually returns false-positives for a lot of inputs, including any three digit number where all three digits are the same like 111. It also errors out without delivering a falsey if the initial input is less than three characters.

@CallumKerr You're right, I wrote this in a hurry. Let me fix it.

PHP, 32 34 bytes
<?=(800>$x=$argv[1]-12?:1)>$x%111;

Run like this:
echo '<?=(800>$x=$argv[1]-12?:1)>$x%111;' | php -- 124

Updates:

I made a little mistake where 12 was considered valid.

Batch, 49 bytes
@for /l %%a in (123,111,789)do @if %%a==%1 echo 1

You need @ before echo 1

3d, 61 bytes
>:&&#a&×∕$#a∕#a%.--v
  v--.%a#$∕a#&%×&a#—'F!,;
v —'F!;
>'T!;

Will output:
T

if input is a three consecutive increasing digits,
F

if not.
Explanation:
:&&  push imput and duplicate twice
#a&× push 0xa (10), duplicate it, multiply top two of the stack: get 100
∕    floor divide top two elements of the stack (we get the first digit)
$    invert top two elements
#a∕  floor divide by 10 (get rid of last digit)
#a%  modulo 10 (get middle digit)
.-   push 1 and difference
-    difference (hence we get 0 if two initial digits have a difference of 1)
—    is top of stack null?
if not:
'F!  print 'F'
,;   pops the stack and exits
if yes:
#a&× get 100
%    modulo (get rid of first digit)
&    duplicate
#a∕  floor divide by 10 (get middle digit)
$    invert
#a%  modulo 10 (get last digit)
.- push 1 and difference
-  difference
— is top of stack null?
yes:
'T!; print 'T' and exit
not:
'F!; print F and exit

Phew, this really ain't golfy.

Link to 3d? (filler text)

yeah, forgot it... Adding it now!

Java 8, 23 bytes
n->n<900&(n-122)%111==1

Ungolfed:
interface N { boolean f(int n); }

public static void main(String[] args) {
  N f = n ->
    n < 900 // 900 is not good
    &
    (n - 122) % 111 == 1 // force 12 to go negative and fail the comparison (can't use 123 because -111 % 111 == 0, while -110 % 111 == -1).
}

Test class:
public class Main {
  private interface N {

    boolean f(int n);
  }

  static void test(N f, int n, boolean expected) {
    boolean result = f.f(n);
    System.out.printf("%s -> %b (%b) -> %s%n", n, result, expected, result == expected ? "OK" : "NOK");
  }

  public static void main(String[] args) {
    N f = n->n<900&(n-122)%111==1;

    test(f,  123, true);
    test(f,  234, true);
    test(f,  345, true);
    test(f,  456, true);
    test(f,  678, true);
    test(f,  789, true);

    test(f,    1, false);
    test(f,    2, false);
    test(f,    3, false);
    test(f,   12, false);
    test(f,  122, false);
    test(f,  124, false);
    test(f,  132, false);
    test(f,  321, false);
    test(f,  457, false);
    test(f,  777, false);
    test(f,  890, false);
    test(f,  900, false);
    test(f, 1011, false);
    test(f, 1230, false);
    test(f, 1234, false);

  }
}

JavaScript (ES6), 41 39 38 37 bytes
Just another JS option. Takes input as a string and outputs 0 for false and 1 for true.
n=>+n[2]&!n[3]&~"123456789".search(n)

See my other solutions here and here

Try it

f=
n=>+n[2]&!n[3]&~"123456789".search(n)
i.addEventListener("input",_=>o.innerText=f(i.value))
<input id=i type=number><pre id=o>

Japt, 6 5 bytes
%#o¥C

Try it online!

I think you can change 12 to C to save a byte

8086 Machine Code, 14 bytes
3C 03   CMP  AL, 3      ; check if input length is 3 chars exactly
75 0A   JNZ  FALSY      ; if not, falsy
AD      LODSW           ; load first char into AL, second into AH, advance SI
40      INC  AX         ; increment first char
3A E0   CMP  AH, AL     ; are chars now equal?
75 04   JNZ  FALSY      ; if not, falsy
AC      LODSB           ; load third char into AL
48      DEC  AX         ; decrement third char
3A E0   CMP  AH, AL     ; are chars now equal?
FALSY:

Input string is SI, length in AL.  Return is Zero Flag where (ZF=1) if Truthy, (ZF=0) if Falsy.

Stax, 5 bytes
╡e╦ù┌

Run and debug it

Java 8, 23 bytes (thanks ASCII-only!)
n->n>12&n<790&n%111==12

 Old version, 40 bytes
n->n>99&n<999&"123456789".contains(n+"")

-1 bytes thanks to gwaugh
Try it online!

This returns Truthy for input of 1234 or 4567, etc. https://tio.run/##fYy9CoMwFEb3PMXFoSQUBe2vSB3dOjmWDjE1EhtvxEShiM9u4wO00wff4ZyWTzxsX@9VaG4t3LnCmSh09SC5qKGYK2N0zREk9S8gyxbSj5VWAqzjzs9k1As679HSDQqbxxP40Fg2kwIk3FYMc8zTdBfEyeF4Ol@uaRAJg84bluI@CNiakfJjXd1FZnRR7yNOI5WRpJvC2E@85f7gONngsqxf

@gwaugh fixed. Thanks.

you could -1 byte by changing n<1000 to n<999 (or even n<790) since the highest Truthy number is 789

@gwaugh done. Thanks again

23, same as C#

Julia 1.0, 18 bytes
n->n∈123:111:789

Try it online!

MathGolf, 6 4 bytes
│ª▒=

Try it online!
Explanation
│       get differences of digits in integer
 ª      push [1]
  ▒     duplicate items in list
   =    pop(a, b), push(a==b)

It would be nice if 2. could be ∞

@JoKing yes, that would be the dream. Right now, ∞ multiplies each element of the list by 2 rather than multiplying the list by 2. I haven't checked if I use ∞ with lists to any extent, but I can't have both implementations at once. I also want to make │ work with integers, to get digit differences which could be useful for some challenges.

@JoKing I realized that I could fit both those things into existing operators, which made sense to have. Check the readme for more changes.

Befunge-98 (PyFunge), 36 bytes
0c75*2+3*&# :b9*8*`#0_# \%# -#0_1.@.

Try it online!
Alternate version that uses the 2-D aspect of Befunge:
c75*2+3*&:98*b*`#v_\%-#v_1.@
                 >     >0. ^

I actually prefer the second, however the first is shorter.  Also, the first version leaves some stack pollution, whereas the second leaves a clean stack.  Either could easily be made for Befunge-93 with a small 4-byte addition.  I did not include it because there is already a 93 answer.

Pyt, 11 bytes
ą₋Đ₋¬⇹Ʃ2=∧Π

Try it online!
ą              implicit input; convert to ąrray of characters
 ₋             reduce by subtraction
  Đ            Đuplicate
   ₋           reduce by subtaction
    ¬          logical NOT (coerce integer to boolean, then negate)
     ⇹         swap top two items on stack
      Ʃ        Ʃum
       2=      ... equals 2?
         ∧     logical AND
          Π    product; implicit print

Thunno 2, 4 bytes
Ṣk&⁼

Attempt This Online!
Explanation
Ṣk&⁼  # Implicit input
Ṣ     # deltas
   ⁼  #        ==
 k&   #           [1, 1]
      # Implicit output

C, 71 bytes
Taking the input as int:
f,d,c;F(n){for(f=c=0;n;)d=n%10,c++,f|=d-(n/=10)%10-1&&n;return!f&c==3;}

Test main:
int main() {
  printf("%d\n", F(123));
  printf("%d\n", F(234));
  printf("%d\n", F(345));
  printf("%d\n", F(456));
  printf("%d\n", F(567));
  printf("%d\n", F(678));
  printf("%d\n", F(789));
  printf("%d\n", F(1));
  printf("%d\n", F(2));
  printf("%d\n", F(3));
  printf("%d\n", F(12));
  printf("%d\n", F(122));
  printf("%d\n", F(124));
  printf("%d\n", F(321));
  printf("%d\n", F(457));
  printf("%d\n", F(777));
  printf("%d\n", F(890));
  printf("%d\n", F(900));
  printf("%d\n", F(1011));
  printf("%d\n", F(1230));
  printf("%d\n", F(1234));
}

Ruby, 114 bytes
i = gets.chomp.to_i
l = [123, 234, 345, 456, 567, 678, 789]
y=false
l.each {|x| if i==x then y=true end;}
puts y

I don't know how many bytes this answer is, but I'm guessing it's not that small.

Do you need those spaces?

You can remove all but one space (puts y)..each can be .map. false can be p. if i==x then y=true end; can be i==x&&y=1

PHP, 35 bytes
<?=($n=$argv[1]-99)<790&$n%111==24;

exploiting that the modulo of a negative number is never positive in PHP

C 61 Bytes
f(char*v){puts(v[3]==0&v[0]+1==v[1]&v[1]+1==v[2]?"T":"F");}
g(v){puts(v<790&v%111==12?"T":"F");}
main(c, v)char**v;{
    f(v[1]);
    g(atoi(v[1]));
}

61 Bytes only includes the function. f(...)
36 Bytes using the trick from Geobits in g(...)

GNU Octave : 74 bytes
golfed:
function r=g(a)t=conv(a-'0',[1,-1],'valid')==1;r=(sum(t)==2).*prod(t);end;

ungolfed:
function r=golf_123(a)
  t=conv(a-'0',[1,-1],'valid')==1;
  r=(sum(t)==2).*prod(t);
endfunction

Explanation: Treat the string as an integer vector, any two consecutive digits will then have derivative given the finite difference filter [1,-1] equal to 1 at each valid convolution output. The prod command calculates product, so it will short circuit to 0 if at least one entry is 0. The sum(t)==2 disqualifies any run of increasing digits longer or shorter than 3.

JAVA 7, 57 bytes
boolean f(int x){return (int)Math.log(x)-1==3&x%111==12;}

You can remove the space in return (int)

AWK, 33 28 27 Bytes
{$0=($1-12)/111~/^[1-7]$/}1

Prints 1 for corresponds to one of the desired values, 0 otherwise.
Updated answer is based on TimmyD's powershell answer.
Example usage:
awk '{$0=($1-12)/111~/^[1-7]$/}1' <<< 789

Prints 1
awk '{$0=($1-12)/111~/^[1-7]$/}1' <<< 12

Prints 0
Since this is using division rather than modulus, the result will be an integer for the desired values, but that integer needs to be between 1 and 7.
Try it online!

21 bytes. Echoes for truthy, ignores for falsey.

SpecBAS - 35 bytes
1 INPUT n: ?(n-12)/111 in [1 TO 7]

Uses the same formula as the Powershell answer, returns 0 for False and 1 for True.
My original version was 59 bytes (and seems more "honest" for being my own work). Input as number and converted to string to avoid "012" showing as True.
1 INPUT n: n$=STR$ n: ?LEN n$=3 AND POS(n$,"0123456789")>0

Clojure, 48 bytes
(defn f [n] (= n ((set (range 123 900 111)) n)))

Test:
user=> (map (fn [n] [n (f n)]) [123 234 345 456 567 678 789])
([123 true]
 [234 true]
 [345 true]
 [456 true]
 [567 true]
 [678 true]
 [789 true])

user=> (map (fn [n] [n (f n)]) [1 2 3 12 122 124 132 321 457 777 890 900 1011 1230 1234])
([1 false]
 [2 false]
 [3 false]
 [12 false]
 [122 false]
 [124 false]
 [132 false]
 [321 false]
 [457 false]
 [777 false]
 [890 false]
 [900 false]
 [1011 false]
 [1230 false]
 [1234 false])

I swear I didn't copy your answer! This can be significantly reduced. See my answer which is the same idea, but without all of the extra bits.

PHP 5.6, 48 bytes
<?=($a=$argv[1])==join("",range($a[0],$a[0]+2));

Wanted to try something a little different from the other PHP answers (and a different approach to most of the posted answers). Take the first number of the input string, add two to it and create a range array, then join those together to create a new string and then return if they're equal or not.
Run with:
echo '<?=($a=$argv[1])==join("",range($a[0],$a[0]+2));' | php -- 123

><> (Fish), 28 Bytes
l3-0=?v0n;>
?+1-@:<;n1^?+2-!

Input is via an execution argument to add each digit to stack, left to right.
Checks if the length of the stack (number) is three, then that there's a difference of one between the third and second digits, then that there's a difference of two between the first and third digits.
Try it online!

C# 6 (36 bytes)
bool f(int x)=>x<790&0==(x+321)%111;

Is f necessary?

Jelly, 8 bytes
Not as short as Dennis's answer (duh), but I'm quite proud of myself for getting the results I wanted out of Jelly.
9Rṡ3
De¢

Try it online!
Explanation:
9R    Push 1-9 to the stack
ṡ3    Slice up the stack in parts of 3, overlapping
      This gives us [1,2,3], [2,3,4], ..., [7,8,9]
D     Convert input to list ( '123' -> [1, 2, 3])
e¢    This checks to see if the decimal list is in the list of our previous link.

Clojure, 25 bytes
(set (range 123 790 111))

Basically the Haskell answer. Creates a range which includes all the truthy answers, then converts it into a set. Sets are functions in Clojure (they implement the function interface and can be called).
Returns the number as the truthy return (every number is truthy in Clojure), and nil for the falsey value.
Use:
(let [s (set (range 123 790 111))]

    (s 123)
    123

    (s 234)
    234

    (s 993)
    nil

SmileBASIC, 27 bytes
INPUT N?N-12==N DIV&H64*111

Using Dennis's algorithm.
If forcing the user to add &H to their input is OK, this works for 24 bytes:
INPUT N?N-18==(N>>8)*273

QBIC, 21 bytes
;[7|~!12+111*a$=A|_Xq

This prints 1 if a match is found, nothing otherwise.
Explanation
;              Get A$ from the command line
[7|            FOR a=1; a <=7 ; a++ (for each of the 7 sequences)
  12+111*a     Generate the number 123, 234, 345 by mult. 111 x index, plus 12
 !        $    Cast that to string B$
~          =A  And IF that matches A$
|_Xq           THEN quit, printing 1
               IF and FOR loop implicitly closed

Befunge-93, 57 53 bytes
#@ #.0 &# ::57*2+3*%34*-#<_# 34*`!#<_# 98*34**`#<_1.@

Try it online!
Explanation
#@ #.0        skip the terminator and output command. Adds a meaningless zero to
                the stack.
&# ::         take in an input and add two more copies to the stack
57*2+3*%      adds input mod 111 ((5*7+2)*3) to the stack
34*-#<_#      compares 12 to the result, if they are the same, continue to move
                right, else move left
34*`!#<_#     checks to see that the input is greater (`) than 12. If it is,
                continue to move right, else move left
98*34**`#<_   check that 864 (9*8*3*4) is greater than the input. (the reason for
                this is that 864 was an easy number to create that was greater than
                the last possible number (789) and was less than the next number
                divisible by 111 (900)
1.@           if you pass all the checks, output 1, otherwise...
@.0># &#      you will move back through the code heading left. (you will do
                the operations, but that will not matter.) Skip the input
                command. Output zero and end the code.

Thue, 84 bytes
123z::=~1
234z::=~1
345z::=~1
456z::=~1
567z::=~1
678z::=~1
789z::=~1
a::=:::
::=
az

Outputs 1 when given one of the target values, and no output when given something else. The z at the end is needed to prevent false positives with numbers like 1230

Unexpanded Sinclair ZX-81 and Timex TS1000/1500 ~99 97 tokenised BASIC bytes
 1 LET A$="123456789"
 2 INPUT B$
 3 LET P=NOT PI
 4 FOR F=VAL "1" TO VAL "7"
 5 LET P=P+(A$(F TO F+VAL "2")=B$)
 6 NEXT F
 7 PRINT P

This is using a sub-string method to scan the string literal A$ for the match as per the test cases; if a match is found then the variable 1 is added to the P, otherwise zero is added to P.

APL(NARS), 40 chars, 80 bytes
{(∼⍵⊆⎕D)∨3≠≢⍵:0⋄(⊂⍎¨⍕⍵)∊{⍵+0..2}¨⍳7:1⋄0}

This is a little long, but would return the 0 if type is not string, or if string is different "123","234",..,"789";  test:
  f←{(∼⍵⊆⎕D)∨3≠≢⍵:0⋄(⊂⍎¨⍕⍵)∊{⍵+0..2}¨⍳7:1⋄0}
  f 'aaa'
0
  f ''
0
  f¨('12')(,'3')('3')('122')('124')('132')('123456789')
0 0 0 0 0 0 0
  f¨('123')('456')('789')
1 1 1

Arturo, 27 bytes
$[n][∧12=n%111n<=>13 789]

Try it
$[n][                      ; a function taking an argument n
              n<=>13 789   ; is n between 13 and 789?
     ∧                     ; and
      12=n%111             ; is n mod 111 equal to 12?
                         ] ; end function

Thunno, \$ 8 \log_{256}(96)\approx \$ 6.58 bytes
dz[11dA=

Attempt This Online!
Port of Emigna's 05AB1E answer.

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


text:
Roll the Alphabet into a Spiral
Write a program or function that, when given n, will print a spiral n characters long made up of the Latin alphabet ABCDEFGHIJKLMNOPQRSTUVWXYZ repeated as needed. This spiral should run through the alphabet only forwards.
Related to Alphabet Spiral, though the spiral runs through the alphabet forwards and backwards, and the spiral is constant.
Test cases
4   AB
    DC

40   UVWXYZ
     TGHIJA
    NSFABKB
    MREDCLC
    LQPONMD
    KJIHGFE

0

10  GHIJ
    FAB
    EDC

1000    UVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ
        TGHIJKLMNOPQRSTUVWXYZABCDEFGHIJA
        SFABCDEFGHIJKLMNOPQRSTUVWXYZABKB
        REZCDEFGHIJKLMNOPQRSTUVWXYZABCLC
        QDYBMNOPQRSTUVWXYZABCDEFGHIJCDMD
        PCXALEFGHIJKLMNOPQRSTUVWXYZKDENE
        OBWZKDEFGHIJKLMNOPQRSTUVWXALEFOF
        NAVYJCDMNOPQRSTUVWXYZABCDYBMFGPG
        MZUXIBCLCDEFGHIJKLMNOPQREZCNGHQH
        LYTWHABKBABCDEFGHIJKLMNSFADOHIRI
        KXSVGZAJAZGHIJKLMNOPQROTGBEPIJSJ
        JWRUFYZIZYFUVWXYZABCDSPUHCFQJKTK
        IVQTEXYHYXETQRSTUVWXETQVIDGRKLUL
        HUPSDWXGXWDSPUVWXYZYFURWJEHSLMVM
        GTORCVWFWVCROTGHIJAZGVSXKFITMNWN
        FSNQBUVEVUBQNSFABKBAHWTYLGJUNOXO
        ERMPATUDUTAPMREDCLCBIXUZMHKVOPYP
        DQLOZSTCTSZOLQPONMDCJYVANILWPQZQ
        CPKNYRSBSRYNKJIHGFEDKZWBOJMXQRAR
        BOJMXQRARQXMLKJIHGFELAXCPKNYRSBS
        ANILWPQZQPWVUTSRQPONMBYDQLOZSTCT
        ZMHKVOPYPONMLKJIHGFEDCZERMPATUDU
        YLGJUNOXONMLKJIHGFEDCBAFSNQBUVEV
        XKFITMNWVUTSRQPONMLKJIHGTORCVWFW
        WJEHSLMLKJIHGFEDCBAZYXWVUPSDWXGX
        VIDGRKJIHGFEDCBAZYXWVUTSRQTEXYHY
        UHCFQPONMLKJIHGFEDCBAZYXWVUFYZIZ
        TGBEDCBAZYXWVUTSRQPONMLKJIHGZAJA
        SFAZYXWVUTSRQPONMLKJIHGFEDCBABKB
        REDCBAZYXWVUTSRQPONMLKJIHGFEDCLC
        QPONMLKJIHGFEDCBAZYXWVUTSRQPONMD
                                LKJIHGFE

Rules

Your input will be a non-negative integer 0 <= n <= 1000, but your code should theoretically handle any non-negative integer.
Your output format may be in any sane format, with delimiters if necessary.
Rotations and reflections are equivalent.
Your alphabet may be uppercase or lowercase.
The empty spaces in your spiral may be filled in with whatever non-alphabetic nulls you see fit.
The spiral itself may be in any shape you see fit. Rectangular spirals work best with ASCII solutions, but graphical solutions may be shorter with circular spirals.
Leading and trailing spaces and newlines are allowed.
This is code golf. The shortest answer in bytes (or equivalent) wins.

As always, if anything is unclear or incorrect, please let me know in the comments. Good luck and good golfing!

most editors will not allow printing out a string that long

@t-clausen.dk I went with the standard signed 32-bit integer maximum. If you have a better suggestion for an upper bound, I'd be happy to edit it in.

Nice and tricky :-)

Logo, 129 87 bytes
Graphical solution, implemented as function
This was built on Calormen.com's Logo interpreter.  The S function takes the number of characters as a parameter and draws them in a spiral.  The T function outputs letters upright to prevent them from rotating with the spiral..  I decided that it looked nicer (and golfed out 42 bytes) to omit correcting the letter orientation.  I also tightened up the spacing which did not change the byte count.  If you were to actually roll up an alphabet, it would look more like this anyway.
Updated Version (letters roll)
TO S:r
PU IF:r[REPEAT:r[LABEL CHAR((REPCOUNT-1)%26)+65
RT 99/SQRT(REPCOUNT)FD 12]]END

Invocation
Invoke as follows: S iterations
Sample output
S 1000

Old Version (letters always upright)

TO T:l:h
RT:h
LABEL CHAR(:l%26)+65
LT:h
END
TO S:r
PU IF:r[REPEAT:r[T REPCOUNT-1 90-HEADING
RT 95/SQRT(REPCOUNT)FD 15]]END

Old output removed to save space.  See it here.

Don't ask how I came up with the math.  I tried searching for formulas online, but most solved the problem by keeping the turn angle constant and increasing the segment length, whereas I wanted to keep the segment length constant and change the angle.  Trial and error seems to have led to a stable formula.  Adjusting the 95 will change the tightness of the spiral, and changing the 15 will adjust the linear spacing of the letters.

Javascript (ES6), 203 201 bytes
n=>{for(a=[],i=d=k=z=0,p=526,j=1;i<n;){p+=[1,32,-1,-32][d&3];j--||(((z^=1)||k++),j=k,d++);(a[y=p>>5]=(a[y]||Array(32).fill` `))[p&31]=String.fromCharCode(65+(i++%26))}return a.map(r=>r.join``).join`
`}

Demo
The demo below should be preferably run in full page.

let f =

n=>{for(a=[],i=d=k=z=0,p=526,j=1;i<n;){p+=[1,32,-1,-32][d&3];j--||(((z^=1)||k++),j=k,d++);(a[y=p>>5]=(a[y]||Array(32).fill` `))[p&31]=String.fromCharCode(65+(i++%26))}return a.map(r=>r.join``).join`
`}

function draw(n) {
  document.getElementById('v').innerHTML = n;
  document.getElementById('o').innerHTML = f(n);
}
draw(500);
pre {font-size:10px}
<input type="range" min="1" max="1000" oninput="draw(this.value)" style="width:500px">

R, 46 or 51 bytes, depending on spacing
s=1:scan();plot(s*sin(s),s*cos(s),pch=letters)

(updated version of plot: the gray spiral isn't plotted by default but I added it after to show that the letters indeed lie on a spiral.)
The spiral isn't of constant spacing, so I hope this is okay. If constant spacing is required, start with s=(1:scan())^.5 instead, and add 5 bytes to the total. Then the output is as below (n=150):

How you space your spiral is completely up to you. I do have two suggestions, though: 1) Keep the second spiral. It adds to your answer even if it's less golfy; 2) Can you draw a spiral line going through the letters in the image of your first spiral? Just to make the alphabet spiral clearer.

Python 3.5, 180 157 152 147 141 bytes
-6 due to Sherlock9
r=[[]]
for x in range(int(input())):
 r=len(r[-1])<len(r[0])and r or[*zip(*r[::-1]),[]];r[-1]+=[chr(x%26+65)]
print(*map(''.join,r),sep='\n')

-5 due to Kap.
R=range
def g(n):
 r=[[]]
 for x in R(n):
  if len(r[-1])==len(r[0]):r=[*zip(*r[::-1]),[]]
  r[-1]+=[chr(x%26+65)]
 print(*map(''.join,r),sep='\n')

Revised Solution, python 3.x:
R=range
def g(n):
 r=[[]]
 for x in R(n):
  if len(r[-1])==len(r[0]):r=list(zip(*r[::-1]))+[[]]
  r[-1]+=[chr(x%26+65)]
 print(*map(''.join,r),sep='\n')

Previous Solution:
R=range
def g(n):
 r=[]
 for x,f in zip(R(n),(j<1for i in R(n)for j in R(i//2+1))):
  if f:r=list(zip(*r[::-1]))+[[]]
  r[-1].append(chr(x%26+65))
 print(*map(''.join,r),sep='\n')

Explanation
r is a list of lists that holds the spiral.  The basic idea is that new letters are added to the bottom row of the spiral (r[-1].append(chr(x%26+65))).  When the bottom row is filled up, the spiral is rotated 90 clockwise and a new empty row is added to the bottom (r = list(zip(*r[::-1]))+[[]]).
The trick is to figure out when to rotate the spiral.  In the first solution, the generator (j<1for i in R(n)for j in R(i//2+1)) produces a sequence of True/False values that tell when to rotate the spiral.  In the revised solution, I changed the way r is initialized.  Now when the length of the bottom row equals the length of the top row, the spiral needs to be rotated.

You can replace if len(r[-1])==len(r[0]):r=list(zip(*r[::-1]))+[[]] with if len(r[-1])==len(r[0]):r=[*zip(*r[::-1]),[]] to save 5 bytes.

Since you only use range once, you can remove R to save bytes. You can also save bytes by converting your answer to a full program, though to preserve the use of [*zip(*r[::-1]),[]], you'll need to use range(int(input())).

Also, for x in range(int(input())):r=len(r[-1])<len(r[0])and r or[*zip(*r[::-1]),[]];r[-1]+=[chr(x%26+65)] since you're checking when the last line is equal or greater to the first line.

Two things: 1) You can make the for loop one line long by separating the statements with semicolons; and 2) you haven't defined n in this version. Either you need to use int(input()) or wrap in back up in a function.

2 bytes from condensing the for loop: for x in range(int(input())):r=len(r[-1])<len(r[0])and r or[*zip(*r[::-1]),[]];r[-1]+=[chr(x%26+65)]

MATL, 21 18 bytes
X^Xk1YL1Y2y)wG>~*c

Input 0 exits with an error (which is allowed by default).
Try it online!
Explanation
X^Xk   % Input n implicitly. Take square root and round up
1YL    % Square matrix of that size containing a spiral of numbers
1Y2    % Predefined literal: string "AB···YZ"
y      % Duplicate the spiral matrix onto the top
)      % Apply as an index inth the string. Gives 2D array of chars
w      % Swap: move copy of the spiral matrix to top
G>~    % Set entries that exceed the input to 0, and the rest to 1
*      % Multiply. This makes unwanted entries equal to 0
c      % Convert to char. 0 is shown as a space. Display implicitly

Python 2, 84 82 bytes
I'm using Turtle again. It's so fun! :D
from turtle import*
up()
for i in range(input()):write(chr(i%26+65));rt(9);fd(9+i)

Try it online
Unfortunately, Trinket.io has a horribly small canvas. I changed 9+i to 9+i/9 and adjusted the turtle's starting point for the purpose of screen-capturing this image, so that more of the output would fit:

One byte from if you remove a space from the import: from turtle import* and another from changing from while to for i in range(input())

Pyth, 32 bytes
JS@Q2ju+.t_G)Hc<*GQQ.u+NY.iJJZ]Y

A program that prints a rectangular lower-case ASCII spiral. Depending on the input, one row or column of leading or trailing whitespace may be present.
Try it online
How it works
JS@Q2ju+.t_G)Hc<*GQQ.u+NY.iJJZ]Y  Program. Input: Q
  @Q2                             Yield sqrt(Q)
JS                                Unary range, J=[1, 2, 3, ..., floor(sqrt(q))]
                         .iJJ     Interleave J with itself, yielding [1, 1, 2, 2, 3, 3, ...
                                  floor(sqrt(Q)), floor(sqrt(Q))]
                    .u+NY    Z    Cumulatively reduce by addition with base case 0,
                                  yielding [0, 1, 2, 4, 6, 9, 12, 16, 20...]
                *GQ               Repeat the lower-case alphabet Q times
               <   Q              Truncate to legth Q
              c                   Split the above at the indices in the above list
      u                       ]Y  Reduce the above, with base case [[]]:
          _G                       Reverse
        .t  )                      Transpose
       +     H                     Add the next arm of the spiral
     j                            Join on newlines and implicitly print

TSQL, 386 362 358 306 bytes
Please note that TSQL doesn't have a way to rotate text. This script is starting from A and calculating which direction the next letter should be placed. (right, down, left, left, left, up, up, right...)
The script can handle a maximum of 7744 letters.
Golfed:
DECLARE @z INT = 7744

DECLARE @ INT=2+SQRT(@z-1)DECLARE @o varchar(max)=REPLICATE(SPACE(@-1)+char(10),@-1);WITH C as(SELECT 0i,@/2a,@/2b UNION ALL SELECT i+1,a+z/2,b+z%2FROM(SELECT*,IIF(a>@/2*2-b,IIF(ab,-2,1))z FROM C)t WHERE i<@z-1)SELECT @o=STUFF(@o,@*a-@+b,1,char(i%26+65))FROM c OPTION(maxrecursion 0)PRINT @o

Ungolfed:
DECLARE @z INT = 7744

DECLARE @ INT=2+SQRT(@z-1)
DECLARE @o varchar(max)=REPLICATE(SPACE(@-1)+char(10),@-1)

;WITH C as
(
  SELECT
    0i,@/2a,@/2b
  UNION ALL
  SELECT
    i+1,a+z/2,b+z%2
    FROM
      (SELECT*,
         IIF(a>@/2*2-b,
           IIF(ab,-2,1))z FROM C)t
  WHERE
    i<@z-1
)
SELECT
  @o=STUFF(@o,@*a-@+b,1,char(i%26+65))
FROM c
OPTION(maxrecursion 0)

PRINT @o

Fiddle

Python 2, 243 bytes
r=range(input())
a=[1j**int((4*i+1)**.5)for i in r]
b=[map(int,(-sum(a[:i]).real,sum(a[:i]).imag))for i in r]
c,d=zip(*b)
for i in range(min(c),max(c)+1):print''.join([i,j]in b and chr(b.index([i,j])%26+65)or' 'for j in range(min(d),max(d)+1))

Ideone it!

PHP, 219 bytes
for($q=ceil(sqrt($a=$argn))**2,$d=1,$x=$y=$w=0;$i<$q;$i++,${yx[$w%2]}+=[-1,1][$d&1],$i%$d?:$d+=$w++&1)$e[$c[]=$x-!($a&1)][$l[]=$y]=$i<$a?chr(65+$i%26):" ";for($k=min($c);$e[$k];print join($e[+$k++])."\n")ksort($e[+$k]);

Try it online!
PHP , 260 Bytes
Old version

for($y=$x=$d=$i=0;$i<$m=ceil(sqrt($n=$argv[1]))**2;$i++){$a[$y][$x]=$i<$n?chr($i%26+65):" ";$d=$y==$x&$y<1?0:(1-$y==$x&$x>0?1:($y==$x&$y>0?2:($y==-$x&$x<0?3:$d)));$d>2?$y--:($d>1?$x--:($d>0?$y++:$x++));}ksort($a);foreach($a as$r){ksort($r);echo join($r)."\n";}

source: Stack Exchange

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

sort: votes


text:
Sheffle tho vawols ureund!
Given an input string, output that string with all vowels a, e, i, o and u swapped at random between each other.
For example, in the string this is a test, there are 4 vowels: [i, i, a, e]. A valid shuffling of those vowels could be [a, i, e, i] therefore yielding the output thas is e tist.
About shuffling
All shuffles shall be equally likely if we consider equal vowels to be distinct. For the example above, those 24 shuffles are possible:

[i1, i2, a, e]    [i1, i2, e, a]    [i1, a, i2, e]    [i1, a, e, i2]
[i1, e, i2, a]    [i1, e, a, i2]    [i2, i1, a, e]    [i2, i1, e, a]
[i2, a, i1, e]    [i2, a, e, i1]    [i2, e, i1, a]    [i2, e, a, i1]
[a, i1, i2, e]    [a, i1, e, i2]    [a, i2, i1, e]    [a, i2, e, i1]
[a, e, i1, i2]    [a, e, i2, i1]    [e, i1, i2, a]    [e, i1, a, i2]
[e, i2, i1, a]    [e, i2, a, i1]    [e, a, i1, i2]    [e, a, i2, i1]

Each one should be equally as likely.
You may not try random shuffles of the entire string until finding one where all vowels are in the right place. In short, your code's running time shall be constant if the input is constant.
Inputs and outputs

You may assume that all letters in the input will be lowercase or uppercase. You may also support mixed casing, though this won't give you any bonus.
The input will always consist of printable ASCII characters. All characters that are in the input shall be in the output, only the vowels must be shuffled around and nothing else.
The input can be empty. There is no guarantee that the input will contain at least one vowel or at least one non-vowel.
You may take the input from STDIN, as a function parameter, or anything similar.
You may print the output to STDOUT, return it from a function, or anything similar.

Test cases
The first line is the given input. The second line is one of the possible outputs.
<empty string>
<empty string>

a
a

cwm
cwm

the quick brown fox jumps over the lazy dog.
tho qeuck brewn fax jumps ovir the lozy dog.

abcdefghijklmnopqrstuvwxyz
abcdefghujklmnipqrstovwxyz

programming puzzles & code golf
pregromming pezzlos & coda gulf

fatalize
fitaleza

martin ender
mirten ander

Scoring
This is code-golf, sa tho shirtist enswer en bytes wons.

You English/American people and your lack of y as vowel.. ;)

@KevinCruijssen I'm not a native speaker and I would also consider y to be a vowel, but last challenge where I said y was a vowel I got asked why I chose that!

@KevinCruijssen, letters aren't vowels: sounds are.

@PeterTaylor You're right, came to the same conclusion short after I made my comment. But still, y is a vowel in Baby (although not in Your). If we look at individual letters I personally consider y a vowel, although I can understand why some don't with all the words starting with y in the English language.

+1 for cwm. Keeping mountaineering and/or Welsh alive ;)

@KevinCruijssen Don't have a cow about vowels that aren't commonly considered so.

Jelly, 15 bytes
f€“¡ẎṢɱ»ðœpżFẊ¥

Try it online!
How it works
f€“¡ẎṢɱ»ðœpżFẊ¥  Main link. Argument: s (string)

  “¡ẎṢɱ»         Yield "aeuoi"; concatenate "a" with the dictionary word "euoi".
f€               Filter each character in s by presence in "aeuoi".
                 This yields A, an array of singleton and empty strings.
        ð        Begin a new, dyadic chain. Left argument: A. Right argument: s
         œp      Partition s at truthy values (singleton strings of vowels) in A.
            FẊ¥  Flatten and shuffle A. This yields a permutation of the vowels.
           ż     Zip the partition of consonants with the shuffled vowels.

Why does this seem fairly slow compared to other answers?

Jelly imports SymPy and NumPy before anything else. This program and the empty program have roughly the same execution time.

Before anyone asks, euoi is a cry of impassioned rapture in ancient Bacchic revels.

@Dennis Out of curiosity though, why does Jelly have built in dictionary words? Where does it get these dictionary words from?

@KevinCruijssen When I designed Jelly, there already were a few golfing languages that used shoco, and simply using an English dictionary seemed like a good way to improve on that idea. I used the file /usr/share/dict/words from my computer and included it in the Jelly interpreter.

As the FX¥ appears to be executed monadically, why does it fail when replacing the ¥ with a $?

@cairdcoinheringaahing Because ż forks if the link to its right is a monad.

R, 92 91
Can't comment yet so I'm adding my own answer albeit very similar to @Andreï Kostyrka answer (believe it or not but came up with it independently).
s=strsplit(readline(),"")[[1]];v=s%in%c("a","e","i","o","u");s[v]=sample(s[v]);cat(s,sep="")

Ungolfed
s=strsplit(readline(),"")[[1]]    # Read input and store as a vector
v=s%in%c("a","e","i","o","u")     # Return TRUE/FALSE vector if vowel
s[v]=sample(s[v])                 # Replace vector if TRUE with a random permutation of vowels
cat(s,sep="")                     # Print concatenated vector

Saved one byte thanks to @Vlo
s=strsplit(readline(),"")[[1]];s[v]=sample(s[v<-s%in%c("a","e","i","o","u")]);cat(s,sep="")

Honestly, I cannot believe. Just kidding. Nice trick to save some bytes!

Just to be honest, I am not stealing your ideas to golf my answer further.

Hehe, gotta get them sweet upvotes so I can comment  ;)

Save a byte with in-line assignment 91 bytes s=strsplit(readline(),"")[[1]];s[v]=sample(s[v<-s%in%c("a","e","i","o","u")]);cat(s,sep="")

Save another byte by using el() instead of [[1]].

R, 99 98 89 bytes
x=el(strsplit(readline(),""))
z=grepl("[aeiou]",x)
x[z]=x[sample(which(z))]
cat(x,sep="")

Seems to be the first human-readable solution! Thanks to Giuseppe for saving 9 bytes!
Test cases:
tho qaeck bruwn fux jemps over tho lozy dig.
progremmang pozzlos & cide gulf

Seems that there is no way to make an internal variable assignment (inside, like, cat), and again some people are going to prove I am wrong...

letters[c(1,5,9,15,21)] is 1 byte longer, and OEIS A161536 and A215721 seem to be of little to no help either.

Wouldn't z=grepl("[aeiou]",x) be shorter?

@Giuseppe You did it again! Thanks.

CJam, 23 bytes
lee_{"aeiou"&},_mrerWf=

Try it online!
Explanation
l            e# Read input, e.g. "foobar".
ee           e# Enumerate, e.g. [[0 'f] [1 'o] [2 'o] [3 'b] [4 'a] [5 'r]].
_            e# Duplicate.
{"aeiou"&},  e# Keep those which have a non-empty intersection with this string
             e# of vowels, i.e. those where the enumerated character is a vowel.
             e# E.g. [[1 'o] [2 'o] [4 'a]].
_            e# Duplicate.
mr           e# Shuffle the copy. E.g. [[2 'o] [4 'a] [1 'o]].
er           e# Transliteration. Replaces elements from the sorted copy with
             e# the corresponding element in the shuffled copy in the original list.
             e# [[0 'f] [2 'o] [4 'a] [3 'b] [1 'o] [5 'r]].
Wf=          e# Get the last element of each pair, e.g. "foabor".

05AB1E, 17 bytes
žMÃ.r`¹vžMyå_iy}?

Explanation
žMÃ                # get all vowels from input
   .r`             # randomize them and place on stack
      ¹v           # for each in input
        žMyå_i }   # if it is not a vowel
              y    # push it on stack
                ?  # print top of stack

Try it online!

Python 3, 109 bytes
Only supports lowercase vowels.
Thanks to @Alissa for saving an extra byte.
import re,random
def f(s):r='[aeiou]';a=re.findall(r,s);random.shuffle(a);return re.sub(r,lambda m:a.pop(),s)

Ideone it!

wouldn't it be shorter if it's a function taking string and returning that string with shuffled vowels?

@Alissa Thanks, it saved one byte! :D

not sure if it will be any shorter, but you could a.pop(random.randrange(0,len(a))) instead of shuffling a

TSQL, 275 bytes
Golfed:
DECLARE @ VARCHAR(99)='the quick brown fox jumps over the lazy dog.'

;WITH c as(SELECT LEFT(@,0)x,0i UNION ALL SELECT LEFT(substring(@,i+1,1),1),i+1FROM c
WHERE i<LEN(@)),d as(SELECT *,rank()over(order by newid())a,row_number()over(order by 1/0)b
FROM c WHERE x IN('a','e','i','o','u'))SELECT @=STUFF(@,d.i,1,e.x)FROM d,d e
WHERE d.a=e.b PRINT @

Ungolfed:
DECLARE @ VARCHAR(max)='the quick brown fox jumps over the lazy dog.'

;WITH c as
(
  SELECT LEFT(@,0)x,0i
  UNION ALL
  SELECT LEFT(substring(@,i+1,1),1),i+1
  FROM c
  WHERE i<LEN(@)
),d as
(
  SELECT
    *,
    rank()over(order by newid())a,
    row_number()over(order by 1/0)b
  FROM c
  WHERE x IN('a','e','i','o','u')
)
SELECT @=STUFF(@,d.i,1,e.x)FROM d,d e
WHERE d.a=e.b
-- next row will be necessary in order to handle texts longer than 99 bytes
-- not included in the golfed version, also using varchar(max) instead of varchar(99)
OPTION(MAXRECURSION 0)

PRINT @

Fiddle

Ruby 45 + 1 = 46 bytes
+1 byte for -p flag
a=$_.scan(e=/[aeiou]/).shuffle
gsub(e){a.pop}

Bash, 75 bytes
paste -d '' <(tr aeoiu \\n<<<$1) <(grep -o \[aeiou]<<<$1|shuf)|paste -sd ''

Takes the string as an argument and prints the result to stdout.
Eg
for x in "" "a" "cwm" \
         "the quick brown fox jumps over the lazy dog." \
         "abcdefghijklmnopqrstuvwxyz" \
         "programming puzzles & code golf" \
         "fatalize" "martin ender"; do
  echo "$x";. sheffle.sh "$x"; echo
done

prints
<blank line>
<blank line>

a
a

cwm
cwm

the quick brown fox jumps over the lazy dog.
tho quuck brown fix jamps ever the lozy dog.

abcdefghijklmnopqrstuvwxyz
ibcdefghajklmnopqrstuvwxyz

programming puzzles & code golf
progremmong pazzlus & cedo gilf

fatalize
fetilaza

martin ender
mertan endir

Brachylog, 39 bytes
@eI:1aToS,I:2f@~:LcS,Tc
.'~e@V;
e.~e@V,

Try it online!
Explanation

Main predicate:
@eI        I is the list of chars of the input.
:1aT       T is I where all vowels are replaced with free variables.
oS,        S is T sorted (all free variables come first).
I:2f       Find all vowels in I.
@~         Shuffle them.
:LcS,      This shuffle concatenated with L (whatever it may be) results in S.
             This will unify the free variables in S with the shuffled vowels.
Tc         Output is the concatenation of elements of T.

Predicate 1:
.          Input = Output…
'~e@V      …provided that it is not a vowel.
;          Otherwise Output is a free variable.

Predicate 2:
e.         Output is an element of the input…
~e@V,      … and it is a vowel.

Java 7, 243 241 bytes
import java.util.*;String c(char[]z){List l=new ArrayList();char i,c;for(i=0;i<z.length;i++)if("aeiou".indexOf(c=z[i])>=0){l.add(c);z[i]=0;}Collections.shuffle(l);String r="";for(i=0;i<z.length;i++)r+=z[i]<1?(char)l.remove(0):z[i];return r;}

Yes, this can probably be golfed quite a bit, but Java doesn't have any handy built-ins for this a.f.a.i.k... Also, I kinda forgot the codegolfed array-variant for Collections.shuffle..
Ungolfed & test cases:
Try it here.
import java.util.*;
class M{
  static String c(char[] z){
    List l = new ArrayList();
    char i,
         c;
    for(i = 0; i < z.length; i++){
      if("aeiou".indexOf(c = z[i]) >= 0){
        l.add(c);
        z[i] = 0;
      }
    }
    Collections.shuffle(l);
    String r = "";
    for(i = 0; i < z.length; i++){
      r += z[i] < 1
               ? (char)l.remove(0)
               : z[i];
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("".toCharArray()));
    System.out.println(c("a".toCharArray()));
    System.out.println(c("cwm".toCharArray()));
    System.out.println(c("the quick brown fox jumps over the lazy dog.".toCharArray()));
    System.out.println(c("abcdefghijklmnopqrstuvwxyz".toCharArray()));
    System.out.println(c("programming puzzles & code golf".toCharArray()));
    System.out.println(c("fatalize".toCharArray()));
    System.out.println(c("martin ender".toCharArray()));
  }
}

Possible output:
a
cwm
tha queck brown fox jumps evor tho lezy dig.
ebcdifghujklmnopqrstavwxyz
prigrommeng puzzlos & cade golf
fatelazi
mertan inder

How about reusing i in the second loop?

I thought "why didn't he go with char[] instead of a List", so I started, but the lack of Arrays.shuffle stopped me right there...

Shaved 6 characters with some minor tweaks: import java.util.*;String c(char[]z){List l=new ArrayList();int i=0,j=z.length;for(;i<j;i++)if("aeiou".indexOf(z[i])>=0){l.add(z[i]);z[i]=0;}Collections.shuffle(l);String r="";for(i=0;i<j;i++)r+=z[i]<1?(char)l.remove(0):z[i];return r;}

MATL, 15 bytes
tt11Y2m)tnZr7M(

Try it online!
Explanation
tt      % Take input string implicitly. Duplicate twice
11Y2    % Predefined string: 'aeiou'
m       % Logical index that contains true for chars of the input that are vowels
)       % Get those chars from the input string. Gives a substring formed by the
        % vowels in their input order
tnZr    % Random permutation of that substring. This is done via random sampling
        % of that many elements without replacement
7M      % Push logical index of vowel positions again
(       % Assign the shuffled vowels into the input string. Display implicitly

Javascript (ES6), 78 76 bytes
s=>s.replace(r=/[aeiou]/g,_=>l.pop(),l=s.match(r).sort(_=>Math.random()-.5))

Saved 2 bytes thanks to apsillers
Alternate version proposed by apsillers (76 bytes as well)
s=>s.replace(r=/[aeiou]/g,[].pop.bind(s.match(r).sort(_=>Math.random()-.5)))

Test

let f =
s=>s.replace(r=/[aeiou]/g,_=>l.pop(),l=s.match(r).sort(_=>Math.random()-.5))

console.log(f("the quick brown fox jumps over the lazy dog."))

Not an improvement (exact same score), but a fun uglification I found: drop the l=... entirely and use the bound function [].pop.bind(s.match(r).sort(_=>Math.random()-.5))) as the second argument to replace (instead of an arrow function). Maybe there's an improvement to be found down that road, but I haven't found one yet. If you used a JS-superset language that has the bind operator ::, I think you could do (s.match(r).sort(_=>Math.random()-.5)))::pop.

Perl, 38 bytes
Includes +1 for -p
Run with the sentence on STDIN
vawols.pl <<< "programming puzzles & code golf"

vawols.pl:
#!/usr/bin/perl -p
@Q=/[aeiou]/g;s//splice@Q,rand@Q,1/eg

Perl 6, 65 bytes
{my \v=m:g/<[aeiou]>/;my @a=.comb;@a[v».from]=v.pick(*);@a.join}

Anonymous function. Assumes lower-case input.
(try it online)

Japt v2.0a0, 14 13 bytes
ō²f\v
NÌr\v@o

Try it

Explanation
           :Implicit input of string U.
ö²         :Generate a random permutation of U.
  f\v      :Get all the vowels as an array.
\n         :Assign that array to U.
NÌ         :Get the last element in the array of inputs (i.e., the original value of U)
  r\v      :Replace each vowel.
     @o    :Pop the last element from the array assigned to U above.

Pyth, 26 bytes
J"[aeiou]"s.i:QJ3.Sf}TPtJQ

A program that takes input of a quoted string and prints the shuffled string.
Try it online
How it works
J"[aeiou]"s.i:QJ3.Sf}TPtJQ  Program. Input: Q
J"[aeiou]"                  J="[aeiou]"
             :QJ3           Split Q on matches of regex J, removing vowels
                      PtJ   J[1:-1], yielding "aeiou"
                   f}T   Q  Filter Q on presence in above, yielding vowels
                 .S         Randomly shuffle vowels
           .i               Interleave non-vowel and vowel parts
          s                 Concatenate and implicitly print

Actually, 24 bytes
;"aeiou";╗@s@`╜íu`░╚@♀+Σ

Try it online!
Explanation:
;"aeiou";╗@s@`╜íu`░╚@♀+Σ
;                         dupe input
 "aeiou";╗                push vowels, store a copy in reg0
          @s              split one copy of input on vowels
            @`╜íu`░       take characters from other copy of input where
              ╜íu           the character is a vowel (1-based index of character in vowel string is non-zero)
                   ╚      shuffle the vowels
                    @♀+   interleave and concatenate pairs of strings
                       Σ  concatenate the strings

Bash, 89
Assumes all input to be lowercase.
a=`tee z|grep -o [aeiou]`
[ -n "$a" ]&&tr `tr -d \ <<<$a` `shuf -e $a|tr -d '
'`<z||cat z

Python 3, 106 bytes
Lowercase only.
import re,random
def f(s):s=re.split('([aeiou])',s);v=s[1::2];random.shuffle(v);s[1::2]=v;return''.join(s)

PHP, 144 129 bytes
Using lowercase input
$r=Aaeiou;$v=str_shuffle(preg_replace("#[^$r]+#",'',$a=$argv[1]));for(;$i<strlen($a);)echo strpos($r,$a[$i++])?$v[$j++]:$a[$i-1];

Explanation:
$r="aeiou"; // set vowels

preg_replace("#[^$r]+#",'',$argv[1]) // find all vowels in input

$v=str_shuffle() // shuffle them

for(;$i<strlen($a);) // run through the text

strpos($r,$a[$i++])?$v[$j++]:$a[$i-1]; // if it's a vowel print the j-th shuffled vowel else print original text

PowerShell v3+, 155 99 bytes
param([char[]]$n)$a=$n|?{$_-match'[aeiou]'}|sort{random};-join($n|%{if($_-in$a){$a[$i++]}else{$_}})

Big props to @Ben Owen for the 56-byte golf
Takes input $n, expecting all lowercase, immediately casts it as a char-array.
We pipe that into a Where-Object clause to pull out those elements that -match a vowel, pipe them to Sort-Object with {Get-Random} as the sorting mechanism. Calling Get-Random without qualifiers will return an integer between 0 and [int32]::MaxValue -- i.e., assigning random weights to each element on the fly. We store the randomized vowels into $a.
Finally, we loop through $n. For each element, |%{...}, if the current character is somewhere -in $a, we output the next element in $a, post-incrementing $i for the next time. Otherwise, we output the current character. That's all encapsulated in parens and -joined together into a string. That string is left on the pipeline, and output is implicit at program conclusion.
Test cases
PS C:\Tools\Scripts\golfing> 'a','cwm','the quick brown fox jumps over the lazy dog.','abcdefghijklmnopqrstuvwxyz','programming puzzles & code golf','fatalize','martin ender'|%{.\vawols.ps1 $_}
a
cwm
thu qaeck brown fix jomps ovor thu lezy deg.
abcdofghejklmnupqrstivwxyz
prugrammong pizzles & code golf
fitaleza
mertin endar

You can save a lot of bytes here by iterating through $n's characters and matching on each vowel to output the char-array of vowels instead.
Something like:
$a=[char[]]$n|?{$_-match'[aeiou]'}|sort{random}

@BenOwen Holy dang, yes. Thanks for the 56-byte golf. For the life of me, I could just not figure out a better way to construct $a.

PHP >= 5.3, 139 136 bytes (and no errors thrown)
array_map(function($a,$b){echo$a.$b;},preg_split("/[aeiou]/",$s=$argv[1]),str_split(str_shuffle(implode(preg_split("/[^aeiou]/",$s)))));

K (oK), 29 bytes
Solution:
{x[a:&x in"aeiou"]:x@(-#a)?a}

Try it online!
Examples:
"pregrommeng pizzlas & codo gulf"
{x[a:&x in"aeiou"]:x@(-#a)?a}"programming puzzles & code golf"
"pregremmong puzzlos & coda gilf"
{x[a:&x in"aeiou"]:x@(-#a)?a}"programming puzzles & code golf"
"pregrommeng pazzlos & cidu golf"

Explanation:
Find locations of the vowels and replace with the vowels drawn in a random order.
{x[a:&x in"aeiou"]:x@(-#a)?a} / the solution
{                           } / anonymous function with input x
 x[              ]            / index into x at these indices
      x in"aeiou"             / is character a vowel
     &                        / indices where true
   a:                         / assign to add
                  :           / assign
                          ?a  / draw randomly from a
                     (   )    / do this together
                       #a     / count length of a
                      -       / negate (draws from list, no duplication)
                   x@         / apply these indices to input

APL (Dyalog Unicode), 21 bytes
{⍵[?⍨≢⍵]}@{⍵∊'AEIOU'}

Try it online!
Assumes uppercase.

Would {⍵∊'AEIOU'} → ∊∘'AEIOU' work?

@Cowsquack I don't think so, since then it would be parsed as ({⍵[?⍨≢⍵]}@∊)∘'AEIOU'.

Kotlin, 122 118 bytes
x->val v=x.filter{"aeiuo".contains(it)}.toList().shuffled()
x.split(Regex("[aeiou]")).reduceIndexed{i,a,s->a+v[i-1]+s}

Try it online!

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


text:
Hate/love conundrum
Challenge description
In this challenge, we only consider love and hate as feelings. If we want to utter a feeling expression of order N, we alternate between these two (starting with hate):
order | expression

1       I hate it.
2       I hate that I love it.
3       I hate that I love that I hate it.
4       I hate that I love that I hate that I love it.

The pattern follows for every positive integer N. Given N, output the correspoinding feeling expression of order N.
Notes

Full stop (.) at the end of the expression is mandatory,
Trailing and leading whitespaces (including newlines) are permitted,
Output for a non-positive or non-integer N is undefined,
This is a code-golf challenge, so make your code as short as possible!

Related.

Quite confused. So is order the input, and expression the output?

@Whothehellisthat Yes, exactly. (Welcome to PPCG! :))

@Whothehellisthat: Yes. You may take input through stdin, though it's often shorter to define a method (function), as you can see in the submissions below.

I hate that I love this question and its answers!

Is it okay if each component of a "feeling expression" of order N is separated by new lines instead of spaces, i.e I hate it \n I love it (where \n is the new line)?

@R.Kap: you mean like I hate that \n I love that \n I hate it. ? No.

Python, 54 bytes
lambda n:("I hate that I love that "*n)[:12*n-5]+"it."

Python 2: Ideone it!
Python 3: Ideone it!

Ported to Haskell: f n=take(12*n-5)(cycle"I hate that I love that ")++"it." (56 bytes)

CJam, 36 bytes
ri{"hatlov"3/='IS@"e that "}/2<"it."

Try it online!
Explanation
ri            e# Read input and convert to integer N.
{             e# For each i from 0 to N-1...
  "hatlov"3/  e#   Push ["hat" "lov"].
  =           e#   Use i as a cyclic index into this array to alternate between
              e#   "hat" and "lov".
  'IS         e#   Push character 'I' and a space.
  @           e#   Pull "hat" or "lov" on top of it.
  "e that "   e#   Push "e that "
}/
2<            e#   Truncate the last "e that " to just "e ".
"it."         e#   Push "it."

C, 83 76 75 74 bytes
Thanks to @Leaky Nun for saving 11 bytes and adding 4 bytes!
Thanks to @YSC for saving a byte!
i;f(n){for(i=0;n--;)printf("I %se %s",i++%2?"lov":"hat",n?"that ":"it.");}

Try it on Ideone

i=0;while(n--) -> for(i=0;n--;) saves 1 char.

Javascript (ES6), 75 73 70 bytes
n=>[...Array(n)].map((_,i)=>i&1?'I love':'I hate').join` that `+' it.'

Saved 2 bytes thanks to Neil
Saved 3 bytes thanks to Whothehellisthat
Test

let f =
n=>[...Array(n)].map((_,i)=>i&1?'I love':'I hate').join` that `+' it.'

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))

Save 3 bytes: ['I hate','I love'][i&1] -> i&1?'I love':'I hate'

@Whothehellisthat - Thanks! I missed that one.

Java 8, 91 bytes
i->{for(int j=0;j++<i;)System.out.printf("I %se %s",j%2>0?"hat":"lov",j<i?"that ":"it.");};

Ungolfed Test Program
public static void main(String[] args) {
    Consumer<Integer> c = i -> {
        for (int j = 0; j++ < i;) {
            System.out.printf("I %se %s", j % 2 > 0 ? "hat" : "lov", j < i ? "that " : "it.");
        }
    };

    c.accept(1);
    c.accept(2);
    c.accept(3);
}

Why not remove the whitespace? c=i->for(...)

I simply forgot.

Nice, you've beat me to it. +1 And probably shorter than my answer would be. PS: I would indicate this as 'Java 8' instead of just 'Java'. Not mandatory however, just personal preference from me since I usually write my answers in Java 7 (and since Java 9 is incoming).

@KevinCruijssen You tell me this everytime ;) fine

@SeanBean Well, usually I already have my Java 7 answer, and you post a shorter answer, which can then most of the time be golfed even more. ;P (This time I can't find anything to make it shorter, though. But perhaps someone else is able to do so.)

You can use String.format instead of System.out.printf, making the lambda a Function<Integer, String> instead of a Consumer<Integer>

@CAD97 I believe printing it and not returning it is part of the spec?

@CAD97 Doesn't that add some additional bytes for return-ing the String?

@KevinCruijssen function output is an acceptable output, but yes, you're correct; I misread and can't test right now.

Question from avenger12: Hows does the Java 8 solution for the Love/Hate Conundrum code golf work? If j=0 at the start of the loop wouldn't the boolean j++ < i == false and thus the body of the for loop wouldn't execute? Thanks in advance for any feedback.

@Maltysen: for (int j = 0; j++ < i;) is essentially equivalent to for (int j = 0; j < i; j++). j++ increments the j variable each time.

Mathematica, 63 bytes
"I love"["I hate"][[#~Mod~2]]&~Array~#~Riffle~" that "<>" it."&

I'm loving the head extraction there, really clever.

@ASimmons It's actually quite an old trick (which I didn't even come up with myself), but I definitely don't get to use it often enough. ;)

Jelly, 25 bytes
“ṅɠT5“£ẏkg⁷»ṁj“¥ıQ»ṙ1“it.

Try it online!
Explanation
                             Input: n, a number.
“ṅɠT5“£ẏkg⁷»                 Compressed string array [' I hate', ' I love']
            ṁ                Cycle for n repetitions.
             j“¥ıQ»          Join by compressed string ' that'.
                   ṙ1        Rotate left once: move the initial space to the end.
                     “it.    Implicitly print the result, then print 'it.'

I need an explanation for this.

05AB1E, 34 32 27 bytes
Saved 5 bytes thanks to Adnan.
“I«¢€Š I„Î€Š “×¹12*5-£…it.«

Explanation
“I«¢€Š I„Î€Š “               # "I hate that I love that "
              ×              # repeat input nr of times
               ¹12*5-£       # take the first input*12-5 chars of string above
                      …it.«  # append "it."
                             # implicitly display

Try it online!

R, 79 bytes
n=scan();for(i in n:1)cat(if((i+n)%%2)"I love"else"I hate",if(i>1)"that "else"it.")

Luckily in R, the default separator for cat is a space.
(Edited from original 73 byte version which didn't quite solve the problem.)

Neat use of the for loop and %%. +1

Retina, 42 38 bytes
Thanks to Leaky Nun for helping me golf it!
11
1I love n
1
I hate n
n$
it.
n
that

Input is taken in unary.
Try it online!
Explanation
11
1I love n

Replace every pair of 1s with 1I love n.
1
I hate n

Replace the remaining 1s with I hate n.
n$
it.
n
that

Replace the n at the end of the line with it. and every other n with that .

You can save four more by dropping l: http://retina.tryitonline.net/#code=MTEKMUkgbG92ZSBuCjEKSSBoYXRlIG4KbiQKaXQuCm4KdGhhdCA&input=MTExMTE

@MartinEnder: I think I ninja'd you to that edit :P

Timestamps say you were 9 seconds late. :P

Perl, 62 54 50 bytes
$_="I xe tx "x$_;s/tx $/it./;s/x/++$.%4?hat:lov/ge

(credit to @Ton Hospel)
Demo: http://ideone.com/zrM27p
Previous solutions:
$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./

(credit to @Dada)
Run with perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'
First solution (only this was mine)
for$x(1..<>){$_.=' I '.($x%2?hat:lov).'e that'}s/\w+$/it./;say

In parts:
for $x (1..<>) {
   $_ .= ' I '.($x % 2 ? hat : lov).'e that'
}
s/\w+$/it./;
say

Demo: http://ideone.com/mosnVz

Hi and welcome to PPCG. Nice answer. Here is a shorter solution though (54 bytes) : perl -pE '$_="I xe that "x$_;s/x/$@++&1?lov:hat/ge;s/\w+.$/it./'.

What does this part mean $@++&1? For @+ perldoc says "holds the offsets of the ends of the last successful submatches in the currently active dynamic scope" which doesn't make much sense for me. As I understand, you use this array in scalar context ($@+ - are you dereferencing it?) to get the number of elements and then add (+) the matched string (&1). No no no I knew I shouldn't have posted to PPCG it's too obfuscated :D

$@ is just a scalar (I could have used $x or any other scalar), ++ is the increment operator, and &1 is roughly the same as %2. So it's basically the same as $x++%2.

So you're using @ for scalar variable name; &1 for "and"ing the last bit to check if it's even (and not a backreference as I thought). Ok understood now, thanks.

Nice solution. You can gain a few more bytes by using $|--  as a toggle instead of $@++%2

$_="I xe tx "x$_;s/tx $/it./;s/x/++$.%4?hat:lov/ge is even better

@TonHospel a look to perldoc shows that you use the $. variable only to use that it's equal to 1 in the beginning (i.e. to avoid doing $a = 1;)? That's cool.

Bash + coreutils, 106 bytes:
for i in `seq $1`;{ printf "I %s %s " `((i%2>0))&&echo hate||echo love` `((i==$1))&&echo it.||echo that`;}

Simply creates a sequence starting at 1 up to and including the input integer using the seq built-in, and then iterates through it one by one, first outputting hate if the value of the iteration variable, i, is not divisible by 2 and love otherwise. In the same iteration, it then chooses to output that if i is not equal to the input value, and it. otherwise.
Try It Online! (Ideone)

Better put the command substitutions directly in printf's string and use no format specifiers. Is pointless to compare whether i%2 is greater than 0. I you reverse the commands in the list, you can use less than comparison instead of i==$1: for i in \seq $1`;{ printf "I `((i%2))&&echo hat||echo lov`e `((i<$1))&&echo that||echo it.` ";}. By the way, we usually label such solutions as Bash + coreutils, because the use of seq`.

Javascript (ES5), 99 94 bytes
function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}

Saved 5 bytes thanks to Leaky Nun.
OLD 99 byte solution:
function(c){for(d="",b=0;b<c;++b)d+=(0==b%2?"I hate":"I love")+" "+(b==c-1?"it.":"that ");return d}

Another 98 byte solution:
function(d){for(c=[],b=0;b<d;++b)c.push(["love","hate"][b%2]);return"I "+c.join(" that I ")+" it"}

My code before minification:
function a(n){
  var hate="I hate",love="I love",it="it ",that="that ",out="";
  for(var i=0;i<n;++i){out+=(i%2==0?hate:love)+" "+(i==n-1?it+".":that)}return out;
}

function(c){for(d="",b=0;b<c;++b)d+=(b%2?"I love ":"I hate ")+(b==c-1?"it.":"that ");return d}

php, 64 62 bytes
<?=str_pad("",$argv[1]*12-5,"I hate that I love that ")."it.";

Unfortunately I couldn't work out a way to avoid repeating the " that I ", or at least no way to do it in less than 7 bytes.
edit: saved 2 bytes thanks to @Jörg Hülsermann

Haskell, 70 bytes
g 1="I hate";g n=g(n-1)++" that "++cycle["I love",g 1]!!n
(++" it.").g

PowerShell v2+, 64 bytes
((1..$args[0]|%{('I love','I hate')[$_%2]})-join' that ')+' it.'

Rather straightforward. Loops from 1 up to the input $args[0], each iteration placing either 'I love' or 'I hate' on the pipeline, based on a pseudo-ternary for modulo-2 (i.e., it alternates back and forth, starting with 'I hate'). Those strings are encapsulated in parens and -joined with ' that ' to smush them together, then string concatenation ' it.' at the end.
Test Cases
PS C:\Tools\Scripts\golfing> 1..5|%{.\hate-love-conundrum.ps1 $_}
I hate it.
I hate that I love it.
I hate that I love that I hate it.
I hate that I love that I hate that I love it.
I hate that I love that I hate that I love that I hate it.

///, 60 57 bytes
/!/I hate //T/that //
/it.//00/!TI love T//Tit./it.//0/!/

-3 bytes thanks to m-chrzan
Input in unary with trailing new line.
Try it online!

You could add /T/that / to the beginning and replace all instances of that  with T.

Lua , 75 Bytes
n=io.read();print(('I hate that I love that '):rep(n):sub(1,n*12-5)..'it.')

Instead of static methods better use instance methods: ('I hate that I love that '):rep(n):sub(1,n*12-5). And would look nicer if you concatenate "it." to the end, because print() outputs its parameters separated by tab.

The ';' between io.read() and print is unneeded, and arg[2] is a valid input method for lua scripts, which is the first command line argument.

C#, 85 83 bytes
string f(int n,int m=2)=>"I "+(1>m%2?"hat":"lov")+(m>n?"e it.":"e that "+f(n,m+1));

Recursively constructs the string, using an optional parameter to keep track of which hate/love and how many to append.
-2 bytes from this tip for checking the evenness/oddness of a number.
No optional parameter solution, 87 86 84 bytes
string h(int n)=>"I "+(0<n?"hat":"lov")+(2>n&-2<n?"e it.":"e that "+h(0<n?~n+2:~n));

This one does the same thing except determines which hate/love to append based on whether the parameter is positive or negative. Each iteration the parameter approaches zero, alternating sign.

Thue, 100 bytes
@::=:::
>##::=>$.
$::=~I hate that I love
>.#::=>&#
&::=~that
>#<::=~I hate it.
>.<::=~it.
::=
>@<

Takes input as unary. (A string of n #s)

Pyke, 36 bytes
2/"I hate ""I love "]*"that "J"it."+

Try it here!
2/                                   -    input/2
                     *               -   ^ * v
  "I hate ""I love "]                -    ["I hate ", "I love "]
                      "that "J       -  "that ".join(^)
                              "it."+ - ^+"it."

Also 36 bytes
12*5+.daෆ   ű   l5d+12"I ":Q*<"it."+

Try it here! (Link uses X instead of I, this should work for the same amount of bytes offline where you can literally use those bytes. Online \r gets automatically replaced with \n)

><> (Fish), 82 Bytes
' I'oov.2coo<;oooo' it.'<
'ahv'v>'et'
oop26<^ooooo^o' that I '^!?:-1oo
'ol^'^>'ev'

Doubt it's very efficient, but it seems to more or less work. Input is via the starting stack, which makes the score 85 Bytes if you include the size of the -v argument required to do so.
Try it online!

R, 92 90 bytes
An R adaptation of @Leaky Nun's python answer. Working with strings in R is tedious as always.
n=scan();cat(rep(strsplit("I hate that I love that ","")[[1]],n)[6:(n*12)-5],"it.",sep="")

This could probably be golfed further though.
Edit: saved 2 bytes by changing:
[1:((n*12)-5)]to [6:(n*12)-5]

It works out better to loop instead; see my alternative R solution.

C, 96 Bytes
c;f(i){printf("I hate");for(;c<i+1/2-1;c++)printf(" that I %s",c&1?"hate":"love");puts(" it.");}

I didn't see the above solution from Releasing Helium Nuclei which is better.

MATL, 37 bytes
:"2@o3]Qv'hate I that it. love'Ybw)Zc

Try it online!
Explanation
The code is based on the following mapping from numbers to strings:
0: 'love'
1: 'hate'
2: 'I'
3: 'that'
4: 'it.'

The program pushes numbers to the string in groups of three: 2, 0, 3; then 2, 1, 3; then 2, 0, 3; ... as many times as the input n. After that, the final 3 is transformed into a 4, the mapping is applied to transform numbers to strings, and the strings are joined using space as separator.
:                         % Input n implicitly. Push range [1 2 ... n]
"                         % For each
  2                       %   Push 2
  @o                      %   Iteration index modulo 2: pushes 0 or 1
  3                       %   Push 3
]                         % End
Q                         % Add 1 to the last 3
v                         % Concatenate stack contents into a numeric column vector
'hate I that it. love'    % Push this string
Yb                        % Split at spaces. Gives a cell array of five strings
w                         % Swap to move numeric vector to top
)                         % Index cell array of strings with that vector. Indexing
                          % is 1-based and modular, so 0 refers to the last string.
                          % This gives a cell array of (repeated) strings
Zc                        % Join those strings by spaces. Display implicitly

JavaScript (ES6), 68 bytes

f=(n,i)=>n?(i?' that I ':'I ')+(i&1?'love':'hate')+f(n-1,-~i):' it.'

document.write('<pre>'+[ 1, 2, 3, 4, 10, 100 ].map(c=>c+': '+f(c)).join`\n`);

///, 68 bytes
/@/1\/#love //%/hate//#/that I //%1i/% i//I %1/I % //1@#% //@/I %1it.

Input in unary - add more 1s in the last section.
Try it online!

dc, 75 bytes
?[1-lbP[I lov]P]sa[e that ]sb[[e it.]Pq]sc[1-[I hat]Pd2%1=ad1>clbPlxx]dsxx

We're really just printing one chunk of string at a time here, and not leaving any garbage on the stack. This is great, we don't need to waste any bytes dealing with a register for our counter.
?                              #Input, works as our decrement counter
[1-lbP[I lov]P]sa              #Macro 'a' decrements our counter, prints string 'b',
                               #then prints 'I lov'
[e that ]sb                    #String 'b'
[[e it.]Pq]sc                  #Macro 'c' prints the tail end of our message and quits
[1-                            #I'll unfold our main macro here; first step is to
                               #decrement our counter
   [I hat]P                    #We always start by hating 'it,' no conditional needed
           d2%1=a              #Check the oddness of our counter; execute 'a' if odd
                 d1>c          #Check our counter; If we're done, execute 'c'
                     lbPlxx]   #Otherwise, print 'b' again and start this macro ('x') over
dsxx                           #Stores the above macro as 'x' and runs it.

Julia, 91 Bytes
Thought I add a julia solution:
f(N)=string("I hate ",join(["that I love that I hate " for _ in 1:N-1])[1:12*(N-1)],"it."))


text:
Climbing binomial tree to find the option value
Background:
In finance, the binomial options pricing model (BOPM) is the simplest technique used for option pricing. The mathematics behind the model is relatively easy to understand and (at least in their basic form) it is not difficult to implement. This model was first proposed by Cox, Ross, and Rubinstein in 1979. Quoting Wikipedia:

The binomial pricing model traces the evolution of the option's key underlying variables in discrete-time. This is done by means of a binomial lattice (tree), for a number of time steps between the valuation and expiration dates. Each node in the lattice represents a possible price of the underlying at a given point in time.
Valuation is performed iteratively, starting at each of the final nodes (those that may be reached at the time of expiration), and then working backwards through the tree towards the first node (valuation date). The value computed at each stage is the value of the option at that point in time.

For this challenge's sake, we will create a simple model to predict potential future prices of the option(s) by creating a lattice or a tree as shown below (a picture is worth a thousand words):

where S is the option price today, p is the probability of a price rise, and t is the period of time or number of steps.
Challenge:
The challenge is to write either a program or a function which take S, p (in percent), and t as the inputs and give the binomial tree as the output. The output of the program or the function must follow the format above, but the boxes and the arrow lines are optional. For example, if the program take inputs S = 100, p = 10%, and t = 3, then its output may be in the following simple form:
                        133.1
                121
        110             108.9
100              99
         90              89.1
                 81
                         72.9

General rules:

This is code-golf, so the shortest answer in bytes wins the challenge.
Don't let esolangs discourage you from posting an answer with regular languages. Enjoy this challenge by providing an answer as short as possible with your programming language. If you post a clever answer and a clear explanation, your answer will be appreciated (hence the upvotes) regardless of the programming language you use.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/ method with the proper parameters, full programs, etc. The choice is yours.
Using a binomial tree built-in is forbidden.
If possible, your program can properly handle a large number of steps. If not, that will just be fine.

References:

Binomial options pricing model
Binomial tree option calculator

Just for the sake of precision, aren't the formula more (1+p).S, (1+(1-p)).S  at T1, (1+p²).S, (1+(p.(1-p))).s and (1-(1-p)²).s at T2 and so on?

@Sefa I apologize for the mistake I made. I've already edited to fix the issue accordingly.

10% is not a valid number in many languages. Are we to take in 0.1 or 10 for 10%?

@LeakyNun I read "(in percent)" in it's true meaning which would mean 0.1 is 10%.

I think p is the probability of a price rise should be p is the **percentage** of a price rise.

Python, 168 167 bytes
q=lambda s,p,t:'\n'.join(''.join('%e'%(s*(1+p)**(c-(r+c-t)//2)*(1-p)**((r+c-t)//2))if(t-c<=r<=t+c)&(r%2^(c+~t%2)%2)else' '*12for c in range(t+1))for r in range(2*t+1))

Test case with anonymous function above assigned to f would be print(f(100,0.1,3)), yielding:
                                    1.331000e+02
                        1.210000e+02
            1.100000e+02            1.089000e+02
1.000000e+02            9.900000e+01
            9.000000e+01            8.910000e+01
                        8.100000e+01
                                    7.290000e+01

Extending the same to t=4 would be print(f(100,0.1,3)), yielding:
                                                1.464100e+02
                                    1.331000e+02
                        1.210000e+02            1.197900e+02
            1.100000e+02            1.089000e+02
1.000000e+02            9.900000e+01            9.801000e+01
            9.000000e+01            8.910000e+01
                        8.100000e+01            8.019000e+01
                                    7.290000e+01
                                                6.561000e+01

For the avoidance of scientific notation while keeping at least 3 significant figures we can use the following 211 byte code instead:
lambda s,p,t:'\n'.join(''.join('%12s'%(v and(10**5>v>.0001and'%f'%v or'%e'%v)or'')for v in[(t-c<=r<=t+c)&(r%2^(c+~t%2)%2)and s*(1+p)**(c-(r+c-t)//2)*(1-p)**((r+c-t)//2)for c in range(t+1)])for r in range(2*t+1))

Test case, print(f(100,0.1,3)) yields:
                                      133.100000
                          121.000000
              110.000000              108.900000
  100.000000               99.000000
               90.000000               89.100000
                           81.000000
                                       72.900000

then when numbers get too big or small, for example print(f(9876.000123,0.99,6)):
                                                                        6.133375e+05
                                                            3.082098e+05
                                                1.548793e+05             3082.098178
                                    77828.796693             1548.793054
                        39109.948087              778.287967               15.487931
            19653.240245              391.099481                7.782880
 9876.000123              196.532402                3.910995                0.077829
               98.760001                1.965324                0.039110
                            0.987600                0.019653                0.000391
                                        0.009876                0.000197
                                                9.876000e-05            1.965324e-06
                                                            9.876000e-07
                                                                        9.876000e-09

Is this a valid output format?

@Adám I don't see why not, the values are clearly separated, readable and in a deterministic order, the question has no output format specification and the example states "may". I'll add more code if need be though -  Anastasiya-Romanova?

I understand The output of the program or the function must follow the format above, but the boxes and the arrow lines are optional to mean that the 2D layout must remain.

@Adám yes you may well be correct!

You alignment will be even worse with S=100, t=5, p=0.5.

@Adám and it also had a bug with the actual values and their positions! Not doing great here... :p Although print(f((100, 0.5, 5)) is fairly readable - but print(f(10000,.9,10)) really starts to get wavy.

Though the format number is not like I expected but your answer deserves a (+1)

@Anastasiya-Romanova秀 If I find a 'nice' way to align everything without resorting to %e I will update it!

@Anastasiya-Romanova秀 I've added longer code that will fall over to scientific notation while keeping 3 significant figures.

Dyalog APL, 60 56 bytes
Needs ⎕IO←0 which is default on many systems. Prompts for S then t then p.
⍉{⍵⌽⍨-⌽⍳≢⍵}↑{⍵\⍨0 1⍴⍨2×≢⍵}¨⍕¨¨⎕{⍵,⊂∪∊(⊃⌽⍵)∘.×1+⍺,-⍺}⍣⎕⊢⎕

Over 50% of the code is to get the right display form.
TryAPL online! (]Box off for proper display – the default on installed systems – emulated here using ⍕.)
Example run:
                133.1
           121
      110       108.9
 100       99
      90        89.1
           81
                72.9

How do I insert the inputs there?

If you run it on a regular system, it will prompt you for S, t, and p (e.g. 0.1) – in that order. If you use TryAPL, you will need to press UpArrow to recall the previous statement, then edit the line right after ∆←.

Ah, it works like R. Unfortunately, it only handles 11 steps. But it's OK. Well done. (+1)

Why do you say so? TryAPL chops output to avoid scrolling, but a real APL system doesn't. You can download it for free here.

I said so because when I input the number of steps 12, the format breaks. R also uses Up Arrow to show the previous code. Thanks for the offer, though it's a good programming language but I'm not interested in learning APL

FYI, here are just the final values for t = 18.

R, 288 bytes
x=scan()
M=Map
U=rbind
noquote(t(do.call(U,M(function(x,y){r=rep;c(r(" ",x),rev(as.vector(U(y,r(" ",length(y))))),r(" ",x))},as.list(x[3]:0),M(function(x,y){sapply(y,function(y)(1-x[2])^y[1]*(1+x[2])^y[2]*x[1])},list(x),lapply(0:x[3],function(y)data.frame(do.call(U,list(y:0, 0:y)))))))))

Sometimes I feel like I'm not even golfing. The maximum t is limited by the amount of system memory. The readability of output is determined by the resolution of your screen/console size.  If we write to file instead, the readability limitations can be bypassed. I was able to run t = 5000, 100, 0.1 on my 16GB ram system; the output is 400+ mb plain text file.
      [,1] [,2] [,3] [,4]  [,5]   [,6]    [,7]     [,8]      [,9]       [,10]            [,11]            [,12]
 [1,]
 [2,]                                                                                285.311670611
 [3,]                                                                                259.37424601
 [4,]                                                                   235.7947691                       233.436821409
 [5,]                                                        214.358881                  212.21529219
 [6,]                                              194.87171            192.9229929                       190.993762971
 [7,]                                     177.1561           175.384539                  173.63069361
 [8,]                             161.051          159.44049            157.8460851                       156.267624249
 [9,]                      146.41         144.9459           143.496441                  142.06147659
[10,]                133.1        131.769          130.45131            129.1467969                       127.855328931
[11,]           121        119.79         118.5921           117.406179                  116.23211721
[12,]      110       108.9        107.811          106.73289            105.6655611                       104.608905489
[13,] 100       99         98.01          97.0299            96.059601                   95.0990049900001
[14,]      90        89.1         88.209           87.32691             86.4536409000001                  85.5891044910001
[15,]           81         80.19          79.3881            78.594219                   77.80827681
[16,]                72.9         72.171           71.44929             70.7347971000001                  70.027449129
[17,]                      65.61          64.9539            64.304361                   63.66131739
[18,]                             59.049           58.45851             57.8739249                        57.295185651
[19,]                                     53.1441            52.612659                   52.08653241
[20,]                                              47.82969             47.3513931                        46.877879169
[21,]                                                        43.046721                   42.61625379
[22,]                                                                   38.7420489                        38.354628411
[23,]                                                                                34.86784401
[24,]                                                                                31.381059609

t = 5000;

Nice answer. I love R. (+1)