text:
Make me a blanket!
I want a blanket that looks like this. Each strip goes over, under, over, under. Can you print it?
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\////
  ////    ////    ////    ////    ////    ////
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\////
  ////    ////    ////    ////    ////    ////
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\////
  ////    ////    ////    ////    ////    ////
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\

Trailing spaces at the end of each line and trailing newlines are acceptable.
Remember, this is code-golf, so the code with the fewest bytes wins.
Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, N bytes

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

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

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

var QUESTION_ID=99023,OVERRIDE_USER=12537;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

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

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

The right edge seems misaligned.

Is the left edge not overlapping intended?

@xnor Sorry, my bad.

@carusocomputing Fixed.

There's still some weirdness -- the left edge messes up the alternation of overs and unders.

@xnor No, it doesn't.

@Oliver You sure? Look at the \\\\ strand from the top left corner. It goes over, over, under, over, under, over.

@xnor Oh, okay... let me fix that.

@xnor Fixed....

Had you used the Sandbox, those issues could have been avoided before this went up on main.

Related: This is my pillow

Python 2, 84 bytes
R=range(24)
for i in R:print''.join(" \// \/\\"[i+~j>>2&1^i+j>>1&2^i&4]for j in R*2)

Thanks to Sp3000 for 6 bytes from turning the arithmetic operations into bitwise ones.

Whoa... how????

i+~j>>2&1^i+j>>1&2^i&4, perhaps?

@Sp3000 That's some nice bitwise precedence. I'll have to remember that when combining arithmetically-derived booleans into an index.

Pyth, 36 bytes
V24sm@" \// \/\\"im<3%k8++BNdt-NdT48

Try it online: Demonstration
Explanation:
We can determine the symbol by checking 3 conditions:
A := row % 8 > 3
B := (row + column) % 8 > 3
C := (row - column - 1) % 8 > 3

If we interpret [A,B,C] as a binary number, we get the following mapping:
01234567
 \// \/\

We can also interpret [A,B,C] as decimal number and perform a modular indexed lookup in the string. This doesn't make a difference because 10 mod 8 = 2.
Now to the code:
V24 iterates N (row-idx) over [0, 1, ..., 23].
sm...48 maps the numbers d (column-idx) in [0, 1, ..., 47] to chars and print the combined string.
++BNd generates the list [N, N+d], +...t-Nd appends N-d-1. So we have get the list [N, N+d, N-d-1]. m<3%k8 checks for each computed number k, if 3 < k % 8, so this gives the list with the conditions [A, B, C].
i...T convents this to a decimal number and then @" \// \/\\" does the lookup in the string.
More or less the same code in Python2: 98 bytes:
R=range(8)
for r in R*3:print''.join(" \// \/\\"[4*(r>3)+2*((r+c)%8>3)+((r-c-1)%8>3)]for c in R*6)

Just trying to get to grips with Pyth so any decent answer with a good explanation gets an upvote from me. was going to try Pyth after my base 3 experiment :)

You should post the Python2 answer as well...

Python 3, 174 172 138 bytes
print("\n".join(o*6for o in("bbbb////"," bb//// ","  ////  "," ////bb ","////bbbb","b//  bbb","bb    bb","bbb  //b")*3).replace("b","\\"))

Found the smallest pattern I could find in the blanket (the "under" and "over" pattern), stuck it in a list and added some list comprehension and string manipulation to unpack it all. Substituted all escaped backslashes by "b" and replaced them back later to save a few bytes.
Thanks to Oliver for golfing off 2 bytes!
Took 34 bytes off by changing the pattern - the whole pattern for the blanket is now in a single list, so only one for loop is needed to unwrap the pattern.

Welcome to PPCG! nice first post! You can shave a byte in python 2 I think, you don't need the parends for print.

Thank you Easterly Irk, I've been lurking around in code golf for too long now, so I decided to participate. :)

You can save two byte by removing the space after 0*6 and u*6

You could save 4 bytes by using the "b" for double backslashes and anywhere you need a single backslash just use escaping:print((("\n".join(o*6 for o in("bb////"," b//// ","  ////  "," ////b ",""))+"\n".join(u*6 for u in("////bb","\\//  b\\","b    b","b\\  //\\","")))*3).replace("b","\\\\"))

dzaima: your code doesn't seem to generate a valid blanket.

Python 2, 171 170 168 bytes
a,b,c=r"\\","/"*4," "
f,g=c*2,c+a+b+c
d=(a*2+b)*6,g*6,(f+b+f)*6,g[::-1]*6,(b+a*2)*6,('\\//'+f+a+"\\")*6,(a+f*2+a)*6,(a+"\\"+f+'//\\')*6
for e in 0,1,2:print'\n'.join(d)

Not pretty and not clever. Just sets variables for the most often used groups of strings then combines them and prints the result 3 times. May try and golf it more later if I don't find a better approach.
1 byte saved by using raw input on the a assignment. Thanks @nedla2004
-2 by assigning a couple of variables but still not a serious competitor

You could define a as r"\"

Thanks @nedla2004 Good point. Threw this together pretty quickly and was going to look at it later. That's a good start :)

Most interested in finding a way round the *6 on each tuple element though. Any ideas?

I don't know how you could do that, but the last line can be exec r"print'\n'.join(d);"*3.

I just posted an alternative just out of interest. Would value your comments on that also.

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

Try it online!

Perl, 209 + 17 = 226 bytes
Run with -mList::Util=max -M5.010 (the second flag is free).  It's not winning any byte count competitions, but here's my solution.
for(0..7){@b=(1)x8;@b[$_+3..$_+7]=(3)x4;@b[7-$_..10-$_]=(2)x4;for$c(0..2){$b[$c+8]=max$b[$c+8],$b[$c];$b[5-$c]=max$b[5-$c],$b[13-$c];}push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6;}say for@a,@a,@a

Readable:
for(0..7){
    @b=(1)x8;
    @b[$_+3..$_+7]=(3)x4;
    @b[7-$_..10-$_]=(2)x4;
    for$c(0..2){
        $b[$c+8]=max$b[$c+8],$b[$c];
        $b[5-$c]=max$b[5-$c],$b[13-$c];
    }
    push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6
}
say for@a,@a,@a

Procedurally generates each segment, then repeats the pattern 6 times, then outputs the total result 3 times.

Woah,I'm not the longest answe any more :) +1 for doing it in Perl anyway.

I could have done it the same way as everyone else (just printing a bunch of lines), but I decided to do things algorithmically instead of explicitly because I felt it was cooler.

Cool by my standards. I've taken an approach that I have never tried before cos it was an interesting challenge. As I said, +1. No insult intended by my comment. That's why I upvoted.

05AB1E, 37 bytes
Uses CP-1252 encoding.
24FNU48FXXN+XN-<)8%3›J" \// \/\"è?}¶?

Try it online!
Explanation
Uses the mod-8 trick expertly explained in Jakube's pyth answer.
24F                                    # for N in [0 ... 23] do:
   NU                                  # save N in X
     48F                               # for N in [0 ... 48] do:
        XXN+XN-<)                      # push [X,X+N,X-N-1]
                 8%                    # mod each by 8
                   3›                  # compare with 3
                     J                 # join
                      " \// \/\"è?     # index into string and print
                                  }    # end inner loop
                                   ¶?  # print newline

PHP 157 126 bytes
Taking the changes @Titus lists in the comments...
I'm annoyed I missed point 1 which I should have caught, but I didn't know strtr() existed which is where most of the savings come - nice work Titus!
NEW:
while($i<32)echo$b=strtr([3322,' 322 ','0220',' 223 ',2233,12013,3003,13021][$i++%8],['  ','\\','//','\\\\']),"$b$b$b$b$b\n";

OLD:
<?$a=[zzyy,' zyy ',syys,' yyz ',yyzz,xysxz,zssz,xzsyx];while($i<32){$b=$a[$i++%8];$b=str_replace([z,x,y,s],['\\\\','\\','//','  '],$b);echo"$b$b$b$b$b$b
";}

Because all the backslashes need escaping it saves quite a bit of space to pack them up as different character and replace them for output, and then once I'm calling str_replace() it makes sense to use it as often as possible.

You can remove the open tag if you use -r. Use these five steps to save another 30 bytes: http://ideone.com/wt4HGB 1) use $a[...] directly as str_replace parameter instead of assigning it. 2) strtr instead of str_replace. 3) Use digits instead of letters. 4) Include the assignment in the echo. 5) Don´t assign $a, just use it.

SOML, 106 bytes
3{"\\\\////”6*p" \\//// ”6*p"  ////  ”6*p" ////\\ ”6*p"////\\\\”6*p"\//  \\\”6*p"\\    \\”6*p"\\\  //\”6*p

a non-competing version using a function that I've only recently added: (83 67 66 bytes)
explanation:
  →$\\→#////→@”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~”
  →$                                                                in the further code replace "$" with "  "
    \\→#                                                            replace "#" with "\\"
        ////→@                                                      replace "@" with "////"
              ”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~” the code to exchange stuff in

so that results in:
”6*p"→~3{"\\\\////~ \\//// ~  ////  ~ ////\\ ~////\\\\~\//  \\\~\\    \\~\\\  //\~”
”6*p"→~3{"A~B~C~D~E~F~G~H~”  modified version of the program (removing "/","\" and " " and replaced with A,B,C,ect.)
”6*p"→~                      replace in the further program "~" with ”6*p" which is:
”                            end string
 6*                          repeat the last thing in stack 6 times
   p                         output the result
    "                        start a string
resulting program:
3{"A”6*p"B”6*p"C”6*p"D”6*p"E”6*p"F”6*p"G”6*p"H”6*p"”
shortened example:
3{"A”6*p"B”6*p"H”6*p"”
3{                      repeat 3 times
  "A”                   push "A" (original: "\\\\////")
     6*p                output it multiplied by 6
        "B”             push "B" (original: " \\//// ")
           6*p          output it multiplied by 6
              "H”       push "H" (original: "\\\  //\")
                 6*p    output it multiplied by 6
                    "”  push an empty string (shorter to do ~” than ”6*p)

Perl, 132 131 113 bytes
@a=((0)x4,1..4);map{say+(map$a[7-$_]?$a[$_]*$r?'/':'\\':$a[$_]?'/':$",0..7)x6;push@a,shift@a;$_%4||($r=!$r)}0..23

Ungolfed:
use strict;
use warnings;
use feature 'say';

my @a = ((1) x 4, (0) x 4);  # print '\' if true
my @b = ((0) x 4, (1) x 4);  # print '/' if true
my $r = 0;                   # print '\' over '/' if true

for (0 .. 23) {
    say((map { $a[$_] ? ($b[$_] * $r ? '/' : '\\') : ($b[$_] ? '/' : ' ') } 0 .. 7) x 6);
    unshift(@a, pop(@a));    # circular shift to left
    push(@b, shift(@b));     # circular shift to right
    $r = !$r if !($_ % 4);   # change print priority
}

Python, 245 236 234 233 230 216 212 198 195 bytes
OK, longer than my last (and any other) answer but would be interested in feedback on the approach.
for a in(40,4496,6200,5456,3240,1188,720,228)*3:print((`a%6561/2178`+`a%2178/729`+`a%729/243`+`a%243/81`+`a%81/27`+`a%27/9`+`a%9/3`+`a%3/1`)*6).replace('0','\\').replace('1','/').replace('2',' ')

Edit
-9 due to @nedla2004 being more on the ball than me
-2 by taking the lambda outside of the loop and so losing 2 indent spaces
-1 by using in' '*3 instead of in 0,1,2 since I don't use h anyway. it's just a counter.
-3 Why, why, why did I leave a newline and 2 indents between the second for and the print??? It's late. Will revisit tomorrow.
-14 Can actually lose the lambda completely and just include the base 3 decoder directly after the print statement. Looks messy but after all, this is code golf :)
-4 No point setting a variable for the integer list. Just use it directly in the second for loop.
-14 and no point using the outer loop. Just multiply the integer tuple by 3 (shamelessly stolen from @nedla2004 to get under 200 :))
-3 Saved 3 by making \=0, /=1 and space=2. This makes the integer list shorter as three of the base 3 numbers now have leading 0's
How it works (and it does)
Since only 3 characters are used:

l is a list of the 8 repeating patterns as integer equivalents of their base 3 representation assuming that " "=0, "\"=1 and "/"=2
The lambda The first code after the print statement is a lightweight converter from integer to a base 3 string
The first loop loops 3 times and the second prints each line with the base 3 characters multiplied by 6 and replaced with /,\ or space.

I'm sure I could use a regex instead of the nested replace() but I'm too tired to try right now. This was just an experiment and longer than my previous Python effort but have posted just for any comments on the approach (and also because I have never worked in base 3 before and I quite enjoyed working out the converter).

You could just remove the first division in the base 3 conversion.

For some reason that was causing me problems earlier but just tried and it works now. many thanks for being more awake than me. I'll re-edit my answer (and you have just saved me 9 bytes :))

I rewrote the base 3 conversion, it is no longer a lambda, I had to make it a function, but it might be able to be converted back to a lambda. You can find the function here.

Thanks. I think a combination of the two may work but that's probably a job for tomorrow evening :) Thanks again for your comments.

The function replaces the lambda, and that is all the complete code is here.

Just lost both the function and the lambda but will be looking at your code tomorrow. Thanks again. If I can get this under 200 I'll be happy with it.

I got it down to 169, here.

@nedla2004 I think that is different enough from mine that you should post it as your own solution. I have no problem with that. Nice work :) As I said, mine was just an idea that I threw out to the community. Nice effort for improving on it.

I think you mixed up the explanation, but the code is correct.

Fixed. Got \ and / wrong way round

and apologies for stealing your *3. Just wanted to get below 200 :)

Ruby, 75 bytes
1152.times{|i|$><<"\\/ /\\\\ /"[(i+j=i/48)/4&1|(i-j)/2&2|j&4]+$/*(i%48/47)}

Better golfed, using a single 8-byte string lookup indexed by j&4 in addition to the other parameters, rather than a modifiable 4-byte string.
Ruby, 81 bytes
1152.times{|i|j=i/48%8;$><<"\\#{'/\\'[j/4]} /"[(i+j)/4&1|(i-j)/2&2]+$/*(i%48/47)}

Prints the diagonal stripes character by character. The correct character is selected from a string of 4 characters depending on the presence / absence of each strand. The overlap character is varied depending on which strand is on top.
Commented
1152.times{|i|j=i/48%8;        #Iterate through all printable chars. j is line number.
  $><<"\\#{'/\\'[j/4]} /"[     #Print a char from "\/ /" if j/4 even or "\\ /" if odd. character changes depending which strand on top.
   (i+j)/4&1|(i-j)/2&2]+       #Print \ if (i+j)/4==0, / if (i-j)/2&2 >0, space if both false. As above if both true.
   $/*(i%48/47)                #If on column 47, print a newline.
}

Haskell, 96 bytes
f n=n`mod`8`div`4
putStr$unlines[["\\ //\\ \\/"!!(f(x-y)+2*f(x+y)+4*f y)|x<-[0..47]]|y<-[0..23]]

Ruby, 135 bytes
puts [3320,1212,720,2172,6520,4144,2920,3184].map{|e|(e.to_s(3).rjust(8,"0").gsub("0"," ").gsub("1","\\").gsub("2","/"))*6+"\n"}.join*3
The number array corresponds to each component of each line, translated to base 3:  = 0, \ = 1, /= 2, then converted to decimal. The gsub() calls are too big, though.
And, just now, I saw @ElPedro's answer. :-( Just coincidence.

e.to_s(3).rjust(8,"0") → ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/") → tr("013"," \\/"); "\n" → $/; .join → *"". You can also save a byte by dividing all of the numbers in the array by 4 and replacing e with (e*4).

Oops, I guess that ought to be tr("021"," /\\").

90 bytes: https://tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/Py21/3yvxjIhE6O2hEUeasLQxAbLgLIyXTL323WPt4DYOojFqHKZHOvPCZYBuwDKNCBEaduCVOZR/PjtPFw0LU3nXw

APL (Dyalog Unicode), 36 34 bytes
'\/ /\\ /'[(2⊥3<8|⊣,-⍨,+)/¨⍳24 48]

Try it online!
Because I can't tolerate an APL answer doing so badly.
This is almost a port of Angs' Haskell answer. Uses ⎕IO←0.
How it works
'\/ /\\ /'[(2⊥0⌷2 4⊤⊣,-⍨,+)/¨⍳24 48]
⍳24 48   ⍝ Construct a matrix containing pairs of (0..23),(0..47)
(...)/¨  ⍝ Map over each pair...
⊣,-⍨,+   ⍝   Given two numbers x and y, construct [x,y-x,x+y]
2 4⊤     ⍝   Convert the three numbers to mixed base;
         ⍝   equivalent to n → [n%8/4,n%4] in Python 2
0⌷       ⍝   Extract first row (n%8/4)
2⊥       ⍝   Convert base 2 to integer
'\/ /\\ /'[...]  ⍝ Convert each number in the entire matrix with
                 ⍝ the character at that index

0⌷2 4⊤ -> 3<8|

@ngn Thanks, updated. (Idk why I insisted ⊤ there)

Python 2, 169 161 165 160 155 154 152
Based on @ElPedro's answer, with small improvements. To see the explanation, see their answer. This is Python 2, even though there seems to be parenthesis near the print.
Saved 8 bytes by using a variable for replace. That works only for strings, and using a function for it would be longer.
Saved 4 bytes by seeing that @ElPedro realized that they did not need l, and I did not either.
Saved 5 bytes by not flipping the range(8), and instead of using += to append to r, adding r to the end of the new digit.
Try it using repl.it
Saved 5 bytes by stealing @ElPedro's new list of values.
Saved 1 byte by removing the space between the in and (.
Saved 2 bytes by removing the variable a.
for x in(40,4496,6200,5456,3240,1188,720,228)*3:
 r=''
 for i in range(8):r=`x/3**i%3`+r
 print(r*6).replace('0','\\').replace('1','/').replace('2',' ')

You can save 1 by removing the space between in and the ( in the first for

Also I have lost three bytes by reordering the sequence of which numbers represent each character in the base 3 list. See my answer for explanation. feel free to copy. As far as I am concerned this one is a joint effort and I'm happy to see that my original idea had at least some potential :)

You don't need a=3**i. Just use for i in range(8):r=x/3**i%3+r to save a couple. operator precedence takes care of the rest :)

Not sure how to delimit the string conversion characters. The parser removed them in my last comment so don't just copy and paste from my suggestion or it will break :)

Good point, I understood.

Here is a sneaky one to save 1 more - print r.replace('0','\\').replace('1','/').replace('2',' ')*6 (loses one bracket)

I think that's about as golfed as it gets. Enjoyed working with you on this one. Now it even looks like Python 2 :)

PHP, 184 bytes
<?$p=['1111////',' 11//// ','  ////  ',' ////11 ','////1111','1//  111','11    11','111  //1'];for($j=0;$j<3;$j++)for($i=0;$i<8;$i++)echo str_replace(1,'\\',str_repeat($p[$i],6))."\n";

Output:
C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\////
  ////    ////    ////    ////    ////    ////
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\////
  ////    ////    ////    ////    ////    ////
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\////
  ////    ////    ////    ////    ////    ////
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\

PowerShell, 89 bytes
0..23|%{$y=$_
-join(48..94|%{('\/'[$y%8-lt4]+'\/ ')[(($_+$y)%8-lt4)+2*(($_-$y)%8-ge4)]})}

Try it online!

05AB1E, 29 bytes
•M;(Ð§0—øθε;û…•…/\ Åв8ôJ6×3и»

Try it online!

Underload, 130 bytes
((\\\\////)( \\//// )(  ////  )( ////\\ )(////\\\\)(\//  \\\)(\\    \\)(\\\  //\)()(::**:*S(
)S)(:(~*a(a)~*^*)~a*^):*:*:*^!^)::**^

Try it online!

Batch, 152 bytes
@call:l
@call:l
:l
@for %%s in (\\\\//// " \\//// " "  ////  " " ////\\ " ////\\\\ "\//  \\\" "\\    \\" "\\\  //\")do @echo %%~s%%~s%%~s%%~s%%~s%%~s

String processing in Batch sucks, so this is probably the best approach. The call-and-fall-through is very slightly shorter than a nested for loop. At least I don't have to quote my backslashes!

APL, 110 bytes
I'm new to APL, so this is a simplistic solution.
A←48⍴'\\\\////'⋄B←48⍴' \\//// '⋄C←48⍴'  ////  '⋄F←48⍴'\//  \\\'⋄G←48⍴'\\    \\'⋄24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

Here's my approach: note that after the first 8 lines of the blanket, the pattern repeats itself. Therefore I only need to define the first 8 lines, and then I can repeat them 3 times. Also note that each line repeats itself after the first 8 characters. Therefore to define a single line I only need to define the first 8 characters and then repeat them 8 times.
Here's an ungolfed solution:
A←48⍴'\\\\////'⋄ ⍝ set A to a 48 element vector (48⍴) of repeated '\\\\////'s
B←48⍴' \\//// '⋄ ⍝ set B to a 48 element vector (48⍴) of repeated ' \\//// 's
C←48⍴'  ////  '⋄ ⍝ ...
D←48⍴' ////\\ '⋄ ⍝ Note that this is actually the reverse of vector B
E←48⍴'////\\\\'⋄ ⍝ Note that this is actually the reverse of vector A
F←48⍴'\//  \\\'⋄
G←48⍴'\\    \\'⋄
H←48⍴'\\\  //\'⋄ ⍝ Note that this is actually the reverse of vector F

24 48 ⍴ A,B,C,D,E,F,G,H ⍝ Make a 24 by 48 character matrix (24 48⍴) by concatenating A,B...H
                        ⍝ and repeating the string until the matrix is full

I noted above that D is the reverse of B, E is the revers of A, and H is the reverse of F. In my actual code, I take advantage of this by not defining D,F, or H and using the reverse function ⊖:
24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

Ruby, 132 bytes
puts Zlib.inflate Base64.decode64 "eJzt0bENADAMAsGeKdggC/3+cyQRC+A2ipuT3RgJgHWGUjm6VXb2Vjn/3KpJ/qtIPlp1v+XSKZKPVk3y/x5+D6/3sAEUXQ+Q"

very simple answer.

Perl 5 + -M5.10.0, 97 bytes
say s/\d(.)/$1x$&/ger x6for('4\4/| 2\4/ |  4/  | 4/2\ |4/4\|\//  3\|2\4 2\|3\  //\\'=~/[^|]+/g)x3

Try it online!


text:
Build me a brick wall!
Challenge
I need help building a brick wall! Throw together some code for me
 using no input and produce the following output wall shown below:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Now, this wall is exactly 10 characters high and 70 characters
 wide.
As stated above, no inputs, only code. Least amount of bytes, we have
 to efficiently build this brick wall. Obviously, this program has to
 function to get the wall built..? or it obviously won't build itself!
 Good luck!

Winner
The winner goes to Marinus using the APL language, requiring a whole 12 bytes!
https://codegolf.stackexchange.com/a/99028/61857

Thank you everyone for participating!

Related, Related,

Also Related. (odd that this should come up today, haha)

This would be around 10 bytes in Crayon, too bad there's no interpreter yet...

could you provide a screenshot possibly @ETHproductions? thanks!

Who's gonna build your wall?

@dylan I'm sorry, a screenshot of what? I don't have an interpreter yet, and the spec isn't even finalized, so I can't write the exact code...

i thought you meant online interpreter, but yeah I understand. sorry for the miscommunication @ETHproductions

That's OK. I'll let you know when I have a working interpreter. I'm working on it right now, actually :)

Related!

For bonus points, make Mexico pay for it.

Donald Trump just found cheap workmanship here!

Haha, just stumbled across this challenge and I remembered being salty when this challenge came out as I had just put a very similar one in the sandbox.

May we output a list of lines?

APL, 12 bytes
10 70⍴'_|__'

Output:
      10 70⍴'_|__'
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

I just noticed this answer as I put my J answer. they're basically the same haha

This outputs something else in addition to the ascii wall. Is this allowed?

when using tryapl.org, I got the wall output. what have you received @TheBitByte?

@Dylan He's probably confused, since the answerer included the program in the output without knowing the REPL nature of APL.

Trumpscript, 303 285 244 231 226 bytes
make i 1000005-1000000
as long as,i;:
make i,i - fact;
say "_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|"
say "___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__"!
America is great

I would like to say this is one of the most verbose languages where almost everything fails to compile into a working program.
Apparently whether - works instead of minus is completely up to the interpreter and sometimes works. This time it did so I'm putting it in as golfed.
Abuses the fact Trumpscript is written in Python and therefore fact when used as an integer is one.
Golfing tips welcome.

I take it Trumpscript doesn't allow numbers less than 1,000,000? ;-)

you are correct.

Can you use i is 1000005-1000000 and i is i-fact? (Just taken a look at the readme of Trumpscript.)

@AlexRacer I'll update once I get to a computer with a Trumpscript interpreter so I can test that

Doesn't python have a way to multiply a string?
e.g.: say "_|_" x 35

I'm surprised it allows you to use 1000000. Documentation states All numbers must be strictly greater than 1 million. The small stuff is inconsequential to us..

Fact and lies (and other truth/false constants) have a random, time based chance to flip flop (be reversed) during tokenization (see tokenizer.py, search flip_flop) may be why it seemed to not work with minus, when really it had to do with fact at that point in time

Actually, the code`s 0 bytes. The 226 bytes come from the file. Fact.

232, doesn't use fact so no possible failing depending on time

J, 12 bytes
10 70$'_|__'

Shapes the string on the right into a 10 by 70 shape. Simple!

BBC BASIC, 28 bytes
Tokenised filesize 23 bytes.
WIDTH70P.STRING$(175,"_|__")

WIDTH70 would normally be followed by a newline. It sets the field width to 70. Then we just print 175 copies of the string, which wrap around.

Best (ab)use of WIDTH that I have seen :)

This should have "23 bytes" in the header then.

@Adám Only if the tokenized version is posted as the answer.

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

Brainfuck is fun, here is my submission.
Here is the output:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Here is a link to try it
https://repl.it/EW2Z/0

WinDbg, 45 bytes
f2000000 L2bc 5f 7c 5f 5f;da/c46 2000000 L2bc

How it works:
f 2000000 L2bc 5f 7c 5f 5f; *Repeat the pattern _|__ (5F 7C 5F 5F) to fill 2BC (700) bytes
                            *starting at 2000000
da /c46 2000000 L2bc        *Show 2BC (700) ASCII chars starting from 2000000 in lines
                            *of length 0x46 (70)

Output:
0:000> f2000000 L2bc 5f 7c 5f 5f;da/c46 2000000 L2bc
Filled 0x2bc bytes
02000000  "_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|"
02000046  "___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__"
0200008c  "_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|"
020000d2  "___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__"
02000118  "_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|"
0200015e  "___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__"
020001a4  "_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|"
020001ea  "___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__"
02000230  "_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|"
02000276  "___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__"

Pyth, 12 bytes
Code:
jcT*175"_|__

Explanation:
       "_|__    # For the string "_|__"
   *175         # Repeat it 175 times
 cT             # Chop into 10 equal pieces
j               # Join them by newlines

Try it here.

Python 2, 37 bytes
s="_|__"*17;print(s+"_|\n__%s\n"%s)*5

Decomposes two rows as 17 copies of _|__, plus another copy interrupted by a newline, plus 17 more copies, plus another newline.
Longer alternatives:
print"%s_|\n__%s\n"%(2*("_|__"*17,))*5

s="_|__"*17;print"%s_|\n__%%s\n"%s%s*5

for i in[0,2]*5:print("_|__"*18)[i:i+70]

print("_|__"*17+"_|\n"+"___|"*17+"__\n")*5

for s in["_|__","___|"]*5:print(s*18)[:70]

s="_|__"*99;exec"print s[:70];s=s[2:];"*10

print("%s"*70+"\n")*10%(175*tuple("_|__"))

Your last alternative is shorter as print(("%s"*70+"\n")*10%(175*(*"_|__",))) in Python 3.

05AB1E, 13 bytes
Code:
"_|__"175×Tä»

Explanation:
"_|__"         # For the string "_|__"
      175×     # Repeat that 175 times
          Tä   # Split into 10 even pieces
            »  # And join them by newlines

Uses the CP-1252 encoding. Try it online!

-2 by using …_|_Ć and the compressed Ƶм for 175 (I realize the second wasn't available when you posted the answer; not sure about the first).

Vim, 30 24 19 keystrokes
18a___|<esc>YP2x}h.yk4P

Thanks to DrMcMoylex and nmjcman101 for saving valuable keystrokes!

Nice answer, welcome to the site! Some tips: 1) a takes a count, so you could do 18a___|<esc> instead of making the macro. 2) <cr> in normal mode is equivalent to j0, so you could take one byte off your second macro.

Cool, thanks for the tips!

I golfed your solution a bit for fun.  Formatting the wall before copy/pasting saves all the bytes of not making a macro: 18a___|<esc>YP2x}h.yk5P is 19 bytes.

Nice, I'll update the answer! I'll just replace the second to last key with 4, otherwise the wall is getting too high :)

PHP, 44 42 41 characters
<?=chunk_split(str_pad(_,700,"|___"),70);

(Just because had no chance to use chunk_split() ever before.)
Thanks to:

user59178 for suggesting to use str_pad() (-1 character)

Sample run:
bash-4.3$ php <<< '<?=chunk_split(str_pad(_,700,"|___"),70);'
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

bytes, not character count.

Same. I use no multibyte characters.

Crossed out 44 is still regular 44 ;(

@pajonk, Fixed with PPCG - Crossed Out 44 user style on my machine: https://i.stack.imgur.com/czn5h.png

You can save a byte by using str_pad instead of str_repeat, largely because _ is treated as a constant with value _.

Perl, 47 34 29 bytes
$_="_|__"x175;say for/.{70}/g

You can golf it down to 29 : say for("_|__"x175)=~/.{70}/g

For some reason, that used to produce no output every time I tried it, but I found another solution in as many bytes.  Thank you though!

Well, the code I suggested does produce a valid output... Maybe you forgot the parenthesis around "_|__"x175 or something like that?

I think that's what it is.  I figured parentheses had to go somewhere, I just couldn't figure out where, lol

Huhu, hard to remember the precedence of every operator (=~ has a higher precedence than x)!

I always seem to have tabs with  perlre, perlop, and perlrun open at all times for that very reason :P

V, 24, 16 bytes
175i_|__ò70|lé

Try it online!
This contains <esc> characters (0x1B) so here is a hexdump:
0000000: 3137 3569 5f7c 5f5f 1bf2 3730 7c6c e90a  175i_|__..70|l..

8 bytes indirectly saved thanks to Jordan!

19 bytes: http://v.tryitonline.net/#code=MTc1aV98X18bw5MuXHs3MH0vwrDDsg&input= I couldn't figure out how to use the .\{-} shortcut mentioned in the V docs, though.

@Jordan Wow, very nice! The \{-} shortcut wouldn't work anyway, since you can't change the number inside. However, you could set the high bit on the \{ to get this instead. Feel free to post that as an answer.

Ah, that makes sense. Posted here: http://codegolf.stackexchange.com/a/99070/11261

Damn I still need to grok this language: 25 bytes

Perl, 31 bytes
say+($@="_|__"x17,"_|
__$@
")x5

You'll need -E flag to run it :
perl -E 'say+($@="_|__"x17,"_|
__$@
")x5'

Thought of a slightly different approach for 29 bytes: say for("_|__"x175)=~/.{70}/g :). I do like the trick you employed there though!

@DomHastings huhu, I wrote the exact same code in the comments of Gabriel Benamy's answer!

D'oh! Didn't see that one! Also then saw it's been used a lot in other answers.. Oh well!

@DomHastings Yea, I didn't thought of it at first, and it was already in Gabriel's answer, so that's why I didn't update my answer after ;)

Python 2, 46 44 Bytes
Just using string multiplication to build the string, and slicing to get the right bits :)
k='_|__'*18
print'\n'.join([k[:70],k[2:]]*5)

thanks to Antony Hatchkins for saving two bytes :)

Could be 2 bytes less: print'\n'.join([k[:70],k[2:]]*5)

@AntonyHatchkins Thanks!

V, 18 bytes
-1 byte thanks to DJMcMayhem.
175i_|__<Esc>Ó.û70}/°ò

Here it is with unprintable characters in xxd format:
0000000: 3137 3569 5f7c 5f5f 1bd3 2efb 3730 7d2f  175i_|__....70}/
0000010: b0f2                                     ..

Try it online!

Nice, I am no longer the only person who has used V! Now I'm going to have to see if I can take the lead back, haha

MATL, 15 bytes
'_|__'700:)70e!

Of course, you can Try it online!
Explanation:
'_|__' % Put a brick on the stack
700    % 700 times
:)     % Makes a happy mason...
70e!   % Secret freemason code

OK, actually, it works as follows:
'_|__' % Put the first bit of the string on the stack
700:   % Put 1, 2, ..., 700 on the stack as array
)      % Index into the string, modularly. Result: '_|___|__ ... __'
70e    % Reshape into 70 rows (and consequently, 10 columns)
!      % Transpose to get the desired output.

Well done! And your smiley is better than mine

@LuisMendo Really, using smileys could be considered a design pattern in MATL. xD Perhaps you could have :) on C... but that would be your last 1-byte code point gone (or is there another reason C is not used?)

You want to get rid of the smiley?? :-P

Jelly, 14 bytes
“_|__”ṁ700s70Y

TryItOnline!
How?
“_|__”ṁ700s70Y - Main link: no arguments
“_|__”         - literal ['_','|','_','_']
      ṁ700     - mould like something 700 long
          s70  - split into chunks of length 70
             Y - join with line feeds

By definition, Jelly cannot be longer than J.

I did something similar without the peculiar ṁ: “_|__”ẋ175œs⁵Y (14 bytes)

PowerShell v2+, 34 30 bytes
'_|__'*175-split"(.{70})"-ne''

Stupid regex matching algorithm requiring the -ne'' ... wastes five bytes!
'_|__'*175-split"(.{70})"-ne''
'_|__'*175                     # Repeat this string 175 times
          -split"       "      # Split on this regex pattern:
                  .{70}        # Match any character 70 times
                 (     )       # Encapsulated in parens so we keep the regex results
                         -ne'' # But don't select the empty strings
                               # Output with newlines via Write-Output is implicit

Saved 4 bytes thanks to Conor!

Would .{70} be any shorter for teh regex?

split works like that in other languages - you always get the unmatched portions whether you want them or not. Some languages have a match operator that can be used to return an array of only matching results, but I don't see a PowerShell equivalent for that.

@Neil Performing 'abc'-split'(.)' will return ('','a','','b','','c',''). There's nothing unmatched, but due to how the algorithm processes through the input string, you get empty strings back. See here.

Yes, and I'm saying you shouldn't be surprised by that result, because that's what split's supposed to do.

@Neil Surprised? No, not really. Doesn't mean I have to be happy about it, though. :D

C, 131 115 113 103 97 95 Bytes
i,j;main(){for(;i<10;puts(i++&1?"|__":"|"))for(j=0;j<18-(i&1);printf(&"|___"[j++?0:i&1?1:3]));}

Time to start golfing this...
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

81 bytes

Bash, 44, 41, 40 bytes
printf _\|__%.0s {1..175}|egrep -o .{70}

The printf makes a single line 700 characters long, the egrep matches it 70 characters at a time.

MATL, 16 bytes
'___|'10:E!70:+)

Try it online!
'___|'   % Push this string
10:E!    % Push [2; 4; 6; ...; 20] (10×1 column vector)
70:      % Push [1, 2, 3, ..., 70] (1×70 row vector)
+        % Add. Gives a 10×70 matrix of all pairwise additions
)        % Index (modular, 1-based) into the string

Beat you with an entire byte: http://codegolf.stackexchange.com/a/99073/32352

CJam, 15 bytes
"_|__"175*70/N*

Try it online!
Port of Adnan's 05AB1E answer.
"_|__"             e# Push this string
      175*         e# Repeat 175 times
          70/      e# Split in pieces of size 70
             N*    e# Join by newlines

Javascript REPL, 45 bytes
"_|__".repeat(175).match(/.{70}/g).join("\n")

Welcome to PPCG! This should be marked as "JavaScript REPL" or similar, as this doesn't print anything at all outside of an interactive console environment.

Isn't this 45 bytes?

@daHugLenny you are right, I counted \n as a single byte

where is the console.log ?

As long as you are using ES6 (I think it is) you can use template strings, so join("\n") becomes join

JavaScript (ES6), 48 bytes
f=(n=350)=>n?(n%35?'_':`
_`)+"|_"[n%2]+f(n-1):""

Because recursion.

///, 43 bytes
/a/___|//b/aaccccc//c/aaa//d/_|b
b__
/ddddd

Try it online!

R, 78 bytes
    strwrap(gsub('(.{70})','\\1 ',paste(rep('___|',175),collapse='')),70)

How?
    x=paste(rep('___|',175),collapse='')   #Creates string on 1 line
    y=gsub('(.{70})','\\1 ',x)             #Adds spaces every 70 characters
    z=strwrap(y,70)                        #Creates a new line every space
    z                                      #Print the finished product

Befunge-93, 42 bytes
:4%1g,1+:"F"%!#v_0#@_
_|__~>:+#5,#:4#<1g*`^

Try it online!

Nice answer. Welcome to the site!

bash 36 Byte
printf '_|__%.0s' {1..175}|fold -w70

OUtput:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

You can omit the w in fold -w70

C, 61 bytes
TCC Version
main(i){for(;i+699;)printf("\n%c"+(--i%70||!i),"___|"[i&3]);}

GCC Version
main(i){for(;i+699;)printf("\n%c"+(i%70||!i),"___|"[--i&3]);}

Welcome to the site!

Python 3, 40 bytes
p="_|__"*17
print((p+"_|\n__"+p+"\n")*5)

Befunge-98, 63 bytes
'_\:3+4%0`!> #0 #\ #|' $ #\_\,1+:7a*%0`!> #0 #, #a_:7aa**\`!#@_

TryItOnline!

Ruby, 30 bytes
Thanks to manatwork for this solution
puts ("_|__"*175).scan /.{70}/

Ruby, 39 bytes
10.times{|i|puts ("_|__"*18)[i%2*2,70]}

The generate-all-then-split approach is shorter here too: puts ("_|__"*175).scan /.{70}/.

@manatwork thanks a lot! I rarely think of using scan as I´m not that comfortable with regexes. You know you could have posted that as your own answer...

///, 51 bytes
If a trailing newline is allowed:
/e/aaaa//a/_|__//b/eeeea_|//c/__eeeea//d/b
c
/ddddd

Try it online!

Pyke, 12 bytes
w�"_|__"*TfX

where � is the literal byte 163.
Try it here! (w� replaced with literal)

Retina, 23 21 20 bytes

175$*_

_|_
!`.{70}

Try it online

Use !\.{70}` to split the string at the end.

You can save another byte like this: http://retina.tryitonline.net/#code=CjE3NSQqXwoKX3xfCiFgLns3MH0&input=

Haskell, 56 47 bytes
unlines$[1..5]>>take 70.cycle<$>["_|__","___|"]

JavaScript (Node.js), 45 bytes
_=>`_|__`.repeat(175).match(/.{70}/g).join`
`

Try it online!
Explanation :
_ =>                    // lambda function (argument passed to save a byte)
    `_|__`              // simple enough
    .repeat(175)        // repeat the above mentioned shape 175 times
    .match(/.{70}/g)    // simple regexp to match a shape 70 (something :) ) long
    .join`\n`           // and join them on a new line

Simple enough.
Alternate version :
JavaScript (Node.js), 714 bytes
_=>`_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__`

Try it online!
No explanation required. Simple hard coded.

Jelly, 13 bytes
70:þ⁵“_|__”ṁY

Try it online!
The dyad given to þ doesn't matter so long as it outputs a scalar, so I chose : solely for aesthetic purposes.
   þ             Take the rangifying outer product
  :              by integer division
70               of 70
    ⁵            and 10,
     “_|__”ṁ     mold "_|__" like it,
            Y    and join on newlines.

05AB1E, 11 bytes
…_|_ĆƵм×Tä»

Try it online!
         ä   # split...
…            # three char string...
 _|_         # literal...
    Ć        # concatenated with its first character...
       ×     # repeated...
      м      # numeric literal...
     Ƶ       # converted from base 255 to decimal plus 101...
       ×     # times...
         ä   # into...
        T    # 10...
         ä   # equal pieces...
          »  # by newlines
             # implicit output

PHP, 46 bytes
<?=wordwrap(str_repeat('_|__',175),70,"\n",1);

Output:
C:\PHP>php build-me-a-brick-wall.php
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

I think wordwrap()'s 3rd parameter should be "\n" as this currently keeps the string unwrapped in PHP 5.6.

@manatwork In the "test online" link you can check the various versions of PHP, it seems working fine in PHP all versions.

Correct, “seems”. But the output is wrapped by the sandbox site, not by PHP. See with “Output: Raw”.

@manatwork I thought the textbox output is acceptable too. I tryed with  <?=wordwrap(str_repeat('_|__',175),70,"\n",1);  and still no wraps in Raw output while it works fine if you save it in a PHP file and run in a browser.

Well, relying on the sandbox sounds similar to what was discussed in When is code that requires a REPL acceptable?. So if you add it to the post title, should be fine. (Honestly, I still not like the idea.) BTW, you can just wrap the line in that place instead of writing \n, to keep the code size at original 45.

@manatwork I added the PHP interpreted version called by console.

chunk_split will save four bytes over wordwrap, because you don´t need the 3rd and 4th parameter. Funny: str_pad("",700,"_|__") has the same length as str_repeat("_|__",175).

@Titus I know, but I didn't want to copy the other answer :) Someone used that before me and the answers would have been too much similar or almost the same...

Racket 159 bytes
(let p((n 2)(x 0)(t 0)(d display))(when(> x 69)(d"\n")(set! x 0))(cond[(> t 699)
(d"\n")][(> n 2)(d"|")(p 0(+ 1 x)(+ 1 t)d)][(d"_")(p(+ 1 n)(+ 1 x)(+ 1 t)d)]))

Ungolfed:
(define (f)
  (let loop ((n 2)   (x 0)   (t 0)  (d display))

    (when (> x 69)  (d "\n")
                    (set! x 0))
    (cond
      [(> t 699)    (d "\n")]

      [(> n 2)      (d "|")
                    (loop    0    (+ 1 x) (+ 1 t) d)]

      [else         (d "_")
                    (loop (+ 1 n) (+ 1 x) (+ 1 t) d)]
      )))

Testing:
(f)

Output:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Ruby, 89 80 77 76 72 53 47 42 Bytes
puts (%w[___]*176*?|)[2..-1].scan(/.{70}/)

Demo:
>> puts (%w[___]*176*?|)[2..-1].scan(/.{70}/)
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Update: I didn’t see there’s already an answer with 30 bytes.

Java 8, 128
This code directly calculates each character and has no imports or dependencies.
Golfed:
()->{String s="";for(int x,y=0;y<10;++y){for(x=0;x<70;++x)s+=((y%2<1&(x+3)%4<1)|(y%2>0&(x+1)%4<1))?"|":"_";s+="\n";}return s;}

Ungolfed:
() -> {
  String s = "";
  for (int x, y = 0; y < 10; ++y) {
    for (x = 0; x < 70; ++x)
      s += ((y % 2 < 1 & (x + 3) % 4 < 1) | (y % 2 > 0 & (x + 1) % 4 < 1)) ? "|" : "_";
    s += "\n";
  }
  return s;
}

Swift 3, 69 bytes
(3...702).map{print($0%4<1 ?"|":"_",terminator:($0-2)%70<1 ?"\n":"")}

Output after compiling and running:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Try online here (In this tool it run as script so it will produce a warning due the map result is unused.

Clojure, 117 110 bytes
(fn[](println(apply str(map #(str(apply str %)"\n")(partition 70(subs(apply str(repeat 175 "_|__"))0 700))))))

Basically creates a long string of "_|__"s 700 characters long, cuts it every 70 characters, then joins them with newline.
Managed to get rid of the calls to join!
Ungolfed:
(defn build-wall []
  (println
    (apply str
      (map #(str (apply str %) "\n")
        (partition 70
          (subs (apply str
                  (repeat 175 "_|__"))
                0 700))))))

Kotlin, 99 bytes
fun main(a:Array<String>){"_|__".repeat(999).split(Regex("(?<=\\G.{70})")).take(10).map(::println)}

Regex taken from here. First ever golf, done in 10 minutes, probably improvable..

Welcome to PPCG! Can you remove some of the spaces? Like a:Array<String>?

How'd I miss that...thanks.

@mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu What does your name mean?

I use random usernames everywhere, I don't like the possibility of somebody googling my nick and finding out everything about my online life.

Lua, 54 bytes
w=("_|__"):rep(17)print((w.."_|\n__"..w.."\n"):rep(5))

No fancy splits for Lua, but it does have an easy repeat.

Python 3, 43
print(("_|__"*17+"_|\n"+"__|_"*17+"_\n")*5)

Fixed to be more Trump-like.

SAS, 68
option linesize=70;data;length w$700;w=repeat('_|__',174);put w;run;

The 174 is not a typo - in SAS the repeat function rather pedantically returns the original string plus n repeats.

Python 2, 46 bytes
import textwrap as t;print t.fill('_|__'*175)

I was going to do an exec loop similar to @xnor's one alternate solution but he/she got to it before me. I guess I'll just have to let Python do the dirty work for me.

R, 62 bytes
Don't have the rep to comment, so posting as an answer: @user3297046's answer can be golfed-down to 62 bytes:
cat(gsub('(.{70})','\\1
',paste(rep('_|__',175),collapse='')))

which results in
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

PHP, 56 bytes
Although I know it can be done smaller using wordwrap or string splits, I prefer more hacky solutions.
for($i=0;$i<700;$i++){echo($i%70?'':'
').'_|___'[$i%4];}

Python 2, 50 48 bytes
for b in range(10):print('_|__'*175)[b*70:][:70]

2 saved with thanks to @xnor but also thanks to @Shebang for the suggestion :)

b*70+70 -> -~b*70 saves a byte :)

Or [b*70:][:70].

Thanks @xnor. Didn't know you could do that. may well go back and trim a couple off some of my other recent answers :)

C#, 106 102 101 118 107 106 100 96 bytes
Thanks shebang for saving 2 bytes and pointing out a mistake, Yodle for saving 6 bytes and Link Ng for saving 4 bytes.
var a="";int i;for(;i++<175;)a+="_|__";for(i=0;i<10;)Console.Write(a.Substring(i++*10,70)+"\n");

You can test it directly on http://csharppad.com/.

Change the a%2==0 to a%2<1 to save a byte :)

Also, you can remove the a++ in the for definition and change a%2 to a++%2!

You can save 4 bytes by declaring i outside the loop, incrementing i within the condition i<175, and using i in the second loop instead of a new integer b.

@Yodle I could save 6 bytes by doing so (and not 4), thanks!

Ahh I guess they have a default value of 0 :P.   In VS it won't let you declare local variables without initializing them, so the =0 made it only 4 for me.

Remove the two pairs of curly braces for 4 bytes

Could you do this and save 2 bytes? int i;for(;i<10;)Console.Write(string.Join("_|__",new string[75]).Substring(i++*10,70)+ "\n");  http://csharppad.com/gist/92a5bcefaeaeb90a96a9cc367593b1c5

Jolf, 17 bytes
RZc*"_|__"Τ755@FS

Try it here!
Explanation
RZc*"_|__"Τ755@FS
   *"_|__"         repeat this string:
          Τ755      7*5*5 = 175 times
 Zc           @F   chop into groups of 70 (F's charcode)
R               S  join by newlines

SOML, 16 bytes
_|__”’ø*L{:jjp»»

explanation:
_|__”             push "_|__"
     ’ø           push 18
       *          repeat the "_|__" 18 times
        L{        repeat 10 times:
          :       duplicate the sting
           jj     pop the last 2 letters off
             p    output it
              »»  put the last 2 characters at the start

Pyth, 24 23 22 bytes
VT:*175"_|__"J*70N+70J

OK, I'm still learning. Any hints gratefully received :)
Edit
Saved a byte by moving the assignment of J to first use

Java 8 + Guava, 81 106 bytes
25 bytes for import: com.google.common.base.*;
Lambda that takes no input and returns the required wall.
()->String.join("\n",Splitter.fixedLength(70).split(Strings.repeat("_|__",175)));

Same as many other solutions. Takes a repeating string of "_|__" 175 times, splits it into lengths of 70, then joins them on newline.

Don't you need imports for this?

@mbomb007 That's why I put '+ Guava' in the title. I assumed that was sufficient.

Imports must be included in the byte count. https://meta.codegolf.stackexchange.com/q/10081/34718; https://meta.codegolf.stackexchange.com/a/8782/34718

GolfSharp, 38 bytes
c(r(175).s(n=>"_|__").j().S(70).j(N));

is it this language?

@aloisdg it is fellow typo corrector! You warmed my heart

C (gcc), 61 58 bytes
-3 bytes thanks to ceilingcat.
f(i){for(i=700;i--;i%70|!i||puts(""))printf(L"__|_"+i%4);}

Try it online!

Symbolic Python, 69 bytes
Outputs as a list of lines.
_=-~(_==_)
__=-~_*-~_*_
_=[('_|__'*__)[:-_],('___|'*__)[:-_]]*-~(_*_)

Try it online!
Alternatively, for 16 more bytes, we can print the wall:
_=-~(_==_)
__=-~_*-~_*_
_=(('_|__'*__)[:-_]+"""
"""+('___|'*__)[:-_]+"""
""")*-~(_*_)

Try it online!

Prolog (SWI), 83 bytes
?-between(0,699,I),(1 is I mod 4->write("|");write("_")),69 is I mod 70,nl,1=0;1=1.

Try it online!

Tcl, 84 78 77 76 bytes
time {append a [expr [incr i]%4-2?"_":"|"];if $i%70<1 {puts $a;unset a}} 700

Try it online!

Interesting trick of append and unset!

@sergiol you sure took your time to reply :P also haven't been using tcl lately. idk if i should start using it again

Common Lisp, 70 bytes
(dotimes(i 700)(format t"~[|~:;_~]~[
~:;~]"(mod(1- i)4)(mod(1+ i)70)))

Try it online!

Canvas, 10 bytes
B?³‟‾Ｈ×‾7ｎ

Try it here!
Canvas, 10 bytes
αｎｑ［‟５＊‾7ｍ

Try it here!

Vyxal j, 10 bytes
‛_|ǏǏ⁺J*₀/

Try it Online!
How?
‛_|ǏǏ⁺J*₀/
‛_|         # Push string "_|"
   ǏǏ       # Append its first character twice, yielding "_|__"
     ⁺J*    # Repeat it 175 times
        ₀/  # Split into ten equal parts

Batch, 90 bytes
@set s=_________________
@for /l %%i in (1,1,5)do @echo _^|%s:_=___^|%&echo __%s:_=_^|__%

|s cause problems if I want to use them as contents of the variable so it's easiest to stick with them as replace strings.

BASH, 91,34 bytes
printf _\|__%.0s {1..175}|fold -70

Java 7, 136 124 120 115 bytes
String c(){String r,x=r="";int i=999,q=0;for(;i-->0;x+="_|__");for(;i++<10;r+=x.substring(q,q+=70)+"\n");return r;}

Ungolfed & test code:
Try it here.
class M{
  static String c(){
    String r,
           x = r = "";
    int i = 999,
        q = 0;
    for(; i-- > 0; x += "___|");
    for(; i++ < 10; r+= x.substring(q, q+=70) + "\n");
    return r;
  }

  public static void main(String[] a){
    System.out.println(c());
  }
}

Output:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Is it possible to use recursion instead of a for-loop here? That could cut down on some amount of data.

Ruby, 30 bytes
puts ('_|__'*175).scan /.{70}/

Output:
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Duplicate of Level River St's Ruby solution posted 20 hours earlier. :(

Vim, 26 22 strokes
Assume the q register to be empty (if not type qqq)
175i_|__<esc>0qq70li<enter><esc>q8@q

It's 8q at the end, not 9q. 9q produces a single underscore on an 11th line.

FurryScript, 71 bytes
A[ <_|> 17 REP +<___|> +BR +<__> 17 REP +<_|__> +BR ]
<<A><A><A><A><A>>

Explanation:
A[ ... ]            {{ Subroutine called A }}
<_|>                {{ Push string "_|" }}
17 REP              {{ Repeat next command 17 times: }}
+<___|>             {{ Concatenate "___|" }}
+BR                 {{ Concatenate newline }}
+<__>               {{ Concatenate "__" }}
17 REP              {{ Repeat next command 17 times: }}
+<_|__>             {{ Concatenate "_|__" }}
+BR                 {{ Concatenate newline }}
<<A><A><A><A><A>>   {{ Template; result of A, 5 times }}

bash, 35 bytes
printf '\e[8;;70t_|__%.0s' {1..175}

Must be run in graphical terminal as it sets the size of the window.

Python 3.5.2, 44 bytes
exec("print('_|__'*18);print('___|'*18);"*5)
This is my first attempted golf, so feel free to leave a suggestion!
Try it here

MySQL, 196 123 118 95 bytes
First wall was backwards, removed procedure.
set @x:=repeat('_|__',99);select left(repeat(concat(left(@x,70),'\n',mid(@x,3,70),'\n'),9),709)

Python 3 - 41 chars
s="_|__"*17
print((s+"_|\n__"+s+"\n")*5)

Java 8, 101 119 bytes
18 for the import: java.util.stream.*;
Lambda that returns the wall. We generate an infinite Stream of brick pieces ('_|__'), limit it to 175, and collect them into a string. We then use replaceAll to swap in a newline every 70 characters.
()->Stream.generate(()->"_|__").limit(175).collect(Collectors.joining()).replaceAll("(.{70})","$1\n")

Gema, 45 characters
\A=@subst{<U70>=\$1\\n;@repeat{175;_|__}}@end

Sample run:
bash-4.3$ gema '\A=@subst{<U70>=\$1\\n;@repeat{175;_|__}}@end'
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Javascript, 232 bytes
brick = ["_","_","_","|"];
brickIndex = 2;
output = "";
for(var y=0;y<10;y++){
    for(var x=0;x<70;x++){
      brickIndex = brickIndex % 4;
      output += brick[brickIndex++];
    }
    output += "\n";
}
console.log(output)

“All solutions to challenges should: (…) Be a serious contender for the winning criteria in use. For example, an entry to a code golf contest needs to be golfed (…)” – [help/on-topic] Please read Tips for golfing in  and/or Tips for golfing in JavaScript for hints on reducing your code's size.

jq, 37 characters
(33 characters code + 4 characters command line options)
range(10)|.*2|("_|__"*70)[.:.+70]

range(10)|("_|__"*70)[.*2:.*2+70]

range(0;20;2)|("_|__"*70)[.:.+70]

Sample run:
bash-4.3$ jq -nr 'range(10)|.*2|("_|__"*70)[.:.+70]'
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

On-line test code 1, code 2 and code 3 (Passing -r through URL is not supported – check Raw Output yourself.)

sh (via base64 and pigz) 59 bytes
echo eNqLr4mPpxxzgQjKMRc5mkZdM+oaAG7xGAs=|base64 -D|pigz -d

Python 3, 54 bytes
for i in range(10):print(('_|__'*175)[70*i:70*(i+1)])

I know this is longer than other Python 3 solutions, so I post because it is a different approach.

Pushy, 21 bytes
`_|__`17:4d;T:vv"^^{{

Really wish I could golf it more, will have another go later. It works like so:
`_|__`                  % Push the brick string to the stack
      17:4d;            % Copy 17 times
            T:          % 10 times do:
              vv"^^     %   Print without the last two characters
                   {{   %   Shift the string left twice

Seeing as there's no online interpreter as of yet, here's what it looks like:
$ pushy brickwall.pshy

_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

Perl, 37 bytes
print$_.$/x!(++$i%35)for('_|',__)x175

Ungolfed:
my $i = 0;
print($_, "\n" x !(++$i % 35)) for ('_|', '__') x 175;

Lithp, 72 bytes
#::((print (replace (repeat "_|__" 175) (regex "(.{70})" "g") "$1\n"))))

Sample usage:
% wall.lithp
(
    (def x #::((print (replace (repeat "_|__" 175) (regex "(.{70})" "g") "$1\n"))))
    (x)
)

Output:
$ ./run.js wall.lithp
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__
_|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__

SOGL V0.12, 10 bytes
Ωo³‘'╥*'4n

Try it Here!
Explanation:
Ωo³‘        push "_|__"
    '╥*     multiply the string 175 times
       '4n  split into lines of length 70

Japt -R, 15 bytes
AÆ70î"_|__"éX*2

Try it online!
Unpacked & How it works
Ao@70î"_|__"éX*2

Ao@      range(10).map(X=>...)
70î        Repeat the following string to length 70...
"_|__"éX*2   This string rotated X*2 chars to the right.
         `-R` joins the resulting array with newline
         Implicit output

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

Try it online !
My first brainfuck answer !
There is a more aerial and commented version :
+++++[>+++++[>>++++>+++++<<<-]>++>-<<<-]>>>>->  value storage
+++++[                                          doing this ↓ 5 times
  <<.>.>                                        first "_|"
  >++++++++[>++>++<<-]>+>+<                     storing 17 two times
    [<<<<...>.>>>-]                             first 17 "|___" batch
    <<<<<.>>>>>>                                new line
    [<<<<<...>.>>>>-]                           second 17 "|___" batch
  <<<<<..<.>>>-                                 last "__" and new line
]

Charm, 87 bytes
f := " ___| " 18 repeat
s := substring pstring newline
[ f 2 72 s f 0 70 s ] 5 repeat i

Try it online!
Charm's repeat makes this kind of thing easy, but its syntax prevents very good scores regardless.
Explanation:
f := " ___| " 18 repeat " function to push 18 bricks " pop
s := substring pstring newline " we need to get a substring before printing it with a newline at two different points during the program, so we save bytes defining a function for it " pop
[ f 2 72 s f 0 70 s ] 5 repeat i " now we apply our functions, getting two slightly different substrings of the bricks from the f function and printing them, repeating this 5 times "

would it be shorter to get the ascii value of the new line ?

10 char p is longer than newline.

Charcoal, 11 bytes
⪪×¹⁷⁵_|__⁷⁰

Try it online!

source: Stack Exchange

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

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

sort: votes


text:
I deserve a castle for it only being Tuesday
It is only Tuesday, ugh. I deserve a treat. Golf me a Castle. The Least amount of bytes wins!
Taken no input and output this image exactly:
 /\           /\
/  \         /  \
----         ----
|  |^^^^^^^^^|  |
-----------------
|       _       |
|   |  | |  |   |
|      | |      |

Edit
Build me a brick wall!
36 votes versus my -9. Okay.

shortest code or lowest byte count.?

Least amount of bytes

@dylan What's the difference?

@DrMcMoylex http://codegolf.stackexchange.com/a/17020/61857

my post was ironic to the date + was fairly simple. yours seems much more complicated and more diverse which is why i didn't take a stab at it.

I haven't upvoted or downvoted but there didn't really seem any smart way to do this. "Build me a brick wall" had repeating patterns which you could work with. This doesn't. I did have a go (in Python) but gave up after a while. I didn't see it in the Sandbox otherwise I would have commented there. Sorry to see all of the downvotes. Sandbox rocks!

Bubblegum, 52 bytes
00000000: 35c8 3111 c030 1443 b1fd a310 815c 08f5  5.1..0.C.....\..
00000010: 5a22 06df 64b0 263f db0f 7562 367d b831  Z"..d.&?..ub6}.1
00000020: eb50 3726 e4ad 9059 5513 c007 c804 2142  .P7&...YU.....!B
00000030: f441 74fc                                .At.

Obligatory Bubblegum answer.

Swift 3, 200 bytes
var z=" /\\ 9/\\\n/  \\ 7/  \\\n-2 7-2\n|  |^7|  |\n-95\n| 5_ 5|\n| 1|  | |  | 1|\n| 4| | 4|",o="",x=""
for c in z.characters{let k="\(c)"
if let b=Int(k){for i in 0...b{o+=x}}else{o+=k
x=k}}
print(o)

Basically loop trough the Characters of z string, if a digit (b) is found then repeat the last character b+1 times
Try online here

Ruby, 130 bytes
f=->a,b=' '{a+b*9+a};g=->s{?|+s.center(15)+?|};puts f[' /\\ '],f['/  \\'],f[c=?-*4],f[d='|  |',?^],f[c,?-],g[?_],g[d+' '+d],g['| |']

This can probably be golfed down more.

JavaScript (ES6), 120 bytes
_=>` /\\44/\\
/8\\36/8\\
173617
|8|38|8|
69
|28_28|
|12|8| |8|12|
|24| |24|`.replace(/\d\d?/g,n=>' -^'[n&3].repeat(n/4))

Demo

let f =

_=>` /\\44/\\
/8\\36/8\\
173617
|8|38|8|
69
|28_28|
|12|8| |8|12|
|24| |24|`.replace(/\d\d?/g,n=>' -^'[n&3].repeat(n/4))

console.log(f())

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


text:
Character by Character
Your program must take in a string like:
test string

And must output each character adding one at a time like this:
t
te
tes
test
test
test s
test st
test str
test stri
test strin
test string

notice how spaces count!
Good luck!
Least Bytes win.
~N

Related.

Is a trailing new line at the end acceptable?

Welcome to Programming Puzzles and Code Golf! This is a nice first challenge :). Unfortunately this has been done before and is therefore a duplicate :(.

Pyth, 3 bytes
j._

Try it here.
j       Join by newlines
 ._     all prefixes of implicit input

You should accept Emigna's answer, because it also has 3 bytes and was posted earlier

05AB1E, 3 bytes
Uses CP-1252 encoding.
.p»

Try it online!
Explanation
     # implicit input
.p   # list of prefixes
  »  # join by newlines

Wow! Only 3 bytes!

MATL, 6 bytes
"GX@:)

Try it online!
         % Implicit input
"        % For each
  G      %   Push input again
  X@:    %   Push [1 2 ... k] where k is iteration index
  )      %   Use as index into the string
         % End for each
         % Implicit display

Nice job! Do I update the winner as new code is posted?

Usually we wait for about a week until accepting an answer as winner

Brachylog, 5 bytes
@[@w\

Try it online!
Assuming that a trailing new line is acceptable
Explanation
@[       Take a prefix of the Input
  @w     Write it to STDOUT followed by a linebreak
    \    False: try another prefix of the input

A trailing new line is fine.


text:
Alternating Fibonacci
In the alternating Fibonacci sequence, you first start with 1 and 1 as usual.
However, instead of always adding the last two values to get the next number, you alternate starting with adding, and every other time you subtract instead.
The sequence starts like this:
1
1
2    # 1 + 1
-1   # 1 - 2
1    # 2 + -1
-2   # -1 - 1
-1   # 1 + -2
-1   # -2 - -1
-2   # -1 + -1
1    # -1 - -2
-1   # -2 + 1
2    # 1 - -1
1    # -1 + 2
1    # 2 - 1

etc.
Notice that after it starts over once it gets to 1 and 1 again.
Given a number N, print the Nth term of the alternating fibonacci sequence.
Remember, this is code-golf, so the code with the smallest number of bytes wins.

Is the sequence 0-indexed or 1-indexed (or either one)?

@Doorknob Either one. Specify in your answer.

Can we return true for 1?

Do the first two 1 values count as initial values for the output? Or do we start directly with the 2?

@LuisMendo The first two count.

JavaScript (ES6), 25 bytes
n=>"334130110314"[n%12]-2

0-indexed. You can shorten the string with a slightly recursive version, though it adds 6 bytes:
f=n=>"3341301"[n]-2||f(13-n%12)

This is still shorter than the definitive recursive formula:
f=n=>n<2||f(n-2)+f(n-1)*(-n%2|1)

Python, 31 bytes
lambda n:2-33107256/5**(n%12)%5

Doesn't bother trying to compute the value. Just looks in up in the peroidic length-12 list [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], which is compressed in base 5.
Compare to a recursive solution (37 bytes) with True's for 1:
f=lambda n:n<2or(-1)**n*f(n-1)+f(n-2)

or to string storage
lambda n:int('334130110314'[n%12])-2

or an attempt at an arithmetical expression.
lambda n:4**n%7%3*(-1)**((n+n%2*4)/6)

Oasis, 10 bytes
Reminds me to implement some more built-ins :p. The input is 0-indexed.
Code:
n>2%x<*c+V

Translated version:
a(n) = (2*((n+1)%2)-1) * a(n-1) + a(n-2)
a(1) = 1
a(0) = 1

And calculates the nth term.
Try it online!

05AB1E, 10 bytes
•É&Â†º•sèÍ

Uses the CP-1252 encoding. Try it online!

I think I should start learning 05AB1E instead of Jelly.

Haskell, 33 26 bytes
a!b=a:b:(a+b)!(-a)
(1!1!!)

Recursive approach. 0-indexed. Try it on Ideone.
Saved 7 bytes thanks to xnor.
Usage:
Prelude> (1!1!!)11
2

Looks shorter to just do a!b=a:b:(a+b)!(-a).

Jelly, 12 bytes
“½Ġ⁻S’b5_2⁸ị

TryItOnline!
1-based, given the first and second values are 1.
Not sure if this is shorter yet, but for this I noted that the series has a period of 12:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]
So, I took that and added 2 to give
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
then converted that as a base 5 number to base 250, to give:
[11, 197, 140, 84]
(which is 184222584).
“½Ġ⁻S’b5_2⁸ị - Main link: n
“½Ġ⁻S’       - base 250 number      184222584
      b5     - convert to base 5   [3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
        _2   - subtract 2          [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]
          ⁸  - left argument, n
           ị - index into (1-based and modular)

Pyth - 13 bytes
Base encoded once cycle series, modular indexed.
@-R2jC"
ûx"5

Try it online here.

Java, 32 bytes
n->"334130110314".charAt(n%12)-50

Since this is Java, the answer is 0-indexed.
Testing and ungolfed:
class Ideone {
  public static void main (String[] args) throws Exception {
    java.util.function.IntFunction f = n->"334130110314".charAt(n%12)-50;
    for (int i = 0; i < 12; i++) {
      System.out.printf("%d -> %d%n", i, f.apply(i));
    }
  }
}

Test on Ideone

MATL, 17 16 15 bytes
'"Bl)e'F5Za2-i)

Input is 1-based.
Try it online!
Explanation
The sequence has period [1 1 2 -1 1 -2 -1 -1 -2 1 -1  2].
'"Bl)e     % Compressed array [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2] with source
           % alphabet [-2 -1 0 1 2]
F5Za       % Decompress with target alphabet [0 1 2 3 4]
2-         % Subtract 2 to transform alphabet into [-2 -1 0 1 2]
i)         % Input N and use as (modular, 1-based) index into the sequence

Mathematica, 40 bytes
Just creates a lookup table and accesses it cyclically, as in ETHproductions's answer. Unnamed function, 1-indexed.
Join[s={2,1,1,2,-1,1},-s][[#~Mod~12+1]]&

WinDbg, 26 bytes
?(85824331b>>@$t0%c*3&7)-2

Input is passed in through the pseudo-register $t0. 0-indexed. +2 of each term in the sequence is stored in 3 bits making 85824331b.
How it works:
? (85824331b >> @$t0 % c * 3 & 7) - 2 ;*? Evalutes the expression. Shifts 85824331b to get
                                       *the 3 bits for the @$t0'th term (mod c (12) when
                                       *the sequence repeats). Bitwise AND by 7 to get the
                                       *desired 3 bits, finally subtract 2 since the terms
                                       *where stored as +2.

Sample output, a loop printing the first 14 values of the sequence:
0:000> .for(r$t0=0;@$t0<e;r$t0=@$t0+1){?(85824331b>>@$t0%c*3&7)-2}
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001
Evaluate expression: 2 = 00000002
Evaluate expression: -1 = ffffffff
Evaluate expression: 1 = 00000001
Evaluate expression: -2 = fffffffe
Evaluate expression: -1 = ffffffff
Evaluate expression: -1 = ffffffff
Evaluate expression: -2 = fffffffe
Evaluate expression: 1 = 00000001
Evaluate expression: -1 = ffffffff
Evaluate expression: 2 = 00000002
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001

Mathematica, 45 41 38 bytes
Thanks to @MartinEnder for 3 bytes.
±0=±1=1;±n_:=±(n-2)+±(n-1)(1-2n~Mod~2)

0-indexed.
Usage
±5

-2

You can probably save three bytes by defining a unary operator ± instead of a function a.

R, 38 bytes
Uses the lookup table solution inspired by @ETHproductions JS answer.
c(s<-c(2,1,1,2,-1,1),-s)[scan()%%12+1]

Edit: Forgot to mention that this is 1-indexed.

C#, 117 Bytes
Golfed:
int A(int n){var f=new List<int>{0,1,1};for(int i=3;i<=n;i++){f.Add(i%2>0?f[i-1]+f[i-2]:f[i-2]-f[i-1]);}return f[n];}

Ungolfed:
public int A(int n)
{
  var f = new List<int> { 0, 1, 1 };

  for (int i = 3; i <= n; i++)
  {
    f.Add(i % 2 > 0 ? f[i - 1] + f[i - 2] : f[i - 2] - f[i - 1]);
  }

  return f[n];
}

Testing:
var alternatingFibonacci = new AlternatingFibonacci();
Console.WriteLine(alternatingFibonacci.B(10));
1

Compile to a Func<int, int> so public int A(int n) is now n=>, you can remove the braces around the for statement saving 2 bytes,  you can pre increment the i in the loop i.e. ++i <= n and set i = 2 saving 3 bytes because it removes the i++ at the end of the statement

Also see my answer if you kept track of the previous variables instead of creating a list of them all it is a lot shorter

DC, 55 bytes
?sd[ln1+snly[[+2Q]sEln2%1=E-]xlyrsylnld>r]sr1sy0sn1lrxp

0-indexed.
?sd                                                     takes input and stores
                                                        it in register d

                                            1sy0sn1     stores 1 in register y
                                                        and 0 in register n and
                                                        appends 1 to the stack

   [ln1+snly                                            adds 1 to register n and
                                                        appends the value of
                                                        register y to the stack

            [[+2Q]sEln2%1=E-]                           adds or subtracts the
                                                        the two values on the
                                                        stack depending on
                                                        parity of n

                             xlyrsylnld>r]              does the rest of the
                                                        stuff required to store
                                                        the new values properly
                                                        and quits if it has
                                                        done enough iterations

                                          sr            stores the main macro
                                                        in register r

                                                   lrxp executes the macro and
                                                        prints the stack

Register d stores the index of the value. Register n counts the number of iterations completed. Register r stores the main macro. Register y stores the later value in the sequence, while the stack contains the earlier value in the sequence.
Visual explanation of whats going on in the big loop (assuming addition):
register: y=1     y=1   y=1    y=1   y=1    y=2
stack:     1      1 1    2     2 1   1 2     1
               ly     +     ly     r     sy

The check to determine whether to add or subtract takes the counter modulo two and uses this trick to make an if then else construction.
At the end the stack contains a single number, the desired value, which is printed with p.
(I'm new to dc, so I'd expect there are some obvious improvements to be made here.)

Actually, 22 bytes
34*@%"334130110314"E≈¬

Try it online!
Explanation:
34*@%"334130110314"E≈¬
34*@%                   input % 12
     "334130110314"E    get that character in the string
                    ≈¬  convert to int, subtract 2

Java 7, 88 82 79 bytes
golfed:
int f(int n){int c,i=0,a=1,b=1;for(;i<n;){c=i++%2>0?a-b:a+b;a=b;b=c;}return b;}

ungolfed:
int f(int n)
{
    int c, i = 0, a = 1, b = 1;
    for (; i < n;)
    {
        c = i++ % 2 > 0 ? a - b : a + b;
        a = b;
        b = c;
    }
    return b;
}

Try it online

Since you go the "logical" way, here are some hints: 1. you forgot to declare int as return type. 2. you can spare bytes by moving the assignment of 0 to the declaration of i: int c,i=0 and for(;i<n;){. 3. You can remove parenthesis around the ternary operator condition.

@OlivierGrégoire thanks dude :) fixed. nice solution btw

Perl 6,  39 35  32 bytes
{(1,1,{|(($/=$^a+$^b),$b-$/)}...*)[$_]}

{(|(334130110314.comb X-2)xx*)[$_]}

{(|334130110314.comb xx*)[$_]-2}

{334130110314.substr($_%12,1)-2}

ABCR, 43 bytes
)AAB)ABB..A))A..A)AA(ABB.)A+A)))AiB5aAb(Bxo

Explanation: the first part ()AAB)ABB..A))A..A)AA(ABB.)A+A)))A) sets up queue A to contain [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], keeping all other queues empty.  iB stores our desired term, and the loop 5aAb(Bx cycles through the the queue that many times.  o prints the front of the queue as a number, which will then be our desired answer.

Batch, 49 bytes
@cmd/cset/a"n=%1%%12,~!(n%%3)*(1|-!(n%%5*(n/4)))"

Takes input as a command-line parameter. Explanation: Closed form uses the following observations:

Sequence is cyclic with period 12
Every third term is ±2 while other terms are ±1
Terms after the third are negative except multiples of 5 (after reducing modulo 12)

We therefore start by reducing modulo 12 (to save 2 bytes). We then reduce modulo three and invert the result, which is 1 for multiples of 3 or 0 otherwise. We then bitwise not that value, giving us -2 for multiples of 3 or -1 otherwise. We then reduce modulo 5 and separately divide by 4, giving zero for terms 1, 2, 3, 5, 10 and 12 (0). Inverting and negating gives us -1 for those values and zero for other values. We then bitwise or that with 1 and multiply with the earlier calculation.

TI-Basic, 26 bytes
Unfortunately, very uninteresting approach. I could not find anything shorter. The list is 1-indexed.
Input :{1,1,2,-1,1,-2:augment(Ans,-Ans:Ans(X

C#, 73 71 bytes
This uses 0-indexed values of n.
n=>{int a=1,b=1,i=0,r;for(;++i<n;){r=i%2>0?a+b:a-b;a=b;b=r;}return b;};

Formatted version:
Func<int, int> f = n =>
{
    int a = 1, b = 1, i = 0, r;

    for(; ++i < n;)
    {
        r = i % 2 > 0 ? a + b : a - b;
        a = b;
        b = r;
    }

    return b;
};

ForceLang, 153 bytes
def s set
s a 1
s b 1
s p 1
s k io.readnum()
if k=0
goto b
label a
s c b.mult p
s c a+c
s a b
s b c
s p p.mult -1
s k k+-1
if k
goto a
label b
io.write a

Turtlèd, 35 bytes
#112-1_--_1-2#?:[*l+].(-r'1)(_"-2")

0 indexed
Explanation:
#112-1_--_1-2#                      the 12 values of sequence. - is -1, _ is -2
              ?:                    input a number and move right that many
                [*l+]               move back to the asterisk on start cell,
                                    increment sting pointer by amount moved
                     .              write pointed char
                      (-r'1)        if it was -, move right, write 1
                            (_"-2") if it was _, write "-2"
      [print grid]

Try it online!