양의 정수를 취하고 각 ASCII가 거북이보다 큰 ASCII 아트 거북이 의 스택을 인쇄하거나 반환하는 프로그램이나 함수를 작성 하십시오.

특히 입력이 1인 경우 출력은 다음과 같아야합니다.

 __
/,,\o

입력이 2다음과 같은 경우 :

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

입력이 3다음과 같은 경우 :

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

입력이 4다음과 같은 경우 :

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

입력이 5다음과 같은 경우 :

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

더 큰 입력에 대해서도 같은 패턴으로 진행됩니다.

참고 :

• o바닥 거북 의 머리 ( )는 항상 오른쪽에 있습니다. 위의 거북의 머리는 앞뒤로 번갈아 가며 나타납니다.
• 줄에 공백이 없어야합니다.
• 불필요한 선행 공백은 허용되지 않습니다. (즉, 바닥 거북의 뒷면이 줄의 시작 부분에 있어야합니다.)
• 단일 선택적 후행 줄 바꿈이 허용됩니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

배치, 256 바이트

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

라인 1에는 후행 공백이 있고 라인 4에는 후행 공백이 있습니다. i따라서 echo각 거북이에 대해 적절한 양의 들여 쓰기 가있는 명령이 포함 됩니다. 한편 u대체 거북이의 밑줄 수가 포함되어 있습니다. 앞선 이상한 거북이는 특별한 경우에 나머지 거북이는 쌍으로 출력됩니다.

C, 131 바이트

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

온라인으로 사용해보십시오.

거북이를 인쇄하는 기능을 정의합니다.

printf의 너비와 정밀도 지정자를 심하게 남용하여 간격과 밑줄을 반복합니다. 각 거북이는 한 번의 printf호출로 인쇄됩니다 .

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

또한 공백이 제거 된 144 바이트의 다른 버전이 있습니다.

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

루비, 100 바이트

재귀 솔루션. 온라인으로 사용해보십시오!

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 바이트

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

온라인으로 사용해보십시오

V , 57, 53 49 바이트

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

여기에는 인쇄 할 수없는 문자가 포함되어 있으므로 다음은 16 진 덤프입니다.

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

온라인으로 사용해보십시오!

설명:

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

펄, 92 바이트

에 대한 91 바이트 코드 +1 -n.

-E추가 비용없이 필요합니다 .

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

용법

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

그의 재 작업으로 -9 바이트의 @Dada 에게 감사드립니다 !

체다 , 105 바이트

n->(|>n).map(i->(1-i%2)*"o"+"\\,"+(n-i-1)*"__"+",/"+i%2*"o"+i/2*"  "+"\n"+(n-i)*"__"+(i+1)*" ").vfuse.rev

망막 , 97 91 88 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

온라인으로 사용해보십시오!

파이썬 2, 116 바이트

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 바이트

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

기본 구조는 재귀 적으로 호출되어 호출 할 최종 번호와 현재 레벨을 알려줍니다. y = 1의 기본값으로 시작하므로 초기 호출에는 하나의 변수 만 필요합니다. 자주 사용되는 두 가지 값을 빠르게 정의합니다. 그런 다음 필요한 횟수만큼 모든 것을 반복합니다.

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

이들 각각은 오른쪽 또는 왼쪽에 머리를 추가하고 적절하게 배치할지 여부를 암시 적으로 테스트합니다.

TSQL, 189 바이트

@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

깡깡이

C, 328 238 234 215 바이트 :

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

많은 문자열 형식과 내장 memset함수를 사용하는 재귀 구현 . 내가 할 수있는 한 시간이 지남에 따라 더 많은 골프를 시도 할 것입니다.

C 온라인! (아이디어)

자바 1.7, 238 바이트

두 가지 기능 세트 : 먼저 입력 (거북의 수)을 반복하고, 둘째는 반복되는 문자 시퀀스를 재귀 적으로 구성하는 것을 용이하게합니다 (즉, 앞 공간, 거북의 뒤 및 배).

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

언 골프 드 :

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

    }

}

그것을 실행하십시오! (아이디어)

바이트 수에서 클래스 정의를 제외해도 괜찮다고 가정했습니다.

루프의 반복 순서를 바꾸거나 (바닥 거북이에서 빌드) 다른 응답과 같이 완전히 재귀 적으로 진행하여이를 조금 더 골프화 할 수 있습니다.

자기주의 사항 : Java에는 실제로 n 문자를 반복하는 내장 약어가 부족합니다 ...

파이썬, 137 120 113 110 바이트

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

언 골프 드 :

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

머리는 단단했다.

F 번호, 218 207 202 196 187 바이트.

변수를 인라인하여 이러한 바이트를 대부분 면도

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

이 파이썬 답변 에서 논리는 뻔뻔스럽게 도난당했습니다.

온라인으로 사용해보십시오.

CJam , 88 바이트

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

가장 큰 거북을 먼저 만들고 (다른 거북은 무엇을 입을 까?) 가장 작은 거북을 만들 때까지 점차적으로 크기를 줄입니다. 0보다 큰 정수에서 작동합니다.

온라인으로 사용해보십시오!

파이썬 2.7 255 238 236 바이트

이것이 다른 Python 2 솔루션 모두에서 잃어 버렸지 만 재귀 적 접근법을 좋아했습니다.

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 : 일부 대체를 제거하여 몇 바이트를 줄였습니다.

edit2 : 밑줄을 변수로 저장하여 2 바이트 면도

파이썬 2, 147 바이트

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)

온라인으로 사용해보십시오

파이썬 2.7 139 114 113 130 바이트

나는 또한 이구아노돈의 재귀 접근 방식을 좋아해서 약간 더 짧은 시도입니다.

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)

편집하다

Destructible Watermelon의 환상적인 팁으로 인해 강력한 25 26 9 바이트 골프. 많은 감사합니다! 그것이 가장 짧은 파이썬 대답이라고 생각하십시오 :-)

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 바이트

^{mazzy, 미친 사람 덕분에 -21 바이트}

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

온라인으로 사용해보십시오!

$_--반복되는 ($_+1)블록을 사용하여 여러 바이트를 저장 하지 않도록 변수를 영리하게 이동합니다 . 또한 단일 인수를 문자열로 변환 한 다음 거북이의 수를 반복하는 범위에서 사용될 때 int로 캐스트합니다. 현재 가장 큰 트릭은 $_%2현재 row_count에서 거북이의 간격의 두 번째 레벨 간격을 뺀 것입니다 (즉, 0이면 짝수이면 1, 홀수이면 1).

그렇지 않으면 의 형식으로 지연 카운터를 포함하여 적절 _하고 카운트를 계산 하는 데 많은 인덱스 수학이 $i++있으며 이제는 헤드를 올바른면에 배치하는 단일 목록 인덱스 만 있습니다.

ES6 (자바 스크립트), 140 바이트

암호

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

테스트

console.log(T(5));

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

캔버스 , 26 바이트

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

여기 사용해보십시오!