text:
Grow Till It's 2017
In this challenge you'll be building a program that grows as it traverses through the ages… Until it's 2017.
Challenge
Whenever this challenge description says “program”, you can also read “function”.
Your submission, when executed, will output a program that is THE LENGTH OF YOUR SUBMISSION + 1 bytes long.
When that program is executed, it will output a program that is THE LENGTH OF YOUR SUBMISSION + 2 bytes long… and so on.
However, when your program has reached a length of 2017 bytes, it must instead output 2017 and exit.
Rules

The output of the final program has to be 2017 and only 2017. It can be a string or an integer, but it must read 2017 and not 2017.0 or 0x7E1 or other such nonsense.
No standard loopholes.
Only your initial program is allowed to require input, which will be added to your bytecount.So if your initial program is 324 characters long and takes an input of 13 bytes, your total score will be 324 + 13 = 337 and the program outputted by it must be 338 bytes long.

Using command line flags (e.g. perl -X) is fine, however – as long as your initial program as well as all generated programs use the same flags.  Also, they too count towards the total bytecount. Dashes, slashes etc. in front of a command line flag don't count towards the total, so e.g. perl -X counts as one additional byte.

If you return a function, it should be an actual function and not a string that, when evaluated, produces a function.
Improper quines (if your program is a quine) are disallowed.

Example

Pseudocode, 99 bytes
IF (PROGRAM LENGTH == 2017)
  PRINT 2017
ELSE
  PRINT (THE SOURCE OF THIS PROGRAM + 1 BYTE PADDING)

Your submission may work differently, as long as it complies with the rules above.

Is just appending NOPs such as ;;; allowed?

@FlipTack Yes.·

"Dashes, slashes etc. in front of a command line flag don't count towards the total, so e.g. perl -X counts as one additional byte." -- Is this intentionally contrary to the norm here as described on Meta? Normally, dashes, slashes, etc. should sometimes be counted, depending on what the invocation without that option looks like: http://meta.codegolf.stackexchange.com/questions/273/on-interactive-answers-and-other-special-conditions

@hvd Don't think I read that one, so no, it's not intentional. That said, I don't think there is much harm in ignoring them so I won't change it for this challenge.

*><>, 29 28 30 bytes
" r::2+l'-':*7-(?ul1-n;Ol?!;ou

Try it here! (*try with 2017 bytes)
*set delay to 0ms or you might have to wait a long time
This adds an additional  each subsquent run. If it has 2017 bytes and is run, it will output 2017 and stop execution with no other output.
Update: Saved 1 byte by checking if the length is less than 2017 instead of equal
Update 2: Fixed output for +2 bytes
Explanation
" r: 2+                         build quine
    :                           copy extra " "
       l                        push length to stack
        '-':*7-                 push "2018" to stack
               (?u     O        if not length < 2018:
                  l1-n;           output length-1 and exit
                       Ol?!;ou  output entire stack and exit

yeah, not quite right when your program has reached a length of 2017 bytes, not 2016

@DestructibleWatermelon fixed

Python 2.7, 90 bytes
Here's a relatively simple one:
p='q';s=r"p+='q';print('p=\''+p+'\';s=r\"'+s+'\";exec s')if len(p)<1929 else'2017'";exec s

Try the first iteration here! Try the penultimate iteration here! Try the final iteration here!
Ungolfed:
p='q'      # The length of string p is the number of iterations so far.

s=r"p+='q';print('p=\''+p+'\';s=r\"'+s+'\";exec s')if len(p)<1928 else'2017'"

exec s     # s contains the source code, but also contains a line saying "p += 'q'",
           # which makes the byte count longer. When the length of p is 1928 (i.e. when the
           # entire program is 2017 bytes long), 2017 is printed instead.

@redstarcoder The final iteration has exactly 2017 characters. You can see the byte count in the upper right corner I think....

Ah my mistake, not sure how that happened, sorry!

You can use p='';... and 1929else, but note that the printing also prints a newline at the end, so you should add a trailing newline to your program, else it grows two bytes after the first run.

Microscript II, 38 bytes
{v{h}sl+s""+vK#s2017=(2017ph)lp"~"ph}~

C, 197 Bytes
#define A ""
char*s="#define A %c %s%c%cchar*s=%c%s%c;%cmain(){printf(sizeof A==1820?%c2017%c:s,34,A,34,10,34,s,34,10,34,34);}";
main(){printf(sizeof A==1820?"2017":s,34,A,34,10,34,s,34,10,34,34);}

><>, 34 bytes
":l' '95**)b*f3++0.1-}'#'r>o<:ln;#

Try it online! Note that, in order to test this for smaller values, your value (minus 1) must be able to be generated in 7 bytes.
Explanation
":l' '95**)b*f3++0.1-}'#'r>o<:ln;#
".................................   push this string
 :                                   duplicate
  l                                  push length of stack
   ' '95**                           push 2016
          )                          1, if length > 2016, 0 otherwise
           b*                        multiply by 11
             f3++                    add 18
                 0.                  jump to that character on this line
                                     if the length is sufficiently long, this skips the
                                     next 10 characters, to the 11th (`b` from earlier):
                             :ln;    (if length is > 2016)
                             :         duplicate
                              l        push length
                               n       output as number
                                ;      terminate
                   1-}'#'r>o<        (if length <= 2016)
                   1-                  subtract 1 from the last char, `#`, to get `"`,
                     }                 which is then moved to the bottom
                      '#'              pushes `#` (will be appended)
                         r             reverses the stack
                          >o<          output stack, until error (accepted by default)
                                 #   This is never reached, but is used to generate `"`

Java, 251 Bytes (Eclipse IDE)
import java.io.*;class G{public static void main(String[]args) throws Exception{File x=new File("./src/G.java");if(x.length()==2017){System.out.print("2017");}else{PrintWriter y=new PrintWriter(new FileOutputStream(x,1>0));y.print("A");y.close();}}}//

This is assuming the project was made in Eclipse, using the convention of .java files in the SRC of the working dir. There are other ways to detect where the source is, but I don't think this is against the rules either.
Basically opens the .java source-code, and appends As until 2017 (after a comment). When the file-size of the source reaches a total of 2017 bytes, it will instead print 2017.

CJam, 39 33 30 bytes
33q:X~

with the input
2017:N=N{33')X+`":X~"+}?

Try it online!
This is functionally equivalent to my previous version, except that it avoids the need to write and escape the quotes. The previous version:
33"2017:N=N{33')X+`\":X~\"+}?":X~

Which outputs
33")2017:N=N{33')X+`\":X~\"+}?":X~

which outputs
33"))2017:N=N{33')X+`\":X~\"+}?":X~

and so on. Finally, the program
33"))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))2017:N=N{33')X+`\":X~\"+}?":X~

Outputs 2017.
How it works
33      Push 33
  q     Read the input: 2017:N=N{33')X+`":X~"+}?
   :X   Store it in variable X
     ~  Eval it

But what does the code in the input actually do?
 2017:N                      Push 2017 and store it in N
       =                     Check if the other number (33 on first run) equals 2017
        N                     If it does, push 2017
         {                    Else, execute this block:
          33                   Push 33
            ')                 Push the ) character
              X                Push X
               +               Concatenate with ')
                `              String representation (wraps it in quotes, escapes quotes inside)
                 ":X~"       Push the string ":X~"
                      +      Concatenate
                       }?    (end of block)

If the first number of the program isn't equal to 2017, then it will output a program in which that number is incremented one more time than it was this time. If it does equal 2017 (i.e. it's been incremented 1984 times), then simply push 2017 and terminate. The first number starts out as 33 (the length of the code); every increment increases the code length by 1 AND that number by 1, so when 33 has been incremented enough to become 2017, the code will also be 2017 bytes long.

Python 2, 217 167 78 bytes
Note that there should be a trailing newline. I used similar concepts to what  Calconym used, so thanks for the inspiration!
p='q';s='p+=p[0];print"p=%r;s=%r;exec s"%(p,s)if len(p)<1941else 2017';exec s

Try it online
Try at 2016; Try at 2017

Previous Version:
This program uses the inspect module to get the current line number. Then, it prints itself but with an extra line after the import, which changes the line number for the next program. There should also be a trailing newline here.
from inspect import*
n=stack()[0][2];s='from inspect import*%sn=stack()[0][2];s=%r;print(s%%(chr(10)*n,s))if n<1852else 2017';print(s%(chr(10)*n,s))if n<1852else 2017

Try it online

JavaScript, 98 83 bytes
That was quite a challenge… Guess that's what I get for requiring actual functions to be returned and not just the function's source.
Original function
function x(){return "3".length>1933?2017:Function(`return ${x}`.replace(/3/,33))()}

I'm using function instead of => here because the latter doesn't support named functions, just assigning anonymous functions to a variable.
First iteration
Running the above in your browser console returns a function that, when cast to a string, looks like:
function x(){return "33".length>1933?2017:Function(`return ${x}`.replace(/3/,33))()}

Getting to 2017
Since every function returns a new function, you can call the original function / its result 1934 times to get 2017.

console.log((
function x(){return "3".length>1933?2017:Function(`return ${x}`.replace(/3/,33))()}
)()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()
)

Tested with Firefox.


text:
Print the current time… taking leap seconds into account

(Note: although related, this challenge is not a duplicate of this one because it requires determining leap seconds automatically rather than hardcoding their times, and is not a duplicate of this one because most of the difficulty comes from determining the time without leap second skewing, something that most time APIs don't do by default. As such, a solution is likely to look different from a solution to either of those challenges.)

We're coming to the end of 2016, but it's going to take slightly longer than most people expect. So here's a challenge celebrating our extra second this year.
Output the current time in UTC, as hours, minutes, seconds. (For example, legitimate output formats for midday would include 12:00:00 and [12,0,0]; the formatting isn't massively important here.)
However, there's a twist: your program must handle leap seconds appropriately, both past and future. This means that your program will have to obtain a list of leap seconds from some online or automatically updated/updatable source. You may connect to the Internet to obtain this if you wish. However, you may only connect to a URL that predates this challenge (i.e. no downloading parts of your program from elsewhere), and you may not use the connection to determine the current time (specifically: your program must function even if any attempt to access the Internet returns a page that's up to 24 hours stale).
Most operating systems' default APIs for the current time will skew time around leap seconds in order to hide them from programs that might otherwise be confused. As such, the main difficulty of this challenge is to find a method or an API to undo that, and work out the true unmodified current time in UTC.
In theory, your program should be perfectly accurate if it ran on an infinitely fast computer, and must not intentionally take more than zero time to run. (Of course, in practice, your program will run on an imperfect computer, and so will probably not run instantaneously. You don't have to worry about this invalidating the results, but must not depend on it for the correctness of your program.)
Your program must function regardless of which timezone the system clock is set to. (However, it may request information from the operating system or environment as to what timezone is being used, and may assume that the reply is accurate.)
As a code-golf, the shortest program wins. Good luck!

Let us continue this discussion in chat.

PowerShell, 161 bytes
(('{0:H:m:s}','23:59:60')[(($d=[datetime]::UtcNow).Ticks-6114960*98e9)/1e8-in((irm ietf.org/timezones/data/leap-seconds.list)-split'[^@]	|
'-match'^\d{9}')])-f$d

Try it online! (doesn't work here, it seems that TIO doesn't recognize irm and iwr, maybe it's a security feature?)
Logic Test (Hardcoded Date):
(('{0:H:m:s}','23:59:60')[(($d=[datetime]'1/1/2017 00:00:00').Ticks-6114960*98e9)/1e8-in((irm ietf.org/timezones/data/leap-seconds.list)-split'[^@]	|
'-match'^\d{9}')])-f$d

Notes
There is a literal TAB and a literal linebreak (0xA) in the regex string, so that I didn't have to escape them (saved 1 byte each).
Explanation
The times given (of the leap seconds) in the ietf file are in seconds since NTP epoch which is 1/1/1900 00:00:00. On Windows, a "tick" is simply one ten-millionth of a second (10,000,000 ticks/sec).
If you add an integer to a [datetime] it counts the integer value as ticks, so I'm using the hardcoded tick value of NTP epoch, then subtracting it from the tick value of the current UTC time (the original value of which is simultaneously being assigned to $d).
To make that hardcoded tick value smaller, I took away some zeros (9 of them) and divided by 98, then multiply by 98e9 (98*109).
The result of that subtraction is the value in ticks since NTP epoch. That gets divided by 1e8 (not 1e9, for reasons that will be clear in a moment) to get the value in seconds (sort of) since NTP epoch. It will be smaller by a factor of 10, actually.
Retrieving the document from the IETF, rather than split it into lines first, then process the lines with the timestamps, I decided to split on both line breaks and on TAB characters, since that's what comes after the timestamp. Because of a single errant line in the file, that alone would include an additional timestamp we don't want. The line looks like this:
#@	3707596800
So I changed the regex to split on [^@]\t (any character that's not @ followed by a TAB) which works to exclude that line, but also ends up consuming the last 0 in each of the timestamps.
That's why I divide by 1e8 and not 1e9, to account for the missing 0.
The current timestamp is checked to see it exists inside the list of neutered leap second timestamps. This whole process I described is inside the array accessor [], so the resulting [bool] value gets coalesced to a 0 ($false) or 1 ($true). The array we're indexing into contains two elements: a format string for displaying the time, and a hardcoded 23:59:60. The truthiness of the aforementioned comparison determines which one will be chosen, and that is fed into the format operator -f with the previously assigned current date $d as its parameter.

What does this print the second after a leap second? I can follow the logic for leap seconds, but not sure I can follow the logic for times either side. (Does Windows naturally display both a leap second and the following second as 00:00:00?)

@ais523 it will display the second after the leap second as whatever the system time is. Windows doesn't know about leap seconds, so the clock will be 1 second fast until corrected by a sync or manual setting. Given the requirements I can't really adjust for that, since it's not possible to determine whether the system time is correct or not without using an external time source, which is banned. About the best I could do is add code to this that forces NTP sync after it has printed the time, which of course could fail (network error, no time source set, etc.), if that's even allowed.

source: Stack Exchange

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

sort: votes


text:
<("<) Bird Dancer (>")>
Your bird has been itching for some exercise and is sick of being stuck in static positions all the time. Write a program that will show a randomly dancing ascii bird, updating every 100ms*n or 200ms*n depending on the dance move. The bird always begins with the dance move <(")>.
The program should accept one input which is a number to multiply the sleep interval by (n >= 0 && n <= 50).
100ms Moves
^(")v
v(")^
^(")^
v(")v

200ms Moves
(>")>
<(")>
<("<)

Extra Details

Randomness doesn't have to be uniform but each dance move should have a reasonable chance of occuring (at least 1 in 60 seems fair, it's OK if the same move occurs twice in a row)
There should only be one bird displayed at a time, not multiple birds
Trailing whitespace is allowed (but other trailing characters are not)
A bird should be displayed before the sleep

Example in Python 3
import random, time, sys

birds = """(>")>
<(")>
<("<)
^(")v
v(")^
^(")^
v(")v"""
birds = birds.split()

interval = int(input("Sleep for 100ms*"))
selection = -1

while True:
    if selection == -1:
        selection = 1
    else:
        selection = random.randint(0, len(birds)-1)
    sys.stdout.write('\r'+birds[selection])
    if selection > 2:
        time.sleep(0.1*interval)
    else:
        time.sleep(0.2*interval)

Winning

This is code-golf so least bytes wins!

Are the bird's eyes a double quote or two single quotes?

@Pavel, double quote

Well, today I learned you don't have to escape quote marks in multi line strings in python.

If my language can't modify outputs, can I just output a new bird every 100/200 ms?

@devRicher sorry the point is specifically to replace the output. Can't you just output a carriage return?

Using Ideone, the Lua \r escape seems to act just like a \n. Neither can I use os.execute("cls") there. @redstarcoder

@devRicher, what about the regular Lua interpreter?

@redstarcoder I tried, but \r works as a newline here too, and cls just gives me the FF control character.

@devRicher, print("hello\rworld") seems to work fine for me Lua 5.3.3.

@redstarcoder That might be the problem, I'm using 5.1.

Is it OK if two consecutive moves randomly happen to be the same? Or given the current move do we have to choose among the other six?

@LuisMendo it's OK if two consecutive moves happen to randomly be the same. I'll try to clarify this in the post when I wake up a bit

MATL, 53 bytes
xXx`'./U;HbG#3@@!{uu'F'v^<>(")'Za7e 7YrY)D5M3>QG*&XxT

Moves are uniformly random.
Below is a sample run withn = 2. Or try it at MATL Online! (The interpreter is experimental. If it doesn't run initially try pressing "Run" again or refreshing the page).

Explanation
x                   % Take input n and delete it
Xx                  % Clear screen
`                   % Do...while
  './U;HbG#3@@!{uu' %   Push this (compressed) string
  F                 %   Specify source alphabet for decompression
  'v^<>(")'         %   Push target alphabet
  Za                %   Base conversion (decompress)
  7e                %   Reshape as a 7-row char matrix. Each row is a move
  7Yr               %   Push random integer from 1 to 7
  Y)                %   Select that row from the char matrix
  D                 %   Display it
  5M                %   Push the integer again
  3>                %   Does it exceed 3? Gives false (0) or true (1)
  Q                 %   Add 1
  G*                %   Multiply by n
  &Xx               %   Pause that many tenths of a second and clear screen
  T                 %   Push true
                    % End (implicit). Since top of the stack is true, this causes
                    % and infinite loop

Matlab,  125 117 bytes
Unfortunately this cannot be displayed in TIO as there is no "streaming" of the output. Here's a gif for an input of 1 instead:

t=input('')*.1;a='^(")vv(")^^(")^v(")v(>")><(")><("<)';while 1;n=randi(7);clc;disp(a(n*5-4:n*5));pause(t+t*(n>4));end

Thanks @LuisMendo for -8 bytes!

*><>, 103 101 bytes
<vD[3'(")'
1x<.5
S\:43_C43CdooI:o@:o@:o@Do
R!"^"x"v">
>:2* _"><"92.
x '>)">('u.02S*2:oooooodO<'<("<)'

Try it here! (write in n on the initial stack or you'll get an error)
I decided to take a stab at my challenge since there were no sub 100 bytes answers. Place n on the stack and away you go! This reuses the (") characters to save some bytes.
Explanation
Initialisation
<vD[3'(")'
Here we store (") for later usage.
<           move the IP left
   [3'(")'  push '(")' to a new stack
  D         move back down to a clean stack
 v          move the IP down into "dance chooser"

Dance chooser
1x<.5
 \

This is frequently executed to select which type of dance we're going to generate.
 x         generate a 100ms dance or a 200ms dance
1  .5      jump to "200ms dance"
 \         mirror IP into "100ms dance"

There's a v above the x and a < to the right of it too. These make the x get re-executed if it tries to move the IP in the wrong direction.
Generate 100ms dance
S\:1*43_C43CdooI:o@:o@:o@Do

Here we generate and output one of the 100ms dance moves.
 \                         mirror the IP right
  :                        copy n
   43 C43C                 call "generate '^' or 'v'" twice
     _                     ignored mirror
          do               output a carriage return
            o              output the first hand of the bird
             I:o@:o@:o@D   select, copy, and output '(")'
                        o  output the second hand of the bird
S                          sleep for previous n*100ms
 \                         mirror IP back to "dance chooser"

43C - Generate "^" or "v"
R!"^"x"v">

This is a simple function that generates "^" or "v" then returns. It works similarly to the dance chooser where it has instructions around x to ensure the IP only moves left or right.
     x      generate "^" or "v"
R!"^"    >  push "^" to stack and return
R     "v"   push "v" to stack and return

Generate 200ms dance
This is another that begins with x. It'll be separated into two sections: <(")> and another (>")> and <("<), because they're two distinct sections and x is the only thing they share.
<(")>
>:2* _"><"b2.

This basically does the beginning of the generate 100ms dance routine, but populates the bird hands as >< instead of a random ^v combo. It multiplies n by two this time as well. This makes it all setup to utilise the generate 100ms dance routine to output the entire bird and wait 200ms instead.
>              move IP right
 :2*           copy n and do n*2
     _         ignored mirror
      "><"     push "><" to stack
          b2.  jump to "output carriage return" in "generate 100ms dance"

(>")> and <("<)
x '>)">('u.02S*2:oooooodO<'<("<)'

This little explanation is about the (>")> and <("<) generation, though the x can send the IP outside of it (explained below).
x                                  move to "choose dance", generate (>")>, <("<), or <(")> (previous routine)
  '>)">('                          push '(>")>' to the stack
                          '<("<)'  push '<("<)' to the stack
         u              O<         ensure inner code block is always executed with IP moving left
                      od           output carriage return
                 ooooo             output bird
             S*2:                  sleep for n*200ms
          .02                      jump to "dance chooser"

JavaScript (ES6) + HTML5: 118 116 + 8 = 124 bytes
Javascript: 119 bytes
f=n=>{a.innerHTML='(>")>0<(")>0<("<)0^(")v0v(")^0^(")^0v(")v'.split(0)[r=+new Date%7],setTimeout(f,(1+(r<3))*100*n,n)}

I'm using the milliseconds since epoch to generate a random-ish number. Theoretically, this would always generate the same (set of) number(s), but a test on my PC gave me a pretty random outcome (most numbers appeared more or less equally). Also using the fact that html elements with an id get added to the global window object in JavaScript, so document.getElementById() is not needed.
HTML: 8 bytes

I'm omitting the quotes here and I'm not closing the b tag. It's not valid html, but all browsers automatically close the tag anyway. I made it bold because b is a one-character HTML element and because my bird's dance deserves being noticed.

When f re-calls itself, it doesn't pass n again. For me at least this seems to only honour n the first time, after which it's zero (or undefined). Also sometimes the output is undefined. Should it be r%7?

You're right, I forgot to pass n. It should indeed be %7. I miscounted the amount of bird poses. Thanks for the correction, it's fixed now.

Sorry I keep increasing your byte counts! Cool golfing, I like the random function and zero splitting

Thanks. I found a 4B improvement while editing my answer, which meant I ended up saving 2B, so it's all right. The zero splitting used to save bytes in ES5 and earlier, but you can omit the parentheses with template strings since ES6, so it's not as useful anymore. It is a remainder from a different approach (where I used a template string as first argument for the setInterval).

PowerShell, 124 117 bytes
(Thanks TimmyD)
for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls}

Try it online! (Not that it will work in TIO...)

You can eliminate $b and use a pseudo-ternary to get down to 117 -- for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls} ... I think shorter is possible; I'm still poking at it.

You just keep bailing me out @TimmyD (thanks)! I think those changes are significant enough to warrant your own answer; it doesn't leave much of anything unique in my code :)

No, they're just minor tweaks on your code. The overall logic is the exact same. Have at it.

Noodel, noncompeting 67 bytes
ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð
ḊḢðḞ’ṀḌcṀḌcİ8c¬ððɲḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ

This challenge was very difficult for Noodel because it does not have any smart arithmetic or comparative based operators. But after doing this challenge, I think Noodel is ready for its first release.
Try it:)
How It Works
                                                                     # Note: The input is immediately pushed onto the stack.
ʠ                                                                    # Moves the pointer for the top of the stack down one.
 ƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð                                      # Creates a string based off of the key "ƘṣḳƑðẉḤż" and the compressed text "ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð" to create "^(")vðv(")^ð^(")^ðv(")vð(>")>ð<(")>ð<("<)" which then gets split by the null character "ð" to create an array of strings which gets pushed to the stack.
                               \n                                    # A new line to separate the literals.
                                 ḊḢðḞ’ṀḌcṀḌcİ8c¬ðð                   # Creates a string based off of the key "ḊḢðḞ" and the compressed text "ṀḌcṀḌcİ8c¬ðð" to create "100ð100ð100ð100ð200ð200ð200" which then gets split the same way as before.
                                                  ɲ                  # Turns each element in the array into a number creating the array of delays.
                                                   ḷ                 # Loops the rest of the code unconditionally.
                                                    ṛ                # Generates a random number from 0 to the length-1 of the array on top of the stack.
                                                     ḋ               # Duplicates the random number.
                                                      ʠ              # Moves the stack pointer down to save one of the random numbers for later.
                                                       ṡ             # Swap the array with the random number such that the array is on top again.
                                                        ʠ            # Moves the stack pointer down such that the random number is on top.
                                                         ạ           # Uses the random number to access the bird array which is now after the random number and pushes the element onto the stack.
                                                          Ç          # Clears the screen and pops the bird and pushes it to the screen.
                                                           ƥƥ        # Moves the stack pointer up two times such that the random number is the top.
                                                             ạ       # Use the random number to access the array with delays and pushes that item onto the stack.
                                                              ƥ      # Moves the stack pointer up in order to have the input on top.
                                                               ḋ     # Duplicates the users input.
                                                                ʠ    # Moves the stack pointer back down in order to have the user input on top followed by the random item from the delay array.
                                                                 ⁺µ  # This command pops two numbers off and multiplies them and pushes the result back on.
                                                                   ḍ # Pops off of the stack and uses that as a delay in milliseconds.

64 bytes
Here is a version that works as a code snippet.
ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ

")><(")><("<)^(")vv(")^^(")^v(")v'[n:n+5]);time.sleep((.1+(n<15)/10)*m);n=(n+random.randint(1,6)*5)%35

I also tried to do it without the chicken ascii art, but that was way longer.
import time,random;n,m=5,int(input())
while 1:
  print(['^v'[n%2]+'(")'+'v^'[0<n<3],''.join(map(chr,[40+20*(n>4),62-22*(n>4),34,41+19*(n>5),62-21*(n>5)]))][n>3])
  time.sleep((.1+(n>3)/10)*m);n=(n+random.randint(1,6))%7

Ruby, 97+1 = 98 bytes
+1 byte from the -n flag.
a=1;loop{puts %w{^(")v <(")> v(")^ (>")> ^(")^ <("<) v(")v}[a];sleep$_.to_i*0.1*(1+a%2);a=rand 7}

Clojure, 185 178 bytes
+18 bytes because it wasn't starting with <(")>.
-7 bytes by inlining birds, and getting rid of the let.
#(loop[m nil r(or m 1)](print"\r"((clojure.string/split"(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v"#" ")r))(flush)(Thread/sleep(*(if(> r 2)100 200)%))(recur 1(rand-int 7)))

Just splits the birds on spaces, picks a random index from 0-6, displays the chosen bird, then if the chosen index is greater than 2, it waits for 100ms, else 200ms.
Clojure really needs a string split method in the core.
Ungolfed:
(defn dancing-bird [n]
  (loop [m nil]
    (let [birds (clojure.string/split "(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v" #" ")
          rand-i (or m 1)]
      (print "\r" (birds rand-i))
      (flush)
      (Thread/sleep (* (if (> r 2) 100 200) n))
      (recur (rand-int 7)))))

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

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


text:
Determine whether a number is 2017-friable without primes in your source code
Out of all the years I've been making this challenge, 2017 is the first year that's been a prime number. So the question will be about prime numbers and their properties.
Your task is to produce a program or function that will take an arbitrarily large positive integer as input, and output or return whether or not the number is 2,017-friable — that is, whether the largest prime factor in that number is 2,017 or less.

Some example inputs and their outputs:
1 (has no prime factors)
true

2 (= 2)
true

80 (= 2 x 2 x 2 x 2 x 5)
true

2017 (= 2017)
true

2019 (= 3 x 673)
true

2027 (= 2027)
false

11111 (= 41 x 271)
true

45183 (= 3 x 15061)
false

102349 (= 13 x 7873)
false

999999 (= 3 x 3 x 3 x 7 x 11 x 13 x 37)
true

1234567 (= 127 x 9721)
false

4068289 (= 2017 x 2017)
true

Your program does not have to literally output true and false — any truthy or falsy values, and in fact any two different outputs that are consistent across true and false cases are fine.

However, you may not use any primes in your source code. Primes come in two types:

Characters, or sequences of characters, that represent prime number literals.

The characters 2, 3, 5, and 7 are illegal in languages where numbers are valid tokens.
The number 141 is illegal because it contains 41, even though 1 and 4 are otherwise valid.
The characters B and D (or b and d) are illegal in languages where they are typically used as 11 and 13, such as CJam or Befunge.

Characters that have prime-valued Unicode values, or contain prime-valued bytes in their encoding.

The characters %)+/5;=CGIOSYaegkmq are illegal in ASCII, as well as the carriage return character.
The character ó is illegal in UTF-8 because its encoding has 0xb3 in it. However, in ISO-8859-1, its encoding is simply 0xf3, which is composite and therefore okay.

The shortest code to do the above in any language wins.

Side note: "friable" is an improvement being adopted over the old-and-undescriptive "smooth" in this context.

@GregMartin Done.

Do truthy and falsy values need to be consistent? Or can they vary as long as they are truthy or falsy?

The lack of = rules out most standard languages...

@LuisMendo They need to be consistent, yes. One output for true, another for false.

This may be handy to check if characters are prime when encoded in ASCII. Just paste your code (one line) as input. The result should be all zeros

-1 for a do X without Y challenge. It's really quite trivial hidden behind a rather unnecessary set of character restrictions

Why is tab illegal?  Its ASCII value is 9.  Are you perhaps thinking of vertical tab (11), which no one ever uses?

Yes, I meant vertical tab. Looks like I misunderstood the purpose of that character when I read about it.

@Downgoat I'm actually surprised the downvote-to-upvote ratio is so small myself. I thought given all the talk about my first New Year's Puzzle being a broken window that nobody would appreciate a challenge like this one anymore. But thankfully it seems like it's unique enough to be good, since some the answers like Dennis's are actually doing some pretty clever stuff.

I don't like the part about them being arbitrarily large. It would be better if they went up to 2^31-1.

I think the the test case 1234567 is wrong, 9721 is bigger than 2017

Congratulations. Your question now has an 11:1 upvote to downvote ratio. Before, it had a 44:3 upvote to downvote ratio. Consider changing the challenge so %)+/5;=CGIOSYaegkmq are valid when not used as the value.

Jelly, 8 bytes
44‘²!*ḍ@

Try it online! Note that test cases 11111 and above are a bit too much for TIO.
Verification
$ source="34,34,fc,82,21,2a,d5,40"
$ xxd -ps -r > 2017.jelly <<< $source
$ xxd -g 1 2017.jelly
0000000: 34 34 fc 82 21 2a d5 40                          44..!*.@
$ eval printf '"%d "' 0x{$source}; echo # Code points in decimal
52 52 252 130 33 42 213 64
$ test_cases="1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289"
$ for n in $test_cases; do printf "%11d: %d\n" $n $(jelly f 2017.jelly $n); done
      1: 1
      2: 1
     80: 1
   2017: 1
   2019: 1
   2027: 0
  11111: 1
  45183: 0
 102349: 0

Test case 999999 has been running for 13 hours. I'm pessimistic about computing 2025!4068289...
How it works
44‘²!*ḍ@  Main link. Argument: n

44        Yield 44.
  ‘       Increment to yield 45.
   ²      Square to yield 2025.
          Note that no integers in [2018, ..., 2025] are prime numbers.
    !     Take the factorial of 2025.
     *    Raise it to the n-th power.
          This repeats all prime factors in 2025! at least n times, so the result
          will be divisible by n if (and only if) all of its prime factors fall
          in the range [1, ..., 2025].
      ḍ@  Test the result for divisibility by n.

You are cruel to numbers. :)

@GregMartin bah. I've seen an answer (in a different language) where an input of size 6 would hog the memory for several hours, then crash. I'll just say: (2^n)!. This also crahes for six-sized inputs, but at least the inputs are in a decimal alphabet rather than a binary one.

Isn't this 13 bytes? Dennis you have so much reputation that I'm sure I'm the one making a mistake here hahah

@AlbertRenshaw It would indeed be 13 bytes in UTF-8, but Jelly uses a custom code page that encode all characters it understands as a single byte each.

@Dennis knew there'd be an explanation; very cool to learn about, thanks!

Jelly, 8 characters, 14 bytes of UTF-8
Æf½ṀḤ<90

Try it online!
Jelly normally uses its own codepage for programs. However, most of its prime-related builtins start with Æ, which is codepoint 13; not very helpful. Luckily, the interpreter also supports UTF-8, which has a friendlier encoding.
Verification
This program, in UTF-8, hexdumps like this:
00000000: c386 66c2 bde1 b980 e1b8 a43c 3930  ..f........<90

Verification that all the bytes are composite:
$ for x in c3 86 66 c2 bd e1 b9 80 e1 b8 a4 3c 39 30; do factor $((0x$x)); done
195: 3 5 13
134: 2 67
102: 2 3 17
194: 2 97
189: 3 3 3 7
225: 3 3 5 5
185: 5 37
128: 2 2 2 2 2 2 2
225: 3 3 5 5
184: 2 2 2 23
164: 2 2 41
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

Verification that all the Unicode codepoints are composite:
$ perl -Mutf8 -E '$a = ord, print `factor $a` for split //, "Æf½ṀḤ<90"'
198: 2 3 3 11
102: 2 3 17
189: 3 3 3 7
7744: 2 2 2 2 2 2 11 11
7716: 2 2 3 643
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

The only token parsed as a number is 90. None of 9, 0, and 90 are prime.
Explanation
The main mathematical insight here is that 45² is 2025, which neatly falls between 2017 (the current year) and 2027 (the next prime). Thus, we can take the square root of every prime factor of the number, and see if any exceeds 45. Unfortunately, we can't write 45 due to the literal 5, so we have to double it and compare to 90 instead.
Æf½ṀḤ<90
Æf        In the list of prime factors,
  ½       taking the square root of each element
   Ṁ      then taking the largest element
    Ḥ     and doubling it
     <90  produces a result less than 90.

Doesn't Jelly require a flag (1 byte) to use UTF-8?

@LuisMendo: The command-line interpreter does, but the interpreter at Try It Online! is configured differently and doesn't require it. So this is just a case of picking the interpreter that interprets your program the way you want. (In any case, the flag in question, u, is composite, so it'd just be a matter of changing the score rather than something that invalidates it.)

Mathematica, 62 58 55 bytes
The last three bytes saved are totally due to Martin Ender!
#4<4||#<44*46&&#6[#^-1#4]&[Divisors[#][[6-4]],,,#,,#0]&

Unnamed function taking a positive integer argument and returning True or False.
Recursive algorithm, with #4<4 being the truthy base case (we only need it to return True on the imput 1, but the extra base cases are fine). Otherwise, we compute the second-smallest divisor (which is necessarily prime) of the input with Divisors[#][[6-4]]; if it's greater than 2024 (44*46) then we exit with False, otherwise we call the function recursively (using #6 set to #0) on the input divided by this small prime factor # (which we have to express as #^-1 times the input #4, since / is disallowed).
Structurally, the first half #4<4||#<44*46&&#6[#^-1#4]& is an anonymous function of six arguments, being called with arguments Divisors[#][[6-4]], Null, Null, #, Null, and #0; this is to get around the prohibition on the characters 2, 3, and 5.
Previous version, which saved four bytes by replacing 8018-6000 with 44*46, inspired by ais523's Jelly answer (Martin Ender also seemed inspired by an ais523 comment):
#<4||Divisors[#][[6-4]]<44*46&&#0[Divisors[#][[6-4]]^-1#]&

This was pretty nasty: I still don't know a way to actually set a variable in Mathematica under these restrictions! Both = and the e in Set are disallowed. Avoiding + and ) was also an issue, but not too hard to work around at the expense of more bytes.

You could perhaps set a lambda parameter rather than a variable. (That said, #2 would also be disallowed, so you'd have to be careful with how your lambdas nested, and the lack of parentheses might make that difficult.)

Implementing @ais523's suggestion saves three bytes: #4<4||#<44*46&&#6[#^-1#4]&[Divisors[#][[6-4]],,,#,,#0]& throws a bunch of warnings because it now tries Divisors[#][[2]] before ensuring that the input is greater than 1 (or 3), but the result is still correct.

Oh man, that's freaking cunning.

Haskell, 48 47 bytes
\n->[snd$[product[1..44*46]^n]!!0`divMod`n]<[1]

Basically a translation of Dennis’ Jelly answer. xnor saved a byte.
Uses […]!!0 as parentheses because ) is banned, and snd + divMod because the m in mod and rem is banned.

Nice trick with the divMod! I think you can replace the !!0<1 with <[1]. But it looks it it's shorted to use div as [\p n->p^n`div`n*n>p^n-1]!!0$product[1..44*46].

There's also \n->[0|p<-[product[1..44*46]^n],0<-[p,p-n..0]], which uses that outputs need only to be consistent.

@xnor Feel free to post those as separate answer(s), I think they’re sufficiently different from mine ^^

Pyke, 10 8 7 9 bytes
P_Z|hwMX<

Try it here!
Saved 1 byte by using Dennis's way of generating 2025
P         -     factors(input)
 _        -    reversed(^)
  Z|      -   ^ or 0
    h     -  ^[0] or 1
        < - ^ < V
     wM   -  ⁴45 (ord("M")-32)
       X  -  ^**2

Actually, 9 bytes
τyM:44u²≥

Thanks to Dennis for lots of bytes!
Try it online!
Explanation:
τyM:44u²≥
τyM        largest prime factor of 2*input (doubled to deal with edge case of n = 1)
   :44u²   2025 (2027 is the next prime after 2017, so any number in [2017, 2026] can be used here - 2025 is very convenient)
        ≥  is 2025 greater than or equal to largest prime factor?

Mathematica, 66 74 bytes
Thanks to Dennis for pointing out that U+F4A1 is prohibited.
Fold[Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]],0<1,Divisors@#]&

Explanation:
Divisors@#: List of integer divisors of the first argument #.
0<1: Golf for True (also avoids the use of the letter e).
Divisors@d^0: List of the form {1, 1, ..., 1} with length equal to the number of divisors of d.
Tr: For a flat list, Tr returns the sum of that list. Thus Tr[Divisors@d^0] returns the number of divisors of d.
Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]]: Anonymous function with two arguments x and d. The idea is that d is a divisor of # and we test to see if it is either composite or less than or equal to 2017 (inclusive). 2017-friability is equivalent to all the divisors satisfying this condition. As ais523 discovered, being a prime less than or equal to 2017 is equivalent to being a prime less than 2025. As Greg Martin pointed out, it suffices to test whether it is less than 2024=44*46. The argument x acts as an accumulator for whether all of the divisors encountered so far satisfy this property. We then left Fold this function through all of the divisors of # with starting value True, since we have access to neither Map nor /@.

Way to fight through the restrictions!

Brachylog, 9 10 bytes
*$ph$r*<90

Try it online!
Basically using the same algorithm as my other answer. $ph finds the first (h) prime factor ($p); this is the largest prime factor, as Brachylog's prime factor lists go from largest to smallest. Then I take the square root ($r), double (*), and test to see if it's less than 90 (<90).
I had to double the input first because 1 has no prime factors (and thus no first prime factor). This adds an extra prime factor of 2, which can't affect whether a number is 2017-friable, but prevents a failure when handling 1.

05AB1E, 10 bytes
fθ46n99-›È

Returns 1 if true, 0 otherwise.
Try it online!
Explanation
f          # Push the list of prime factors (ordered)
 θ         # Get the last element
  46n99-   # Push 2017 (46² - 99)
        >  # Push 1 if the last prime factor is greater than 2017, 0 otherwise
         È # Is the resulting number even ? Transforms 1 to 0 and 0 to 1.
           # Implicit display

Welcome to PPCG!

MATL, 15 bytes
t:\~ftZp*44QU<A

Outputs 0 for non-2017-friable or 1 for 2017-friable.
Try it online! Or verify all test cases.
This program checks that all bytes are composite.
Explanation
t       % Implicit input n. Duplicate
:       % Range [1 2 ... n]
\       % Modulo. Gives 0 for divisors of n
~f      % Indices of zero values
t       % Duplicate
Zp      % Is-prime. Gives 1 for primes, 0 for composites
*       % Multiply
44QU    % 44, add 1, square: 2025
<       % Less than, element-wise
A       % True (1) if all entries are nonzero

Bash, 144 bytes
ASCII encoding:
{
printf '[ '
`tr D-Z _-z <<<KFH`tor $1|tr -d :|`tr B-Z _-z <<<JUH`p -o '[0-9]*$'
printf ' -lt $[24*86-46] ]'
}|tr \\n \ |`tr B-Z _-z <<<EDVK`

As usual for shell, the exit code indicates success (0) or failure (non-0).
This is effectively a different spelling of
[ factor $1|tr -d :|grep -o '[0-9]*$' -lt 2018 ]

We get the largest factor with factor $1|grep -o '[0-9]*$'; the tr -d : is to special-case for input = 1.
The expression $[6*6*69-466] evaluates to 2018.
It was tricky to use tr for the command names and still use command substitution - I couldn't use the nesting form $(  ), so I ended up piping into another Bash to evaluate the result.
Test results:
$ for i in 1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289; do printf '%d %s\n' $i `./105241.sh $i  && echo true || echo false`; done
1 true
2 true
80 true
2017 true
2019 true
2027 false
11111 true
45183 false
102349 false
999999 true
1234567 false
4068289 true

Confirmation of character codes:
$ grep -v '^#' ./105241.sh | perl -n -Mutf8 -E '$a = ord, print `factor $a` for split //, $_' | grep -v ': .* ' | wc -l
0

Pyt, 21 19 bytes
ϼ↕1⦋91+₂⬠1+Đ1+⬠⇹₂->

Try it online!
This uses Pyt's custom encoding, in which all of the characters used are non-prime bytes. It returns false if the number IS 2017-friable, and true if it is not.

code
action

ϼ
gets the unique prime factors of the input

↕1⦋
gets the largest of those

91+₂⬠1+Đ1+⬠⇹₂-
pushes 2017

>
is the largest prime factor greater than 2017?; implicit print

The number 3 is forbidden, assuming that it's a numeric literal.

good catch. i was only looking at the bytes. i'll fix

Pyth, 11 bytes
!s>R^h44h1P

Try it online. Test suite.
Uses Dennis's trick to get 2025, then checks if no prime factors of input are greater.

Julia 0.4, 84 38 37 bytes
n->1^n:44*46|>prod|>t->t^n-t^n÷n*n<1

Expects a BigInt as argument.
Try it online! or verify that no byte is prime.

Japt, 14 bytes
k æ¨44*46 ?0:1

Returns 1 if true, 0 if false.
Try it here.

k has a prime value

Braingolf, 11 bytes [very non-competing]
VRp#ߢ-?0:1

Try it online!
Unreadable due to the ߢ which screws with the numbers, however still works in an interpreter.
I didn't even notice the character restrictions when I wrote this, but all I had to do was change the weird unicode character from 2017 to 2018.
Given 2018 is not a prime, any prime <= 2018 is also <= 2017
Explanation
VRp#ߢ-?0:1  Implicit input from command-line args
VR            Create stack2, return to stack1
  p           Split last item into prime factors, push each one to stack in asc order
   #ߢ         Push 2018
     -      Subtract last 2 items (highest prime factor - 2017)
      ?     If last item > 0..
       0    ..push 1
        :   Else..
         1  ..Push 1
            Implicit output of last item on stack

Japt -!, 12 bytes
Japt gets jipped here 'cause k is our built-in for prime factors, and # converts characters to their codepoints.
â fj d¨44*46

Try it


text:
Generate a Padovan Spiral
Introduction
Similar to the Fibonacci Sequence, the Padovan Sequence (OEIS A000931) is a sequence of numbers that is produced by adding previous terms in the sequence. The initial values are defined as:
P(0) = P(1) = P(2) = 1

The 0th, 1st, and 2nd terms are all 1. The recurrence relation is stated below:
P(n) = P(n - 2) + P(n - 3)

Thus, it yields the following sequence:
1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37, 49, 65, 86, 114, 151, 200, 265, 351, ...

Using these numbers as side lengths of equilateral triangles yields a nice spiral when you place them all together, much like the Fibonacci Spiral:

Image courtesy of Wikipedia

Task
Your task is to write a program that recreates this spiral by graphical output, with input corresponding to which term.
Rules

Your submission must be able to handle at least up to the 10th term (9)
Your submission must be a full program or function that takes input and displays a graphical result (either outputs an image or graphs, etc)
You must show proof of your graphical output in your submission
Rotations of the output are allowed, in 60 degree multiples, with the same representation
Going counter-clockwise is also allowed
Standard loopholes are forbidden

You may assume that input will be >0 and that correct format of input will be given.
Scoring
This is code-golf, so the shortest code in bytes wins. Happy New Years everyone!

Is trailing space after lines allowed?

@Pavel Yes. Let me add that

Does the output have to be identical to the example or are reflections and rotations (multiples of 60 degrees)  allowed?

@LevelRiverSt I would allow that. Let me clarify that in the post.

I think this would also be interesting as a [graphical-output] challenge.

@mbomb007 added option for graphical output.

Is it allowed to mirror the output?

@JanDvorak what do you mean by that?

I mean, is it okay if my spiral grows counter-clockwise rather than clockwise like yours does?

@JanDvorak Yes, that is allowed. Let me add that into the challenge

Not a fan of allowing both ASCII art and graphical output in the same challenge. They're very very different tasks, and mixing them together makes answers solving the two different possibilities completely incomparable. It would be better to have two separate challenges, one for ASCII art and one for graphical output.

@MartinEnder Ok, sure. Since both of the answers here currently are graphical-output, I could have another challenge for ASCII. Would that be ok?

@AndrewLi sounds good to me.

Mathematica, 119 108 bytes
Thanks to Martin Ender for saving 11 bytes!
±n_:=If[n<4,1,±(n-2)+±(n-3)];Graphics@Line@ReIm@Accumulate@Flatten@{0,z=I^(2/3),±# z^(#+{2,4,1})&~Array~#}&@

Unnamed function taking a positive integer argument (1-indexed) and returning graphics output. Example output for the input 16:

Developed simulataneously with flawr's Matlab answer but with many similarities in design—even including the definition I^(2/3) for the sixth root of unity! Easier-to-read version:
1  (±n_:=If[n<4,1,±(n-2)+±(n-3)];
2   Graphics@Line@ReIm@
3   Accumulate@Flatten@
4   {0,z=I^(2/3),±# z^(#+{2,4,1})&~Array~#}
5  ])&

Line 1 defines the Padovan sequence ±n = P(n). Line 4 creates a nested array of complex numbers, defining z along the way; the last part ±# z^(#+{2,4,1})&~Array~# generates many triples, each of which corresponds to the vectors we need to draw to complete the corresponding triangle (the ±# controls the length while the z^(#+{2,4,1}) controls the directions). Line 3 gets rid of the list nesting and then calculates running totals of the complex numbers, to convert from vectors to pure coordinates; line 2 then converts complex numbers to ordered pairs of real numbers, and outputs the corresponding polygonal line.

nevermind that part was just me being stupid.

Matlab, 202 190 bytes
N=input('');e=i^(2/3);f=1/e;s=[0,e,1,f,-e,e-2];l=[1,1,1,2];M=N+9;T=[l,2:M-3;2:M+1;3:M+2];for k=5:N;l(k)=l(k-2)+l(k-3);s(k+2)=s(k+1)+e*l(k);e=e*f;end;T=[T;T(1,:)];plot(s(T(:,1:N)));axis equal

Output for N=19 (1-based indexing):

Explanation
The rough idea is basically working with complex numbers. Then the edges of the triangles point always in the direction of a sixth root of unity.
N=input('');                         % Fetch input
e=i^(2/3);                           % 6th root of unity
f=1/e;                               %  "
s=[0,e,1,f,-e,e-2];                  % "s" is a list of vertices in the order as the spiral is defined
l=[1,1,1,2];                         % "l" is a list of edge-lengths of the triangles
for k=5:N;                           % if we need more values in "l"/"s" we calculate those
    l(k)=l(k-2)+l(k-3);
    s(k+2)=s(k+1)+e*l(k);
    e=e*f;
end;
M=N+9;
T=[[1,1,1,2,2:M-3];2:M+1;3:M+2]';    % this matrix describes which vertices from s are needed for each triangle (the cannonical way how meshes of triangles are stored)
trimesh(T(1:N,:),real(s),imag(s));   % plotting the mesh, according to "T"
axis equal

Nice job! Is there any possibility of an explanation?

explanation added!

really like the use of complex numbers here.

PHP + SVG , 738 Bytes
<?php
$a=[1,1,1];
for($i=0;$i<99;)$a[]=$a[$i]+$a[++$i];
$d=$e=$f=$g=$x=$y=0;
$c=[333,999];
$z="";
foreach($a as$k=>$v){
if($k==$_GET['n'])break;
$h=$v/2*sqrt(3);
if($k%6<1){$r=$x+$v/2;$s=$y+$h;$t=$r-$v;$u=$s;}
if($k%6==1){$r=$x-$v/2;$s=$y+$h;$t=$x-$v;$u=$y;}
if($k%6==2){$r=$x-$v;$s=$y;$t=$r+$v/2;$u=$y-$h;}
if($k%6==3){$r=$x-$v/2;$s=$y-$h;$t=$r+$v;$u=$s;}
if($k%6==4){$r=$x+$v/2;$s=$y-$h;$t=$r+$v/2;$u=$y;}
if($k%6>4){$r=$x+$v;$s=$y;$t=$r-$v/2;$u=$y+$h;}
$d=min([$d,$r,$t]);
$e=max([$e,$r,$t]);
$f=min([$f,$s,$u]);
$g=max([$g,$s,$u]);
$p="M$x,{$y}L$r,{$s}L$t,{$u}Z";
$z.="<path d=$p fill=#{$c[$k%2]} />";
$x=$r;
$y=$s;
}
?>
<svg viewBox=<?="$d,$f,".($e-$d).",".($g-$f)?> width=100% height=100%>
<?=$z?>
</svg>

Output for 16

<svg viewBox=-53,-12.124355652982,75.5,42.435244785437 width=100% height=100%>
<path d=M0,0L0.5,0.86602540378444L-0.5,0.86602540378444Z fill=#333 /><path d=M0.5,0.86602540378444L0,1.7320508075689L-0.5,0.86602540378444Z fill=#999 /><path d=M0,1.7320508075689L-1,1.7320508075689L-0.5,0.86602540378444Z fill=#333 /><path d=M-1,1.7320508075689L-2,0L0,0Z fill=#999 /><path d=M-2,0L-1,-1.7320508075689L0,0Z fill=#333 /><path d=M-1,-1.7320508075689L2,-1.7320508075689L0.5,0.86602540378444Z fill=#999 /><path d=M2,-1.7320508075689L4,1.7320508075689L0,1.7320508075689Z fill=#333 /><path d=M4,1.7320508075689L1.5,6.0621778264911L-1,1.7320508075689Z fill=#999 /><path d=M1.5,6.0621778264911L-5.5,6.0621778264911L-2,-8.8817841970013E-16Z fill=#333 /><path d=M-5.5,6.0621778264911L-10,-1.7320508075689L-1,-1.7320508075689Z fill=#999 /><path d=M-10,-1.7320508075689L-4,-12.124355652982L2,-1.7320508075689Z fill=#333 /><path d=M-4,-12.124355652982L12,-12.124355652982L4,1.7320508075689Z fill=#999 /><path d=M12,-12.124355652982L22.5,6.0621778264911L1.5,6.0621778264911Z fill=#333 /><path d=M22.5,6.0621778264911L8.5,30.310889132455L-5.5,6.0621778264911Z fill=#999 /><path d=M8.5,30.310889132455L-28.5,30.310889132455L-10,-1.7320508075689Z fill=#333 /><path d=M-28.5,30.310889132455L-53,-12.124355652982L-4,-12.124355652982Z fill=#999 /></svg>

Two small things to golf: $k%6==0 can be $k%6<1 and $k%6==5 can be $k%6>4.

Python 3, 280, 262 bytes
18 bytes saved thanks to ovs
Golfed:
import turtle
P=lambda n:n<4or P(n-3)+P(n-2)
N=int(input())
M=9
t=turtle.Turtle()
Q=range
R=t.right
L=t.left
F=t.forward
S=[P(x)*M for x in Q(N,0,-1)]
A=S[0]
F(A)
R(120)
F(A)
R(120)
F(A)
L(120)
i=1
while i<N:
 A=S[i]
 for j in Q(3):F(A);L(120)
 F(A)
 L(60)
 i+=1

Same thing with some comments:
import turtle

# P(n) returns nth term in the sequence
P=lambda n:n<4or P(n-3)+P(n-2)

# M: scales the triangle side-length
M=9
# N: show triangles from 1 to (and including) N from sequence
N=int(input())
t=turtle.Turtle()
Q=range
R=t.right # R(a) -> turn right "a" degrees
L=t.left  # L(a) -> turn left "a" degrees
F=t.forward # F(l) -> move forward "l" units

# S: M*P(N),M*P(N-1), ... M*P(1)
S=[P(x)*M for x in Q(N,0,-1)]

# draw the largest triangle
A=S[0]
F(A)
R(120)
F(A)
R(120)
F(A)
L(120)
i=1

# draw the next N-1 smaller triangles
while i<N:
 A=S[i]
 for j in Q(3):F(A);L(120)
 F(A)
 L(60)
 i+=1

Screenshot for N=9:

dwitter 151
s=(n)=>{P=(N)=>N<3||P(N-3)+P(N-2)
for(a=i=0,X=Y=500,x.moveTo(X,Y);i<n*4;i++)k=9*P(i/4),x.lineTo(X+=C(a)
*k,Y+=S(a)*k),x.stroke(),a+=i%4>2?1.047:2.094}

can be tested on http://dwitter.net (use fullscreen)

basic idea is logo turtle, golfed. stole the P() func from above!
i imagine more could be golfed by recursion but this is not bad.

LOGO, 119 bytes
to s:n
make"x 10
make"y:x
make"z:y
bk:z
repeat:n[lt 60
fw:z
rt 120
fw:z
bk:z
make"w:y+:z
make"z:y
make"y:x
make"x:w]end

To use, do something like this:
reset
lt 150
s 12

Sample output (can't embed because it's not HTTPS and it failed to upload to imgur)

Sadly the link no longer works but you can paste the code into this online interpreter.


text:
Calculate Power Series Coefficients
Given a polynomial \$p(x)\$ with integral coefficients and a constant term of \$p(0) = \pm 1\$, and a non-negative integer \$N\$, return the \$N\$-th coefficient of the power series (sometimes called "Taylor series") of \$f(x) = \frac{1}{p(x)}\$ developed at \$x_0 = 0\$, i.e., the coefficient of the monomial of degree \$N\$.
The given conditions ensure that the power series exist and that the its coefficients are integers.
Details
As always the polynomial can be accepted in any convenient format, e.g. a list of coefficients, for instance \$p(x) = x^3-2x+5\$ could be represented as [1,0,-2,5].
The power series of a function \$f(x)\$ developed at \$0\$ is given by
$$f(x) = \sum_{k=0}^\infty{\frac{f^{(n)}(0)}{n!}x^n}$$
and the \$N\$-th coefficient (the coefficient of \$x^N\$) is given by
$$\frac{f^{(N)}}{N!}$$
where \$f^{(n)}\$ denotes the \$n\$-th derivative of \$f\$
Examples

The polynomial \$p(x) = 1-x\$ results in the geometric series \$f(x) = 1 + x + x^2 + ...\$ so the output should be \$1\$ for all \$N\$.

\$p(x) = (1-x)^2 = x^2 - 2x + 1\$ results in the derivative of the geometric series \$f(x) = 1 + 2x + 3x^2 + 4x^3 + ...\$, so the output for \$N\$ is \$N+1\$.

\$p(x) = 1 - x - x^2\$ results in the generating function of the Fibonacci sequence \$f(x) = 1 + x + 2x^2 + 3x^3 + 5x^4 + 8x^5 + 13x^6 + ...\$

\$p(x) = 1 - x^2\$ results in the generating function of \$1,0,1,0,...\$ i.e. \$f(x) = 1 + x^2 + x^4 + x^6 + ...\$

\$p(x) = (1 - x)^3 = 1 -3x + 3x^2 - x^3\$ results in the generating function of the triangular numbers \$f(x) = 1 + 3x + 6x^6 + 10x^3 + 15x^4 + 21x^5 + ...\$ that means the \$N\$-th coefficient is the binomial coefficient \$\binom{N+2}{N}\$

\$p(x) = (x - 3)^2 + (x - 2)^3 = 1 + 6x - 5x^2 + x^3\$ results in \$f(x) = 1 - 6x + 41x^2 - 277x^3 + 1873x4 - 12664x^5 + 85626x^6 - 57849x^7 + \dots\$

Would it be acceptable to take a polynomial as an infinite list of power-series coefficients like [1,-1,0,0,0,0,...]?

Yes, I think that this is an acceptable format.

Nice examples chosen!

I'm glad you appreciate it, thank you=)

Mathematica, 24 23 bytes
Saved 1 byte thanks to Greg Martin
D[1/#2,{x,#}]/#!/.x->0&

Pure function with two arguments # and #2. Assumes the polynomial #2 satisfies PolynomialQ[#2,x]. Of course there's a built-in for this:
SeriesCoefficient[1/#2,{x,0,#}]&

Well done beating the built-in! I guess you can save a byte by assuming that # is the integer N and #2 is the polynomial.

Matlab, 81 79 75 bytes
Unlike the previous two answers this doesn't make use of symbolic calculations. The idea is that you can iteratively calculate the coefficients:
function C=f(p,N);s=p(end);for k=1:N;q=conv(p,s);s=[-q(end-k),s];end;C=s(1)

Try it online!
Explanation
function C=f(p,N);
s=p(end);            % get the first (constant coefficient)
for k=1:N;
    q=conv(p,s);     % multiply the known coefficients with the polynomial
    s=[-q(end-k),s]; % determine the new coefficient to make the the product get "closer"
end;
C=s(1)           % output the N-th coefficient

GeoGebra, 28 bytes
Derivative[1/A1,B1]/B1!
f(0)

Input is taken from the spreadsheet cells A1 and B1 of a polynomial and an integer respectively, and each line is entered separately into the input bar. Output is via assignment to the variable a.
Here is a gif showing the execution:

Using builtins is much longer, at 48 bytes:
First[Coefficients[TaylorPolynomial[1/A1,0,B1]]]

Haskell, 44 bytes
p%n=(0^n-sum[p!!i*p%(n-i)|i<-[1..n]])/head p

A direct computation without algebraic built-ins. Takes input as an infinite list of power series coefficients, like p = [1,-2,3,0,0,0,0...] (i.e. p = [1,-2,3] ++ repeat 0) for 1-2*x+x^2. Call it like p%3, which gives -4.0.
The idea is if p is a polynomial and q=1/p is it inverse, then we can express the equality p·q=1 term-by-term. The coefficient of xn in p·q is given by the convolution of the coefficients in p and q:
p0· qn + p1· qn-1 + ... + pn· q0
For p·q=1 to hold, the above must equal zero for all n>0. For here, we can express qn recursively in terms of q0, ..., qn-1 and the coefficients of p.
qn = - 1/p0 · (p1· qn-1 + ... + pn· q0)
This is exactly what's calculated in the expression sum[p!!i*p%(n-i)|i<-[1..n]]/head p, with head p the leading coefficient p0. The initial coefficient q0 = 1/p0 is handled arithmetically in the same expression using 0^n as an indicator for n==0.

J, 12 bytes
1 :'(1%u)t.'

Uses the adverb t. which takes a polynomial p in the form of a verb on the LHS and a nonnegative integer k on the RHS and computes the kth coefficient of the Taylor series of p at x = 0. In order to get the power series, the reciprocal of p is taken before applying it.
Try it online!

Maple, 58 26 bytes
This is an unnamed function that accepts a polynomial in x and an integer N.
EDIT: I just noticed that there is a builtin:
(p,N)->coeftayl(1/p,x=0,N)

MATL, 19 bytes
0)i:"1GY+@_)_8Mh]1)

Translation of @flawr's great Matlab answer.
Try it online!
How it works
0)      % Implicitly input vector of polynomial coefficients and get last entry
i       % Input N
:"      % For k in [1 2 ... N]
  1G    %   Push vector of polynomial coefficients
  Y+    %   Convolution, full size
  @     %   Push k
  _     %   Negate
  )     %   Index. This produces the end-k coefficient
  _     %   Negate
  8M    %   Push first input of the latest convolution
  h     %   Concatenate horizontally
]       % End
1)      % Get first entry. Implicitly display

JavaScript (ES6), 57 bytes
(a,n)=>a.reduce((s,p,i)=>!i|i>n?s:s-p*f(a,n-i),!n)/a[0]

Port of @xnor's Haskell answer. I originally tried an iterative version but it turned out to be 98 bytes, however it will be much faster for large N, as I'm effectively memoising the recursive calls:
(a,n)=>[...Array(n+1)].fill(0).map((_,i,r)=>r[i]=r.reduce((s,p,j)=>s-p*(a[i-j]||0),!i)/a[0]).pop()

n+1 terms are required, which are saved in the array r. It is initially zeros which allows reducing over the entire array r at once, as the zeros will not affect the result. The last calculated coefficient is the final result.

PARI/GP, 31 27 bytes
f->n->Pol(Ser(1/f,,n+1))\x^n

Maxima, 31 25 bytes
Saved 6 bytes thanks to the comment of @alephalpha
f(e,R):=taylor(1/e,x,0,R)

Try it online!

A named function is shorter: f(e,R):=taylor(1/e,x,0,R).

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