Dessiner une double hélice ASCII

55

Ecrivez un programme qui prend un entier N via stdin ou la ligne de commande.

Si N est 0, la lettre unique Odoit ê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 Oextré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 Oextré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.
Les passe-temps de Calvin
la source
9
Question brillante!
Joshpbarron
il me semble que pour n = 0, il pourrait être pratique d’imprimer <spc>O<spc> ou \nO\n. Est -ce unnecesary leader des espaces a permis?
Level River St
1
print "."Zoomez pour voir l'hélice. * nodnod *
David Richerby
@steveverrill Cela a peut-être été utile, mais il y a tellement de réponses que je ne veux pas changer la règle. J'ai précisé que les espaces de début ne faisant pas partie du modèle ne sont pas autorisés.
Les passe-temps de Calvin

Réponses:

16

CJam, 56 55 53 52 50 octets

S'O:Ori:X0>"\/"=" / \\\ / "+Xz*1>O]s3/X"z"<~N*X\O?

Regardez cette taille! Les principaux coupables sont N = 0des cas particuliers et le \lieu de /l'hélice verticale.

Voici comment cela fonctionne:

S'O:O                                  e# Put a space on stack. Now put char O on stack
                                       e# and assign it to variable O. This is not really
                                       e# helping in golfing as using 'O everywhere is
                                       e# same number of bytes
     ri:X                              e# Read input as in integer and store it in X
         0>"\/"=                       e# If X is greater than 0, choose /, otherwise \
                " / \\\ / "            e# Put this string on stack
                           +           e# Append to chosen \ or /
                            Xz*        e# Repeat it abs(X) times
1>                                     e# Remove the first character from repeated string
  O]                                   e# Put char O on stack, wrap everything in an array
                                       e# and convert it to string.
    3/                                 e# Split the string into parts of length 3
      X"z"<~                           e# If X is positive, transpose the array to get a
                                       e# horizontal helix, otherwise it would be vertical
            N*                         e# Join the parts with newline
              X\O?                     e# If X was 0, then pick char O instead of this
                                       e# final joined string.

Le code est divisé en trois parties:

  • La partie 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 étant 2, 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.
  • La deuxième partie consiste à corriger la chaîne ci-dessus avec des éléments supplémentaires et à scinder. Pour une entrée 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 'Oau début et un autre 'Oà la fin. Ensuite, nous l'avons scindé en parties de 3
  • Enfin, nous décidons de transposer ou non cette chaîne de division pour une hélice verticale; Rejoignez les parties par des nouvelles lignes; Et choisissez entre ceci et un seul caractère 'O(pour la casse saisie 0)

Essayez-le en ligne ici

Optimiseur
la source
10

JavaScript (ES6), 126 132 133

A=n=>(F=(f,j='')=>f+(j+f).repeat(n-1),n>0?F(' /\\')+`
o${F('  ','/')}o
`+F(' \\/'):(n=-n)?` o${F(`
/ \\
\\ /
`,' \\')} o`:'o') 

// Test
for(i=0;i<10;i++)
  P.innerHTML = P.innerHTML + A(i)+'\n\n\n',
  N.innerHTML = N.innerHTML + A(-i)+'\n\n\n'
pre { 
  font-size: 10px;
  line-height: 9px;
}
<table>
<tr><th>Positive</th><th>Negative</th></tr>
<tr><td valign=top><pre id=P></pre></td><td><pre id=N></pre></td></tr>
</table>

À l'aide d'une chaîne basée sur un modèle, les nouvelles lignes comptent.

Plus lisible

A=n=>(
  F=(f,j='')=>f+(j+f).repeat(n-1),
  n > 0 ? F(' /\\') + '\no' + F('  ','/') + 'o\n'+F(' \\/')
  : (n=-n) ? ' o' + F('\n/ \\\n\\ /\n',' \\')'+' o':'o'
)  
edc65
la source
1
Et je pensais que je suis bon avec JS ... que n=>(fait-on? Je n'ai jamais vu ni utilisé cet opérateur auparavant.
YU NO WORK
@YUNOWORK est une fonctionnalité ES6 permettant de créer une fonction. Elle n’est disponible que sur FireFox. Voir developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
edc65
Voilà des trucs sympas, qui devraient se pencher sur ES6 trop tôt. Merci de clarifier!
YU NO WORK
8

Pyth, 52 octets

M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)?jb?gQ\/>Q0msdCg_Q\\Q\O

Manifestation.

Explication:

La première section, M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)définit une fonction gqui prend deux entrées. La première entrée, Gest le nombre de répétitions à utiliser. C'est la valeur absolue de l'entrée. La deuxième entrée, Hest 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. *hGdest la chaîne d' G+1espaces. j"/\\"*hGdrejoint cette chaîne avec "/\"comme délimiteur. La valeur Jde 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 ces Gtemps de chaîne avec *G. Ensuite, on enlève son dernier caractère avec P. Enfin, nous entourons cette chaîne de deux Ocaractères, avec j ... *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\Osélectionne entre trois possibilités différentes, positive, négative et nulle. Le premier si-alors conditionne Q, l'entrée. La deuxième condition sur >Q0, si l'entrée est positive.

Si Qest égal à zéro, \Ole caractère Oest imprimé.

Si Qest non nul, nous joignons le résultat du deuxième ternaire sur les nouvelles lignes et l’imprimons avec jb. Si Qest positif, la liste jointe et imprimés est gQ\/, g(Q,"/").

Si Qest négatif, la liste jointe et imprimée est msdCg_Q\\. Nous commençons par g_Q\\ce qui est g(-Q,"\"). Ensuite, nous transposons les lignes et les colonnes avec C. msdtransforme les nuplets de caractères résultants en chaînes, prêtes à être jointes sur de nouvelles lignes et imprimées.

isaacg
la source
6

Python 2, 118

n=input()
a=[' O '[n==0:]]+['/ \\','\\ /','  /\\ '[n<0::2]]*abs(n)
a[-1]=a[0]
for x in[a,zip(*a)][n>0]:print''.join(x)

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

grc
la source
1
Bon travail. Une chose: ce devrait être une lettre majuscule "O" plutôt que le chiffre 0.
Alex A.
@Alexa. Merci - j'ai complètement raté ça.
grc
5

Java, 500 488 octets

Mon 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)?

import java.util.*;class t{public static void main(String[] args){Scanner sc=new Scanner(System.in);int n=Integer.parseInt(sc.nextLine());if(n>0){for(int i=0;i<n;i++)System.out.print(" /\\");o("");System.out.print('o');for(int i=0;i<n-1;i++)System.out.print("  /");o("  o");for(int i=0;i<n;i++)System.out.print(" \\/");}else if(n<0){o(" o ");for(int i=0;i<-n-1;i++){o("/ \\");o("\\ /");o(" \\ ");}o("/ \\");o("\\ /");o(" o ");}else o("o");}static void o(String s){System.out.println(s);}}
britboy3456
la source
5
Bienvenue chez PPCG! Ce n'est pas important que vous soyez un facteur 10 d'un langage de golf comme CJam avec Java. ;) La joie est d'essayer de battre les réponses dans la même langue ou de langues de même verbosité et d'apprendre de nouvelles bizarreries de votre langue. Je ne connais pas très bien le golf en Java, mais vous pouvez certainement économiser des octets avec un nom de classe plus court et des noms de variables à une lettre. Aussi, ne pouvez-vous pas simplement import System.*ou quelque chose pour sauver l'écriture à Systemchaque fois?
Martin Ender
En effet, il peut, 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é).
bloo
+1 pour Java. Vous pouvez vous débarrasser de la scvariable car elle n'est appelée qu'une fois. Rase 14 octets.
topher
Je sais que cela fait presque trois ans, mais bon nombre de choses peuvent être jouées au golf: 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.
Kevin Cruijssen le
1
En outre, une fonction est autorisée pour ce défi; elle peut donc comporter 251 octets lors de l'utilisation d'un lambda Java 8+: 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.
Kevin Cruijssen le
5

Haskell, 156 octets

h 0="O"
h n|n>0=' ':c n "/\\ "++"\nO"++c(n-1)"  /"++"  O\n "++c n "\\/ "
   |0<1=" O\n/ \\\n"++c(-n-1)"\\ /\n \\\n/ \\\n"++"\\ /\n O"
c x=concat.replicate x

Vous pouvez ensuite l'écrire comme suit:

*Main> putStrLn $ h 1
 /\ 
O  O
 \/ 
*Main> putStrLn $ h 0
O
*Main> putStrLn $ h (-1)
 O
/ \
\ /
 O
*Main> putStrLn $ h 3
 /\ /\ /\ 
O  /  /  O
 \/ \/ \/ 
*Main> putStrLn $ h (-3)
 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O
*Main>
Willem Van Onsem
la source
2
Vous pouvez écrire 1<2ou quelque chose comme ça au lieu de True, et sauvegarder un octet.
marinus
@marinus: mis à jour, merci beaucoup.
Willem Van Onsem
4

C #, 242 241 238 230 222 219 octets

Sous l'impulsion du commentaire de Martin , voici ma première tentative:

string h(int n){int x=0;string p="",r=n==0?"O":p;if(n>0){for(;x++<n;){r+=" /\\";p+=" \\/";}r+="\nO  ";for(;x-->2;)r+="/  ";r+="O\n"+p;}else if(n<0){r+=@" O
/ \
";for(--x;x-->n;)r+=@"\ /
 \
/ \
";r+=@"\ /
 O";}return r;}

Plus lisiblement:

string h(int n)
{
    int x = 0;
    string p = "",
            r = n==0 ? "O" : p;
    if (n > 0) {
        for (; x++ < n;) {
            r += " /\\";
            p += " \\/";
        }
        r += "\nO  ";
        for (; x-- > 2;) r += "/  ";
        r += "O\n" + p;
    }
    else if(n<0) {
        r += @" O
/ \
";
        for (--x; x-- > n;) r += @"\ /
 \
/ \
";
        r += @"\ /
 O";
    }
    return r;
}
James Thorpe
la source
3

C # 199 197 196 octets

string f(int n){var u=n<0;int m=u?-n:n;string a="",b=" O ";for(;m-->0;)b+="\n/ \\\n\\ /\n "+(m==0?"O ":u?"\\ ":"/ ");for(;++m<3;)a+=string.Concat(b.Split('\n').Select(s=>s[m]))+"\n";return u?b:a;}

Version non-golfée:

    string f(int n)
    {
        var u = n < 0;
        int m = u ? -n : n;
        string a = "", b = " O ";
        for (; m-- > 0; ) b += "\n/ \\\n\\ /\n " + (m == 0 ? "O " : u ? "\\ " : "/ ");
        for (; ++m < 3;) a += string.Concat(b.Split('\n').Select(s => s[m])) + "\n"; 
        return u ? b : a;
    }

L'idée est de construire l'affichage horizontal à partir de l'affichage vertical en rendant la matrice de caractères transposée.

Vincent Ripoll
la source
Nice - Je n'avais pas encore eu l'occasion d'essayer une réponse de transposition en C #. Notez que vous avez le « \ » et « / » le tour de mauvaise façon pour les crossovers, et vous pouvez enregistrer quelques octets en changeant for(;m>0;--m)à for(;m-->0;)dans les deux boucles
James Thorpe
Cette chaîne: "\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 ligne
James Thorpe
Oui, j’ai introduit la variable u pour raccourcir la solution, mais j’ai oublié d’inverser le test des crossovers. Merci pour l'idée de raccourcir la condition de boucle (bien que je ne puisse pas raccourcir la deuxième boucle car m est alors égal à 0 et je l'utilise comme index). Pour l'astuce newline, cela ne fonctionne pas sous Windows car le b.Split ('\ n') devrait être remplacé par b.Split ('\ n', '\ r') qui coûte 5 caractères et n'enregistre que 3.
Vincent Ripoll
Ah bon, je suppose que je ne l'avais pas remarqué parce que je ne divisais rien. Je viens aussi de remarquer que vous pourriez passer bool uà var uun autre octet entier :)
James Thorpe
Comme votre version n’utilisait aucune variante, je ne voulais pas obtenir un avantage indu. :)
Vincent Ripoll
3

Python 3, 118 octets

x=int(input())
print("O"if x==0else" /\\"*x+"\nO "+" / "*(x-1)+" O\n"+" \\/"*x if x>0else(" O"+"\n/ \\\n\\ /\n \\"*-x)[:-1]+"O")

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.

Mattermonkey
la source
2

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.

n->(if n==0 println("O")else m=abs(n);A=B=reshape(split(" / "*(n>0?"/":"\\")*" \\\\ /",""),(3,3));E=[" ";"O";" "];if m>1for i=2:m B=hcat(B,A)end end;B[:,1]=E;B=hcat(B,E);C=n>0?B:B';for i=1:size(C,1) println(join(C[i,:]))end end)

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:

function f(n)
    if n == 0
        println("O")
    else
        m = abs(n)

        # Split the string into a 3x3 matrix with a slash on the left,
        # or a backslash for n < 0
        A = B = reshape(split(" / " * (n > 0 ? "/" : "\\") * " \\\\ /", ""), (3, 3))

        # We can get the O lines where needed by appending this
        E = [" "; "O"; " "]

        # Grow the helix by abs(n)
        if m > 1
            for i = 2:m
                B = hcat(B, A)
            end
        end

        # Exchange the first column for E
        B[:,1] = E

        # Add E onto the right
        B = hcat(B, E)

        # If n is negative, we actually want the transpose
        C = n > 0 ? B : B'

        # Print the rows of C
        for i = 1:size(C, 1)
            println(join(C[i,:]))
        end
    end
end

Quelques exemples:

julia> f(1)
 /\
O  O
 \/

julia> f(-2)
 O 
/ \
\ /
 \
/ \
\ /
 O
Alex A.
la source
2

Python 3, 135 octets

n=int(input());m=abs(n)-1;print({n:" O\n/ \\\n"+m*"\ /\n \\\n/ \\\n"+"\\ /\n O",m+1:n*" /\\"+"\nO"+"  /"*m+"  O\n"+" \/"*n,0:"O"}[n])

Essayez-le en ligne ici

OrangeHat
la source
2

Perl, 91 97

La transposition s'est avérée trop chère à la fin.

#!perl -n
print/-/?"\0\23"^" \\
/ \\
\\ /
"x-$_." O":-$_?" /\\"x$_.("*`"^" / "x$_." O
"." \\/"x$_):O

Solution précédente:

#!perl -n
$".="`"^"/ 
\\ /
/ \\
 "x abs.O;print/-/?$"=~y!/\\!\\/!r:/^0/?O:map{($"=~/^.{$_}(.)/mg,$/)}2,1,0

Testez - moi .

nutki
la source
C'est vraiment gentil. Vous pouvez économiser deux octets supplémentaires en les remplaçant /^0/?O:etcpar$_?etc:O
alexander-brett
@ alexander-brett cela ne nécessiterait aucune EOL en entrée, car "0 \ n" est évalué à true.
nutki
Vous pouvez probablement vous en tirer sans exiger de fin de vie sur stdin :). De plus, vous pouvez en économiser 4 avec$".="\23"^"\\ / \\ \\ / "x abs."O ";print/-/?$":/^0/?O:map{reverse$/,$"=~/(.).{$_}$/mg}0..2
alexander-brett
@ alexander-brett, cela produit des barres obliques inverses dans la ligne centrale pour les nombres positifs, ce qui est incorrect, non?
nutki
Oh mec, c'est comme ça que je vais loin en jouant vite. Vous avez absolument raison. De plus, ai-je mentionné le fait que j'aime vraiment cette idée de transposition de tableaux?
alexander-brett
2

Schéma, 379 octets

Ma première tentative de code de golf et, malheureusement, l’un des plus longs. :(

(define (h i) (define a string-append) (define (k n p q s e) (cond ((= i n) (p s (k (q n 1) p q s e))) ((= 0 n) e) (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\") (k (q n 1) p q s e))))) (if (= i 0) "O\n" (apply a (map (lambda (s) (a s "\n")) (if (> i 0) (k i (lambda (x y) (map a x y)) - '(" /" "O " " \\") '("\\" " O" "/")) (k i append + '(" O" "/ \\") '("\\ /" " O")))))))

Ungolfified:

(define (h i)
  (define a string-append)

  (define (k n p q s e)
    (cond ((= i n) (p s (k (q n 1) p q s e)))
          ((= 0 n) e)
          (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\")
                   (k (q n 1) p q s e)))))

  (if (= i 0) "O\n"
      (apply a (map (lambda (s) (a s "\n"))
                    (if (> i 0)
                        (k i (lambda (x y) (map a x y)) -
                           '(" /" "O " " \\")
                           '("\\" " O" "/"))
                        (k i append +
                           '(" O" "/ \\")
                           '("\\ /" " O")))))))
Alan Third
la source
2

Java, 282

Ma première approche, avec des noms de variables particulièrement sympathiques:

class H{public static void main(String[]_){int N=Integer.parseInt(_[0]),í=N;String ì="/ \\\n\\ /\n",I=" o \n",i="",l=I;for(;í-->0;)i+=" /\\";i+="\no";for(í=N;í-->1;)i+="  /";i+="  o\n";for(í=N;í-->0;)i+=" \\/";for(í=1;í++<-N;)l+=ì+" \\ \n";System.out.println(N<0?l+ì+I:N>0?i:"o");}}

Je ne sais pas pourquoi je fais ça. Ça doit être quelque chose de récréatif.

Marco13
la source
2

Java, 317

Ma première tentative de golf de code.

public class t{public static void main(String[]e){int n=Integer.parseInt(e[0]);String s=new String(new char[n==0?0:(n>0?n:-n)-1]),u="\0";System.out.print(n==0?"O":n>0?s.replace(u," /\\")+" /\\\nO"+s.replace(u,"  /")+"  O\n"+s.replace(u," \\/")+" \\/":" O \n/ \\\n"+s.replace(u,"\\ /\n \\ \n/ \\\n")+"\\ /\n O \n");}}
Olivia Trewin
la source
1

Python 3, 165 octets

x,a,b,c,d=int(input())-1,'\ /',' / ','/ \\','\ /\n \\\n/ \\\n'
print([[' O\n/ \\\n'+d*abs(x+2)+'\ /\n O',' /'+a*x+'\\\nO '+b*x+' O\n \\'+c*x+'/'],'OO'][x==-1][x>-1])

Essayez-le en ligne ici .

Tim
la source
1

Perl, 193 197 187 180 166 163B

Pénalité de 1 octet pour le commutateur de ligne de commande -n. Courir avec echo 1|perl -M5.10.0 -n scratch.pl:

$_*=3;$s=($m=abs)==$_;$_?map{say if$_=join'',map{(map[/./g]," O ",(('/ \\', '\\ /',$s?' / ':' \\ ')x$m)[0..$m-2]," O")[$s?$_:$j][$s?$j:$_]}0..$m;$j++}0..$m:say'O'

Avec des espaces:

$_ *= 3;
$s = ($m = abs) == $_;
$_ ? map{
      say if $_=join '', map {
       ( map[/./g],
          " O ",
          (('/ \\', '\\ /',$s?' / ':' \\ ') x $m)[0..$m-2],
          " O"
        )[$s ? $_ : $j][$s ? $j : $_]
       }0..$m;
      $j++
    } 0..$m
  : say 'O'
alexander brett
la source
Est-il conventionnel de -M5.10.0ne pas contribuer à votre nombre d'octets? say est pratique pour le code golf…
xebtl
@TheSuitIsBlackNot a dit que c'était (dans le commentaire supérieur codegolf.stackexchange.com/a/49762/19039 sur) - Je suppose que c'est parce que c'est une version linguistique.
alexander-brett
1

PHP, 341

$s='';$n=$argv[1];$l=PHP_EOL;if($n>0){for($i=0;$i<$n;$i++)$s.=" /\\";$s.=$l;for($i=0;$i<$n;$i++){if($i==0)$s.='o';if($i<$n-1)$s.='  /';if($i==$n-1)$s.='  o';}$s.=$l;for($i=0;$i<$n;$i++)$s.=" \\/";}else{$n=abs($n);for($i=0;$i<$n;$i++){if($i== 0)$s.=' o '.$l;$s.="/ \\".$l."\\ /".$l;if($i < $n-1)$s.=' \\ '.$l;if($i==$n-1)$s.=' o '.$l;}}echo $s;

Version non-golfée

$s = '';
$n = $argv[1];
echo PHP_EOL;
if($n > 0)
{
    for($i=0;$i<$n;$i++)
    {
        $s.=" /\\";
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        if($i==0) { 
            $s.='o';
        }
        if($i < $n-1) {
            $s.='  /';
        }    
        if( $i == $n-1)
        {
            $s.='  o';
        }
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        $s.=" \\/";
    }
} else
{
    $n = abs($n);
    for($i=0;$i<$n;$i++)
    {
        if($i == 0) {
            $s.=' o '.PHP_EOL;    
        }    
        $s.="/ \\".PHP_EOL."\\ /".PHP_EOL;
        if($i < $n-1) {
            $s.=' \\ '.PHP_EOL;
        }    
        if( $i == $n-1) {
            $s.=' o '.PHP_EOL;
        }    
    }    
}

echo $s;
kuldeep.kamboj
la source
1

JAVA 377 384 octets

class F{public static void main(String[] a){int n=Integer.parseInt(a[0]);if(n>0){for(int i=0;i<n;i++)p(" /\\");p("\n");for(int i=0;i<n;i++){if(i==0)if(n>1)p("O  ");else p("O  O");else if(i==n-1)p("/  O");else p("/  ");}p("\n");for(int i=0;i<n;i++){p(" \\/");}}else{p(" O\n");for(int i=0;i<Math.abs(n);i++){p("/ \\\n\\ /\n O\n");}}}static void p(String s){System.out.print(s);}}
Angelo Tricarico
la source
1

C ++ 269 262 258

#include <string>
#include <iostream>
int main(){int i,j;std::cin>>i;std::string s,u,t;if(i>0){for(j=i;j;j--){s+=" /\\";t+="/  ";u+=" \\/";}t[0]='O';t+="O";s=s+'\n'+t+'\n'+u;}else{for(j=i;j;j++)s+=" \\\n/ \\\n\\ /\n";s[1]='O';s+=" O";}std::cout<<(i==0?"O":s);}
Chris.Wilson
la source
1

R, 228 201

n=scan();z=cat;f=`for`;if(!n)z("O");if(n>0){f(i,1:n,z(" /\\"));z("\nO  ");if(n>1)f(i,2:n,z("/  "));z("O\n");f(i,1:n,z(" \\/"))};if(n<0){z(" O\n");f(i,-n:1,{z("/ \\\n\\ /\n ");if(i>1)z("\\\n")});z("O")}

Ma première tentative de code golf. Je pense que cela fonctionne mais ce n'est pas subtil.

n=scan(); # enter number here
z=cat;
if(!n) z("O\n");
if(n>0){
  z(" ");
  for(i in 1:n) z("/\\ ");
  z("\nO");
  if(n>1){
    for(i in 2:n) z("  /")
  };
  z("  O\n ");
  for(i in 1:n) z("\\/ ")
};
if(n<0){
  z(" O \n");
  for(i in -n:1){
    z("/ \\\n\\ /");
    if(i>1) z("\n \\\n")
  };
z("\n O ")
}
Flet
la source
1

Groovy, 142 134 129 125 120 118

a=args[0]as int;b="\n/ \\\n\\ /\n ";print!a?"O":a>0?" /\\"*a+"\nO  ${"/  "*(a-1)}O\n"+" \\/"*a:" O$b${"\\$b"*(1-a)}O"

Enfin lié avec python 2!

Dbramwell
la source
1

Charbon de bois , 28 24 22 octets

↙OF↔θ/¶\¶ \¶↗‖BO¿›N⁰⟲T

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

↙O

Imprimez le haut Oet laissez le curseur un espace en bas à gauche.

F↔θ/¶\¶ \¶

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

‖B

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

O

Écraser le dernier \avec un O.

¿›N⁰⟲T

Si l'entrée était positive, faites pivoter la toile.

Neil
la source
1

Toile , 33 32 30 octets

 /¶O:╴⤢╷\ /¶ \×+;↔+──╴0<?↷}╴‽O

Essayez-le ici!

Explication:

 /¶O:                           push " /\¶O" twice
     ╴⤢╷                        push the absolute value of the input, -1
        \ /¶ /×                 repeat "\ /¶ /" horizontally that many times
               +                append that horizontally to one of the first strings
                ;               and get the other, reverse it
                 ↔+             and then append it to the result of above. Now the top part of the helix is done
                   ──           vertically palindromize with no mirroring (works because of a misake - it just doesn't overlap smartly)
                     ╴0<? }     if the input is less than 0
                         ↷        rotate clockwise the whole thing
                           ╴‽   if the input is falsy (aka 0)
                             O    push O; implicitly output the top of stack
dzaima
la source
0

C ++, 352

Pas du tout la réponse la plus courte, mais la première en C ++ à ce jour :)

#include <iostream>
int main(int argc, char* argv[]){int a=argv[0][0]-'0';if(a==0){printf("o");}else if(a>0){for(int i =0; i < a;i++){printf(" /\\");}printf("\no");for(int i=0;i<a-1;i++){printf("  /");}printf("  o\n");for(int i=0;i<a;i++){printf(" \\/");}}else{printf(" o\n/ \\\n\\ /\n");for(int i=0;i>a+1;i--){printf("/ \\\n\\ /\n");}printf(" o");};}

La voici en C ++ Shell avec des espaces à tester

Points d'interrogation
la source
0

perl 156

$==pop;print$=>0?' /\\'x$=.$/:'',$=>0?'O'.'  /'x$=."\bO
":'',$=>0?' \\/'x$=:'';print$=<0?" O":'';print"
/ \\
\\ /
 \\" for$=..-1;print$=<0?"\bO":!$=?"O":''

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.

Caek
la source
0

C, 189 octets

char*h="6Er66 e66Ee 6rE66",*v="6e6 E6r r6E 6r6 6e6",*z="e",*u;b,m,w,c,p;f(n){b=n<0;u=b?v:n?h:z;for(m=b?4:1,w=n*(b?-3:3);u[p];p+=++c%((w+2)*m)==w*m?m:p%(6*m)==m*4?-m*3:0)putchar(u[p++]-22);}

Avec des espaces et des nouvelles lignes:

char *h="6Er66 e66Ee 6rE66",
     *v="6e6 E6r r6E 6r6 6e6",
     *z="e",
     *u;
b, m, w, c, p;
f(n) {
    b = n < 0;
    u = b ? v : n ? h : z;
    for (m = b ? 4 : 1, w = n * (b ? - 3 : 3);
         u[p];
         p += ++c % ((w + 2) * m) == w * m ? m : p % (6 * m ) == m * 4 ? - m * 3 : 0)
        putchar(u[p++] - 22);
 }

Quelques notes sur l'approche:

  • Stocke le motif dans des tableaux de caractères. Ils sont décalés de 22 caractères pour éviter d’avoir besoin de plusieurs barres obliques inverses pour échapper aux caractères spéciaux.
  • Utilise des motifs distincts pour horizontal, vertical et zéro. J'ai d'abord envisagé d'utiliser un seul motif et de le parcourir différemment pour les valeurs positives et négatives. Je ne l'ai pas mis en œuvre, mais j'avais l'impression que cela compliquerait un peu plus la logique. D'autant que la barre oblique centrale a la direction opposée pour les deux cas. Et comme les tables ne sont pas si grandes, cela semblait plus prometteur.
  • Le code consiste principalement en des calculs d’index, avec une logique pour décider quand c’est fait et quand le modèle tourne en boucle. La plupart des calculs sont faits pour que cela fonctionne dans les deux cas avec leurs dimensions et règles de répétition différentes.
Reto Koradi
la source
0

Perl, 184 octets

$n=pop;$p=$n>0;$_=' \ /'x(1+abs$n*3);$n=$p?$n*4+1:3;$_=join'
',/.{$n}/g;$r=$p?'.':'.*
';s/($r$r)$r($r)/$1$2/g;$p and s/^\S|\S$/O/gm or s/^ \S $|(?<=^ )\S|\S $/O/g;y~\\/~/\\~if$p;print;

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!

CJ Dennis
la source
0

PHP, 155

$n=$argv[1];$r='str_repeat';$k="/ \\\n\\ /\n";echo$n>0?" /{$r('\ /',$n-1)}\\\nO{$r('  /',$n-1)}  O\n \\{$r('/ \\',$n-1)}/":" O\n{$r("$k \\\n",-$n-1)}$k O";
mk8374876
la source