Ecrivez un programme ou une fonction qui prend un nombre entier positif et imprime ou renvoie une pile de ce nombre de tortues de type ASCII , où chaque tortue est plus grande que celle située au-dessus.

Plus précisément, si l'entrée est 1, la sortie doit être:

 __
/,,\o

Si l'entrée est 2:

  __
o/,,\
 ____
/,__,\o

Si l'entrée est 3:

   __
  /,,\o
  ____
o/,__,\
 ______
/,____,\o

Si l'entrée est 4:

    __
  o/,,\
   ____
  /,__,\o
  ______
o/,____,\
 ________
/,______,\o

Si l'entrée est 5:

     __
    /,,\o
    ____
  o/,__,\
   ______
  /,____,\o
  ________
o/,______,\
 __________
/,________,\o

Et ainsi de suite dans le même schéma pour des entrées plus importantes.

Notez que:

• La tête ode la tortue inférieure est toujours à droite. Les têtes des tortues ci-dessus alternent alors d'avant en arrière.
• Aucune ligne ne peut avoir d'espaces de fin.
• Les espaces de début superflus ne sont pas autorisés. (Par exemple, le dos de la tortue du bas devrait être au début de la ligne.)
• Un seul retour à la ligne facultatif est autorisé.

Le code le plus court en octets gagne.

Lot, 256 octets

@set i=echo 
@%i%off
set u=
for /l %%j in (2,2,%1)do call set i=%%i%%  
set/af=%1^&1
if %f%==1 %i% __&%i%/,,\o&set u=__
for /l %%j in (2,2,%1)do call:l
exit/b
:l
set i=%i:~0,-2%
%i%  _%u%_
%i%o/,%u%,\
%i% __%u%__
%i%/,_%u%_,\o
set u=__%u%__

Notez que la ligne 1 a un espace de fin et la ligne 4 a deux espaces de fin. icontient donc une echocommande avec la quantité d'indentation appropriée pour chaque tortue. Pendant ce temps ucontient le nombre de traits de soulignement chez les tortues en alternance. Une tortue principale impaire est spéciale-cased et ensuite le reste des tortues sont sorties par paires.

C, 131 octets

i,j;f(n){char _[3*n];memset(_,95,3*n);for(i=n;i--;printf("%*.*s\n%*s/,%.*s,\\%s\n",j+n+1,j+j,_,i,"o"+1-i%2,j+j-2,_,"o"+i%2))j=n-i;}

Essayez-le en ligne.

Définit une fonction qui imprime les tortues.

Abuse fortement des spécificateurs de largeur et de précision de printf pour obtenir l'espacement et répéter les traits de soulignement. Chaque tortue est imprimée en un seul printfappel:

printf("%*.*s\n%*s/,%.*s,\\%s\n",j+n+1,j+j,_,i,"o"+1-i%2,j+j-2,_,"o"+i%2)

J'ai aussi une version différente de 144 octets avec les espaces blancs supprimés:

c,i;f(n){for(i=n;i--;){
    char*p=" _\n o/,_,\\o\n";
    int C[]={i+1,c=n+n-i-i,1,i&~1,i%2,1,1,c-2,1,1,1-i%2,1};
    for(c=0;p[c];)C[c]--?putchar(p[c]):++c;
}}

Ruby, 100 octets

Solution récursive Essayez-le en ligne!

f=->n,i=1{f[n-1,i+1]if n>1;puts' '*i+?_*n*2,"%#{i-1}s/,#{?_*2*~-n},\\"%(i<2?'':'o '[i%2])+' o'[i%2]}

05AB1E, 45 octets

Lvð¹y-©>ׄ__y×UXJ,„/,X¨¨„,\J'o®ÉiìëJ}ð®®É-×ì,

Essayez-le en ligne

V , 57, 53 49 octets

i ³_
/,_,\oÀñHyjí_/___
ëPhjI ñdjí___
òkk$x^PXkk

Puisque cela contient des caractères non imprimables, voici un hexdump:

00000000: 6920 b35f 0a2f 2c5f 2c5c 6f1b c0f1 4879  i ._./,_,\o...Hy
00000010: 6aed 5f2f 5f5f 5f0a eb50 1668 6a49 20f1  j._/___..P.hjI .
00000020: 646a ed5f 5f5f 0af2 6b6b 2478 5e50 586b  dj.___..kk$x^PXk
00000030: 6b                                       k

Essayez-le en ligne!

Explication:

i ³_\n/,_,\o<esc>       "Insert the original turtle with one extra underscore

Àñ                      "Arg1 times:
  Hyj                   "  Go the the beginning of the file, and yank a turtle
     í_/___             "  Extend the lenght of every turtle by two
ëP                      "  Move to the beginning of the file again, and paste the turtle we yanked
  <C-v>hjI              "  Move this turtle one to the right
           ñ            "Stop looping.

dj                      "Delete a turtle (since we have one too many)
  í___                  "Make every turtle shorter (since they are all too long)

ò                       "Recursively:
 kk                     "  Move up two lines
   $x                   "  Delete the last character on this line (an 'o')
     ^P                 "  And paste this 'o' at the beginning of the line
       X                "  Remove one space
        kk              "  Move up two lines again

Perl, 92 octets

Code 91 octets +1 pour -n.

Requiert -Esans frais supplémentaires.

for$i(1..$_){say$"x$_._,$v=_ x(--$i*2),_.$/.$"x(--$_-1),$_%2?o:$"x!!$_,"/,$v,\\",$_%2?"":o}

Usage

perl -nE 'for$i(1..$_){say$"x$_._,$v=_ x(--$i*2),_.$/.$"x(--$_-1),$_%2?o:$"x!!$_,"/,$v,\\",$_%2?"":o}' <<< 3
   __
  /,,\o
  ____
o/,__,\
 ______
/,____,\o

Merci à @Dada pour -9 octets pour son travail renouvelé!

Cheddar , 105 octets

n->(|>n).map(i->(1-i%2)*"o"+"\\,"+(n-i-1)*"__"+",/"+i%2*"o"+i/2*"  "+"\n"+(n-i)*"__"+(i+1)*" ").vfuse.rev

Retina , 97 91 88 octets

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

.+
  $&$*_$&$*_o
+`^( *?)(.)__(_+)(.)
$1 $4$3$2¶$&
 (.)__(_*) ?
  __$2¶$%`$1/,$2,\
Rm`^ 

Essayez-le en ligne!

Python 2, 116 octets

m=input()
for i in range(m):r=m-i;b=r%2;h='o';a='__';u=i*a;s=' '*r;print s+u+a+'\n'+s[:b-2]+h*-~-b+"/,"+u+",\\"+b*h

R , 150 octets

a=function(x,y=1){d=x-y;t=d%%2;cat(rep(" ",d+1),rep("_",2*y),"\n",rep(" ",d-t),"o"[t],"/,",rep("_",2*y-2),",\\","o"[!t],"\n",sep="");if(y<x)a(x,y+1)}

plus proprement (ajoute un octet)

a=function(x,y=1){
     d=x-y
     t=d%%2
     cat(rep(" ",d+1),rep("_",2*y),"\n",rep(" ",d-t),"o"[t],"/,",rep("_",2*y-2),",\\","o"[!t],"\n",sep="")
     if(y<x)a(x,y+1)
}

La structure de base s’appelle elle-même de manière récursive - elle indique à la fois le numéro final à appeler et le niveau actuel. Commence avec une valeur par défaut pour y = 1, de sorte qu'il ne nécessite qu'une seule variable pour l'appel initial. Définit rapidement deux valeurs fréquemment utilisées. Ensuite, il répète tout le nombre de fois nécessaire.

"o"[t],"o"[!t]

Chacune de celles-ci teste implicitement s'il faut ajouter la tête à droite ou à gauche et la placer de manière appropriée.

TSQL, 189 octets

Maintenant, avec acceptation des entrées - grâce à @PatrickRoberts

DECLARE @i INT=##i##,@ INT=0a:PRINT SPACE(@i-@)+REPLICATE('__',@+1)+'
'+SPACE((@i-@-1)/2*2)+IIF((@i-@-1)%2=1,'o/,','/,')+REPLICATE('__',@)+IIF((@i-@-1)%2=0,',\o',',\')SET
@+=1IF @i>@ GOTO a

Violon

C, 328 238 234 215 octets:

B;M(w,j,R){j=w;if(j<=B){char b[j*2-1],k[j*2+1];b[j*2-2]=k[j*2]=0;memset(b,95,j*2-2);memset(k,95,j*2);R=(B+1-j)%2;printf("%*s\n%*s/,%s,\\%s\n",j*2+B+1-j,k,B-j,R?"":"o",b,R?"o":"");j++;M(j);}}main(){scanf("%d",&B);M(1);}

Une implémentation récursive utilisant beaucoup de formatage de chaîne et la memsetfonction intégrée . Je vais essayer de jouer au golf avec le temps autant que je peux.

C il en ligne! (Idéone)

Java 1.7, 238 octets

Un ensemble de deux fonctions: la première itération sur la saisie (nombre de tortues), la seconde facilite la construction récursive d'une séquence de caractères répétés (c'est-à-dire les espaces de début, le dos et le ventre des tortues).

String f(int n){String s="";for(int i=-1,x=-2;++i<n;){int m=(i+n)%2;s+=r(' ',n-i)+r('_',i*2+2)+"\n"+r(' ',n-i-(m==1?1:2))+(m==0?"o":"")+"/,"+r('_',x+=2)+",\\"+(m==1?"o":"")+"\n";}return s;}String r(char c,int n){return n>0?c+r(c,--n):"";}

Ungolfed:

class C {
    public static void main(String[] a) {
        System.out.println(new T().f(1));
        System.out.println(new T().f(2));
        System.out.println(new T().f(3));
        System.out.println(new T().f(4));
        System.out.println(new T().f(5));
    }

    static class T {

        String f(int n) {
            String s = "";
            for (int i = -1, x = 0; ++i < n; x+=2) {
                int m = (i + n) % 2;
                s += r(' ', n - i) + r('_', i * 2 + 2) + "\n" + r(' ', n - i - (m == 1 ? 1 : 2)) + (m == 0 ? "o" : "") + "/," + r('_', x) + ",\\" + (m == 1 ? "o" : "") + "\n";
            }
            return s;
        }

        String r(char c, int n) {
            return n > 0 ? c + r(c, --n) : "";
        }

    }

}

Exécuter! (Idéone)

J'ai supposé que nous pouvions exclure la définition de classe du nombre d'octets.

Je pourrai peut-être jouer un peu plus loin en inversant l'ordre d'itération de la boucle (construction à partir de la tortue du bas) et / ou en me rendant complètement récursif, à l'instar de certaines des autres réponses.

Note à moi-même: il manque vraiment à Java un raccourci intégré pour répéter n caractères ...

Python, 137 120 113 110 octets

m=input()
for i in range(m):p=m-i;b=p%2;print' '*p+'__'*-~i+'\n'+' '*(p-2+b)+'o'*-~-b+'/,'+'__'*i+',\\'+'o'*b

Ungolfed:

m=input()
for i in range(m):
  p=m-i                              // Abstract m-i for a few bytes
  b=p%2                              // Determines every other turtle from bottom

  print' '*p + '__'*-~i + '\n' +    // The top of the turtle
       ' '*(p-2+b) +                // Leading spaces (-1 for every other turtle)
       '0'*-~-b +                   // Add a leading head to every other turtle
       '/,'+'__'*i +                // Body of the turtle
       ',\\'+'0'*b                  // Add a trailing head to every other turtle

Les têtes étaient difficiles.

F #, 218 207 202 196 187 octets.

Rasé la plupart de ces octets en ajoutant des variables

let R=String.replicate
let t n=let rec L i r k=if i<n then L(i+1)(R(k+i%2+1)" "+R((n-i)*2)"_"+"\n"+R k" "+R(i%2)"o"+"/,"+R(n*2-i*2-2)"_"+",\\"+R(1-i%2)"o"+"\n"+r)(k+i%2*2)else r in L 0""0

La logique est volée sans vergogne de cette réponse en Python

Essayez-le en ligne.

CJam , 88 octets

ri_[S\_'_*_+N+\O\"/,"\('_*_++','\+'o]\({_[(S+\(2>\(S\+)'O^c+\(-2<\(\('o\{;O}&\;]}*]-1%N*

Crée d'abord la plus grosse tortue (sinon, sur quoi se placerait une autre tortue?), Puis réduit progressivement la taille jusqu'à la fabrication de la plus petite. Fonctionne pour tout entier supérieur à 0.

Essayez-le en ligne!

Python 2.7, 255 238 236 octets

Même si cela perd aux deux autres solutions Python 2, j’ai aimé mon approche récursive:

def r(s,p):
 for(a,b)in p:s=a.join(s.split(b))
 return s
def t(w):
 i='_'*2*w;s='\n __%s\n/,%s,\o'%(i,i)
 if w:s=r(t(w-1),[('\n ','\n'),('Z/',' /'),('\\Z\n','\\\n'),(' /','o/'),('\\','\\o'),('o','Z')])+s
 return s
print t(input()-1)[1:]

edit1: supprimé quelques octets en éliminant certains remplacements

edit2: rasé 2 octets en enregistrant les traits de soulignement en tant que variable

Python 2, 147 octets

n=input()
s=' ';r=[];i=k=0
while i<n:a=i%2;r=[s*k+s*a+s+'_'*(n-i)*2+s,s*k+'o'*a+'/,'+'_'*(n-i-1)*2+',\\'+'o'*(1-a)]+r;k+=a*2;i+=1
print'\n'.join(r)

Essayez-le en ligne

Python 2.7, 139 114 113 130 octets

J'ai aussi aimé l'approche récursive d'Iguanodon, alors voici une tentative légèrement plus courte.

def t(n):
 if n>1:t(n-1)
 a=i-n;b=(a+1)%2;print' '*(a+1)+'__'*n+'\n'+' '*(a-1+b)+'o'*(not b)+'/,'+'__'*(n-1)+',\\'+'o'*b
i=input()
t(i)

MODIFIER

Un puissant 25 26 9 octets joué au golf en raison de quelques conseils fantastiques de la pastèque destructible. Merci beaucoup! Je pense que c’est peut-être la réponse la plus courte en Python :-)

def t(n):
 if n>1:t(n-1)
 a=i-n;b=-~a%2;print' '*-~a+'__'*n+'\n'+' '*(a-1+b)+'o'*-~-b+'/,'+'__'*~-n+',\\'+'o'*b
i=input()
t(i)

PowerShell , 105 100 97 87 85 84 octets

^{-21 octets grâce à mazzy, le fou}

"$args"..1|%{' '*$_--+($m='__'*$i++)+'__'
' '*($_-$_%2)+("/,$m,\o","o/,$m,\")[$_%2]}

Essayez-le en ligne!

Décale intelligemment les variables en utilisant $_--pour éviter d'utiliser des ($_+1)blocs répétés pour économiser plusieurs octets. Il convertit également l'argument unique en une chaîne qui est ensuite convertie en un entier lorsqu'il est utilisé dans une plage dans laquelle parcourir le nombre de tortues. La plus grosse astuce consiste maintenant à ce que le 2ème niveau d'espacement d'une tortue n'augmente que tous les rangs en soustrayant $_%2(c'est-à-dire 0 si pair, 1 si impair) du nombre_ligne actuel.

Sinon, il faut beaucoup d'indexation pour calculer correctement _et compter, y compris un compteur de décalage sous la forme de $i++, et maintenant, un seul index de liste pour placer la tête du bon côté.

ES6 (JavaScript), 140 octets

Code

T=(i,h=0,p=1,R="repeat")=>(i>1?T(i-1,~h,p+1)+"\n":"")+" "[R](p)+'--'[R](i)+"\n"+" "[R](p-1+h)+(h?"o":"")+"/,"+'__'[R](i-1)+",\\"+(!h?"o":"")

Tester

console.log(T(5));

     --
    /,,\o
    ----
  o/,__,\
   ------
  /,____,\o
  --------
o/,______,\
 ----------
/,________,\o

Toile , 26 octets

╷_×,×ｌ_×∔/×║o×⇵↔⁸¹－［  ×↔｝］

Essayez-le ici!