당신의 임무는이 정확한 텍스트를 인쇄하는 것입니다 :

            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

사건은 중요하지 않습니다.

이것은 code-golf 이므로 바이트 수가 가장 적은 코드가 이깁니다.

체다, 50 45 42 37 바이트

25|>0=>i->print" "*(i/2|0)+(65+i)@"90

간단하지만 체다의 콘 서스 범위 구문을 사용합니다 (숫자 및 알파벳 모두)

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

설명

25 |> 0 =>    // Map range [0, 26) (i.e. [25, 0] reversed) over....
   i -> 
     print    // Prints in it's own line...
     " " * (i/2 |0) +     // Number of spaces is floor(n/2).
                          // `|0` for flooring is hack from JS
     (65 + i) @" 90       // Char code range is this

65에 대한 문자 코드 A및 90대한A

05AB1E , 15 13 바이트

A.svy12N;ï-ú,

온라인으로 사용해보십시오! ( ú아직 TIO가 아니기 때문에 위와 약간 다릅니다 )

설명

1. 알파벳을 밀어
2. 알파벳 접미사 계산
3. 12 색인 / 2 공백을 추가하십시오
4. 인쇄

파이썬 2, 70 바이트

배관에서 Emigna 의 대답, -2 교체하기위한 바이트 -i-1로~i

for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]

R, 67 66 59 바이트

편집 : @ rturnbull 덕분에 몇 바이트를 절약했습니다.

for(i in 25:0)cat(rep(" ",i/2),letters[i:25+1],"\n",sep="")

rep함수에 전달 된 숫자 가 가장 가까운 정수 (예 :)로 자동으로 내림 된다는 사실을 악용하면 rep("*",1.99) => "*"실제 전달 된 시퀀스는 floor(13-1:26/2)다음과 같습니다.

12 12 11 11 10 10  9  9  8  8  7  7  6  6  5  5  4  4  3  3  2  2  1  1  0  0

Pyth, 15 바이트

j_m+*/d2\ >GdUG

결과를 STDOUT에 인쇄하는 프로그램.

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

작동 원리

j_m+*/d2\ >GdUG  Program
             UG  Yield [1, 2, 3, 4, ..., 26]
  m              Map over the range with variable d:
          >Gd      Yield alphabet with first d-1 letters discarded
   +               Prepend
     /d2             d//2
    *   \            spaces
 _               Reverse
j                Join on newlines
                 Implicitly print

파이썬 2, 52 바이트

n=26;s=''
while n:n-=1;s=chr(97+n)+s;print n/2*' '+s

s인쇄 할 문자열 을 누적하고 선행 공백 수를 업데이트합니다 n/2. 에서 while끝나는 0루프는 exec루프를 이기는 것보다 드문 숫자 루프입니다 (53 바이트).

n=26;s=''
exec"n-=1;s=chr(97+n)+s;print n/2*' '+s;"*n

또한 53 바이트 대안 :

s=''
exec"s=chr(122-len(s))+s;print s.center(26);"*26

자바 스크립트 (ES6), 85 75 69 68 바이트

for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+`
`

@ l4m2 덕분에 -1 바이트 .

Brain-Flak , 244 바이트

((((((()()()()())){}{}){}){}()){})((((()()()){}){}()){}){(({}[()]<>)<({}<(<>({})<>)>){({}[()]<(({})[()])>)}({}({})<>[({})]<>(((()()()){}){}){}())((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{}){({}[()]<((((()()()()){}){}){})>)}((()()()()()){})><>)}<>

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

이것은 충분히 읽을 수 있어야합니다. 필요한 경우 전체 설명이 있습니다.

push 122 (z): ((((((()()()()())){}{}){}){}()){})
push 26:      ((((()()()){}){}()){})
loop 26 times (i = 25..0): {
 (
  i--, push to b stack:({}[()]<>)
  <
   put 122 from a stack under i: ({}<(<>({})<>)>)
   i times push letter-1: {({}[()]<(({})[()])>)}
   replace top 0 with 26-i: ({}({})<>[({})]<>(((()()()){}){}){}())
   devide by two: ((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{})
   add spaces: {({}[()]<((((()()()()){}){}){})>)}
   push 10 (\n): ((()()()()()){})
  >
  flip stack back: <>
 push i--: ) 
}
flip to results stack: <>

젤리 , 15 13 바이트

@miles 덕분에 -2 바이트 (존재하는 것으로 의심되지만 형성되지 않은 niladic chain을 형성 함)

ØaJ’H⁶ẋżṫJ$ṚY

TryItOnline!

방법?

ØaJ’H⁶ẋżṫJ$ṚY - Main link
Øa            - alphabet yield -> ['a', 'b', 'c', ..., 'y', 'z']
  J           -    range(length)      -> [1, 2, 3, ..., 25, 26]
   ’          -    decrement          -> [0, 1, 2, ..., 24, 25]
    H         -    halve              -> [0,.5  1, ..., 12, 12.5]
     ⁶        -    literal [' ']
      ẋ       -    repeat list        -> [[], [], [' '], ..., 12x' ', 12x' ']
          $   - last two links as a monad
         J    -     range(length)     -> [1, 2, 3, ..., 25, 26]
        ṫ     -     tail (vectorises) -> [['a'-'z'], ['b'-'z'], ..., ['y','z'], ['z']]
       ż      - zip
              -> [[[],['a'-'z']], [[],['b'-'z']], ..., [12x' ',['y','z']], [12x' ',['z]]]
           Ṛ  - reverse whole array
            Y - join with line feeds (implicit print)

C, 72 68 바이트

m(i){for(char*k=&k[i=26];i;printf("%*c%s\n",--i/2+1,0,k))*--k=64+i;}

05AB1E , 5 바이트

A.s.c

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

A.s.c
A     Push 'abcdefghijklmnopqrstuvwxyz'
 .s   Push suffixes starting from the shortest one
   .c Centralize focused on the left

Turtlèd , 70 68 바이트

후행 공간에 주목

#abcdefghijklmnopqrstuvwxyz#' -{ -{ +.r_}' l[ l-]d,(*@!' r)(!@*)_}' 

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

작동 방식 :

#abcdefghijklmnopqrstuvwxyz#              Set string var to this value
                            ' -           write space on first grid cell, string pointer-=1
                               {                                    } While cell is space
                                 -                 decrement string pointer
                                  {     }    While cell is space
                                    +.       increment string pointer, write pointed char
                                      r      move right
                                       _     write non-space if pointed char is last char

                                         '[space]   write space on cell
                                           l        move left
                                            [ l-]   move left, pointer-- until cell's space
                                                 d, move down, write character var \
                                                                           (initially *)

                                                   (*     ) if cell is *
                                                     @!     set char var=!
                                                       ' r  write space over *, move right

                                                           (!    ) if cell is !
                                                             @*    set char var=*
                                                               '[space] write space over !

                                                                 _ (explanation below)
                                               write (*|!) if pointed char is last char

                                                                   '[space]    Write space

사람이 읽을 수있는 설명 (?) :

문자열 var를 사용하여 알파벳을 포함합니다. 반복 할 때마다 마지막 줄에 도달 한 후 줄 바꿈 될 때까지 색인이 하나씩 줄어 듭니다. 대체 들여 쓰기에는 char var를 사용합니다. 각 반복은 char var를 확인하고 뒤집습니다. * 인 경우 오른쪽으로 이동하여 첫 번째 문자가 정렬되고 그렇지 않으면 마지막 문자가 정렬됩니다.

펄, 44 바이트

이것은 @ xnor 's answer 의 포트입니다 .

$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--

다음 을 실행해야합니다 -E(또는 -M5.010).

perl -E '$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--';

PHP, 71 바이트

for(;++$i<27;)echo str_pad(substr(join(range(a,z)),-$i),26," ",2)."\n";

자바 7128 127 바이트

1 바이트를 저장했습니다. kevin에게 감사합니다.

String c(int n,String s,char v,String d){String c="";for(int j=0;j++<(n-1)/2;c+=" ");return n>0?c(--n,s=v+s,--v,d+c+s+"\n"):d;}

언 골프

  class A {

public static void main(String[] args) {
System.out.print(c(26, "", (char)122, ""));
}
static String c(int n, String s, char v, String d){

    String c = "";

    for (int j = 0; j++ < (n - 1)/2; c += " ");

    return n > 0 ? c(--n, s = v + s, --v, d + c + s + "\n" ) : d;
}
}

함수에서 122를 넘지 않고

132 바이트

String c(String s,int n,String d){String c="";int v=96,j=0;for(;j++<(n-1)/2;c+=" ");return n>0?c(s=(char)(v+n--)+s,n,d+c+s+"\n"):d;}

언 골프

  class A{

public static void main(String[] args) {
System.out.print(c("",26,""));

}
static String c(String s, int n, String d) {
    String c = "";
    int v = 96,j=0;
    for (; j++ < (n - 1)/2; c += " ");
    return n > 0 ? c(s = ( char) (v + n--) + s, n, (d + c + s + "\n")) : d;
     }
  }

루비, 64 바이트

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}

Japt , 16 바이트

;C¬£SpY/2 +CsYÃw ·

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

설명:

;C¬£SpY/2 +CsYÃw ·
;C                  // Alphabet shortcut
  ¬                 // Split into an array of chars
   £          Ã     // Map each item X and index Y by:
    SpY/2           //  " " repeated floor(Y/2) times
          +CsY      //  + alphabet.slice(Y)
               w    // Reverse the array of lines
                 ·  // Join with newlines

REXX, 52 바이트

do i=1 to 26
  say centre(right(xrange(a,z),i),26)
  end

산출:

            Z             
            YZ            
           XYZ            
           WXYZ           
          VWXYZ           
          UVWXYZ          
         TUVWXYZ          
         STUVWXYZ         
        RSTUVWXYZ         
        QRSTUVWXYZ        
       PQRSTUVWXYZ        
       OPQRSTUVWXYZ       
      NOPQRSTUVWXYZ       
      MNOPQRSTUVWXYZ      
     LMNOPQRSTUVWXYZ      
     KLMNOPQRSTUVWXYZ     
    JKLMNOPQRSTUVWXYZ     
    IJKLMNOPQRSTUVWXYZ    
   HIJKLMNOPQRSTUVWXYZ    
   GHIJKLMNOPQRSTUVWXYZ   
  FGHIJKLMNOPQRSTUVWXYZ   
  EFGHIJKLMNOPQRSTUVWXYZ  
 DEFGHIJKLMNOPQRSTUVWXYZ  
 CDEFGHIJKLMNOPQRSTUVWXYZ 
BCDEFGHIJKLMNOPQRSTUVWXYZ 
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Vim, 25 번의 키 스트로크

:h<_␍jjYZZPqqPxYPr Yq12@q

여기서 ␍는 Enter 키이며 때로는로 표기됩니다 <cr>.

설명

:h<_␍jjYZZ                 " get a-z
          P                " initialize by pasting
           qq              " start record macro @q
             Px            " paste and remove the 1st char
               YPr␣        " yank and paste and replace 1st char with space
                   Y       " yank the whole line again
                    q      " end recording
                     12@q  " call macro 12 @q times

그래도 ViM을 처음 사용합니다. 11 월에 시작했습니다. 초기화 P를 매크로 의 초기화 와 병합하는 방법이 있는지 궁금합니다 .

골프 ViM 시퀀스를 테스트하는 "올바른"방법은 무엇입니까? 나는로 테스트했다 \vi -u /dev/null. 그러나 VM에서도:h<_␍ 작동하지 않습니다. 또한 내 ViM이 첫 번째 공백이 아닌 문자 haha로 이동하는 이유를 잘 모르겠습니다.

PS OS X를 사용하기 전에 Hexagony에서 훌륭한 도구로 골프를 쳤습니다. 이제 OS XI에서는 와인을 마시지 않으므로 설명과 디버깅을위한 훌륭한 도구를 실행하지 않습니다. ViM과 함께 여행을 시작했습니다!

C # (. NET 코어) , 112 바이트

()=>string.Join("\n",new int[26].Select((_,i)=>"".PadLeft(12-i/2)+"abcdefghijklmnopqrstuvwxyz".Substring(25-i)))

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

()=>string.Join("\n", // OP doesnt want to output a sequence of string...
    new int[26].Select((_,i)=> // yield range from 0 to 25
        "".PadLeft(12-i/2)+ // add spaces to center
            "abcdefghijklmnopqrstuvwxyz".Substring(25-i)))  // remove letters

Tcl , 92 바이트

set a {}
time {set a [format %c [expr 123-[incr i]]]$a;puts [format %[expr 13+$i/2]s $a]} 26

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

set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr 74-$i/2]s $a]} 26

데모

과정 중간에 우연히 이탤릭 버전의 모자를 얻었습니다.

tcl, 94

set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]} 26

데모

set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr ($i-48)/2]s $a]}

데모

과정 중간에 우연히 이탤릭 버전의 모자를 얻었습니다.

tcl, 99

set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]}

데모

공통 Lisp, SBCL, 83 82 바이트

(dotimes(i 27)(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))

설명

(dotimes(i 27) ; loop from i=0 to i=26
(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))
;print out part of alphabet starting from character number 26-i (counting from zero)
;using justification (~26:@<~a~>) to center with weight 26 characters

-1 <enter>대신 ASCII 전용 sugestion을 사용하여 사용~%

T-SQL, 107 바이트

DECLARE @t VARCHAR(99)=SPACE(13),@ INT=27a:SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))PRINT @t
SET @-=1IF @>1GOTO a

SQL 함수를 사용하여 올바른 위치에 올바른 문자를 입력하여 각 줄의 문자열을 수정합니다 STUFF(). 형식화 :

DECLARE @t VARCHAR(99)=SPACE(13), @ INT=27
a:
    SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))
    PRINT @t
    SET @-=1
IF @>1 GOTO a

@/2문자를 삽입 할 위치를 결정하기 위해 정수 나누기 (나머지 없음)를 사용합니다. @%2은 IS MODULO기능, (공간, 덮어 쓰기) (문자 삽입) 0 사이 플립 1.

대문자 문자를 선호하는 경우 CHAR(@+63)대신 사용하십시오 (바이트 수를 변경하지 마십시오).

Perl 5, 40 38 bytes

-2 bytes thanks to @Dom Hastings

say$"x(13+--$x/2),@a[$x..-1]for@a=a..z

Try it online!

Stax, 7 bytes

ô2òΘé8└

Run and debug it

Haskell (Lambdabot), 73 bytes

unlines[([1..div(26-length x)2]>>" ")++x|x<-reverse.init$tails['a'..'z']]

same length:

do x<-reverse.init$tails['a'..'z'];([1..div(26-length x)2]>>" ")++x++"\n"

I use init.tails or tail.inits with a possible reverse in front in pretty much every challenge; I wish they would add it to Prelude already.

Python 2, 66 64 bytes

i=91;exec'i-=1;print`map(chr,range(i,91))`[2::5].center(26);'*26

Groovy, 53 bytes

('z'..'a').each{println((it..'z').join().center(26))}

Output:

            z             
            yz            
           xyz            
           wxyz           
          vwxyz           
          uvwxyz          
         tuvwxyz          
         stuvwxyz         
        rstuvwxyz         
        qrstuvwxyz        
       pqrstuvwxyz        
       opqrstuvwxyz       
      nopqrstuvwxyz       
      mnopqrstuvwxyz      
     lmnopqrstuvwxyz      
     klmnopqrstuvwxyz     
    jklmnopqrstuvwxyz     
    ijklmnopqrstuvwxyz    
   hijklmnopqrstuvwxyz    
   ghijklmnopqrstuvwxyz   
  fghijklmnopqrstuvwxyz   
  efghijklmnopqrstuvwxyz  
 defghijklmnopqrstuvwxyz  
 cdefghijklmnopqrstuvwxyz 
bcdefghijklmnopqrstuvwxyz 
abcdefghijklmnopqrstuvwxyz

QBIC, 57 bytes

[25,0,-1|Y=Z[1,a/2|Y=Y+@ |]X=Z[a,25|X=X+$CHR$(65+|c)]?Y+X

This one works surprisingly well with QBIC' FOR loops. Explanation (of previous version - same principle applies):

[26,1,-1|          Loops from 26 to 1, decrementing 'a'
                   'a' is used to determine the number of spaces per line and the last letter we want to print
Y=Z                Z is always an empty string in this program, 
                   Y will hold the spaces we need to center this line
[1,a/2|Y=Y+@ |]    Add a space to Y equal to half the value of 'a', giving us a center alignment
X=Z                X holds the characters we need on this line, reset it
[a,26|             FOR c = a to 26 --> loop over the last part of the alphabet
X=X+$CHR$(64+|c)]  Convert c+64 to ASCII and append
?Y+X               Print the spaces and the letters

<outer FOR loop is closed by QBIC>

Output:

            Z
            YZ
           XYZ
           WXYZ
          VWXYZ
          UVWXYZ
         TUVWXYZ
         STUVWXYZ
        RSTUVWXYZ
        QRSTUVWXYZ
       PQRSTUVWXYZ
       OPQRSTUVWXYZ
      NOPQRSTUVWXYZ
      MNOPQRSTUVWXYZ
     LMNOPQRSTUVWXYZ
     KLMNOPQRSTUVWXYZ
    JKLMNOPQRSTUVWXYZ
    IJKLMNOPQRSTUVWXYZ
   HIJKLMNOPQRSTUVWXYZ
   GHIJKLMNOPQRSTUVWXYZ
  FGHIJKLMNOPQRSTUVWXYZ
  EFGHIJKLMNOPQRSTUVWXYZ
 DEFGHIJKLMNOPQRSTUVWXYZ
 CDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Racket 137 bytes

(for((n(range 122 96 -1)))(for((i(floor(/(- n 97)2))))(display #\space))
(for((i(range n 123)))(display(integer->char i)))(displayln ""))

Ungolfed:

(define (f)
  (for ((n (range 122 96 -1)))
       (for ((i (floor(/(- n 97)2))))
         (display #\space))
       (for ((i (range n 123)))
         (display (integer->char i)))
    (displayln "")))

Testing:

(f)

Output:

            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz