Napisz program lub funkcję, która przyjmuje dodatnią liczbę całkowitą i wypisuje lub zwraca stos tylu żółwi sztuki ASCII , gdzie każdy żółw jest większy niż ten nad nim.

W szczególności, jeśli dane wejściowe są 1, dane wyjściowe powinny wynosić:

 __
/,,\o

Jeśli dane wejściowe to 2:

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

Jeśli dane wejściowe to 3:

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

Jeśli dane wejściowe to 4:

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

Jeśli dane wejściowe to 5:

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

I tak dalej, dla większych nakładów.

Uwaga:

• Głowa ożółwia dolnego jest zawsze po prawej stronie. Głowy żółwi powyżej zmieniają się naprzód i wstecz.
• Żadne linie nie mogą mieć spacji końcowych.
• Zbędne spacje wiodące są niedozwolone. (tj. tył dolnego żółwia powinien znajdować się na początku linii.)
• Pojedynczy opcjonalny znak nowej linii jest dozwolony.

Najkrótszy kod w bajtach wygrywa.

Partia, 256 bajtów

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

Zauważ, że linia 1 ma spację końcową, a linia 4 ma dwie spacje końcowe. idlatego zawiera echopolecenie z odpowiednią ilością wcięć dla każdego żółwia. Tymczasem uzawiera liczbę znaków podkreślenia u przemiennych żółwi. Wiodący nieparzysty żółw ma specjalną obudowę, a następnie reszta żółwi jest wysyłana parami.

C, 131 bajtów

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

Wypróbuj online.

Definiuje funkcję, która drukuje żółwie.

Znacznie narusza specyfikacje printf szerokości i precyzji, aby uzyskać odstępy i powtarzać podkreślenia. Każdy żółw jest drukowany za pomocą jednego printfpołączenia:

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

Mam też inną wersję, która ma 144 bajty z usuniętymi białymi znakami:

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

Rubinowy, 100 bajtów

Rozwiązanie rekurencyjne. Wypróbuj 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 bajtów

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

Wypróbuj online

V. , 57, 53 49 bajtów

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

Ponieważ zawiera znaki niedrukowalne, oto zrzut heksowy:

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

Wypróbuj online!

Wyjaśnienie:

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 bajty

91 bajtów kodu +1 dla -n.

Wymaga -Ebez dodatkowych kosztów.

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

Stosowanie

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

Dzięki @Dada za -9 bajtów za jego przeróbkę!

Cheddar , 105 bajtów

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 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online!

Python 2, 116 bajtów

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 bajtów

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

bardziej czysto (dodaje bajt)

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

Podstawowa struktura rekurencyjnie nazywa się sama - mówiąc sobie zarówno ostateczny numer, który ma zostać wywołany, jak i aktualny poziom. Zaczyna się od wartości domyślnej dla y = 1, więc potrzebuje tylko jednej zmiennej do pierwszego połączenia. Szybko definiuje dwie często używane wartości. Następnie po prostu powtarza wszystko niezbędną liczbę razy.

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

Każdy z nich domyślnie sprawdza, czy dodać głowę w prawo czy w lewo i odpowiednio ją umieścić.

TSQL, 189 bajtów

Teraz z akceptacją danych wejściowych - dzięki @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

Skrzypce

C, 328 238 234 215 bajtów:

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

Rekursywna implementacja wykorzystująca wiele formatowania łańcuchów i wbudowaną memsetfunkcję. Postaram się pograć w golfa z czasem, jak tylko będę mógł.

C It Online! (Ideone)

Java 1.7, 238 bajtów

Zestaw dwóch funkcji: pierwsza iteruje nad wejściem (liczba żółwi), druga ułatwia konstruowanie sekwencji powtarzalnych znaków rekurencyjnie (tj. Spacje wiodące, grzbiet i brzuch żółwi).

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

Nie golfowany:

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

    }

}

Uruchom! (Ideone)

Uznałem, że można wykluczyć definicję klasy z liczby bajtów.

Mogę być w stanie zagrać w golfa nieco dalej, odwracając kolejność iteracji pętli (buduj od dolnego żółwia w górę) i / lub przechodząc w pełni rekurencyjny, jak niektóre inne odpowiedzi.

Uwaga do siebie: Java naprawdę nie ma wbudowanego skrótu do powtarzania n znaków ...

Pyton, 137 120 113 110 bajtów

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

Nie golfowany:

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

Głowy były twarde.

F #, 218 207 202 196 187 bajtów.

Ogolono większość tych bajtów, wstawiając zmienne

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

Logika zostaje bezwstydnie skradziona z tej odpowiedzi w języku Python

Wypróbuj online.

CJam , 88 bajtów

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

Najpierw robi największego żółwia (bo inaczej co stałby każdy inny żółw?), A następnie stopniowo zmniejsza rozmiar, aż powstanie najmniejszy. Działa dla dowolnej liczby całkowitej większej niż 0.

Wypróbuj online!

Python 2.7, 255 238 236 bajtów

Mimo że przegrywa to z dwoma innymi rozwiązaniami Python 2, podobało mi się moje rekurencyjne podejście:

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: usunął kilka bajtów, eliminując niektóre zamienniki

edit2: ogolono 2 bajty, zapisując podkreślenia jako zmienne

Python 2, 147 bajtów

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)

Wypróbuj online

Python 2.7, 139 114 113 130 bajtów

Podobało mi się również rekurencyjne podejście Iguanodon, więc oto nieco krótsza próba.

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)

EDYTOWAĆ

Potężny 25 26 9 bajtów grał w golfa dzięki fantastycznym wskazówkom Destructible Watermelon. Wielkie dzięki! Pomyśl, że może to być teraz najkrótsza odpowiedź w języku 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 bajtów

^{-21 bajtów dzięki mazzy, wariatowi}

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

Wypróbuj online!

Sprytnie zmienia zmienne za pomocą $_-- aby uniknąć używania powtarzających się ($_+1)bloków w celu zapisania kilku bajtów. Konwertuje również pojedynczy argument na ciąg znaków, który jest następnie rzutowany na liczbę całkowitą, gdy jest używany w zakresie do iteracji przez liczbę żółwi. Największa sztuczka polega teraz na tym, że 2. poziom odstępów żółwia zwiększa się tylko o co drugi rząd, odejmując $_%2(tj. 0, jeśli parzysty, 1, jeśli nieparzysty) od bieżącej liczby_wierszy.

W przeciwnym razie trzeba dużo matematyki indeksu, aby się poprawnie _i liczy, w tym licznik opóźnień w postaci $i++, a teraz tylko jeden indeks listy, aby umieścić głowę po właściwej stronie.

ES6 (JavaScript), 140 bajtów

Kod

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

Płótno , 26 bajtów

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

Wypróbuj tutaj!