Dessine un triangle astérisque


57

Inspiré par une tâche de programmation 101, voici une tâche qui, espérons-le, n'est pas trop facile ou qui fait double emploi (un peu difficile de chercher des choses comme celle-ci).

Contribution:

  • Un entier positif n >= 1.

Sortie:

  • n lignes d'astérisques, chaque nouvelle ligne ayant un astérisque de plus que la ligne précédente et commençant par un astérisque dans la première ligne.

Règles générales:

  • C'est du code-golf, donc la réponse la plus courte en octets est gagnante.
  • Comme le cours est dispensé en C ++, je suis impatient de voir les solutions en C ++.

Cas de test (n = 5):

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

6
Pas de duplication, juste un sous-ensemble de Générer un triangle rectangle .
Manatwork

2
Espaces de formation autorisés sur chaque ligne?
Luis Mendo

2
Une nouvelle ligne de fuite est-elle acceptable?
Fataliser

1
Une nouvelle ligne principale est-elle autorisée?
Riley

Je ne vois pas de raison pourquoi pas.
Sickboy

Réponses:


41

Vim, 8 octets

o <Esc><C-V>{r*J

Prend les entrées dans le tampon readahead, donc si l’entrée est 15, vous taperiez cela puis le code ci-dessus. Ceci est une règle stupide, mais semble être autorisé . Si vous avez entré des données dans un registre "a, vous vous en tiendriez juste @adevant (10). Si vous l'avez dans le fichier de démarrage, vous préférez D@"au lieu de cela (11).

S'appuie sur l'utilisation abusive de :set autoindent, qui est celle par défaut dans les règles de vimgolf.com et celle par défaut dans Vim 8 (et tout le monde l'utilise de toute façon).

  • o <Esc>: Avec son argument de nombre, si votre texte commence par un espace et si vous l'avez :set autoindent, Vim disparaît et crée une cascade d'indent.
  • <C-V>{r*: Transformer tous ces espaces en *s. J'utilise un bloc visuel pour que, même si vos paramètres de mise en retrait désagréables regroupent vos espaces dans des onglets, vous aurez toujours le bon nombre de *s.
  • J: En commençant par omalheureusement laissé une ligne blanche en haut. Cela l'enlève.

1
Cette réponse est incroyablement impressionnante. Une des réponses les plus cool de vim que j'ai vues.
DJMcMayhem

1
Cela ressemble à un poisson. Ou une fusée.
Stephan Bijzitter

1
Je me suis crispé un peu et j'ai viré Vim -u NONEpour voir cela par moi-même ... Cela n'a pas fonctionné, il semble que cela autoindentsoit activé dans le vimrc par défaut , pas dans Vim 8 lui-même, j'ai donc dû l'activer manuellement. Mais bravo pour l'ingéniosité de cette réponse! Mais pourquoi n'y a-t-il qu'un seul espace par nouvelle ligne? Pourquoi cela ne fonctionne-t-il qu'avec des espaces mais pas avec d'autres personnages? J'ai encore beaucoup à apprendre, semble-t-il :)
Christian Rondeau

Commencer par O <Esc>ne nécessitera pas Jà la fin.
Primo

1
@udioica une nouvelle ligne de fin est généralement considérée comme acceptable.
Primo

23

JavaScript (ES6), 31 octets

Celui-ci comprend à la fois un saut de ligne de début et de fin.

Nous commençons avec une chaîne sne contenant qu'un saut de ligne. Ensuite, nous traitons nles appels récursifs en ajoutant un astérisque à gauche de cette chaîne à chaque itération. La concaténation de toutes les chaînes intermédiaires conduit au résultat attendu.

f=(n,s=`
`)=>n?s+f(n-1,'*'+s):s

Sans astérisque, 36 octets

f=(n,s=`
`)=>n?s+f(n-1,atob`Kg`+s):s

Comment ça marche ?
Alexis_A 10/10/16

1
@Alexis_A - J'ai ajouté une courte description.
Arnauld

3
Belle réponse récursive; Je n'aurais jamais pensé à la technique que vous utilisez s. Vous pouvez le rendre un peu moins crypté avec n?s+f(n-1,'*'+s):s.
ETHproductions 10/10/16

19

05AB1E , 7 à 6 octets

Utilise le codage CP-1252 .

'*×.p»

Version sans astérisque de 8 octets:

žQTè×.p»

Essayez-le en ligne!

Explication

Exemple utilisant input n = 5

'*      # push "*"
        # STACK: "*"
  ×     # repeat input number times
        # STACK: "*****"
   .p   # get prefixes of string
        # STACK: ['*', '**', '***', '****', '*****']
     »  # join by newlines
        # implicit print

@TheBitByte 10žQSè×.p»est une extension logique de cette réponse pour obtenir ce que vous vouliez pour la prime et ce n'est que de 10 octets. Donnez à Emigna la prime si personne ne bat 10 octets haha.
Urne Magique Octopus

1
@carusocomputing: TžQè×.p»même 8 octets.
Emigna

Toujours en train d'essayer d'apprendre la langue, j'ai raté l'instruction T; Je pensais que c’était bizarre qu’il y ait eu beaucoup de pressions de Base2, mais pas de base 10. Je dois encore parcourir tout le contenu de info.txt pour pouvoir faire quoi que ce soit dans cette langue heh.
Urne Magique Octopus

@carusocomputing, certaines commandes sont vraiment faciles à manquer, surtout si vous connaissez une autre façon de le faire :)
Emigna

1
@carusocomputing: Vous ne savez pas exactement de quoi vous parlez. La seule commande de liste que j'utilise ici est »cette commande, qui est spécifiquement conçue pour fusionner des listes avec des délimiteurs dans une chaîne (et Sgâcherait cela). Mais beaucoup de commandes 05AB1E vectorisent, oui.
Emigna

15

PowerShell, 21 octets

1..$args[0]|%{'*'*$_}

Boucle d’ 1entrée en entrée $args[0], chaque itération utilisant la multiplication de chaînes pour construire une chaîne $_comportant autant d’ astérisques. Le comportement par défaut pour l'implicite Write-Outputà la fin est avec une nouvelle ligne pour le séparateur, nous l'obtenons donc gratuitement.

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 5
*
**
***
****
*****

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 2
*
**

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 7
*
**
***
****
*****
******
*******

13

Python 2, 37 à 34 octets

i=1;exec"print'*'*i;i+=1;"*input()

Ideone

iest initialisé à 1;
puis des execcommandes pour exécuter la chaîne de code suivante, elle doit donc être construite;
la chaîne est "print'*'*i;i+=1;"la *suivante mais la chaîne a la priorité sur la execet demande à la première répétition de répéter la chaîne input();
la execcommande exécute maintenant la longue chaîne qui agit comme une boucle, printune autre chaîne de longueur croissante, utilisant *à nouveau pour répéter le caractère '*', puis incrémentant iavec i+=1.

Python 3, 41 Octets
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; ou
lambda n,i=1:exec("print('*'*i);i+=1;"*n)


13

Gelée , 6 à 5 octets

”*ẋþY

TryItOnline

Comment?

”*ẋþY - Main link: n
”*    - literal string "*"
   þ  - form outer product with the dyadic function:
  ẋ   -     repeat list (right input is an implicit range(n), Jelly defaults to 1-based)
            so the outer product is like:
            [[i*'*' for i in range(1,len("*")+1)] for x in range(1,n+1)]
    Y - join with line feeds
      - implicit print

Bounty:
Je ne suis pas sûr de ce qu'est la clause no ordinals, puisqu'un personnage est la recherche d'un ordinal.
La recherche directe ne porterait que 42Ọẋþ³Ysur 7 octets (où le ³nous obtient l’entrée).
Une méthode légèrement indirecte consisterait, pour 8 octets , à “)’Ọẋþ³Yrechercher ')'dans la page de code de jelly, indexé 1, donc “)’42.


Quelque chose d'intéressant se produit lorsque vous utilisez un zéro non significatif dans l'entrée, par exemple. essayez "0414141" comme entrée. Je ne connais pas très bien le golf, je ne saurais donc pas par où commencer pour l'expliquer.
Luc

Je pense qu'il est évalué en tant que chaîne et qu'il est donc itératif. Chaque caractère est alors un entier car ils sont tous des chiffres (ce sera une erreur avec "hi" par exemple)
Jonathan Allan

11

C #, 42 octets

f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

Programme complet avec cas de test:

using System;

namespace DrawAnAsteriskPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,string>f= null;
            f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

            Console.WriteLine(f(5));
        }
    }
}

Vous en avez besoin puisqu'il s'agit d'une fonction récursive.
adrianmp

droite. Je n'ai pas vu ça
Cyoce

10

Pyth , 6 octets

j._*"*

Essayez ici .

Explication

j            Join by newlines
 ._          all prefixes of
    *        the result of repeating
      "*     the string "*"
             as many times as the implicit input 

3
Ma première réponse Pyth
Luis Mendo

9

GNU sed , 25 24 20 + 1 (drapeau n) = 21 octets

Edit: 4 octets de moins sur la base des commentaires de Riley

x;G;:;P;s:\n.:*\n:;t

Essayez-le en ligne!

Exemple d'exécution: l'entrée est au format unaire, ce qui est autorisé pour sed en fonction de ce consensus

me@LCARS:/PPCG$ sed -nf draw_triangle.sed <<< "0000"

*
**
***
****

Une nouvelle ligne principale est présente dans la sortie, mais cela est autorisé par l'OP.

Explication:

x;G             # prepend a newline to unary string
:               # start loop
   P            # print first line only
   s:\n.:*\n:   # shift one unary char from 2nd line to 1st, converted to a '*'
t               # repeat

Si vous Pimprimez avant la substitution et qu'une nouvelle ligne principale est autorisée, vous n'en avez pas besoin /0$/. Si une nouvelle ligne n'est pas autorisée, vous pouvez toujours enregistrer un octet avec x;G;:;/*/P;s:\n.:*\n:;t. J'ai posé des questions sur une nouvelle ligne principale, mais je n'ai pas encore eu de réponse.
Riley

8

Matlab, 26 23 octets

Bon vieux Matlab ...

@(n)tril(repmat('*',n))

A des espaces de fuite. trilvous donne la matrice triangulaire inférieure.

edit: sauvé 2 bythes grâce à Luis Mendo


Vous avez raison - merci - pas encore très compétitif: P
mathause

8

C ++ - 92 96 octets

#include<string>
int main(){int n;std::string s;scanf("%d",&n);for(;n--;)puts((s+="*").data());}

Essayez-le en ligne

Ungolfed:

//this one hurts, but c++ strings are mutable
#include<string> 
int main(){
    int n;
    //this one hurts as well
    std::string s; 
    //read input to n
    //longer than 'std::cin>>n', but no #include<iostream> needed
    scanf("%d",&n); 
    // same as 'while(n--)', also characterwise, but way cooler
    for(;n--;) 
        //add a '*' the string
        //data() does the same as c_str()
        //puts automatically adds an '\n'
        puts((s+="*").data()); 
}

devrait être 'int main () {}' pour +4 octets.

vrai, zut - comportement donc non standard de gcc / ideone
Anedar

7

Méduse , 12 11 9 octets

\P$'*
  i

Essayez-le en ligne!

Explication

Le programme ci-dessus est équivalent au pseudocode fonctionnel suivant:

\            P      $       i        '*
map_prefixes(print, reshape(input(), '*'))

Le $(refaçonner) crée une chaîne d' Nastérisques. \Pcrée une fonction qui prend une liste (ou une chaîne) et transmet chacun de ses préfixes à P(print). Par conséquent, il imprime successivement les chaînes de 1à Nastérisques.


7

R, 45 octets

Pour l'approche en boucle:

for(i in 1:scan())cat(rep("*",i),"\n",sep="")

6

Brachylog , 12 octets

yke:"*"rj@w\

Essayez-le en ligne!

Cela suppose qu'une nouvelle ligne est acceptable

Explication

yk                The range [0, …, Input - 1]
  e               Take one element I of that range
   :"*"rj         Juxtapose "*" I times to itself
         @w       Write that string followed by a new line
           \      False: backtrack to another element of the range

Pas de nouvelle ligne, 15 octets

-:"*"rj:@[f~@nw

Essayez-le en ligne!

Celui-ci fonctionne en prenant tous les préfixes de "*" × Input.


6

Haskell, 35 38 octets

Compréhension de liste grâce à nimi:

f x=unlines[[1..n]>>"*"|n<-[1..x]]

Ancienne version:

f 0=""
f n=f(n-1)++([1..n]>>"*")++"\n"

Version alternative:

g n=([1..n]>>"*")++"\n"
f n=[1..n]>>=g

Vous pouvez utiliser ([1..n]>>"*")au lieu de replicate n'*'pour sauvegarder un octet. Je compte aussi que 39 octets.
Laikoni

Belle version alternative! Cependant, je pense que le nombre d'octets est toujours de un et devrait être de 38. (Voir par exemple ici ) Le problème pourrait être la nouvelle ligne après f 0=""laquelle est compté comme un octet, mais affiché comme deux octets / caractères dans certains éditeurs de texte.
Laikoni

Merci! Je vois maintenant que j’étais en train d’ajouter une fin de ligne lorsque je comptais les caractères. Ne ferez plus cette erreur!
Craig Roy

2
Vous pouvez passer à une compréhension de la liste: f x=unlines[[1..n]>>"*"|n<-[1..x]].
nimi

6

Pyth, 7 octets

VQ*\*hN

Bloqué un octet grâce à @ETHproductions Essayez-le en ligne

en utilisant la technique de @ PIetu1998

6, octets

j*L*\*S

Bonne réponse! Vous pouvez remplacer "*"par \*.
ETHproductions 10/10/16

@ETHproductions Je n'en avais jamais entendu parler, merci!
Dignissimus - Spammy

Vous pouvez supprimer un autre octet avec une carte. j*L\*S( Splage incluse , multipliez chacune *Lpar "*" \*, join par newline) Pyth insère un Q implicite à la fin.
PurkkaKoodari

jm*\*hest également 6 octets.
hakr14

6

2sable , 24 à 11 octets

>G')Ç>çJN×,

Essayez-le en ligne!

Et aucun signe d'astérisque! Golfé du 24 au 11 grâce à @Emigna .

Explication:

>G')Ç>çJN×,
>            Push input+1
 G           For N in range (1,input+1)
  ')Ç>çJ     Push '*' by getting ascii code for ')' and adding 1
        Nx,  Print '*' repeated N times

1
Quelques astuces õVYIn'affecte en aucune manière votre code et peut être supprimé. 1+est le même que >. Si vous créez l'astérisque dans la boucle, vous pouvez également le supprimer UX. Utiliser ×au lieu de la boucle interne économise encore plus d'octets. Sans changer de méthode, vous pouvez le réduire à 11 octets ou moins.
Emigna

1
Agréable!
J'éditerai

Pourriez-vous ajouter une explication?
Tampon Over Read

Code merveilleux, félicitations pour obtenir la prime! Le bot communautaire ne semble en avoir attribué que 25, et non pas les 50 originaux, car j’ai oublié d’accorder la prime avant la date limite, désolé pour cela.
mémoire tampon a été

1
Ne t'inquiète pas pour ça. Je suis juste content d’atteindre la barre des 100 représentants. @TheBitByte
Geno Racklin Asher

6

Brain-Flak 75 Octets

Comprend +3 pour -A

{(({})[()]<{({}[()]<(((((()()()){}()){})){}{})>)}{}((()()()()()){})>)}{}

Essayez-le en ligne!


Explication:

{(({})[()]<                                                        >)}
#reduce the top element by one until it is 0 after doing the following
#Push this element back on to act as a counter for the next step.
#(counts down from input to 0 we'll call this counter)

           {({}[()]<                          >)}
           #reduce the top element by one until it is 0 after doing the following
           #(counts down from counter to 0)

                    (((((()()()){}()){})){}{})  
                    #push 42 (the ASCII code for *)

                                                 {}
                                                 #pop the counter used to push
                                                 #the right number of *s

                                                   ((()()()()()){})
                                                   #push a 10 (newline)

                                                                      {}
                                                                      #pop the null byte

cela inclut un octet nul en sortie? Je ne pense pas que cela soit permis ...
Citron destructible

Non, je veux dire un octet nul
Citron destructible

@ DestructibleWatermelon Ouais, je suppose que oui. Solution facile cependant. Merci.
Riley

6

Dyalog APL , 8 octets

'*'⍴⍨¨⍳

matrifier la liste composée de

'*' la chaîne "*"

⍴⍨ remodelé par

¨ chacun des

les entiers 1 à travers l'argument.

TryAPL en ligne!


Ressemble à 8 octets pour moi.
Erik the Outgolfer

1
si peut être un seul octet:(,⍕⊢)⌸⍳
ngn le

@ ngn C'est très intelligent! Affichez-le comme le vôtre. Vous pouvez en effet le compter comme un seul octet si vous écrivez 7 bytes<sup>SBCS</sup>.
Adám

5

V , 8 octets

Àé*hòlÄx

Essayez-le en ligne!


Oh oui Àé hòlÄ!
Jonathan Allan

2
@ JonathanAllan Hey, au moins c'est plus lisible que Jelly. (À moi);)
DJMcMayhem

La page de code de Jelly est, je pense, plutôt bien organisée. Découvrez la surcharge de la page Atoms du wiki réalisée récemment par Lynn.
Jonathan Allan

3
@ JonathanAllan Ouais, j'y crois. Cela ne ressemble peut-être pas à ça, mais la mnémonique de V est bien organisée à cause des clés que vous utilisez pour les taper dans vim. Donc, ma solution dans vim-key Lingo est <M-@><M-i>*h<M-r>l<M-D>x(m signifie méta, ce qui signifie alt). Ce sont tous de bons mnémoniques pour ce que fait la commande.
DJMcMayhem

5

JavaScript (ES6), 34 octets

f=x=>x?f(x-1)+`
`+'*'.repeat(x):''

5

Perl 6 , 23 octets

{.put for [\~] '*'xx$_}

(Si la sortie est autorisée à être une liste de "lignes" sans nouvelles lignes .put for peuvent être supprimés)

Explication:

# bare block lambda with implicit parameter 「$_」
{
  .put            # print with trailing newline
    for           # for every one of the following
      [\~]        # produce using concatenation operator
        '*' xx $_ # list repeat '*' by the input
}

(Voir la documentation producesi vous ne comprenez pas ce qui [\~] ...se passe)


5

Perl 5, 22 20 octets

say"*"x$_ for 1..pop

Exécutez-le avec le -Ecommutateur pour obtenir say.

$ perl -E 'say"*"x$_ for 1..pop' 5
*
**
***
****
*****

Écrit comme un programme complet, il ressemblerait à ceci:

use strict;
use feature 'say';

# get the argument
my $limit = pop @ARGV;

foreach my $i (1 .. $limit) { 
    say "*" x $i; 
}
  • shiftet poptravaille implicitement sur @ARGV(la liste des arguments) en dehors de subs
  • ..est l' opérateur de gamme
  • say comprend une nouvelle ligne
  • xest un opérateur pour répéter des chaînes et est expliqué dans perlop

Pas sûr si j'ai besoin d'octets supplémentaires pour le commutateur de ligne de commande.
simbabque

Je crois que le -Edrapeau compte pour 1 octet supplémentaire.
ETHproductions 10/10/16

Qu'en est-il de prendre le nombre comme entrée au lieu de paramètre? perl -E 'say"*"x$_ for 1..<>' <<< 5
manatwork

@manatwork ouais cela fonctionnerait. Je ne suis pas bon à compter cependant. Je ne sais pas si c'est autorisé.
simbabque

1
-Eest gratuit (car il remplace -ece qui serait nécessaire de toute façon). Si vous voulez vraiment prendre le numéro à partir de la ligne de commande (pourquoi pas, même si <>est plus court d'un octet et autorisé), vous devriez utiliser popau lieu de shift(deux octets plus court)! En tout cas, bienvenue sur PPCG, heureux de vous voir jouer au golf!
Dada

5

Perl, 19 octets

-4 octets grâce à @Ton Hospel et son remaniement de la solution!

eval"s//*/;say;"x<>

Nécessite un drapeau gratuit -E(ou -M5.010) à exécuter. Prend un nombre à partir de l'entrée:

perl -E 'eval"s//*/;say;"x<>' <<< "5"

1
Vous pouvez faire evalla même longueur que la forsolution (utiliser à la <>place de pop) aveceval"s//*/;say;"x<>
Ton Hospel

@TonHospel Ineed, gentil! Merci!
Dada

5

J, 11 8 octets

Économisé 3 octets grâce aux miles!

]\@#&'*'

Voici une décomposition:

(]\@#&'*') x
x (]\@#) '*'
]\ (x # '*')

Maintenant, ce dernier se lit comme "les préfixes ( ]\) de la chaîne constituée de xcopies de '*'". Observer:

   5 ]\@# '*'
*
**
***
****
*****
   ]\ 5# '*'
*
**
***
****
*****
   ]\ 5 # '*'
*
**
***
****
*****
   ]\@#&'*' 5
*
**
***
****
*****

Cas de test

   f =: ]\@#&'*'
   f 3
*
**
***
   f 5
*
**
***
****
*****
   f 1
*
   f 2
*
**
   f &. > ;/1+i.10
+-+--+---+----+-----+------+-------+--------+---------+----------+
|*|* |*  |*   |*    |*     |*      |*       |*        |*         |
| |**|** |**  |**   |**    |**     |**      |**       |**        |
| |  |***|*** |***  |***   |***    |***     |***      |***       |
| |  |   |****|**** |****  |****   |****    |****     |****      |
| |  |   |    |*****|***** |*****  |*****   |*****    |*****     |
| |  |   |    |     |******|****** |******  |******   |******    |
| |  |   |    |     |      |*******|******* |*******  |*******   |
| |  |   |    |     |      |       |********|******** |********  |
| |  |   |    |     |      |       |        |*********|********* |
| |  |   |    |     |      |       |        |         |**********|
+-+--+---+----+-----+------+-------+--------+---------+----------+

Solutions plus anciennes, 11 octets

'*'#~"+1+i.

C'est équivalent

'*' #~"0 1 + i.

1 + i.est la gamme [1, x]. Ensuite, '*' #~"0appliqué à cette plage forme des copies (élément) de '*'.

Programme de bonus:

[:#&'*'\#&1

Ceci est un fork plafonné #&'*'\appliqué au résultat #&1de l'entrée. #&1donne un tableau de xuns et des #&'*'\formes '*'aux préfixes de ce tableau.

Cas de test

   f1 =: '*'#~"+1+i.
   f2 =: [:#&'*'\#&1
   f1 1
*
   f2 2
*
**
   f1 3
*
**
***
   f2 4
*
**
***
****
   f2 5
*
**
***
****
*****
   f1 5
*
**
***
****
*****
   (f1;f2)3
+---+---+
|*  |*  |
|** |** |
|***|***|
+---+---+
   f1;f2
f1 ; f2
   (f1;f2)5
+-----+-----+
|*    |*    |
|**   |**   |
|***  |***  |
|**** |**** |
|*****|*****|
+-----+-----+
   (f1;f2)10
+----------+----------+
|*         |*         |
|**        |**        |
|***       |***       |
|****      |****      |
|*****     |*****     |
|******    |******    |
|*******   |*******   |
|********  |********  |
|********* |********* |
|**********|**********|
+----------+----------+

Vous pouvez également obtenir les préfixes de la chaîne de ncopies de '*'pour 8 octets en utilisant]\@#&'*'
miles

@miles: et une autre version à 9 octets:'*'"0\@i.
Jonah

5

Vim, 22 , 18 frappes

O <esc>J:h r<cr>lyEZZ<C-v>{@"

Un grand crédit à @Udioica pour avoir fourni une réponse géniale sur vim que j'ai développée. Cette réponse ne contient aucun astérisque, dans l’espoir de gagner la prime.

Explication:

La saisie est tapée avant le reste du programme. Udioica a inventé ce truc génial. Taper <n>O <esc>créera une pyramide d’espaces et une ligne vide, tant que vous avez :set autoindentactivé. Cette option est activée par défaut dans vim 8 et neovim, mais pas les anciennes versions de vim. Comme cela crée également une ligne supplémentaire, nous avons l'habitude Jde joindre cette ligne à la suivante, ce qui supprime simplement la ligne située en dessous de nous.

Maintenant, à ce stade, nous devons remplacer tous ces espaces par des astérisques. Si je ne craignais pas d'utiliser des astérisques dans mon code, je sélectionnerais simplement le tout <C-v>{et le type r*, ce qui remplace chaque caractère de la sélection par un astérisque. Mais je ne peux pas faire ça.

Nous ouvrons donc les pages d’aide à :h r. La chose intéressante à propos de cela est que dans la fenêtre de vim, cette page est affichée comme:

                            r
r{char}         Replace the character under the cursor with {char}.
                ...

Avec le curseur sur le premier 'r'. Cependant, le fichier lui-même contient ce texte:

                            *r*
r{char}         Replace the character under the cursor with {char}.
                ...

Assez pratique. Donc, nous passons au-dessus d'un caractère avec l, et tirons le texte r*avec yE([y] à la [E] nd de ce mot).

Pour fermer ce tampon, nous utilisons le raccourci pour enregistrer un fichier ZZ. Maintenant, nous sélectionnons visuellement nos espaces et lançons le texte tiré comme si nous l'avions dactylographié @". Cela fonctionne parce que "@" exécute le registre suivant sous forme de frappes vim, et "est le registre par défaut pour yanking.


Voulez-vous expliquer comment cela fonctionne?
corvus_192

@ corvus_192 J'ai ajouté une explication plus complète, ainsi qu'un peu plus de golf.
DJMcMayhem

La taille du fichier de données ne doit-elle pas être ajoutée au nombre d'octets?
aross

@aross la taille du fichier d'aide? Non, car ce fichier est installé à côté de vim et constitue une fonctionnalité par défaut.
DJMcMayhem

5

C, 47 46 45 43 octets

Prend les entrées de la ligne de commande

f(n){for(n&&f(n-1);~n;putchar(n--?42:10));}

Fondamentalement, si n n'est pas 0, recurse sur n-1. en haut de la récursivité, où n est 0, une nouvelle ligne est simplement imprimée, la boucle for se termine lorsque n est égal à -1 ou ~ n est égal à zéro, sinon elle affiche le code ASCII 42, qui est '*'. Essayez sur ideone

C ++ 58 octets + 19 pour inclure iostream est 77

#include<iostream>
int f(int n){for(n&&f(n-1);~n;std::cout<<(n--?"*":"\n"));}

main(c,v)char**v;
{
    f(atoi(v[1]));
}

a.exe 3
*
**
***

Pour moi, semble fonctionner avec &&: n?f(n-1):0n&&f(n-1).
Manatwork

@manatwork Merci bourgeon. enregistrer un autre octet
cleblanc

Dans ideone, les empreintes de 2 triangles montrent à la fin il y a un '\ n' plus: * ** *** * ** *** **** ***** Je dis le cas 0 le cas fin reversion, print one \ n more
RosLuP

@RosLup Oui, c'est l'impression d'une nouvelle ligne de début et de fin. Je pense que le PO a dit que c'était OK dans ses commentaires.
Cleblanc

4

Rétine , 14 octets

Le nombre d'octets suppose un codage ISO 8859-1.

.+
$**
.
$`$&¶

Essayez-le en ligne!

Explication

.+
$**

Transformez l'entrée Nen Nastérisques.

.
$`$&¶

Remplacez chaque astérisque par tous les éléments jusqu’à et y compris cet astérisque (c’est le $`$&) et un saut de ligne (c’est le ).



4

Cubix , 22 octets

?(.;I:^;/-.@o;(!\>'*oN

Testez-le en ligne! Sort un retour à la ligne final.

Au début, je n'étais pas sûr de pouvoir placer ceci sur un cube de 2, mais à la fin, tout s'est bien passé:

    ? (
    . ;
I : ^ ; / - . @
o ; ( ! \ > ' *
    o N
    . .

J'ajouterai une explication quand j'en aurai le temps, j'espère plus tard aujourd'hui.


Explication à tout moment? : P
FlipTack
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.