Hintergrund

Dies ist ein Standardlehrbuchbeispiel zur Demonstration von Schleifen.

Dies ist eines der ersten Programme, die ich gelernt habe, als ich vor ca. 10 Jahren anfing, Programmieren zu lernen.

Aufgabe

Diesen genauen Text drucken Sie aus:

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

Technische Daten

• Möglicherweise haben Sie zusätzliche nachgestellte Zeilenumbrüche.
• Möglicherweise stehen am Ende jeder Zeile zusätzliche nachgestellte Leerzeichen (U + 0020), einschließlich der zusätzlichen nachgestellten Zeilenumbrüche.

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

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

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

Probieren Sie es online!

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

C (gcc), 41 bis 39 Bytes

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

Bash + Coreutils, 19 Bytes

Ich ziehe es vor, Sachen in Bash mit 'yes' zu wiederholen.

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

Ich habe 2 Bytes auf Vorschlag von @ Neil gespart. Wenn das Verzeichnis, in dem Sie diesen Befehl ausführen, jedoch nicht nur Dateien enthält, die mit einem '.' dot Sie die Sterne umschließen müssen *mit ".

Bash + Coreutils, 21 Bytes

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

Vim, 13 8 Bytes

5 Bytes dank @Lynn gespart

qqi*␛9.o␛q9@q 

10i*␛Y9p

10i*␛füge 10 mal ein *und Y9pkopiere die Zeile und füge sie 9 mal ein.

Pyth, 6 Bytes

VT*T\*

Tist 10 in Pyth, Vabführt Anweisungszeiten aus b a, \*ist die Sternzeichenkonstante und multipliziert ( *) eine Zeichenfolge und eine Ganzzahl und wiederholt diese Zeichenfolge n-mal. Das implizite Drucken von Pyth Vbedeutet, dass 10 Zeilen gedruckt werden.

Hexagonie, 37 35 34 31

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

Erweitert:

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

Probieren Sie es online aus

Grundsätzlich gibt es nur zwei for-Schleifen, die von zehn bis null zählen, wobei auf der inneren Schleife ein Sternchen und auf der äußeren Schleife ein Zeilenumbruch ausgegeben wird.

Erläuterung:

Dieses Programm besteht aus drei Hauptteilen: Initialisierung des Speichers, einer Schleife, in der zehn Sternchen gedruckt werden, und einer Schleife, in der eine neue Zeile gedruckt wird. Die Schleife, die eine neue Zeile druckt, enthält auch die Schleife, die die Sternchen druckt.

Zunächst führt der Code die vollständig lineare Speicherinitialisierung aus. Der Code arbeitet zu sein: 10"+}42. Dies setzt die Erinnerung an die nahegelegenen Kanten so, dass sie wie folgt aussieht:

10 \ / 10
    |
   42

42 ist der ASCII-Code für das Sternchen, und die zwei Zehner werden als unsere Schleifenzähler verwendet. Bemerkenswert ist, dass der Speicherzeiger gerade von den beiden Zehnern weg zeigt. Wenn Sie also nach hinten gehen, werden Sie auf einen der Zehner gesetzt.

Als nächstes starten wir die Sternchen-Druckschleife. Linear, sieht der Code wie: ;".._(. Dies druckt ein Sternchen aus, bewegt den Speicherzeiger nach links und rückwärts und dekrementiert schließlich den Wert dort. Nach einer Iteration würde der Speicher wie folgt aussehen:

10 \ / 9
    |
   42

Dann treffen wir die Schleifenbedingung: ganz links unten >. Wenn die Kante, die wir gerade dekrementiert haben, immer noch positiv ist, springen wir herum und führen a aus {, um uns zurück auf die 42 zu bewegen. Dann drücken wir a $und kehren zum Anfang der Druckschleife zurück ;, indem wir die Taste überspringen <. Wenn der Wert Null war, begeben wir uns in die andere Schleife.

Die äußere Schleife beginnt mit dem Zurücksetzen der kürzlich auf Null gestellten Speicherflanke auf zehn (dies ist die 10im Code angegebene, nach Südwesten gehende). Dann drucken wir diese zehn als ASCII-Zeichen aus, was eine neue Zeile ist. Als nächstes gehen wir auf die anderen Speicherkante oder vermindern, mit {(und dann ausführen , was zu einer Reihe von noops betragen: =${_=. Nach einer Iteration dieser Schleife würde der Speicher wie folgt aussehen:

 9 \ / 10
    |
   42

Diesmal zeigt der Speicher von der Kante nach außen und speichert eine Neun im obigen Diagramm. Als nächstes führen wir die aus, <die als Schleifenbedingung für die äußere Schleife fungiert. Wenn der Wert ungleich Null war, springen wir von einigen Spiegeln ab und beginnen erneut mit der Ausführung sinnvoller Anweisungen, nachdem wir den oberen Rand des Sechsecks im sich "bewegenden Südwesten betreten haben . Dies führt dazu, dass wir uns rückwärts und nach links bewegen, wieder auf die 42, aber nach innen gerichtet. Dann =dreht der unsere Richtung um und setzt den Zustand korrekt zurück, um die innere Schleife erneut zu beginnen. Wenn die Flanke auf Null gesetzt wurde, geht der Befehlszeiger auf ein kleines Abenteuer, das nichts unternimmt, bis es das Programm verlässt.

Das Abenteuer beginnt damit, dass der Befehlszeiger nach Nordosten wagt und dabei die Sicherheit der Himmelsrichtungen auf gefährliche Weise missachtet. Es ignoriert mutig einen Spiegel, der an seiner Richtung ausgerichtet ist ( /) und springt heldenhaft von einem Trampolin ($), die der tödlichen Falle eines anderen, völlig identischen Trampolins gänzlich ausweicht. Während der Zeiger auf die Leere nicht initialisierter Sechskantkanten starrt, addiert er die beiden leeren Kanten, denen er gegenübersteht, ohne einen Moment lang ins Stocken zu geraten, und setzt die aktuelle Kante auf die Summe: 0 (die Kante war zuvor eigentlich Null, aber der Zeiger mag es Ich glaube, das war ziemlich wichtig. Da die Kante Null ist, macht der Zeiger an der Weggabelung eine Linkskurve und geht in einen mysteriösen Wald (aus Sechsecken). Dort ist es desorientiert und bewegt sich vorwärts und rückwärts und vorwärts, bis es an der gleichen Stelle im Gedächtnis landet, an der es begonnen hat. In der Annahme, dass das Problem darin bestehen muss, dass die aktuelle Flanke beim letzten Mal auf Null gesetzt wurde, pflanzt der Zeiger mutig a1in die aktuelle Kante. Dann untersucht der edle Zeiger einen anderen Weg, einen mit ... einer Falle! Die aktuelle Flanke wird dekrementiert und auf Null zurückgesetzt! Der durch die schockierende Wendung der Ereignisse betäubte Zeiger stolpert zurück in die Falle und setzt die aktuelle Flanke auf negativ. Wütend versucht der Zeiger, in den vergleichsweise angenehmen Wald zurückzukehren, nur um festzustellen, dass sich die Wege erneut verschoben haben und der Zeiger in eine Höhle läuft, da die aktuelle Kante nicht positiv ist. Und mit einer Höhle meine ich das Maul eines riesigen sechseckigen Wurms. Hilflos verflucht der Zeiger mit seinem sterbenden Atem die Sexualität. Auch das Programm endet.

Emacs, 10 8 Tastenanschläge

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

Erläuterung

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

Dank Sean für zwei Tastenanschläge zu speichern, was darauf hindeutet , zu ersetzen C-udigitmit C-digit.

Gelee , 7 Bytes

”*x⁵Ṅ9¡

Was ist los?

”*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 es auf tryitonline

PowerShell, 14 - 12 Byte

,('*'*10)*10

Erstellt eine Zeichenfolge mit Sternchen der Länge 10mithilfe der Zeichenfolgenmultiplikation. Verkapselt dies in Parens und fügt es in den Komma-Operator ein, um ein Array zu erstellen. Wir verwenden die Array-Multiplikation, um ein Array mit 10 Elementen zu erstellen, das aus diesem Element besteht (dh ein Array mit 10 Elementen aus Sternchenfolgen). Das bleibt in der Pipeline und die Ausgabe ist implizit (da die Standardeinstellung Write-Outputfür ein Array durch Zeilenumbrüche getrennt ist, erhalten wir das kostenlos - danke an @Joey für die Klarstellung).

Älter, 14 Bytes

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

Volles Programm. Schleifen von 0bis 9durch eine ForEach-ObjectSchleife |%{...}. Bei jeder Iteration verwenden wir die String-Multiplikation, um einen Längen- 10String von zu erstellen *. Diese resultierenden Zeichenfolgen Write-Outputverbleiben in der Pipeline und die Ausgabe am Ende ist implizit (da die Standardeinstellung für ein Array durch Zeilenumbrüche getrennt ist, erhalten wir diese kostenlos - danke an @Joey für die Klarstellung).

V , 7 Bytes

10é*10Ä

Probieren Sie es online!

Ungefähr so ​​einfach wie eine Antwort sein kann.

Erläuterung:

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

Nicht konkurrierende Version (5 Bytes):

10O±*

Erläuterung:

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

Dies funktionierte nicht, als die Herausforderung aufgrund eines Fehlers veröffentlicht wurde.

Qualle , 12 10 Bytes

Vielen Dank an Zgarb für das Speichern von 2 Bytes.

P$'*
 &;10

Probieren Sie es online!

Erläuterung

Dieses Programm verwendet eine konventionellere Schreibweise und stellt den folgenden Ausdruck dar:

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

&;Nimmt einen einzelnen Wert und erzeugt ein Paar mit dem zweifachen dieses Wertes, so &;(10)gibt uns [10 10]. Dann $entsteht eine Umformung, die ein 10x10-Gitter von Sternchen bildet. Zum Schluss wird Pdas Array im "Matrixformat" gedruckt, wobei jeder String in einer eigenen Zeile gedruckt wird.

HTML & CSS, 104 60 Bytes

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

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

^{Ich bin nicht sicher, ob die Byteanzahl korrekt ist (da ich die <style>Tags für CSS nicht zähle . Der HTML-Code könnte auch gekürzt werden, wenn ich einen HTML-Präprozessor verwende, aber ich bin nicht sicher, ob dies gegen die Regeln verstößt}

Dank Handarbeit und Business Cat.

^{Siehe mein Jade-Eintrag von 36 Bytes}

Python 2, 22 21 Bytes

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

MATLAB, 14 Bytes

repmat('*',10)

APL , 9 Bytes

Funktioniert mit allen jemals erstellten APLs.

10 10⍴'*'

10 10 zehn Zeilen und zehn Spalten

⍴ zyklisch r epeating

'*' ein Stern

TryAPL online!

Java 7, 63 Bytes

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

Nur zum Spaß. Ich kann anscheinend keine Tricks finden, um dies zu verkürzen. Der Versuch, eine Logik für eine 100-Schleife hinzuzufügen oder einen String zurückzugeben, anstatt zu drucken, wird schlimmer.

Ruby, 15 Zeichen

puts [?**10]*10

Probelauf:

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

Notizblock, 34 31 Tastenanschläge

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

^ bezeichnet Strg- <folgendes Zeichen> -Tastendruck, ↑ ↓ sind Auf- bzw. Ab-Tasten.

Stellt Crypto für 3 gespeicherte Tastenanschläge zur Verfügung.

Emojicode , 54 Bytes

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

Erläuterung:

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

Erläuterung

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

Probieren Sie es online aus

R 27 29 Bytes

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

Eine alternative Antwort (34 Bytes) lautet: cat(rep('**********',10),sep='\n')

PHP, 32 Bytes

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

(Variante 32 Bytes - wurde mit geschrieben 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"

Probieren Sie es online!

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

Brainfuck, 46 43 Bytes

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

Probieren Sie es online! Benötigt einen Dolmetscher mit einem Band, das links offen ist und 8-Bit-Zellen hat.

Der erste Teil dieses Programms erstellt +[[---<]+[-->]<]das Band folgendermaßen:

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

Dies ergibt eine 40 für die Ausgabe von Sternchen ( *, ASCII 42), eine 20 für die Verwendung als Schleifenzähler und eine 10 für die Ausgabe von Zeilenumbrüchen.

JavaScript (ES6), 37 Byte

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

Eine klare Antwort.

Cheddar, 21 20 Bytes

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

Noch eine einfache Antwort.

Haskell, 29 Bytes

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

<list1> >> <list2>macht (length <list1>)Kopien <list2>.

R, 35 33 32 Bytes

Ô R, du bist manchmal so wortreich .

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

Interessanterweise hat die catFunktion keinen Wert (sie liefert NULLSTDOUT), so dass Sie so etwas nicht tun können rep(cat(rep))), was lustiger gewesen wäre!

EDIT:
Neue von @LeakyNun vorgeschlagene Lösung, -2 Bytes.

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

BEARBEITEN: Kürzung nur um -1 Byte, durch @ user5957401

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

Retina , 12 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus. Der Zeilenvorschub ist signifikant.

10$**
.
$_¶

In der ersten Stufe wird eine Zeichenfolge mit zehn Sternchen geschrieben, in der zweiten Stufe wird jedes Sternchen durch die gesamte Zeichenfolge und einen Zeilenvorschub ersetzt. Dies druckt zwei hintere Zeilenvorschübe.

J , 10 9 Bytes

1 Byte danke an @ Adám.

10 10$'*'

Online-Dolmetscher .

Erläuterung

10 10Legt die Dimension für den Operator fest, $der ein Array mit den angegebenen Dimensionen erstellt.