Selon moi, une tornade ressemble à ceci:
########
#######
######
#####
####
###
##
#
Cette tornade commence par la largeur n
, et sur chaque ligne suivante, un caractère est supprimé à gauche ou à droite, selon l'entrée.
Contribution
L'entrée sera une liste d'une sorte de deux valeurs uniques (une chaîne de deux caractères uniques fonctionne aussi), et un entier positif facultatif pour indiquer la largeur de départ. Si l'entier facultatif n'est pas pris, la largeur de départ est supérieure de 1 à la longueur de la liste. Soit la largeur de départ n
.
Comment faire une tornade
Dans mon exemple, je choisis ma liste pour contenir 1
s et 0
s, bien que vous puissiez choisir deux valeurs constantes distinctes ou une chaîne de deux caractères constants distincts.
La première ligne sera composée de caractères n
non blancs (vous pouvez choisir n'importe quel caractère cohérent; je choisis #
pour mon exemple).
Ensuite, pour chaque numéro de la liste, si le numéro est 0
, supprimez le caractère gauche et créez une nouvelle ligne; si c'est un 1
, supprimez le bon caractère et créez une nouvelle ligne.
Ainsi, la tornade ci-dessus est la sortie de 8, [1, 0, 0, 0, 1, 0, 0]
.
Sortie
La sortie peut être une liste de chaînes, une liste de listes de caractères ou une chaîne multiligne. Les espaces de fin sur chaque ligne sont autorisés et un retour à la fin à la fin est autorisé.
Cas de test
Ces tests incluent la largeur de départ et les listes d'utilisation de 1, 0
.
5, [1,0,0,1]
#####
####
###
##
#
10, [1,0,0,1,0,1,0,0,1]
##########
#########
########
#######
######
#####
####
###
##
#
7, [1,1,1,1,1,1]
#######
######
#####
####
###
##
#
100,
[1,0,0,0,0,1,0,0,0,1,1,0,1,0,0,1,0,0,1,0,0,1,1,0,1,1,1,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,1,1,0,0,1,1,1,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,1,1,1,1,1,1,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,1,0,1,0,1,0,0,1,1,0,0,0,0,1]
Règles
- Des échappatoires standard s'appliquent
- Le code le plus court en octets gagne! code-golf
- Le fond n'a pas besoin d'être un espace (j'ai oublié de le préciser plus tôt).
- Votre langue doit uniquement prendre en charge les nombres (largeurs) qu'elle peut gérer, mais si votre interprète a été réécrit avec une taille de nombre plus grande, elle doit théoriquement fonctionner.
Réponses:
V ,
15, 12 octetsEssayez-le en ligne!
l
pour la droite, (est parfaitement logique, n'est-ce pas?) et>
pour la gauche.la source
Python 2 ,
6659 octets-7 octets grâce à Arnold Palmer
Essayez-le en ligne!
0
enlever de la droite,1
enlever de la gauchela source
len(z)+1
parx
si "entier positif facultatif" signifie que vous n'avez pas à l'utiliser. Le libellé de la question donne l'impression que ceci est autorisé car il dit "Si l'entier optionnel n'est pas pris" contre "Si l'entier optionnel n'est pas donné".vim,
8582 octets<ESC>
est 0x1B,<CR>
est0x0D
,<C-v>
est 0x16. Et<ESC>OH
est une séquence multi-octets représentant la touche HOME.L'entrée utilise
a
comme valeur "supprimer gauche" etb
comme valeur "supprimer droite".Pas de lien TIO, malheureusement. Je ne pouvais pas le faire fonctionner sous V. Test en copiant le code dans tornado.vim (en remplaçant
<ESC>
, etc. par leurs octets réels) et en exécutant comme suit:-3 octets en raison de la suggestion de Neil.
la source
^
place de␛OH
?^
passe au premier caractère non vierge.␛OH
va au premier caractère.0
non ...05AB1E ,
119 octets-2 octets grâce à Erik l'Outgolfer
Supprimer de gauche:
1
Supprimer de droite:
0
Essayez-le en ligne!
la source
0×ηsηO
a tellement de potentiel mais je ne peux pas le comprendre sous 11 octets.ðy×ì
paryú
-2.Rétine ,
3028 octetsEssayez-le en ligne! Prend juste une chaîne de 0 et de 1 et calcule la largeur en fonction de la chaîne. Explication: La première étape prend la chaîne d'entrée et la duplique une fois pour chaque point limite, en insérant un
#
à ce point. La deuxième étape change ensuite tous les chiffres après le#
plus de#
s, créant le triangle. Le troisième stange supprime ensuite tous les autres et modifie les zéros en espaces, ce qui se traduit par «l'oscillation» du torndao.la source
J, 32 octets
non golfé
Essayez-le en ligne!
la source
' #'#~0(,.#\.)@,+/\
, où l'entrée est inversée à partir de l'échantillon puisque le défi vous permet de choisir les deux valeurs distinctes.Perl, 43 octets
Code de 42 octets + 1 pour
-l
.Essayez-le en ligne!
la source
R ,
8582 octets3 octets économisés grâce à Giuseppe
Essayez-le en ligne!
Explication:
la source
{}
et utilisé une nouvelle ligne littérale au lieu de'\n'
Haskell, 50 octets
Essayez-le en ligne!
Si la liste d'entrée peut être une liste de noms de fonctions, nous pouvons enregistrer un octet
Haskell, 49 octets
Exemple d'utilisation:
h 5 [g,f,f,g]
.Essayez-le en ligne!
Comment ça marche:
la source
Python 2,
5857 octetsedit: sauvé 1 octet grâce à xnor
Essayez-le en ligne!
1 pour retirer de la gauche, 0 pour retirer de la droite.
la source
s=" "*i+s[:-1]
avec la gauche et la droite permutées.R ,
116109102 octets-5 octets grâce à user2390246 (et 2 autres je me suis sauvé)
Outgolfed par user2390246
Essayez-le en ligne!
Renvoie une fonction anonyme qui prend
n
et un vecteurl
avec0
pour supprimer de la gauche et1
pour supprimer de la droite, et imprime le résultat sur la console avec la mise en forme de droite.la source
#
s sera n-i + 1: Essayez-le en ligne! Bien qu'il y ait une approche légèrement meilleure si vous imprimez simplement ligne par ligne plutôt que de construire une matrice: codegolf.stackexchange.com/a/133720/66252Japt ,
1413 octets-1 octet grâce à @ETH
L'entrée est le tableau, puis la taille. Les valeurs de tableau sont
""
ou" "
, qui représentent la suppression de la droite ou de la gauche, respectivement. Utilise à la"
place de#
et renvoie un tableau de chaînes.L'idée ici était de créer d'abord un tableau du remplissage gauche pour chaque ligne, d'où les chaînes d'entrée. Ensuite, chaque ligne obtient le
"
s ajouté, en utilisant le fait que le nombre de"
s diminue de 1 à chaque fois.Essayez-le en ligne!
Tous utilisent le
-R
drapeau pour formater la sortie en la joignant à des retours à la ligne.Explication
Implicite:
U
= tableau d'entrée,V
= numéro d'entrée.Réduisez cumulativement le tableau d'entrée (
å
) avec la concaténation de chaînes (+
). Il en résulte le tableau de chaque valeur intermédiaire de la réduction. Ensuite, ajoutez (u
) une chaîne vide (P
) au tableau.Mappez
£
chaque valeur à elle-même (X
) concaténée avec ...Le caractère guillemet (
Q
) a été répété (p
)V--
(V´
) fois. Cela diminue également àV
chaque fois.la source
YnV
àV´
++
ou--
dans Japt.ArnoldC , 3132 octets
ArnoldC n'a pas de concaténations de chaînes, donc cela crée une tornade à partir de
8
s et utilise1
s pour l'espacer. ArnoldC ne prend également en charge que des entiers jusqu'à 16 bits, de sorte qu'il déborde avec une entrée de plus de 7 chiffres. (Donc ça ne fera que des mini-tornades)1
est à gauche, tout autre chiffre est à droite (bien que je ne recommanderais pas0
, car vous ne pouvez pas commencer par cela.)Contribution:
1221122
Sortie:
Code de golf:
Essayez-le en ligne!
Code non golfé (5178 octets):
la source
Haskell ,
6764 octetsL'entrée est inversée:
0
signifie supprimer à droite et1
supprimer à gauche:Essayez-le en ligne!
"Ungolfed"
la source
Java (OpenJDK 8) ,
138133 bytesEssayez-le en ligne!
la source
C,
6863 octetsCela utilise la spécification de largeur de champ dynamique dans une
printf()
chaîne de format. La fonction est appelée comme ceci:la source
int s=0;
et en plaçants;
avant lef(w,i)
. Comme çaJavaScript (ES6), 64 octets
Fonction anonyme prenant des paramètres dans la syntaxe de curry (a) (b). Dans le tableau b, une chaîne vide représente la suppression de la droite et un espace représente la suppression de la gauche.
En utilisant 1 et 0 comme dans les exemples, le score est de 70
Tester
la source
PowerShell , 53 octets
Essayez-le en ligne!
Prend l'entrée
$a
comme entier facultatif et$b
comme tableau de1
et0
s. (Notez que mon tableau de1
et0
est inversé à partir de celui du défi.) Construit la ligne initiale de#
et la laisse sur le pipeline. Boucle ensuite de0
à$a
. A chaque itération, nous sortons un nombre d'espaces éventuellement incrémenté, suivi d'un nombre pré-décrémenté de#
. Oui, cela va cracher un retour à la ligne vierge à la fin, car nous bouclons jusqu'à$a
plutôt que le nombre d'éléments dans la liste.Toutes les chaînes individuelles sont laissées sur le pipeline et la sortie avec un séparateur de nouvelle ligne entre elles est implicite à la fin du programme.
la source
C #, 181 octets
Essayez-le en ligne!
Version complète / formatée:
la source
Fusain , 17 octets
Essayez-le en ligne! Le lien est vers la version verbeuse la plus proche du code. Explication:
La première entrée donne le nombre d'itérations de boucle.
Étant donné que les indices de boucle par défaut sont indexés à zéro, nous en ajoutons un ici pour obtenir le nombre correct de
#
s.En partant du bas de la tornade et en remontant, vous économisez un octet, mais nous devons ensuite inverser la deuxième entrée afin d'indexer le chiffre actuel.
Si le chiffre actuel est un
1
, remontez. Cela fait que la ligne précédente a un supplément#
à la fin.Si le chiffre actuel est un
0
, déplacez-vous vers le haut et vers la gauche. Cela fait que la ligne précédente a un supplément#
au début.la source
C # , 159 octets
Explication
Essayez-le en ligne!
la source
PHP, 136 octets
Enregistrez dans un fichier php et testez avec
php file.php 8 '1,0,0,0,1,0,0'
. Sortie:Hélas, préparer l'entrée est la moitié du travail.
Une autre version (158 octets) utilisant
str_repeat
au lieu deprintf
et ...goto
de toutes choses:la source