This question already has an answer here:

Related

Goats are great. Everybody loves goats.

And they also, for some reason, are an excellent complex ascii art for many languages to have built-ins for. Because of this, I personally feel a catalogue to document just how easily a language can print goats is greatly needed.

The Challenge

Given an integer input via any means print that many Goats separated by Newlines.

Your Goat for reference is:

  ___.
 //  \\
((   ''
 \\__,
/6 (%)\,
(__/:";,;\--____----_
;; :';,:';`;,';,;';`,`_
  ;:,;;';';,;':,';';,-Y\
   ;,;,;';';,;':;';'; Z/
   / ;,';';,;';,;';;'
  / / |';/~~~~~\';;'
 ( K  | |      || |
  \_\ | |      || |
   \Z | |      || |
      L_|      LL_|
      LW/      LLW/

Your particular goat may have more whitespace around it, if required.

Example

Given 3 on input, Output:

  ___.
 //  \\
((   ''
 \\__,
/6 (%)\,
(__/:";,;\--____----_
;; :';,:';`;,';,;';`,`_
  ;:,;;';';,;':,';';,-Y\
   ;,;,;';';,;':;';'; Z/
   / ;,';';,;';,;';;'
  / / |';/~~~~~\';;'
 ( K  | |      || |
  \_\ | |      || |
   \Z | |      || |
      L_|      LL_|
      LW/      LLW/
  ___.
 //  \\
((   ''
 \\__,
/6 (%)\,
(__/:";,;\--____----_
;; :';,:';`;,';,;';`,`_
  ;:,;;';';,;':,';';,-Y\
   ;,;,;';';,;':;';'; Z/
   / ;,';';,;';,;';;'
  / / |';/~~~~~\';;'
 ( K  | |      || |
  \_\ | |      || |
   \Z | |      || |
      L_|      LL_|
      LW/      LLW/
  ___.
 //  \\
((   ''
 \\__,
/6 (%)\,
(__/:";,;\--____----_
;; :';,:';`;,';,;';`,`_
  ;:,;;';';,;':,';';,-Y\
   ;,;,;';';,;':;';'; Z/
   / ;,';';,;';,;';;'
  / / |';/~~~~~\';;'
 ( K  | |      || |
  \_\ | |      || |
   \Z | |      || |
      L_|      LL_|
      LW/      LLW/

The Rules

  • You must take an integer input where 0 < input < 256, and print that many goats.
  • Goats may vary in whitespace, as long as the shape of the goat is the same.
  • You must submit a full program.
  • This is a catalogue, so any language or language version newer than the challenge is acceptable. Like usual, creating a language that prints N goats in 0 bytes isn't incredibly creative. Also, as this is a catalogue, no answer will be accepted.
  • This is however , so shortest answer per language.
  • If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck-derivatives like Alphuck), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.

The Catalogue

Shamelessly stolen from The Hello World Challenge

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

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 snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 107765; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 58375; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

marked as duplicate by Rohan Jhunjhunwala, Taylor Scott, Post Left Ghost Hunter, Christopher, Mego code-golf Apr 1 '17 at 20:16

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

  • 2
    I would like to vote as a dupe of the rickroll challenge – Blue Jan 23 '17 at 8:31
  • 25
    I downvoted because this challenge seems to be pandering to languages that have this exact goat art implemented as a built-in. And otherwise it's just copying a fixed string n times, where the string has too little structure to beat hardcoding or general-purpose compression for many languages. – xnor Jan 23 '17 at 9:20
  • 3
    I find it kinda funny that both given answers aren't even matching OP's specified output.. Both answers use " (double quotes) instead of the 'specified' ' (single quotes). Also, every line in OP's 'specified' output is missing a space, although I'm assuming that's just a StackExchange formatting issue? – Kevin Cruijssen Jan 23 '17 at 10:47
  • 2
    @ATaco At this moment, none of the answers has a positive score, so you can delete the question if you want to. – Dennis Jan 23 '17 at 16:31
  • 4
    Closevoters: there is nothing unclear about this challenge. Downvote challenges that you dislike - don't close-vote them unless they actually have issues. – Mego Jan 30 '17 at 4:04

Ruby (2.3), 312 bytes

Hey, at least I didn't use a built-in!

n=gets.to_i
puts "
  ___.
 //  \\\\
((   ''
 \\\\__,
/6 (%)\,
(__/:\";,;\--____----_
;; :';,:';`;,';,;';`,`_
  ;:,;;';';,;':,';';,-Y\\ 
   ;,;,;';';,;':;';'; Z/
   / ;,';';,;';,;';;'
  / / |';/~~~~~\\';;'
 ( K  | |      || |
  \\_\\ | |      || |
   \\Z | |      || |
      L_|      LL_|
      LW/      LLW/\n"*n
  • 1
    You can save a few bytes by making this a function that accepts a number as an argument Just sayin' ! Returning a string instead of printing would be shorter too, if allowed... – Level River St Jan 23 '17 at 22:45
  • @LevelRiverSt The challenge requires only a full program – Cows quack Jan 24 '17 at 17:35

Jelly,  194  191 bytes

-3 replacing b24ị with (a since-developed atom)

“wɦLż8ßȧṛ Ỵ?þġЮạSḍọsñL1⁶ƁṄṫȥẊ`m®Ø⁼ƒ⁺Ė6⁺oHpæİṇµ\ṅṁ⁷V⁶k¡i£}ḣọSƑṭ<ḃṚSØ:kŒxṘıquṂUnƭ⁾DEØẓ×ðH¦ḅċ5pðḳṅ⁶Ḅḍ€®85ɲPp¦Ø0B¥=ẊCƲ<7eØ7ƥ÷8¡ÆḅẎṣṂ(hþẓ]ƲƤȦE¶ƙCɼƭżÆµėṙṾḞ\&O ¬ṆñKmɠ’ṃ“ .¶/\(',6%):";-`YZ|~KLW_”Ṅ¡’

Try it online!

How?

The 24 distinct characters from which the goat is constructed are:
.¶/\(',6%):";-`YZ|~KLW_
where represents a line feed, and the first character is a space.

A goat may now be thought of as a 277 digit base 24 number, G, where each digit represents the 1-based and mod-24 index of a character in the above list.

The code forms G using base 250, transforms G to a base 24 representation as a list of digits and indexes into the character set. It then repeats an instruction to print the resulting character array and a line feed n-1 times.

a long string of bytes
  |
“...’ṃ“ .¶/\(',6%):";-`YZ|~KLW_”Ṅ¡’ - Main link: n
“...’                               - make G using base 250
      “ .¶/\(',6%):";-`YZ|~KLW_”    - the characters of a goat, ¶ being a line feed
     ṃ                              - base decompression (use the 24 characters as the base 24 digits)
                                  ’ - decrement n to give n-1
                                 ¡  - repeat the previous link n-1 times
                                Ṅ   - print the result and a line feed

The only slight complication is that Jelly's base 250 representation is 1-based and the indexing is modular, so when a zero digit is present it will be a 250 digit - the remedy is to reduce the next most significant digit by 1, and repeat if that becomes a zero. (This occasionally will make for shorter code, but not this time.)

RProgN, 16 bytes

"goat " read m C

I assume this is the answer you've been waiting for...

Try it online!

JavaScript (ES6), 306 bytes

Some slightly compressed goats...

[..."abcdefghijklmnopqrs"].map((c,i)=>s=s.split(c).join(`
 jnk me|h--~~|omLqq
r__pr,; |rr';  \\`.substr(i*2,2)),s=`rl_.a//rss
((r ''assl,
/6 (%)s,
(l/:";nsfllff_
;; :q,:q\`;,qnq\`,\`_k;:n;b':,j,-Ysc;nnb':;j Z/c/ ;,bqnq;'k/ /oq/gg~sq;'a( Krhdks_soodcsZood
i_|iL_|
iW/iLW/
`)&&console.log(s.repeat(prompt()))

Lua, 306 bytes

:rep()'s io.read() times.

print(([[  ___.
 //  \\
((   ''
 \\__,
/6 (%)\,
(__/:";,;\--____----_
;; :';,:';`;,';,;';`,`_
  ;:,;;';';,;':,';';,-Y\
   ;,;,;';';,;':;';'; Z/
   / ;,';';,;';,;';;'
  / / |';/~~~~~\';;'
 ( K  | |      || |
  \_\ | |      || |
   \Z | |      || |
      L_|      LL_|
      LW/      LLW/
]]):rep(io.read()))

SOGL, 174 bytes

▼īj-ηī¤ķJφB╝║α$a3╬ο'Βw)woE;@ē¹█lα.⁶↓!mΙ;┌.}γ§⁹≡r³╝╚wΓδΘργ±:⁾▓√׀⅝╝█%čczgΧMθL`«UΓ║νZ█č└sΩ±⅛mΤCρ2o¦≠]ΖøΙΧ²`žB+9‰κ╚¦¤Ƨ¹≥ΗxƧWJ∞┐∑¹±YEōΟ№Χθ≥⁹~E∞θ<a∙λy⌠s⁹░WP≡Φ╝∆~λ?(l$′Ζŗ=Κ╗2Ψ⁄>τ-‘*

vary simple (from the outside)

...‘   push that string decompressed
    *  multiply by input

I had to chop the goat up into pieces of strings that each when compressed is as small as possible, which then get each compressed and joined together. more info

  • 3
    Chopping up goats? D: that's mean :P – HyperNeutrino Aug 24 '17 at 1:18

Not the answer you're looking for? Browse other questions tagged or ask your own question.