Escriba un programa o función que tome un número entero positivo e imprima o devuelva una pila de tantas tortugas de arte ASCII , donde cada tortuga es más grande que la que está encima.

Específicamente, si la entrada es 1, la salida debería ser:

 __
/,,\o

Si la entrada es 2:

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

Si la entrada es 3:

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

Si la entrada es 4:

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

Si la entrada es 5:

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

Y así sucesivamente en el mismo patrón para entradas más grandes.

Tenga en cuenta que:

• La cabeza (la o) de la tortuga inferior siempre está a la derecha. Las cabezas de las tortugas arriba se alternan de un lado a otro.
• Ninguna línea puede tener espacios finales.
• No se permiten espacios iniciales superfluos. (es decir, la parte posterior de la tortuga inferior debe estar al comienzo de la línea).
• Se permite una nueva línea final opcional.

El código más corto en bytes gana.

Lote, 256 bytes

@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%__

Tenga en cuenta que la línea 1 tiene un espacio final y la línea 4 tiene dos espacios finales. ipor lo tanto, contiene un echocomando con la cantidad adecuada de sangría para cada tortuga. Mientras tanto, ucontiene el número de guiones bajos en tortugas alternativas. Una tortuga impar principal tiene una carcasa especial y luego el resto de las tortugas salen en parejas.

C, 131 bytes

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;}

Pruébalo en línea.

Define una función que imprime las tortugas.

Abusa mucho de los especificadores de ancho y precisión de printf para obtener el espacio y repetir los guiones bajos. Cada tortuga se imprime usando una sola printfllamada:

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

También tengo una versión diferente que es 144 bytes con espacios en blanco eliminados:

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 bytes

Solución recursiva. Pruébalo en línea!

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 bytes

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

Pruébalo en línea

V , 57, 53 49 bytes

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

Como esto contiene caracteres no imprimibles, aquí hay 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

Pruébalo en línea!

Explicación:

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 bytes

Código de 91 bytes +1 para -n.

Requiere -Esin costo adicional.

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

Uso

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

¡Gracias a @Dada por -9 bytes con su retrabajo !

Cheddar , 105 bytes

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 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Python 2, 116 bytes

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 bytes

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)}

más limpiamente (agrega un byte)

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 estructura básica se llama a sí misma recursivamente, diciéndose a sí misma tanto el número final a llamar como el nivel actual. Comienza con un valor predeterminado para y = 1, por lo que solo necesita una variable para la llamada inicial. Define rápidamente dos valores que se usan con frecuencia. Luego simplemente repite todo el número necesario de veces.

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

Cada uno de estos prueba implícitamente si se debe agregar la cabeza a derecha o izquierda y colocarla adecuadamente.

TSQL, 189 bytes

Ahora con aceptación de entrada, gracias a @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

Violín

C, 328 238 234 215 bytes:

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);}

Una implementación recursiva que utiliza mucho formato de cadena y la memsetfunción incorporada . Intentaré jugar más golf con el tiempo tanto como pueda.

¡C en línea! (Ideona)

Java 1.7, 238 bytes

Un conjunto de dos funciones: primero itera sobre la entrada (# de tortugas), segundo facilita la construcción de una secuencia de caracteres repetidos de forma recursiva (es decir, los espacios iniciales, la parte posterior y el vientre de las tortugas).

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):"";}

Sin golf:

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) : "";
        }

    }

}

¡Ejecutarlo! (Ideona)

Supuse que está bien excluir la definición de clase del recuento de bytes.

Es posible que pueda jugar un poco más de golf al invertir el orden de iteración del bucle (construir desde la tortuga inferior hacia arriba) y / o volverme completamente recursivo como algunas de las otras respuestas.

Nota personal: Java realmente carece de una taquigrafía incorporada para repetir n caracteres ...

Pitón, 137 120 113 110 bytes

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

Sin golf:

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

Las cabezas estaban duras.

F #, 218 207 202 196 187 bytes.

Afeitó la mayoría de estos bytes al incluir 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 lógica es robada descaradamente de esta respuesta de Python

Pruébalo en línea.

CJam , 88 bytes

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

Primero hace la tortuga más grande (porque de lo contrario, ¿en qué se pararía cualquier otra tortuga?), Luego reduce gradualmente el tamaño hasta que se haga la más pequeña. Funciona para cualquier número entero mayor que 0.

Pruébalo en línea!

Python 2.7, 255 238 236 bytes

Aunque esto pierde con las otras dos soluciones de Python 2, me gustó mi enfoque recursivo:

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: eliminó algunos bytes al eliminar algunos reemplazos

edit2: afeitó 2 bytes guardando los guiones bajos como una variable

Python 2, 147 bytes

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)

Pruébalo en línea

Python 2.7, 139 114 113 130 bytes

También me gustó el enfoque recursivo de Iguanodon, así que aquí hay un intento un poco más corto.

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)

EDITAR

Un poderoso 25 26 9 bytes de golf debido a algunos consejos fantásticos de Destructible Watermelon. ¡Muchas gracias! Piensa que puede ser la respuesta más corta de Python ahora :-)

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 bytes

^{-21 bytes gracias a mazzy, el loco}

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

Pruébalo en línea!

Cambia inteligentemente las variables $_--para evitar usar ($_+1)bloques repetidos para guardar varios bytes. También convierte el argumento único en una cadena que luego se convierte en un int cuando se usa en un rango para recorrer el número de tortugas. El mayor truco ahora es que el segundo nivel del espaciado de una tortuga solo aumente cada dos filas restando $_%2(es decir, 0 si es par, 1 si es impar) del conteo de filas actual.

De lo contrario, se trata de una gran cantidad de índice de matemáticas para conseguir adecuada _y cargos, incluyendo un contador de retraso en la forma de $i++, y ahora sólo un único índice de la lista para poner la cabeza en el lado correcto.

ES6 (JavaScript), 140 bytes

Código

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":"")

Prueba

console.log(T(5));

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

Lienzo , 26 bytes.

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

Pruébalo aquí!