Schreiben Sie ein Programm oder eine Funktion, die eine positive Ganzzahl aufnimmt und einen Stapel von ASCII-artigen Schildkröten ausgibt oder zurückgibt , wobei jede Schildkröte größer ist als die darüber liegende.

Wenn es sich bei der Eingabe um Folgendes handelt 1, sollte die Ausgabe wie folgt lauten:

 __
/,,\o

Wenn die Eingabe lautet 2:

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

Wenn die Eingabe lautet 3:

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

Wenn die Eingabe lautet 4:

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

Wenn die Eingabe lautet 5:

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

Und so weiter im selben Muster für größere Eingaben.

Beachten Sie, dass:

• Der Kopf oder unteren Schildkröte ist immer rechts. Die Köpfe der Schildkröten wechseln sich dann ab.
• Zeilen dürfen keine nachgestellten Leerzeichen enthalten.
• Überflüssige führende Leerzeichen sind nicht erlaubt. (dh die Rückseite der unteren Schildkröte sollte sich am Anfang der Linie befinden.)
• Eine einzelne optionale nachgestellte Zeile ist zulässig.

Der kürzeste Code in Bytes gewinnt.

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

Beachten Sie, dass in Zeile 1 ein Leerzeichen und in Zeile 4 zwei Leerzeichen stehen. ienthält daher echofür jede Schildkröte einen Befehl mit der entsprechenden Einrückung. Inzwischen uenthält die Anzahl der Unterstriche abwechselnd Schildkröten. Eine führende ungerade Schildkröte hat ein spezielles Gehäuse und der Rest der Schildkröten wird paarweise ausgegeben.

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

Probieren Sie es online aus.

Definiert eine Funktion, die die Schildkröten druckt.

Verwendet die Angaben zu Breite und Genauigkeit von printf in hohem Maße, um den Abstand zu ermitteln und die Unterstriche zu wiederholen. Jede Schildkröte wird mit einem einzigen printfAufruf gedruckt :

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

Ich habe auch eine andere Version, die 144 Bytes ohne Leerzeichen enthält:

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

Rekursive Lösung. Probieren Sie es 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}ð®®É-×ì,

Probieren Sie es online aus

V , 57, 53, 49 Bytes

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

Da dies nicht druckbare Zeichen enthält, ist hier ein 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

Probieren Sie es online!

Erläuterung:

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

91 Byte Code +1 für -n.

Benötigt -Ekeine zusätzlichen Kosten.

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

Verwendungszweck

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

Vielen Dank an @Dada für -9 Bytes bei seiner Überarbeitung !

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

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es 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)}

sauberer (fügt ein Byte hinzu)

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

Die Grundstruktur ruft sich rekursiv auf und teilt sich sowohl die letzte anzurufende Nummer als auch die aktuelle Ebene mit. Beginnt mit einer Standardeinstellung für y = 1, sodass für den ersten Aufruf nur eine Variable erforderlich ist. Definiert schnell zwei häufig verwendete Werte. Dann wiederholt es einfach alles so oft wie nötig.

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

Bei jedem dieser Tests wird implizit geprüft, ob der Kopf rechts oder links angebracht werden soll, und er wird entsprechend platziert.

TSQL, 189 Bytes

Jetzt mit Eingabeaufnahme - dank @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

Geige

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

Eine rekursive Implementierung mit viel Formatierung der Zeichenfolgen und der eingebauten memsetFunktion. Ich werde versuchen, dies im Laufe der Zeit so viel wie möglich zu tun.

C es online! (Ideone)

Java 1.7, 238 Bytes

Ein Satz von zwei Funktionen: Erstens iteriert er über die Eingabe (Anzahl der Schildkröten), und zweitens erleichtert er die rekursive Erstellung einer Folge sich wiederholender Zeichen (dh die führenden Leerzeichen, der Rücken und der Bauch der Schildkröten).

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

    }

}

Starte es! (Ideone)

Ich habe angenommen, dass es in Ordnung ist, die Klassendefinition von der Byteanzahl auszuschließen.

Möglicherweise kann ich dies ein wenig weiter verbessern, indem ich die Iterationsreihenfolge der Schleife umdrehe (von unten nach oben) und / oder wie bei einigen anderen Antworten vollständig rekursiv gehe.

Hinweis für sich selbst: Java fehlt wirklich eine eingebaute Kurzschrift, um n Zeichen zu wiederholen ...

Python, 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

Die Köpfe waren hart.

F # 218 207 202 196 187 Bytes.

Die meisten dieser Bytes wurden durch Inlining von Variablen rasiert

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

Die Logik wird schamlos aus dieser Python-Antwort gestohlen

Probieren Sie es online aus.

CJam , 88 Bytes

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

Lässt die größte Schildkröte zuerst erscheinen (denn auf was würde sonst jede andere Schildkröte stehen?) Und verringert dann allmählich die Größe, bis die kleinste hergestellt ist. Funktioniert für jede Ganzzahl, die größer als 0 ist.

Probieren Sie es online!

Python 2.7, 255 238 236 Bytes

Obwohl dies für beide anderen Python 2-Lösungen nicht mehr funktioniert, hat mir mein rekursiver Ansatz gefallen:

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: löschte einige Bytes, indem einige Ersetzungen beseitigt wurden

edit2: Rasiert 2 Bytes, indem die Unterstriche als Variable gespeichert werden

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)

Probieren Sie es online aus

Python 2.7, 139 114 113 130 Bytes

Ich mochte auch Iguanodons rekursiven Ansatz, daher hier ein etwas kürzerer Versuch.

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)

BEARBEITEN

Mächtige 25 - 26 - 9 Bytes, die dank einiger fantastischer Tipps von Destructible Watermelon golfen haben. Danke vielmals! Denke, es könnte jetzt die kürzeste Antwort von Python sein :-)

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 bytes dank mazzy, dem verrückten mann}

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

Probieren Sie es online!

Verschiebt Variablen geschickt mit $_--, um zu vermeiden, dass wiederholte ($_+1)Blöcke verwendet werden, um mehrere Bytes zu sparen. Es konvertiert auch das einzelne Argument in eine Zeichenfolge, die dann in ein int umgewandelt wird, wenn sie in einem Bereich verwendet wird, um die Anzahl der Turtles zu durchlaufen. Der größte Trick besteht nun darin, dass die 2. Stufe des Schildkrötenabstands jede zweite Zeile nur durch Subtrahieren $_%2(dh 0, wenn gerade, 1, wenn ungerade) von der aktuellen Zeilenanzahl erhöht wird.

Ansonsten ist es eine Menge Index-Mathematik, um richtig zu werden _und zu zählen , einschließlich eines Verzögerungszählers in Form von $i++und jetzt nur eines einzelnen Listenindex, um den Kopf auf die richtige Seite zu setzen.

ES6 (JavaScript), 140 Byte

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

Prüfung

console.log(T(5));

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

Canvas , 26 Bytes

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

Probieren Sie es hier aus!