Escreva um programa ou função que receba um número inteiro positivo e imprima ou retorne uma pilha dessas muitas tartarugas de arte ASCII , em que cada tartaruga é maior que a acima.

Especificamente, se a entrada for 1, a saída deve ser:

 __
/,,\o

Se a entrada for 2:

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

Se a entrada for 3:

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

Se a entrada for 4:

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

Se a entrada for 5:

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

E assim por diante no mesmo padrão para entradas maiores.

Observe que:

• A cabeça (a o) da tartaruga de fundo está sempre à direita. As cabeças das tartarugas acima se alternam.
• Nenhuma linha pode ter espaços à direita.
• Espaços à esquerda supérfluos não são permitidos. (ou seja, a parte de trás da tartaruga de fundo deve estar no início da linha.)
• Uma única nova linha opcional à direita é permitida.

O código mais curto em bytes vence.

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

Observe que a linha 1 tem um espaço à direita e a linha 4 tem dois espaços à direita. iportanto, contém um echocomando com a quantidade apropriada de indentação para cada tartaruga. Enquanto isso, ucontém o número de sublinhados em tartarugas alternativas. Uma tartaruga ímpar líder é de invólucro especial e, em seguida, o restante das tartarugas é produzido em pares.

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

Experimente online.

Define uma função que imprime as tartarugas.

Abusa fortemente os especificadores de largura e precisão da printf para obter o espaçamento e repetir os sublinhados. Cada tartaruga é impressa usando uma única printfchamada:

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

Eu também tenho uma versão diferente com 144 bytes sem o espaço em branco removido:

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

Solução recursiva. Experimente online!

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}ð®®É-×ì,

Experimente online

V , 57, 53 49 bytes

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

Como ele contém caracteres não imprimíveis, aqui está um 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

Experimente online!

Explicação:

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.

Requer -Esem custo extra.

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

Graças a @Dada por -9 bytes com seu re-trabalho!

Queijo 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

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

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

de forma mais limpa (adiciona um 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)
}

A estrutura básica se chama recursivamente - dizendo a si mesmo o número final a ser chamado e o nível atual. Começa com um padrão para y = 1, portanto, ele precisa apenas de uma variável para a chamada inicial. Define rapidamente dois valores usados ​​com freqüência. Depois, repete tudo o número de vezes necessário.

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

Cada um deles testa implicitamente se deve adicionar a cabeça à direita ou à esquerda e colocá-la adequadamente.

TSQL, 189 bytes

Agora com aceitação de entrada - graças 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

Violino

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

Uma implementação recursiva usando muita formatação de string e a memsetfunção interna . Vou tentar jogar isso mais ao longo do tempo, tanto quanto eu puder.

C It Online! (Ideona)

Java 1.7, 238 bytes

Um conjunto de duas funções: primeiro itera sobre a entrada (número de tartarugas), a segunda facilita a construção de uma sequência de caracteres repetidos de forma recursiva (ou seja, os espaços principais, as costas e a barriga das tartarugas).

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

    }

}

Executá-lo! (Ideona)

Supus que não há problema em excluir a definição de classe da contagem de bytes.

Eu posso ser capaz de jogar um pouco mais adiante, revertendo a ordem de iteração do loop (construindo da tartaruga inferior para cima) e / ou indo totalmente recursivo como algumas das outras respostas.

Nota para si mesmo: Java realmente não possui uma abreviação incorporada para repetir n caracteres ...

Pitão, 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

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

As cabeças estavam duras.

F #, 218 207 202 196 187 bytes.

Raspou a maioria desses bytes inserindo variáveis

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

A lógica é descaradamente roubada desta resposta Python

Experimente online.

CJam , 88 bytes

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

Cria a maior tartaruga primeiro (porque, caso contrário, o que todas as outras tartarugas suportariam?), Depois reduz gradualmente o tamanho até que a menor seja feita. Funciona para qualquer número inteiro maior que 0.

Experimente online!

Python 2.7, 255 238 236 bytes

Mesmo que isso perca para as outras soluções Python 2, gostei da minha abordagem recursiva:

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: eliminou alguns bytes eliminando algumas substituições

edit2: raspou 2 bytes salvando os sublinhados como uma variável

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)

Experimente online

Python 2.7, 139 114 113 130 bytes

Eu também gostei da abordagem recursiva do Iguanodon, então aqui está uma tentativa um pouco mais curta.

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

Um poderoso 25 26 9 bytes jogou devido a algumas dicas fantásticas da Destructible Watermelon. Muito Obrigado! Acho que pode ser a resposta mais curta do Python agora :-)

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 graças a mazzy, o homem louco}

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

Experimente online!

Inteligentemente muda variáveis ​​usando $_--para evitar o uso de ($_+1)blocos repetidos para economizar vários bytes. Ele também converte o argumento único em uma sequência que é convertida em int quando usada em um intervalo para iterar através do número de tartarugas. O maior truque agora é ter o 2º nível de espaçamento de uma tartaruga apenas aumentar todas as outras linhas subtraindo $_%2(ou seja, 0 se for par, 1 se for ímpar) da contagem atual de linhas.

Caso contrário, é bastante matemático de índice se adequar _e contar, incluindo um contador de lag na forma de $i++, e agora apenas um único índice de lista para colocar a cabeça no lado correto.

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

Teste

console.log(T(5));

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

Tela , 26 bytes

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

Experimente aqui!