Ecrivez un programme qui prend un entier N via stdin ou la ligne de commande.
Si N est 0, la lettre unique O
doit être imprimée sur stdout.
Si N est positif , cette double hélice horizontale ASCII art , N segments larges, doit être imprimée.
Si N est 1, le résultat est:
/\
O O
\/
Si N est 2, le résultat est:
/\ /\
O / O
\/ \/
Si N est 3, le résultat est:
/\ /\ /\
O / / O
\/ \/ \/
Si N est 4, le résultat est:
/\ /\ /\ /\
O / / / O
\/ \/ \/ \/
Le motif continue exactement de la même manière pour les N plus grands. Notez que la barre oblique ( /
) doit être utilisée à tous les endroits où les hélices se croisent, à l'exception des O
extrémités.
Si N est négatif , cette double hélice verticale de l’art ASCII, dessinée avec N segments hauts, doit être imprimée.
Si N est -1, le résultat est:
O
/ \
\ /
O
Si N est -2, le résultat est:
O
/ \
\ /
\
/ \
\ /
O
Si N est -3, le résultat est:
O
/ \
\ /
\
/ \
\ /
\
/ \
\ /
O
Si N est -4, le résultat est:
O
/ \
\ /
\
/ \
\ /
\
/ \
\ /
\
/ \
\ /
O
Le motif continue exactement de la même manière pour les N plus petits. Notez que les barres obliques inversées ( \
) doivent être utilisées à tous les endroits où les hélices se croisent, à l'exception des O
extrémités.
Détails
- Au lieu d’un programme, vous pouvez écrire une fonction qui prend N en tant qu’entier et affiche le résultat normalement ou le renvoie sous forme de chaîne.
- La sortie de n'importe quel N peut éventuellement contenir une nouvelle ligne.
- Toute ligne de sortie pour n'importe quel N peut éventuellement contenir 4 espaces de fin ou moins.
- Il ne devrait jamais y avoir d'espace principal qui ne fasse pas partie du modèle spécifié.
- Le code le plus court en octets gagne.
la source
<spc>O<spc>
ou\nO\n
. Est -ce unnecesary leader des espaces a permis?print "."
Zoomez pour voir l'hélice. * nodnod *Réponses:
CJam,
56 55 53 5250 octetsRegardez cette taille! Les principaux coupables sont
N = 0
des cas particuliers et le\
lieu de/
l'hélice verticale.Voici comment cela fonctionne:
Le code est divisé en trois parties:
X0>"\/"=" / \\\ / "+
donne soit"/ / \\\ / "
ou"\ / \\\ / "
qui est crucial car l’hélice est simplement constituée d’alternative"/ \"
et"\ /"
rejoint par l’un" / "
ou l’ autre" \ "
. Par exemple, si vous considérez l'entrée comme étant2
, votre dernière chaîne répétée serait"/ / \\ / / / \\ / "
(sans échappement). Cela a évidemment plus/
au début et un espace supplémentaire à la fin.2
, la chaîne finale souhaitée sans nouvelles lignes serait" O / \\\ / / / \\\ / O"
, mais après le point ci-dessus, nous en avons seulement"/ / \\\ / / / \\\ / "
. Nous supprimons donc le premier caractère, ajoutons un espace et'O
au début et un autre'O
à la fin. Ensuite, nous l'avons scindé en parties de 3'O
(pour la casse saisie 0)Essayez-le en ligne ici
la source
JavaScript (ES6), 126
132 133À l'aide d'une chaîne basée sur un modèle, les nouvelles lignes comptent.
Plus lisible
la source
n=>(
fait-on? Je n'ai jamais vu ni utilisé cet opérateur auparavant.Pyth, 52 octets
Manifestation.
Explication:
La première section,
M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)
définit une fonctiong
qui prend deux entrées. La première entrée,G
est le nombre de répétitions à utiliser. C'est la valeur absolue de l'entrée. La deuxième entrée,H
est le caractère à placer au centre des spirales.La fonction retourne une liste de 3 éléments, composée des 3 lignes de la spirale positive et des 3 colonnes de la spirale négative.
Le premier élément est défini par
Jj"/\\"*hGd
.*hGd
est la chaîne d'G+1
espaces.j"/\\"*hGd
rejoint cette chaîne avec"/\"
comme délimiteur. La valeurJ
de départ enregistre la valeur résultante pour une utilisation future.Le deuxième élément est
jP*G+*2dH*2\O
. Nous commençons avec+*2dH
. Il s’agit de deux espaces suivis du caractère saisi. Ensuite, nous répétons cesG
temps de chaîne avec*G
. Ensuite, on enlève son dernier caractère avecP
. Enfin, nous entourons cette chaîne de deuxO
caractères, avecj ... *2\O
.Le troisième élément est généré avec
_J
. C'est simplement l'inverse de la première ligne.Cette dernière section
?jb?gQ\/>Q0msdCg_Q\\Q\O
sélectionne entre trois possibilités différentes, positive, négative et nulle. Le premier si-alors conditionneQ
, l'entrée. La deuxième condition sur>Q0
, si l'entrée est positive.Si
Q
est égal à zéro,\O
le caractèreO
est imprimé.Si
Q
est non nul, nous joignons le résultat du deuxième ternaire sur les nouvelles lignes et l’imprimons avecjb
. SiQ
est positif, la liste jointe et imprimés estgQ\/
,g(Q,"/")
.Si
Q
est négatif, la liste jointe et imprimée estmsdCg_Q\\
. Nous commençons parg_Q\\
ce qui estg(-Q,"\")
. Ensuite, nous transposons les lignes et les colonnes avecC
.msd
transforme les nuplets de caractères résultants en chaînes, prêtes à être jointes sur de nouvelles lignes et imprimées.la source
Python 2, 118
Crée la double hélice verticale à partir d'une liste de chaînes et la transpose pour obtenir celle horizontale. Je suis sûr que cela pourrait être amélioré.
la source
Java,
500488 octetsMon premier essai, et malheureusement, il est 10 * plus long que le leader actuel :(. Quelqu'un a-t-il des conseils (autres que d'utiliser un langage différent)?
la source
import System.*
ou quelque chose pour sauver l'écriture àSystem
chaque fois?import static java.lang.System.*;
ou il pourrait enregistrer le flux de sortie standard en tant que variable (bien que, je ne sais pas s'il permettrait de sauvegarder ou d'entraver, dans ce cas, il n'a pas vérifié).sc
variable car elle n'est appelée qu'une fois. Rase 14 octets.class M{public static void main(String[]a){int n=new Integer(new java.util.Scanner(System.in).next()),i=n;if(n>0){for(;i-->0;)o(" /\\");o("\no");for(i=n;i-->1;)o(" /");o(" o\n");for(i=0;i++<n;)o(" \\/");}else if(n<0){o(" o \n");for(i=0;i++<~n;)o("/ \\\n\\ /\n \\ \n");o("/ \\\n\\ /\n o \n");}else o("o\n");}static<T>void o(T s){System.out.print(s);}}
( 352 octets ) Essayez-le en ligne.n->{int i=n;if(n>0){for(;i-->0;)o(" /\\");o("\no");for(i=n;i-->1;)o(" /");o(" o\n");for(i=0;i++<n;)o(" \\/");}else if(n<0){o(" o \n");for(i=0;i++<~n;)o("/ \\\n\\ /\n \\ \n");o("/ \\\n\\ /\n o \n");}else o("o\n");};<T>void o(T s){System.out.print(s);}
essayez-le en ligne.Haskell, 156 octets
Vous pouvez ensuite l'écrire comme suit:
la source
1<2
ou quelque chose comme ça au lieu deTrue
, et sauvegarder un octet.C #,
242241238230222219 octetsSous l'impulsion du commentaire de Martin , voici ma première tentative:
Plus lisiblement:
la source
C #
199197196 octetsVersion non-golfée:
L'idée est de construire l'affichage horizontal à partir de l'affichage vertical en rendant la matrice de caractères transposée.
la source
for(;m>0;--m)
àfor(;m-->0;)
dans les deux boucles"\n/ \\\n\\ /\n "
pourrait également être raccourcie selon les méthodes de ma réponse - utilisation@"..."
, où chaque "\\" devient "\" et chaque "\ n" devient une nouvelle lignebool u
àvar u
un autre octet entier :)Python 3, 118 octets
Ma toute première soumission de golf de code, donc ce n'est peut-être pas du tout impressionnant.
Utilise simplement l'opérateur ... si ... autrement ... de Python pour séparer les trois scénarios. Cela donne une chaîne faite de répéter certaines petites chaînes un certain nombre de fois à imprimer.
la source
Julia, 229 octets
Oh mec, c'est beaucoup trop grand. C'est la réponse la plus longue à ce jour par une large marge. Je pourrais probablement économiser beaucoup en renvoyant la chaîne plutôt qu'en l'imprimant ou en évitant complètement l'approche par matrice. Je ferai des expériences avec ça plus tard.
Cela crée une fonction lambda qui prend un seul entier et imprime la double hélice formatée de manière appropriée. Pour l'appeler, donnez-lui un nom, par exemple
f=n->(...)
.Ungolfed + explication:
Quelques exemples:
la source
Python 3, 135 octets
Essayez-le en ligne ici
la source
Perl, 91
97La transposition s'est avérée trop chère à la fin.
Solution précédente:
Testez - moi .
la source
/^0/?O:etc
par$_?etc:O
$".="\23"^"\\ / \\ \\ / "x abs."O ";print/-/?$":/^0/?O:map{reverse$/,$"=~/(.).{$_}$/mg}0..2
Schéma, 379 octets
Ma première tentative de code de golf et, malheureusement, l’un des plus longs. :(
Ungolfified:
la source
Java, 282
Ma première approche, avec des noms de variables particulièrement sympathiques:
Je ne sais pas pourquoi je fais ça. Ça doit être quelque chose de récréatif.
la source
Java, 317
Ma première tentative de golf de code.
la source
Python 3, 165 octets
Essayez-le en ligne ici .
la source
Perl,
193197187180166163BPénalité de 1 octet pour le commutateur de ligne de commande -n. Courir avec
echo 1|perl -M5.10.0 -n scratch.pl
:Avec des espaces:
la source
-M5.10.0
ne pas contribuer à votre nombre d'octets?say
est pratique pour le code golf…PHP, 341
Version non-golfée
la source
JAVA 377
384octetsla source
C ++
269262258la source
R,
228201Ma première tentative de code golf. Je pense que cela fonctionne mais ce n'est pas subtil.
la source
Groovy,
142134129125120118Enfin lié avec python 2!
la source
Charbon de bois ,
282422 octetsEssayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:
Imprimez le haut
O
et laissez le curseur un espace en bas à gauche.Imprimer les chaînes
/
,\
et\
et répétez l' opération pour la valeur de nombre absolu de l'entrée.Revenez sur le dernier
\
.Réfléchissez pour créer le côté droit de l'hélice. Je le fais ici car sinon, l'
↗
analyse ne serait pas analysée sans ambiguïté.Écraser le dernier
\
avec unO
.Si l'entrée était positive, faites pivoter la toile.
la source
Toile ,
333230 octetsEssayez-le ici!
Explication:
la source
C ++, 352
Pas du tout la réponse la plus courte, mais la première en C ++ à ce jour :)
La voici en C ++ Shell avec des espaces à tester
la source
perl 156
Assez simple tentative, mon deuxième golf. Je pense que les nouvelles lignes comptent pour 1 octet, non?
Maintenant, essayez de trouver comment joindre tous ces ternaires. J'ai beaucoup de progrès à faire avec ceux de
:'';
partout.la source
C, 189 octets
Avec des espaces et des nouvelles lignes:
Quelques notes sur l'approche:
la source
Perl, 184 octets
Je pensais que ça allait être beaucoup plus court! Il y a probablement des choses simples que je peux faire pour économiser quelques octets. Cela fait cinq ans que j'ai programmé sérieusement en Perl!
la source
PHP, 155
la source
J ,
67 59 5551 octetsEssayez-le en ligne!
la source