Contexte

Ceci est un exemple classique de manuel à illustrer pour les boucles.

C'est l'un des premiers programmes que j'ai appris lorsque j'ai commencé à apprendre la programmation il y a environ 10 ans.

Tâche

Vous devez imprimer ce texte exact:

**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Spécifications

• Vous pouvez avoir des retours à la ligne supplémentaires.
• Vous pouvez avoir des espaces de fin supplémentaires (U + 0020) à la fin de chaque ligne, y compris les nouvelles lignes de fin.

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Classement

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

/* Configuration */

var QUESTION_ID = 88653; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // 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 "https://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 "https://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,]*[^\s,]),.*?(\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,
      });
    
  });
  
  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;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, 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 > b.lang) return 1;
    if (a.lang < b.lang) 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="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>
<div id="language-list">
  <h2>Winners 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>
<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>

Brainfuck , 47 octets

++++++++++[->++++>+>+<<<]>++>[-<..........>>.<]

Essayez-le en ligne!

++++++++++[->++++>+>+<<<]   set the tape to 40 10 10
>++>                        set the tape to 42 10 10
[-<..........>>.<]          come on

C (gcc), 41 39 octets

main(i){for(;++i<puts("**********"););}

Bash + coreutils, 19 octets

Je préfère répéter des choses dans Bash en utilisant «oui».

yes **********|head

J'ai enregistré 2 octets par la suggestion de @ Neil. Mais lorsque le répertoire dans lequel vous exécutez cette commande ne contient pas que des fichiers commençant par un '.' dot que vous devez joindre les étoiles *avec ".

Bash + coreutils, 21 octets

yes "**********"|head

Vim, 13 à 8 octets

5 octets sauvegardés grâce à @Lynn

qqi*␛9.o␛q9@q 

10i*␛Y9p

10i*␛insérez 10 fois *, Y9pcopiez la ligne et collez-la 9 fois.

Pyth, 6 octets

VT*T\*

Test 10 en Pyth, Vabexécute les b atemps d' instruction , \*est la constante de caractère astérisque, et multiplie ( *) une chaîne et un entier répète cette chaîne n fois. L'impression implicite avec Pyth Vsignifie que 10 lignes sont imprimées.

Hexagone, 37 35 34 31

10"+}(=${";<$<1}42/.0@_=<>\;>(_

Étendu:

   1 0 " +
  } ( = $ {
 " ; < $ < 1
} 4 2 / . 0 @
 _ = < > \ ;
  > ( _ . .
   . . . .

Essayez-le en ligne

Fondamentalement, il n’ya que deux boucles for, le décompte allant de 10 à zéro, l’impression d’un astérisque sur la boucle interne et une nouvelle ligne sur la boucle externe.

Explication:

Ce programme comprend trois parties principales: l’initialisation de la mémoire, une boucle imprimant dix astérisques et une boucle imprimant une nouvelle ligne. La boucle qui imprime une nouvelle ligne contient également la boucle qui affiche les astérisques.

Tout d'abord, le code exécute l'initialisation de la mémoire totalement linéaire. Le code fonctionne comme: 10"+}42. Ceci configure la mémoire des bords proches pour ressembler à:

10 \ / 10
    |
   42

42 est le code ASCII du caractère astérisque et les deux dizaines seront utilisés comme compteurs de boucle. Il est à noter que le pointeur de la mémoire est actuellement orienté à l’écart des deux dizaines. Par conséquent, le fait de revenir en arrière nous place sur l’un des dizaines.

Ensuite, nous commençons la boucle d'impression astersisque. Linéairement, le code ressemble à : ;".._(. Cela affiche un astérisque, déplace le pointeur de la mémoire en arrière et à gauche et décrémente la valeur à cet endroit. Après une itération, la mémoire ressemblerait à ceci:

10 \ / 9
    |
   42

Ensuite, nous atteignons la condition de boucle: la plus en bas à gauche >. Si le bord que nous venons de décrémenter est toujours positif, nous rebondissons et exécutons un {pour nous ramener sur le 42. Puis nous frappons un $et retournons au début de la boucle d'impression ;, en sautant le <. Si la valeur était zéro, nous nous dirigeons dans l'autre boucle.

La boucle externe commence par réinitialiser le bord de mémoire récemment remis à zéro à dix (il s'agit 10du code dans le code sud-ouest). Ensuite, nous imprimons ce dix comme un caractère ASCII, qui est une nouvelle ligne. Ensuite, nous passons sur l'autre bord de la mémoire et le décrémentez avec {(puis exécutons ce qui équivaut à un tas de noops: =${_=. Maintenant, après une itération de cette boucle, la mémoire ressemblerait à ceci:

 9 \ / 10
    |
   42

Cette fois, la mémoire est tournée vers l’extérieur du bord, stockant un neuf dans le diagramme ci-dessus. Ensuite, nous exécutons le <qui agit comme condition de boucle pour la boucle externe. Si la valeur était différente de zéro, nous rebondissons sur certains miroirs, puis nous recommençons à exécuter des instructions significatives après être entré au sommet de l'hexagone au "sud-ouest en mouvement. Cela nous oblige à reculer et à gauche, à nouveau sur le 42, mais vers l'intérieur. Ensuite, l’ =inversion de notre direction, réinitialisant l’état correctement pour que la boucle interne recommence. Si le bord a été mis à zéro, le pointeur d'instruction se lance dans une petite aventure qui ne fait rien jusqu'à ce qu'il quitte le programme.

L'aventure commence par le pointeur d'instructions se dirigeant vers le nord-est, ignorant dangereusement la sécurité des points cardinaux. Il ignore courageusement un miroir aligné sur sa diretion ( /) et saute héroïquement d'un trampoline ($) évitant entièrement le piège mortel d'un autre trampoline totalement identique. En regardant le vide des bords hexagonaux non initialisés, le pointeur, sans faiblir un instant, ajoute les deux bords vides qu'il fait face ensemble, fixant ainsi le bord actuel à leur somme: 0 (le bord était en fait nul auparavant, mais le pointeur aime crois que c'était assez important). Comme le bord est égal à zéro, le pointeur tourne à gauche à l'embranchement de la route et entre dans une forêt mystérieuse (d'hexagones). Là, il se trouve désorienté, allant d’avant en arrière, jusqu’à ce qu’il se retrouve au même endroit dans sa mémoire de départ. Pensant que le problème doit être que le bord actuel a été réglé à zéro la dernière fois, le pointeur plante bravement une1dans le bord actuel. Ensuite, le noble pointeur explore un autre chemin, un avec: un piège! Le front actuel est décrémenté et remis à zéro! Le pointeur, hébété par la tournure choquante des événements, retombe dans le piège en définissant le bord actuel sur négatif. En colère, le pointeur tente de retourner dans la forêt relativement agréable, mais remarque que, le bord actuel n'étant pas positif, les chemins se sont à nouveau déplacés et le pointeur se retrouve dans une grotte. Et par une grotte, je veux dire la bouche d'un ver géant hexagonal. Impuissant, le pointeur maudit la sexualité avec son dernier souffle. En outre, le programme se termine.

Emacs, 10 à 8 frappes

F3 C-1 0 * ENTER F4 C-9 F4

Explication

F3             Starts a macro recording
C-1 0 *        Apply 10 times command '*': prints 10 asterix'
ENTER          Insert new line
F4             Stops the macro record
C-9 F4         Apply 9 times the macro

Merci à Sean pour avoir sauvé deux frappes de touche, suggérant de remplacer C-udigitpar C-digit.

Gelée , 7 octets

”*x⁵Ṅ9¡

Que se passe-t-il?

”*x⁵Ṅ9¡  - No arguments
”*       - character literal, *
  x      - multiply (dyadic operation)
   ⁵     - integer literal, 10 (we have now constructed the string '**********')
    Ṅ    - Print & linefeed (monadic operation)
     9   - integer literal, 9
      ¡  - Repeat n times (n is 9 as the first Ṅ is not a repeat)

Testez-le sur tryitonline

PowerShell, 14 12 octets

,('*'*10)*10

Construit une chaîne d'astérisques de longueur à l' 10aide de la multiplication de chaîne. Encapsule cela dans parens et alimente cela dans l'opérateur de virgule pour construire un tableau. Nous utilisons la multiplication de tableau pour construire un tableau de 10 éléments constitué de cet élément (c’est-à-dire un tableau de chaînes astérisque de 10 éléments). Cela reste sur le pipeline et la sortie est implicite (puisque la valeur Write-Outputpar défaut pour un tableau est séparée par une nouvelle ligne, nous l'obtenons gratuitement - merci à @Joey pour la clarification).

Plus ancien, 14 octets

0..9|%{'*'*10}

Programme complet. Boucles de 0à 9travers une ForEach-Objectboucle |%{...}. À chaque itération, nous utilisons la multiplication de chaînes pour créer une 10chaîne de longueur de *. Les chaînes résultantes sont laissées dans le pipeline et la sortie à la fin est implicite (étant donné que la valeur Write-Outputpar défaut pour un tableau est séparée par des lignes, nous l'obtenons gratuitement - grâce à @Joey pour la clarification).

V , 7 octets

10é*10Ä

Essayez-le en ligne!

À peu près aussi simple qu'une réponse peut être.

Explication:

10      "10 times:
  é*    "insert an asterisk
    10Ä "make 10 copies of the current line

Version non concurrente (5 octets):

10O±*

Explication:

10O     " Insert the following on the next ten lines:
   ±    "   10 copies of
    *   "   an asterisk

Cela n'a pas fonctionné lorsque le défi a été posté à cause d'un bogue.

Méduse , 12 à 10 octets

Merci à Zgarb d’avoir économisé 2 octets.

P$'*
 &;10

Essayez-le en ligne!

Explication

En utilisant une notation plus conventionnelle, ce programme représente l'expression suivante:

P( $( &;(10), '* ) )

&;prend une seule valeur et crée une paire avec deux fois cette valeur, &;(10)nous donne donc [10 10]. Ensuite, $reshape forme une grille d’astérisques 10x10. Enfin, Paffiche le tableau au "format matrice" qui imprime chaque chaîne sur sa propre ligne.

HTML et CSS, 104 60 octets

p::after{content:"**********"

<p><p><p><p><p><p><p><p><p><p>

^{Je ne sais pas si le nombre d'octets est correct (car je ne compte pas les <style>balises pour CSS. Le code HTML pourrait également être raccourci si j'utilisais un préprocesseur HTML, mais je ne suis pas sûr qu'il s'agisse d'enfreindre les règles.}

Merci à manatwork et Business Cat.

^{Voir mon entrée Jade de 36 octets}

Python 2, 22 21 octets

print('*'*10+'\n')*10

MATLAB, 14 octets

repmat('*',10)

APL , 9 octets

Fonctionne sur tous les APL jamais réalisés.

10 10⍴'*'

10 10 dix lignes et dix colonnes

⍴ cyclique r épéter

'*' une étoile

TryAPL en ligne!

Java 7, 63 octets

void f(){for(int i=0;i++<10;)System.out.println("**********");}

Juste pour le plaisir. Je n'arrive pas à trouver des astuces pour rendre cela plus court. Essayer d'ajouter une logique pour une boucle de 100 ou de renvoyer une chaîne au lieu d'une impression ne fait qu'empirer les choses.

Ruby, 15 personnages

puts [?**10]*10

Échantillon échantillon:

bash-4.3$ ruby -e 'puts [?**10]*10'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Bloc-notes, 34 à 31 frappes

**********
^A^C↓^V^A^C↓^V^V^V^V

^ indique que vous appuyez sur les touches Ctrl- <caractère suivant>, ↑ up sont respectivement les touches haut et bas.

Accessoires pour Crypto pour 3 frappes enregistrées.

Emojicode , 54 octets

🏁🍇🔂i⏩0 10🍇😀🔤**********🔤🍉🍉

Explication:

🏁🍇                        👴 The beginning of program.
    🔂 i ⏩ 0 10 🍇          👵 This is called a "range".
                          It basically starts with i=0 and increments until i=10, then exits. 👵
        😀 🔤**********🔤    👵 😀 is printing class.
                          The 🔤s make the characters they surround string literals. 👵
    🍉                     👴 End of range
🍉                         👴 End of program

05AB1E, 7 octets

TF'*T×,

Explication

TF      # 10 times do:
  '*T×  # repeat asterisk 10 times
      , # print with newline

Essayez-le en ligne

R, 27 29 octets

cat(rep('\r**********\n',10))

Une autre réponse (34 octets) est: cat(rep('**********',10),sep='\n')

PHP, 32 octets

for(;$i++<10;)echo"**********
";

(variante 32 octets - a été écrit avec echo)

<?=str_repeat("**********
",10);

(variante 33 octets)

<?=str_pad("",110,"**********
");

(variante 33 octets)

for(;$i++<110;)echo$i%11?"*":"
";

(variante 35 octets)

for(;$i++<10;)printf("%'*10s
",'');

(variante 38 octets)

<?=($a=str_repeat)($a("*",10)."
",10);

MATL , 8 octets

'*'10tX"

Essayez-le en ligne!

'*'   % Push '*' (string containing an asterisk)
10t   % Push 10 twice
X"    % Repeat the string 10×10 times. Implicitly display

Brainfuck, 46 43 octets

+[[---<]+[-->]<]<<[--<<++..........-->>>.<]

Essayez-le en ligne! Nécessite un interprète avec une bande ouverte à gauche et dotée de cellules 8 bits.

La première partie de ce programme +[[---<]+[-->]<]installe la bande comme suit:

[255, 250, 245, ... 15, 10, 5, 0, 250, 240, 230, ..., 40, 30, 20, 10, 0]
                                                                      ^

Cela donne un 40 pour la sortie des astérisques ( *, ASCII 42), un 20 à utiliser comme compteur de boucle et un 10 à utiliser pour la sortie des nouvelles lignes.

JavaScript (ES6), 37 octets

console.log(`**********
`.repeat(10))

Une réponse simple.

Cheddar, 21 à 20 octets

print('*'*10+'
')*10

Encore une réponse simple.

Haskell, 29 octets

putStr$[0..9]>>"**********\n"

<list1> >> <list2>fait des (length <list1>)copies de <list2>.

R, 35 33 32 octets

Ô R, tu es tellement bavard parfois .

for(i in 1:10)cat(rep("*",10),"\n")

Fait intéressant, la catfonction n'a aucune valeur (elle fournit NULLà STDOUT), vous ne pouvez donc pas faire quelque chose comme rep(cat(rep))), ce qui aurait été plus drôle!

EDIT:
Nouvelle solution proposée par @LeakyNun, -2 octets.

for(i in 1:10)cat("**********\n")

EDIT: Raccourcissez-le juste par -1 octet, par @ user5957401

for(i in 0:9)cat("**********\n")

Rétine , 12 octets

Le nombre d'octets suppose un codage ISO 8859-1. Le premier saut de ligne est significatif.

10$**
.
$_¶

La première étape écrit une chaîne de dix astérisques, la deuxième étape remplace chaque astérisque par la chaîne complète et un saut de ligne. Ceci imprime deux sauts de ligne de fin.

J , 10 9 octets

1 octet grâce à @ Adám.

10 10$'*'

Interprète en ligne .

Explication

10 10spécifie la dimension de l'opérateur $qui construit un tableau avec les dimensions spécifiées.