Scrivi un programma o una funzione che accetta un numero intero positivo e stampa o restituisce una pila di tante tartarughe di arte ASCII , dove ogni tartaruga è più grande di quella sopra di essa.

In particolare, se l'input è 1, l'output dovrebbe essere:

 __
/,,\o

Se l'input è 2:

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

Se l'input è 3:

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

Se l'input è 4:

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

Se l'input è 5:

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

E così via nello stesso schema per input più grandi.

Nota che:

• La testa (la o) della tartaruga inferiore è sempre sulla destra. Le teste delle tartarughe sopra si alternano avanti e indietro.
• Nessuna riga può contenere spazi finali.
• Non sono ammessi spazi iniziali superflui. (cioè la parte posteriore della tartaruga inferiore dovrebbe essere all'inizio della linea.)
• È consentita una singola riga finale finale facoltativa.

Vince il codice più breve in byte.

Lotto, 256 byte

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

Si noti che la riga 1 ha uno spazio finale e la riga 4 ha due spazi finali. icontiene quindi un echocomando con la quantità appropriata di rientro per ogni tartaruga. Nel frattempo ucontiene il numero di caratteri di sottolineatura nelle tartarughe alternate. Una tartaruga dispari leader è in un involucro speciale e quindi il resto delle tartarughe viene prodotto in coppia.

C, 131 byte

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

Provalo online.

Definisce una funzione che stampa le tartarughe.

Abusa pesantemente degli identificatori di larghezza e precisione di printf per ottenere la spaziatura e ripetere i caratteri di sottolineatura. Ogni tartaruga viene stampata usando una sola printfchiamata:

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

Ho anche una versione diversa di 144 byte con spazio bianco rimosso:

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

Rubino, 100 byte

Soluzione ricorsiva. Provalo 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 byte

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

Provalo online

V , 57, 53 49 byte

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

Poiché questo contiene caratteri non stampabili, ecco un dump esadecimale:

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

Provalo online!

Spiegazione:

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 byte

91 byte codice +1 per -n.

Richiede -Esenza costi aggiuntivi.

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

Grazie a @Dada per -9 byte con la sua rielaborazione!

Cheddar , 105 byte

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 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Python 2, 116 byte

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

più pulito (aggiunge 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 struttura di base chiama ricorsivamente se stessa, indicando sia il numero finale da chiamare sia il livello corrente. Inizia con un valore predefinito per y = 1, quindi necessita solo di una variabile per la chiamata iniziale. Definisce rapidamente due valori utilizzati di frequente. Quindi ripete tutto il numero necessario di volte.

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

Ognuno di questi implica implicitamente se aggiungere la testa a destra o sinistra e posizionarla in modo appropriato.

TSQL, 189 byte

Ora con accettazione dell'input - grazie 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 byte:

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

Un'implementazione ricorsiva che utilizza molta formattazione di stringhe e la memsetfunzione integrata. Cercherò di giocare a golf più nel tempo che posso.

C Online! (Ideone)

Java 1.7, 238 byte

Un insieme di due funzioni: la prima scorre sull'input (numero di tartarughe), la seconda facilita la costruzione ricorsiva di una sequenza di caratteri ripetuti (ovvero gli spazi iniziali, la parte posteriore e il ventre delle tartarughe).

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

    }

}

Eseguirlo! (Ideone)

Ho pensato che fosse giusto escludere la definizione della classe dal conteggio dei byte.

Potrei essere in grado di giocare a golf un po 'più invertendo l'ordine di iterazione del loop (costruendo dalla tartaruga inferiore in alto) e / o andando completamente ricorsivo come alcune delle altre risposte.

Nota per sé: Java non ha davvero una scorciatoia integrata per ripetere n caratteri ...

Pitone, 137 120 113 110 byte

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

Le teste erano dure.

F #, 218 207 202 196 187 byte.

Rasato la maggior parte di questi byte incorporando le variabili

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 logica è spudoratamente rubata da questa risposta di Python

Provalo online.

CJam , 88 byte

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

Crea prima la tartaruga più grande (perché altrimenti cosa starebbe su ogni altra tartaruga?), Quindi riduce gradualmente le dimensioni fino a quando non viene creata quella più piccola. Funziona con qualsiasi numero intero maggiore di 0.

Provalo online!

Python 2.7, 255 238 236 byte

Anche se questo perde in entrambe le altre soluzioni Python 2, mi è piaciuto il mio approccio ricorsivo:

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: eliminato alcuni byte eliminando alcune sostituzioni

edit2: rasato 2 byte salvando i trattini bassi come variabile

Python 2, 147 byte

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)

Provalo online

Python 2.7, 139 114 113 130 byte

Mi è piaciuto anche l'approccio ricorsivo di Iguanodon, quindi ecco un tentativo leggermente più breve.

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)

MODIFICARE

Un potente 25 26 9 byte ha giocato a golf a causa di alcuni fantastici consigli di Anguria distruttibile. Grazie molto! Pensa che potrebbe essere la risposta più breve di Python ora :-)

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 byte

^{-21 byte grazie a mazzy, l'uomo pazzo}

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

Provalo online!

Sposta abilmente le variabili usando $_--per evitare l'uso di ($_+1)blocchi ripetuti per salvare diversi byte. Converte anche il singolo argomento in una stringa che viene quindi lanciata in un int quando utilizzato in un intervallo per scorrere il numero di tartarughe. Il trucco più grande ora sta avendo il 2 ° livello di spaziatura di una tartaruga solo aumentare ogni altra riga sottraendo $_%2(cioè 0 se pari, 1 se dispari) dall'attuale row_count.

Altrimenti, è un sacco di matematica dell'indice da ottenere corretta _e conta, incluso un contatore di ritardo nella forma di $i++, e ora solo un singolo indice di lista per mettere la testa dalla parte giusta.

ES6 (JavaScript), 140 byte

Codice

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

Test

console.log(T(5));

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

Tela , 26 byte

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

Provalo qui!