Antecedentes

Este es un ejemplo de libro de texto estándar para demostrar los bucles.

Este es uno de los primeros programas que aprendí cuando comencé a aprender programación hace ~ 10 años.

Tarea

Debe imprimir este texto exacto:

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

Especificaciones

• Es posible que tenga nuevas líneas adicionales.
• Puede tener espacios finales adicionales (U + 0020) al final de cada línea, incluidas las nuevas líneas finales adicionales.

Puntuación

Este es el código de golf . La respuesta más corta en bytes gana.

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

/* 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 bytes

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

Pruébalo en línea!

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

C (gcc), 41 39 bytes

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

Bash + coreutils, 19 bytes

Prefiero repetir cosas en Bash usando 'sí'.

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

Ahorré 2 bytes por sugerencia de @ Neil. Pero cuando el directorio donde está ejecutando este comando no solo contiene archivos que comienzan con un '.' dot necesita para encerrar las estrellas *con ".

Bash + coreutils, 21 bytes

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

Vim, 13 8 bytes

Guardado 5 bytes gracias a @Lynn

qqi*␛9.o␛q9@q 

10i*␛Y9p

10i*␛inserte 10 veces *, Y9pcopie la línea y péguela 9 veces.

Pyth, 6 bytes

VT*T\*

Tes 10 en Pyth, Vabejecuta b atiempos de instrucción , \*es la constante de carácter de asterisco y multiplica ( *) una cadena y un entero repite esa cadena n veces. La impresión implícita de Pyth con Vmedios se imprimen 10 líneas.

Hexagonia 37 35 34 31

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

Expandido:

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

Pruébalo en línea

Básicamente solo tiene dos para bucles contando desde diez hasta cero, imprimiendo un asterisco en el bucle interno y una nueva línea en el bucle externo.

Explicación:

Este programa consta de tres partes principales: inicialización de la memoria, un bucle que imprime diez asteriscos y un bucle que imprime una nueva línea. El bucle que imprime una nueva línea también contiene el bucle que imprime los asteriscos.

Primero, el código ejecuta la inicialización de memoria totalmente lineal. El código funciona a ser: 10"+}42. Esto configura la memoria de los bordes cercanos para que se vea así:

10 \ / 10
    |
   42

42 es el código ASCII para el carácter de asterisco, y las dos decenas se utilizarán como nuestros contadores de bucle. Es de destacar que el puntero de memoria está apuntando actualmente lejos de las dos decenas, por lo que moverse hacia atrás nos colocará en una de las decenas.

A continuación, comenzamos el ciclo de impresión de astersisk. Linealmente, el código es el siguiente: ;".._(. Esto imprime un asterisco, mueve el puntero de memoria hacia atrás y hacia la izquierda y finalmente disminuye el valor allí. Después de una iteración, la memoria se vería así:

10 \ / 9
    |
   42

Luego llegamos a la condición de bucle: el extremo inferior izquierdo >. Si el borde que acabamos de disminuir sigue siendo positivo, rebotamos y ejecutamos a {para movernos de nuevo al 42. Luego golpeamos ay regresamos $al comienzo del ciclo de impresión ;, saltando el <. Si el valor era cero, nos dirigimos al otro ciclo.

El bucle externo comienza restableciendo el borde de memoria recientemente puesto a cero a diez (este es 10el código, que va hacia el suroeste). Luego, imprimimos este diez como un carácter ASCII, que es una nueva línea. A continuación, pasamos a la otra orilla de memoria y disminuirlo con {(y luego ejecutar lo que equivale a un montón de noops: =${_=. Ahora, después de una iteración de este ciclo, la memoria se vería así:

 9 \ / 10
    |
   42

Esta vez, la memoria está mirando hacia afuera desde el borde y almacena un nueve en el diagrama anterior. Luego ejecutamos el <que actúa como la condición del bucle para el bucle externo. Si el valor no es cero, rebotamos en algunos espejos, luego comenzamos a ejecutar instrucciones significativas nuevamente después de ingresar a la parte superior del hexágono en el "suroeste en movimiento. Esto hace que nos movamos hacia atrás y hacia la izquierda, nuevamente a la 42, pero mirando hacia adentro. Luego, =cambia nuestra dirección, restableciendo el estado correctamente para comenzar el ciclo interno nuevamente. Si el borde se estableció en cero, el puntero de instrucción se embarca en una pequeña aventura que no hace nada hasta que sale del programa.

La aventura comienza con el puntero de instrucciones que se aventura hacia el noreste, sin tener en cuenta la seguridad de las direcciones cardinales. Valientemente ignora un espejo que está alineado con su dirección ( /) y salta heroicamente de un trampolín ($) evadiendo por completo la trampa mortal de otro trampolín totalmente idéntico. Mirando el vacío de los bordes del hexágono no inicializados, el puntero, sin vacilar por un momento, agrega los dos bordes en blanco que enfrenta, estableciendo el borde actual en su suma: 0 (el borde era en realidad cero de antemano, pero al puntero le gusta creo que esto fue bastante importante). Como el borde es cero, el puntero gira a la izquierda en la bifurcación de la carretera y se adentra en un bosque misterioso (de hexágonos). Allí, se encuentra desorientado, moviéndose hacia adelante y hacia atrás y hacia adelante, hasta que termina en el mismo lugar en la memoria que comenzó. Pensando que el problema debe ser que el borde actual se estableció en cero la última vez, el puntero planta valientemente un1en el borde actual Entonces, el noble puntero investiga otro camino, uno tendido con ... ¡una trampa! ¡El borde actual se reduce y vuelve a cero! El puntero, aturdido por el sorprendente giro de los acontecimientos, vuelve a tropezar en la trampa y establece el borde actual en negativo. Enfurecido, el puntero intenta regresar al bosque relativamente agradable, solo para darse cuenta de que, dado que el borde actual no es positivo, los caminos han cambiado una vez más y el puntero se encuentra caminando hacia una cueva. Y por una cueva, me refiero a la boca de un gusano hexagonal gigante. Indefenso, el puntero maldice la sexinidad con su último aliento. Además, el programa termina.

Emacs, 10 8 pulsaciones de teclas

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

Explicación

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

Gracias a Sean por guardar dos pulsaciones de teclas, sugiriendo reemplazar C-udigitcon C-digit.

Jalea , 7 bytes

”*x⁵Ṅ9¡

¿Que esta pasando?

”*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)

Pruébalo en tryitonline

PowerShell, 14 12 bytes

,('*'*10)*10

Construye una cadena de asteriscos de longitud 10usando la multiplicación de cadenas. Encapsula eso en parens y lo introduce en el operador de coma para construir una matriz. Utilizamos la multiplicación de matrices para construir una matriz de 10 elementos que consta de ese elemento (es decir, una matriz de cadenas de asterisco de 10 elementos). Eso queda en la tubería, y la salida es implícita (dado que el valor predeterminado Write-Outputpara una matriz está separado por una nueva línea, lo obtenemos de forma gratuita, gracias a @Joey por la aclaración).

Mayores, 14 bytes

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

Programa completo Bucles de 0a 9través de un ForEach-Objectbucle |%{...}. En cada iteración, usamos la multiplicación de cadenas para crear una 10cadena de longitud de *. Esas cadenas resultantes se dejan en la tubería, y la salida al final es implícita (dado que el valor predeterminado Write-Outputpara una matriz está separado por una nueva línea, lo obtenemos de forma gratuita, gracias a @Joey por la aclaración).

V , 7 bytes

10é*10Ä

Pruébalo en línea!

Tan simple como puede ser una respuesta.

Explicación:

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

Versión no competitiva (5 bytes):

10O±*

Explicación:

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

Esto no funcionó cuando se publicó el desafío debido a un error.

Medusa , 12 10 bytes

Gracias a Zgarb por guardar 2 bytes.

P$'*
 &;10

Pruébalo en línea!

Explicación

Usando notación más convencional, este programa representa la siguiente expresión:

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

&;toma un solo valor y crea un par con dos veces ese valor, así &;(10)que nos da [10 10]. Luego $se reforma la forma que forma una cuadrícula de asteriscos de 10x10. Finalmente, Pimprime la matriz en "formato de matriz" que imprime cada cadena en su propia línea.

HTML y CSS, 104 60 bytes

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

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

^{No estoy seguro si el recuento de bytes es correcto (ya que no estoy contando las <style>etiquetas para CSS. El HTML también podría acortarse si utilizo un preprocesador HTML, pero no estoy seguro si eso está infringiendo las reglas}

Gracias a manatwork y Business Cat.

^{Mira mi entrada de Jade de 36 bytes}

Python 2, 22 21 bytes

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

MATLAB, 14 bytes

repmat('*',10)

APL , 9 bytes

Funciona en todas las APL jamás realizadas.

10 10⍴'*'

10 10 diez filas y diez columnas

⍴ cíclicamente r epeating

'*' una estrella

TryAPL en línea!

Java 7, 63 bytes

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

Sólo por diversión. Parece que no puedo encontrar ningún truco para hacer esto más corto. Intentar agregar lógica para un bucle de 100 o devolver una cadena en lugar de imprimir simplemente termina peor.

Ruby, 15 caracteres.

puts [?**10]*10

Ejecución de muestra:

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

Bloc de notas, 34 31 pulsaciones de teclas

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

^ denota Ctrl- <siguiente carácter> pulsación de tecla, ↑ ↓ son teclas arriba y abajo, respectivamente.

Atrezzo a Crypto para 3 pulsaciones de teclas guardadas.

Emojicode , 54 bytes

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

Explicación:

🏁🍇                        👴 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 bytes

TF'*T×,

Explicación

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

Pruébalo en línea

R, 27 29 bytes

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

Una respuesta alternativa (34 bytes) es: cat(rep('**********',10),sep='\n')

PHP, 32 bytes

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

(variante 32 bytes - se escribió con echo)

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

(variante 33 bytes)

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

(variante 33 bytes)

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

(variante 35 bytes)

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

(variante 38 bytes)

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

MATL , 8 bytes

'*'10tX"

Pruébalo en línea!

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

Brainfuck, 46 43 bytes

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

Pruébalo en línea! Requiere un intérprete con una cinta abierta a la izquierda y con celdas de 8 bits.

La primera parte de este programa +[[---<]+[-->]<]configura la cinta así:

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

Esto da un 40 para generar asteriscos ( *ASCII 42), un 20 para usar como contador de bucle y un 10 para usar para generar nuevas líneas.

JavaScript (ES6), 37 bytes

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

Una respuesta directa.

Cheddar, 21 20 bytes

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

Otra respuesta más directa.

Haskell, 29 bytes

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

<list1> >> <list2>hace (length <list1>)copias de <list2>.

R, 35 33 32 bytes

Ô R, eres tan prolijo a veces .

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

Curiosamente, la catfunción no tiene valor (proporciona NULLa STDOUT), por lo que no puede hacer algo así rep(cat(rep))), ¡lo que hubiera sido más divertido!

EDITAR:
Nueva solución propuesta por @LeakyNun, -2 bytes.

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

EDITAR: acortándolo solo por -1 byte, por @ user5957401

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

Retina , 12 bytes

El recuento de bytes asume la codificación ISO 8859-1. El avance de línea principal es significativo.

10$**
.
$_¶

La primera etapa escribe una cadena de diez asteriscos, la segunda etapa reemplaza cada asterisco con la cadena completa y un salto de línea. Esto imprime dos avances de línea finales.

J , 10 9 bytes

1 byte gracias a @ Adám.

10 10$'*'

Intérprete en línea .

Explicación

10 10especifica la dimensión al operador $que construye una matriz con las dimensiones especificadas.