fundo

Este é um exemplo de livro padrão para demonstrar para loops.

Este é um dos primeiros programas que aprendi quando comecei a aprender programação ~ há 10 anos.

Tarefa

Você deve imprimir este texto exato:

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

Especificações

• Você pode ter novas linhas extras à direita.
• Você pode ter espaços extras à direita (U + 0020) no final de cada linha, incluindo as novas linhas extras à direita.

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores 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

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

Experimente online!

++++++++++[->++++>+>+<<<]   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

Prefiro repetir coisas no Bash usando 'yes'.

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

Eu salvei 2 bytes por sugestão de @ Neil. Mas quando o diretório em que você está executando este comando não contém apenas arquivos começando com um '.' dot você precisa colocar as estrelas *com ".

Bash + coreutils, 21 bytes

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

Vim, 13 8 bytes

Guardado 5 bytes graças a @Lynn

qqi*␛9.o␛q9@q 

10i*␛Y9p

10i*␛insira 10 vezes *, Y9pcopie a linha e cole 9 vezes.

Pitão, 6 bytes

VT*T\*

Té 10 em Pyth, Vabexecuta b atempos de instrução , \*é a constante de caractere asterisco e multiplica ( *) uma string e um número inteiro repete essa string n vezes. A impressão implícita de Pyth com Vmeios 10 linhas é impressa.

Hexagony, 37. 35 34 31

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

Expandido:

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

Experimente online

Basicamente, existem apenas dois para loops, contando de dez a zero, imprimindo um asterisco no loop interno e uma nova linha no loop externo.

Explicação:

Este programa consiste em três partes principais: inicialização da memória, um loop que imprime dez asteriscos e um loop que imprime uma nova linha. O loop que imprime uma nova linha também contém o loop que imprime os asteriscos.

Primeiro, o código executa a inicialização da memória totalmente linear. O código trabalha-se: 10"+}42. Isso define a memória das bordas próximas para se parecer com:

10 \ / 10
    |
   42

42 é o código ASCII para o caractere asterisco e as duas dezenas serão usadas como nossos contadores de loop. É digno de nota que o ponteiro da memória está atualmente apontando para fora das duas dezenas, portanto, retroceder nos colocará em uma das dezenas.

Em seguida, iniciamos o ciclo de impressão astersisk. Linearmente, o código se parece com: ;".._(. Isso imprime um asterisco, move o ponteiro da memória para trás e para a esquerda e, finalmente, diminui o valor lá. Após uma iteração, a memória seria semelhante a:

10 \ / 9
    |
   42

Então atingimos a condição do loop: o canto inferior esquerdo >. Se a borda que acabamos de decrescer ainda é positiva, pulamos e executamos a {para nos mover de volta para a 42. Em seguida, pressionamos a $e retornamos ao início do ciclo de impressão ;, pulando o <. Se o valor for zero, vamos para o outro loop.

O loop externo começa redefinindo a borda da memória recentemente zerada para dez (este é 10o código, indo para sudoeste). Em seguida, imprimimos esses dez como um caractere ASCII, que é uma nova linha. Em seguida, vamos passar para a outra margem memória e diminui-lo com {(e, em seguida, executar o que equivale a um monte de noops: =${_=. Agora, após uma iteração desse loop, a memória seria semelhante a:

 9 \ / 10
    |
   42

Desta vez, a memória está voltada para fora a partir da borda, armazenando nove no diagrama acima. Em seguida, executamos o <que atua como condição do loop externo. Se o valor for diferente de zero, saltaremos de alguns espelhos e começaremos a executar instruções significativas novamente depois de entrar no topo do hexágono no "sudoeste em movimento. Isso nos leva a recuar e a esquerda para os 42 novamente, mas voltados para dentro. Então ele =vira em nossa direção, redefinindo o estado adequadamente para iniciar o loop interno novamente. Se a borda foi ajustada para zero, o ponteiro de instruções inicia uma pequena aventura que não faz nada até sair do programa.

A aventura começa com o ponteiro de instruções que se dirige para o nordeste, desconsiderando perigosamente a segurança das direções cardeais. Corajosamente ignora um espelho que está alinhado com sua direção ( /) e heroicamente salta de um trampolim ($) escapando inteiramente da armadilha mortal de outro trampolim totalmente idêntico. Observando o vazio das arestas hexagonais não inicializadas, o ponteiro, sem hesitar por um momento, adiciona as duas arestas em branco que enfrenta, definindo a aresta atual em sua soma: 0 (a aresta era realmente zero antes, mas o ponteiro gosta de acredite que isso foi muito importante). Como a margem é zero, o ponteiro faz uma curva à esquerda na bifurcação da estrada, entrando em uma floresta misteriosa (de hexágonos). Lá, ele se vê desorientado, movendo-se para frente e para trás e para frente, até acabar no mesmo lugar na memória que começou. Pensando que o problema deve ser que a borda atual foi zerada da última vez, o ponteiro bravamente planta um1na borda atual. Então, o apontador nobre investiga outro caminho, um colocado com ... uma armadilha! A aresta atual é decrementada e volta a zero! O ponteiro, atordoado pela reviravolta chocante dos eventos, volta a tropeçar na armadilha, colocando a borda atual em negativa. Enfurecido, o ponteiro tenta retornar à floresta relativamente agradável, apenas para perceber que, como a borda atual não é positiva, os caminhos mudaram novamente e o ponteiro se vê entrando em uma caverna. E por uma caverna, quero dizer a boca de um verme hexagonal gigante. Desamparado, o ponteiro amaldiçoa a sexualidade com seu hálito moribundo. Além disso, o programa termina.

Emacs, 10 8 pressionamentos de tecla

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

Explicação

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

Agradecemos a Sean por salvar duas teclas pressionadas, sugerindo a substituição C-udigitpor C-digit.

Geléia , 7 bytes

”*x⁵Ṅ9¡

O que está acontecendo?

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

Teste em tryitonline

PowerShell, 14 12 bytes

,('*'*10)*10

Constrói uma cadeia de asteriscos de comprimento 10usando a multiplicação de cadeias. Encapsula isso em parens e alimenta isso no operador de vírgula para construir uma matriz. Usamos multiplicação de array para construir um array de 10 elementos que consiste nesse elemento (ou seja, um array de 10 elementos de seqüências de caracteres de asterisco). Isso é deixado no pipeline e a saída é implícita (como o padrão Write-Outputpara uma matriz é separado por nova linha, obtemos isso de graça - graças a @Joey pelo esclarecimento).

Mais antigo, 14 bytes

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

Programa completo. Loops de 0para 9através de um ForEach-Objectloop |%{...}. A cada iteração, usamos a multiplicação de cadeias para criar uma 10cadeia de comprimento de *. Essas seqüências resultantes são deixadas no pipeline e a saída no final é implícita (como o padrão Write-Outputpara uma matriz é separado por nova linha, obtemos isso de graça - graças a @Joey pelo esclarecimento).

V , 7 bytes

10é*10Ä

Experimente online!

Tão simples quanto uma resposta pode ser.

Explicação:

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

Versão não concorrente (5 bytes):

10O±*

Explicação:

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

Isso não funcionou quando o desafio foi lançado devido a um bug.

Água-viva , 12 10 bytes

Obrigado ao Zgarb por salvar 2 bytes.

P$'*
 &;10

Experimente online!

Explicação

Usando notação mais convencional, este programa representa a seguinte expressão:

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

&;pega um único valor e cria um par com duas vezes esse valor, o que &;(10)nos dá [10 10]. Em seguida, $é remodelado, o que forma uma grade de 10x10 de asteriscos. Por fim, Pimprime a matriz em "formato de matriz", que imprime cada sequência em sua própria linha.

HTML e CSS, 104 60 bytes

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

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

^{Não tenho certeza se a contagem de bytes está correta (como não estou contando as <style>tags para CSS. O HTML também pode ser reduzido se eu usar um pré-processador HTML, mas não tenho certeza se isso está violando as regras}

Graças a manatwork e Business Cat.

^{Veja minha entrada Jade de 36 bytes}

Python 2, 22 21 bytes

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

MATLAB, 14 bytes

repmat('*',10)

APL , 9 bytes

Funciona em todos os APLs já feitos.

10 10⍴'*'

10 10 dez linhas e dez colunas

⍴ ciclicamente r epeating

'*' uma estrela

TryAPL online!

Java 7, 63 bytes

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

Apenas por diversão. Não consigo encontrar nenhum truque para tornar isso mais curto. Tentar adicionar lógica para um loop de 100 ou retornar uma String em vez de imprimir apenas acaba pior.

Ruby, 15 caracteres

puts [?**10]*10

Exemplo de execução:

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

Bloco de notas, 34 31 pressionamentos de tecla

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

^ indica Ctrl- <caractere seguinte> pressionamento de tecla, ↑ ↓ são teclas para cima e para baixo, respectivamente.

Adota o Crypto por 3 pressionamentos de tecla salvos.

Emojicode , 54 bytes

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

Explicação:

🏁🍇                        👴 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×,

Explicação

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

Experimente online

R, 27 29 bytes

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

Uma resposta alternativa (34 bytes) é: cat(rep('**********',10),sep='\n')

PHP, 32 bytes

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

(variante 32 bytes - foi escrita com 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"

Experimente online!

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

Brainfuck, 46 43 bytes

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

Experimente online! Requer um intérprete com uma fita aberta à esquerda e com células de 8 bits.

A primeira parte deste programa +[[---<]+[-->]<]configura a fita da seguinte forma:

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

Isso fornece 40 para a saída de asteriscos ( *ASCII 42), 20 para usar como contador de loop e 10 para a saída de novas linhas.

JavaScript (ES6), 37 bytes

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

Uma resposta direta.

Queijo Cheddar, 21 20 bytes

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

Mais uma resposta direta.

Haskell, 29 bytes

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

<list1> >> <list2>faz (length <list1>)cópias de <list2>.

R, 35 33 32 bytes

Ô R, às vezes você é tão detalhado .

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

Curiosamente, a catfunção não tem valor (fornece NULLSTDOUT), então você não pode fazer algo parecido rep(cat(rep))), o que seria mais engraçado!

EDIT:
Nova solução proposta por @LeakyNun, -2 bytes.

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

EDIT: Encurtando-o apenas por -1 byte, por @ user5957401

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

Retina , 12 bytes

A contagem de bytes assume a codificação ISO 8859-1. O avanço de linha principal é significativo.

10$**
.
$_¶

O primeiro estágio grava uma sequência de dez asteriscos, o segundo estágio substitui cada asterisco pela sequência inteira e um avanço de linha. Isso imprime dois feeds de linha à direita.

J , 10 9 bytes

1 byte graças a @ Adám.

10 10$'*'

Intérprete online .

Explicação

10 10especifica a dimensão para o operador $que cria uma matriz com as dimensões especificadas.