sfondo

Questo è un esempio di manuale standard da dimostrare per i loop.

Questo è uno dei primi programmi che ho imparato quando ho iniziato a studiare la programmazione ~ 10 anni fa.

Compito

Devi stampare questo testo esatto:

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

Specifiche

• Potresti avere nuove righe finali.
• Potresti avere spazi finali aggiuntivi (U + 0020) alla fine di ogni riga, comprese le nuove righe finali finali.

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

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

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

Provalo online!

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

C (gcc), 41 39 byte

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

Bash + coreutils, 19 byte

Preferisco ripetere cose in Bash usando 'yes'.

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

Ho salvato 2 byte su suggerimento di @ Neil. Ma quando la directory in cui stai eseguendo questo comando non contiene solo file che iniziano con un '.' dot è necessario racchiudere le stelle *con ".

Bash + coreutils, 21 byte

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

Vim, 13 8 byte

5 byte salvati grazie a @Lynn

qqi*␛9.o␛q9@q 

10i*␛Y9p

10i*␛inserisci 10 volte *e Y9pcopia la linea e incollala 9 volte.

Pyth, 6 byte

VT*T\*

Tè 10 in Pyth, Vabesegue i b atempi di istruzione , \*è la costante di carattere asterisco e moltiplicando ( *) una stringa e un numero intero ripete quella stringa n volte. La stampa implicita di Pyth con stampa di V10 linee.

Hexagony, 37 35 34 31

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

Allargato:

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

Provalo online

Fondamentalmente ne ha solo due per il conto alla rovescia da dieci a zero, stampando un asterisco sul loop interno e una nuova riga sul loop esterno.

Spiegazione:

Questo programma è composto da tre parti principali: inizializzazione della memoria, un loop che stampa dieci asterischi e un loop che stampa una nuova riga. Il ciclo che stampa una nuova riga contiene anche il ciclo che stampa gli asterischi.

Innanzitutto, il codice esegue l'inizializzazione della memoria totalmente lineare. Il codice funziona a essere: 10"+}42. Questo imposta la memoria dei bordi vicini in modo che assomigli a:

10 \ / 10
    |
   42

42 è il codice ASCII per il carattere asterisco e le due decine verranno utilizzate come contatori di loop. Da notare che il puntatore della memoria sta puntando in modo diverso dalle due decine, quindi spostarsi all'indietro ci metterà su una delle dieci.

Quindi, iniziamo il ciclo di stampa dell'asterisco. Linearmente, il codice è simile: ;".._(. Questo stampa un asterisco, sposta il puntatore della memoria all'indietro ea sinistra e infine diminuisce il valore lì. Dopo un'iterazione, la memoria sarebbe simile a:

10 \ / 9
    |
   42

Quindi raggiungiamo la condizione del loop: quella in basso a sinistra >. Se il bordo che abbiamo appena decrementato è ancora positivo, rimbalziamo ed eseguiamo un {per riportarci indietro sul 42. Quindi colpiamo a $e torniamo all'inizio del ciclo di stampa, il ;, saltando il <. Se il valore era zero, ci dirigiamo nell'altro loop.

Il ciclo esterno inizia reimpostando il bordo di memoria recentemente azzerato su dieci (questo è il 10nel codice, andando a sud-ovest). Quindi, stampiamo questi dieci come un carattere ASCII, che è una nuova riga. Successivamente, passiamo all'altro bordo memoria e farlo diminuire con {(e quindi eseguire ciò che equivale a un gruppo di noops: =${_=. Ora, dopo un'iterazione di questo ciclo, la memoria sarebbe simile a:

 9 \ / 10
    |
   42

Questa volta, la memoria è rivolta verso l'esterno dal bordo memorizzando un nove nel diagramma sopra. Successivamente eseguiamo ciò <che funge da condizione di loop per il loop esterno. Se il valore era diverso da zero rimbalziamo su alcuni mirror, quindi ricominciamo a eseguire istruzioni significative dopo aver inserito la parte superiore dell'esagono nel "sud-ovest in movimento. Questo ci fa muovere indietro e verso sinistra, di nuovo sulla 42, ma rivolti verso l'interno. Quindi =ribalta la nostra direzione, ripristinando correttamente lo stato per ricominciare il ciclo interno. Se il bordo era impostato su zero, il puntatore dell'istruzione procede in una piccola avventura che non fa nulla fino a quando non esce dal programma.

L'avventura inizia con il puntatore delle istruzioni che si avventura a nord-est, trascurando pericolosamente la sicurezza delle direzioni cardinali. Ignora coraggiosamente uno specchio che è allineato con la sua direzione ( /) e salta eroicamente da un trampolino ($) eludere completamente la trappola mortale di un altro trampolino identico. Fissando il vuoto dei bordi esagonali non inizializzati, il puntatore, senza esitare per un momento, aggiunge i due bordi vuoti che affronta insieme, impostando il bordo corrente alla loro somma: 0 (il bordo era effettivamente zero prima, ma al puntatore piace credo che questo fosse piuttosto importante). Dato che il bordo è zero, il puntatore fa una svolta a sinistra al bivio, camminando in una foresta misteriosa (di esagoni). Lì, si trova disorientato, muovendosi avanti e indietro e avanti, fino a quando non finisce nello stesso punto della memoria in cui è iniziato. Pensando che il problema deve essere che il bordo corrente è stato impostato su zero l'ultima volta, il puntatore coraggiosamente pianta a1nel bordo corrente. Quindi, il nobile puntatore indaga su un altro percorso, uno tracciato con ... una trappola! Il fronte corrente viene decrementato e riportato a zero! Il puntatore, sbalordito dalla svolta sconvolgente degli eventi, inciampa di nuovo nella trappola impostando il bordo corrente su uno negativo. Infuriato, il puntatore tenta di tornare nella foresta relativamente piacevole, solo per notare che poiché il bordo attuale non è positivo, i percorsi si sono nuovamente spostati e il puntatore si ritrova a camminare in una grotta. E per grotta intendo la bocca di un gigantesco verme esagonale. Indifeso, l'indicatore maledice la sessualità con il suo respiro morente. Inoltre, il programma termina.

Emacs, 10 8 sequenze di tasti

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

Spiegazione

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

Grazie a Sean per aver salvato due sequenze di tasti, suggerendo di sostituirlo C-udigitcon C-digit.

Gelatina , 7 byte

”*x⁵Ṅ9¡

Cosa sta succedendo?

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

Provalo su tryitonline

PowerShell, 14 12 byte

,('*'*10)*10

Costruisce una stringa di asterischi di lunghezza 10usando la moltiplicazione di stringhe. Incapsula quello in parentesi e lo inserisce nell'operatore virgola per costruire un array. Usiamo la moltiplicazione di array per costruire un array di 10 elementi costituito da quell'elemento (cioè un array di 10 elementi di stringhe di asterisco). È rimasto sulla pipeline e l'output è implicito (poiché il valore predefinito Write-Outputper un array è separato da newline, lo otteniamo gratuitamente - grazie a @Joey per il chiarimento).

Più vecchio, 14 byte

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

Programma completo. Passa da un loop 0all'altro . Ogni iterazione, usiamo la moltiplicazione di stringhe per creare una stringa di lunghezza di . Le stringhe risultanti vengono lasciate sulla pipeline e l'output alla fine è implicito (poiché il valore predefinito per un array è separato da newline, lo otteniamo gratuitamente - grazie a @Joey per il chiarimento).9ForEach-Object|%{...}10*Write-Output

V , 7 byte

10é*10Ä

Provalo online!

Più semplice di una risposta può essere.

Spiegazione:

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

Versione non competitiva (5 byte):

10O±*

Spiegazione:

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

Questo non ha funzionato quando la sfida è stata pubblicata a causa di un bug.

Meduse , 12 10 byte

Grazie a Zgarb per aver salvato 2 byte.

P$'*
 &;10

Provalo online!

Spiegazione

Utilizzando una notazione più convenzionale, questo programma rappresenta la seguente espressione:

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

&;accetta un singolo valore e crea una coppia con due volte quel valore, quindi &;(10)ci dà [10 10]. Quindi $è rimodellare che forma una griglia 10x10 di asterischi. Infine, Pstampa l'array in "formato matrice" che stampa ogni stringa su una propria riga.

HTML e CSS, 104 60 byte

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

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

^{Non sono sicuro che il conteggio dei byte sia corretto (in quanto non sto contando i <style>tag per CSS. L'HTML potrebbe anche essere abbreviato se avessi usato un preprocessore HTML, ma non sono sicuro che questo infrange le regole}

Grazie a manatwork e Business Cat.

^{Vedi la mia voce di giada di 36 byte}

Python 2, 22 21 byte

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

MATLAB, 14 byte

repmat('*',10)

APL , 9 byte

Funziona su tutti gli APL mai realizzati.

10 10⍴'*'

10 10 dieci righe e dieci colonne

⍴ ciclicamente r epeating

'*' una stella

ProvaAPL online!

Java 7, 63 byte

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

Solo per calci. Non riesco a trovare alcun trucco per renderlo più breve. Cercare di aggiungere la logica per un 100-loop o restituire una stringa invece di stampare finisce semplicemente peggio.

Rubino, 15 personaggi

puts [?**10]*10

Esecuzione di esempio:

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

Blocco note, 34 31 sequenze di tasti

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

^ indica Ctrl- <carattere seguente> tasto premuto, ↑ ↓ sono rispettivamente i tasti su e giù.

Prop a Crypto per 3 battute salvate.

Emojicode , 54 byte

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

Spiegazione:

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

TF'*T×,

Spiegazione

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

Provalo online

R, 27 29 byte

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

Una risposta alternativa (34 byte) è: cat(rep('**********',10),sep='\n')

PHP, 32 byte

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

(variante 32 byte - è stata scritta con echo)

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

(variante 33 byte)

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

(variante 33 byte)

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

(variante 35 byte)

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

(variante 38 byte)

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

MATL , 8 byte

'*'10tX"

Provalo online!

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

Brainfuck, 46 43 byte

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

Provalo online! Richiede un interprete con un nastro aperto a sinistra e con celle a 8 bit.

La prima parte di questo programma +[[---<]+[-->]<]imposta il nastro in questo modo:

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

Ciò fornisce un 40 per l'output di asterischi ( *, ASCII 42), un 20 da utilizzare come contatore di loop e un 10 da utilizzare per l'output di nuove righe.

JavaScript (ES6), 37 byte

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

Una risposta semplice.

Cheddar, 21 20 byte

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

Ancora un'altra risposta semplice.

Haskell, 29 byte

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

<list1> >> <list2>fa (length <list1>)copie di <list2>.

R, 35 33 32 byte

Ô R, sei così prolisso a volte .

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

È interessante notare che la catfunzione non ha alcun valore (fornisce NULLa STDOUT), quindi non puoi fare qualcosa del genere rep(cat(rep))), che sarebbe stato più divertente!

EDIT:
nuova soluzione proposta da @LeakyNun, -2 byte.

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

EDIT: accorciandolo solo di -1 byte, di @ user5957401

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

Retina , 12 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1. L'alimentazione principale è significativa.

10$**
.
$_¶

Il primo stadio scrive una stringa di dieci asterischi, il secondo stadio sostituisce ogni asterisco con l'intera stringa e un avanzamento riga. Ciò stampa due avanzamenti riga finali.

J , 10 9 byte

1 byte grazie a @ Adám.

10 10$'*'

Interprete online .

Spiegazione

10 10specifica la dimensione per l'operatore $che crea un array con le dimensioni specificate.