Imprimer une grille d'astérisques de 10 sur 10


83

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 . 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.


2
@DylanMeeus "Vous devez imprimer ce texte exact :"
Leaky Nun

13
@DylanMeeus Etant donné que cela concerne les outils de développement masquant les sorties répétées de la console, il n'est pas natif des consoles JavaScript et ne fait pas partie de la spécification JavaScript - ainsi que du fait que cette fonctionnalité peut être désactivée - je pense que cela devrait être acceptable. Tous les navigateurs ne le réduiront pas comme ça.
Trotski94

6
@ Sneaket LeakyNun Leaderboard s'il vous plaît!
dkudriavtsev

2
L’un des aspects les plus intéressants de ce défi est que, selon votre langue, ********** peut être plus court qu’une boucle. Je me demande alors quand il est préférable pour une langue donnée de basculer entre 1 ou 2 boucles.
Dwana

1
vous dites que les nouvelles lignes sont acceptables. Les nouvelles lignes principales sont-elles également acceptables?
Albert Renshaw

Réponses:




65

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

2
Excellente idée à utiliser yes. Nous étiquetons généralement des solutions telles que «Bash + coreutils».
manatwork

8
Bien que 10 lignes par hasard se trouve être la valeur par défaut pour head.
Digital Trauma

3
Pouvez-vous sauvegarder deux octets en exigeant que tous les fichiers du répertoire en cours commencent par un .?
Neil

@ Neil, est-ce que votre commentaire est pour ma réponse? Si oui, je ne comprends pas :)
CousinCocaine

1
Vous pouvez également écrire yes \**********|headsans restriction sur les fichiers.
Florian F

50

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.


8
10i*♥Y9ptravaux.
Lynn

1
C'est fou vi.
nbubis

Je pense que vous pouvez compter les touches au lieu d'octets pour les éditeurs de texte, ce qui signifie que <ESC> serait plus court.
addison

1
Pourquoi ♥ et pas?
CL.

1
J'aurais utilisé yy9pmoi-même, mais bon travail en utilisant des majuscules pour sauver un personnage!
Joe Z.

49

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.


40

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.


Bon sang, j'espère que le ver a accepté d'avaler un pointeur. Ces choses peuvent faire mal .
Joffan

3
+1 pour l'écriture la plus intéressante - la seule - explication hexagonale que j'ai jamais lue. Je me sentais tellement tendu quand le bord était décrémenté!
Joe

37

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.


9
+1, je révote toujours les réponses de l'éditeur de texte (même si je suis plutôt un gars de vim moi-même) :)
DJMcMayhem

1
Si ne C-ucompte que pour une seule frappe, vous pouvez supprimer deux traits en tapant C-1 C-0(ou M-1 M-0) au lieu de C-u 1 0et C-9au lieu de C-u 9.
Sean

15
+1 parce que vous avez dû utiliser emacs pour écrire ceci.
addison

1
Alternativement (ne sauve rien), la répétition de ligne peut être faite à l'intérieur de la macro:F3 C-1 0 * ENTER C-1 0 F4
Jonathan Carroll

@JonathanCarroll oui, nous économiserions des octets si nous imprimions plus de 10 lignes;)
YSC

29

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


9
J'aime vraiment le Ṅ9¡.
Dennis

Liste Version: ”*ẋ⁵Wẋ⁵.
Erik the Outgolfer

@EriktheGolfer vous auriez besoin d'un Ysur la fin pour "imprimer ce texte exact"
Jonathan Allan

@ JonathanAllan C'est une liste en soi, cependant. Il ne s'agit pas "d'imprimer ce texte exact", mais si vous voulez y travailler, vous l'utiliserez.
Erik the Outgolfer

26

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).


5
J'aime ça, parce que powershell peut être tellement prolixe. Pourtant, c'est élégant et court.
Dwana

Eh bien, techniquement, le tableau n'est jamais passé par un ToStringélément, il est déroulé et passé élément par élément à Write-Output. Dans les contextes où le tableau est converti en chaîne, ses éléments sont séparés par des espaces.
Joey

@ Joey Ah, juste, c'est une meilleure façon de le dire. Je vais modifier le libellé (et mon modèle de réponse ;-)).
AdmBorkBork

1
Je suis peut-être partial ici parce que je suis impliqué dans une implémentation de PowerShell, j'ai donc dû apprendre beaucoup de ce qui se passe réellement à l'intérieur de l'interprète;)
Joey

25

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.


Point de commande: é et Ä sont des caractères multi-octets (au moins dans utf-8, comme vous les avez ici), donc ce programme a une longueur de 9 octets.
rob

6
@rob Ils sont encodés en utf-8 ici, parce que c'est exactement comme cela que le navigateur fonctionne. V utilise l’encodage "Latin1", où ils se trouvent E9et C4respectivement.
DJMcMayhem

21

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.


20

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


Vous pouvez omettre les points de fermeture automatique /et écrire toutes les balises dans la même ligne. Mais il vaut mieux changer les balises en <p>car c'est plus court même si vous avez besoin d'ajouter p{margin:0}.
manatwork

2
Ce n'est pas valide css. Vous avez besoin du crochet de fermeture!
Richard Hamilton

25
@RichardHamilton css valides et css fonctionnant ne sont pas la même chose
undergroundmonorail

1
@ClementNerma Pourquoi quelqu'un devrait-il mettre du code après cela?
Erik the Outgolfer

2
vous pouvez laisser le dernier >je crois
12Me21

16

Python 2, 22 21 octets

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

print(("*"*10+'\n')*10)a travaillé pour moi.
Piepi

6
@ piepi C'est pourquoi vous préférez généralement jouer au golf dans Python 2: vous n'avez pas besoin de parenthèses pour appeler print.
Shooqie

@shooqie Vous ne pouvez pas battre une solution Python3 avec Python2. Python2 et Python3 sont des langages différents. Vous ne voudriez pas non plus comparer la solution Python2 à un langage de golf spécialisé tel que Pyth.
Alfe

16

MATLAB, 14 octets

repmat('*',10)

Je n'ai pas MATLAB pour tester cela, donc je ne suis pas sûr qu'il y ait des espaces entre les *s.
Erik the Outgolfer

@EriktheGolfer clairement pas :)
PieCot

matsuggère une matrice, c'est pourquoi j'ai demandé.
Erik l'Outgolfer

2
@EriktheGolfer excusez-moi, j'ai été impoli. En fait, Mat fait référence à une matrice, mais dans ce cas, il s'agit d'une matrice de caractères, c'est-à-dire un tableau de chaînes (chaque ligne est semblable à une chaîne). Ainsi, la matrice en sortie est imprimée ligne par ligne, sans espaces entre les éléments de la même ligne.
PieCot

16

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!


Il convient de noter que cette solution n'est pas spécifique à Dyalog; cela fonctionne aussi avec GNU APL.
Arc676

3
@ Arc676 True. En fait, cela fonctionne sur tous les APL jamais fabriqués.
Adám

argh, il me manque juste un octet de plus ... Je t'ai presque battu avec le truc du "format":∘.⊢⍨⍕⍨,⍨5
ngn le

@ ngn C'est merveilleusement horrible!
Adám

14

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.


1
Vous pouvez le réduire d'un octet si vous le déclarez icomme variable de classe (sa valeur par défaut est 0):int i;void f(){for(;i++<10;)System.out.println("**********");}
shooqie

1
Cela empêcherait la réutilisation si je ne le faisais pas i=0quelque part dans la fonction, annulant ainsi les économies réalisées.
Geobits

3
+1 Semble vous êtes en effet que ce droit est le plus court .. récursive est de 65 octets: int i=10;void f(){System.out.println("**********");if(i-->0)g();}; Un par un récursif est de 67 octets: int i=99;void f(){System.out.print(i%10<1?"*\n":"*");if(i-->0)g();}; L' utilisation String-constructeur avec char-tableau est de 82 octets: void g(){System.out.print(new String(new char[10]).replace("\0","**********\n"));}; et un String.format est de 81 octets: void g(){System.out.print(String.format("%010d",0).replace("0","**********\n"));}. Ah bon, on a essayé. ;)
Kevin Cruijssen

2
Mais cela compte-t-il sans avoir à ajouter la déclaration de classe elle-même? Quel est le programme complet java7 le plus court capable de le faire?
Jsbueno

1
Vous devez compter l'énoncé d'importation afin qu'il ne fonctionne pas pour économiser ici.
Geobits

14

Ruby, 15 personnages

puts [?**10]*10

Échantillon échantillon:

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

Pouvez-vous expliquer ?**10? Il crée effectivement une chaîne de dix astérisques, mais je ne sais pas comment ...
erich2k8

3
La ?est la notation littérale des caractères, donc ?* == '*'. La 2ème *est la String.*méthode , donc ?**10 == '*'.*(10).
manatwork

Je crains de ne toujours pas comprendre pourquoi ?la notation littérale de quoi que ce soit, mais il est peut-être préférable de laisser certaines questions sans réponse. ;)
erich2k8

Désolé, je ne trouve aucune référence à ce sujet. Il s’agit simplement de la syntaxe Ruby, qui autorise diverses notations littérales de chaîne plus une dans le cas où la chaîne comporte un caractère: une ?marque suivie du caractère, sans nécessiter une paire de fermeture de la ?marque.
manatwork

1
Je l'ai trouvé dans la référence ici: ruby-doc.org/core-2.3.0/doc/syntax/literals_rdoc.html There is also a character literal notation to represent single character strings, which syntax is a question mark (?) followed by a single character or escape sequence that corresponds to a single codepoint in the script encoding:
erich2k8

13

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.


2
Vous devez utiliser les frappes pour compter ceci.
Leaky Nun

1
C'est Shift + Up. Ctrl + Up est autre chose.
Neil

1
31 frappes**********↵^A^C↓^V^A^C↓^V^V^V^V
Crypto

1
26 frappes*****^A^C^V^V↵^A^C^V^A^C^V^V^V^V^V
Andy

5
23 frappes**^A^C^V^V^V^V^V↵^A^C^V^V^A^C^V^V^V^V^V
Andy

13

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

2
Je compte 54 octets UTF-8.
Conor O'Brien

Cette langue déteste Windows 7 ...
John Dvorak


10

R, 27 29 octets

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

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


Cela ajoute un espace supplémentaire au début de toutes les lignes sauf la première (voir ici ).
Plannapus

Merci, cela fonctionne en ajoutant \r.
Mamie

1
Une autre alternative, trop (37) octets: cat(matrix('*',10,10),fill=10,sep='') r-fiddle
Jonathan Carroll

Une autre alternative, également 29 octets:write(rep("*",100),"",10,,"")
Giuseppe

1
Et write(rep("**",50),1,5,,"")est 27 octets et évite le premier retour de chariot.
J.Doe

9

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);

3
Le second peut également contenir jusqu'à 32 octets :<?=str_repeat("**********↵",10);
insertusernamehere

1
Comme vous avez déjà une belle collection d’alternatives, en voici une autre pour le plaisir: echo chunk_split(str_repeat("*",100),10);la plus longue jusqu’à présent, à mon avis, c’est la façon de procéder de PHP.
Manatwork

Peut être un octet plus court avec le codage WIN-1252: for(;++$i<111;)echo$i%11?~Õ:~õ;oufor(;++$i<11;)echo~ÕÕÕÕÕÕÕÕÕÕõ;
aross le

Une autre variante modulo pour 33 octets: for(;$i++<110;)echo"*↵"[$i%11<1];. Et d'ajouter une solution 37 octets à cette collection: for(;$i++<110;)echo chr($i%11?42:10);.
Tite


8

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.


7

JavaScript (ES6), 37 octets

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

Une réponse simple.


5
Vous ne pouvez pas économiser 6 en utilisant alert?
Kevin L

1
On pourrait peut-être économiser 13 octets en supprimant le console.log()et en spécifiant REPLdans le titre.
Patrick Roberts

6

Cheddar, 21 à 20 octets

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

Encore une réponse simple.


4
Utilisez une nouvelle ligne pour économiser 1 octet
Leaky Nun

2
Faire une fonction en utilisant ->au lieu d'imprimer peut-être?
Downgoat

6

Haskell, 29 octets

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

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


6

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")

3
for(i in 1:10)"**********\n"
Leaky Nun

1
@ LeakyNun: la simplicité est la clé! J'en ai cattout de même, sinon ça ne produit rien.
Frédéric

cat(rep("**********\n",10))
Leaky Nun

@ LeakyNun Cela ne produirait pas le résultat souhaité: voir ici . Le séparateur par défaut dans catest un espace, d’où cette sortie.
Plannapus

5

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.


5

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.


1
Également 9 octets:'*'$~,~10
Conor O'Brien
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.