Нарисуй алфавитную шляпу

22

Ваша задача распечатать этот точный текст:

            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  kolmogorov-complexity  alphabet 
— Оливер Ни
источник
2
Почему отрицательные голоса?
— Оливер Ни
19
Я подозреваю, что некоторые люди просто устали от всех вызовов алфавита ascii-art KC.
— xnor
Можем ли мы сделать это в верхнем регистре?
— Downgoat
7
Если серьезно, еще одна проблема с алфавитом?
— Эрик Outgolfer
2
Мне нравятся эти проблемы с алфавитом. Это можно легко переименовать в елки.
— Пит Арден

Ответы:

6

Чеддер, 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

— Downgoat
источник
1
Zэто 90не A.
— Мего
5

05AB1E , 15 13 байт

A.svy12N;ï-ú,

Попробуйте онлайн! (немного отличается от выше, поскольку úеще не на TIO)

объяснение

  1. Нажмите алфавит
  2. Вычислить суффиксы алфавита
  3. Prepend 12-index / 2 пробела
  4. Распечатать
— Emigna
источник
4

Python 2, 70 байт

Портировано из ответа Emigna , -2 байта для замены -i-1на~i

for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]
— Карл Напф
источник
Я вполне уверен, что использование карты может привести к более короткому алфавиту, за исключением, возможно, строчных букв с более высокими значениями
— Destructible Lemon
На самом деле я не уверен больше. Я думаю, что это все равно не сработает :( soz
— Разрушаемый лимон
4

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
— Billywob
источник
1
Это выходит короче, чем моя попытка матрицы. Заменить 14...-1на 13?
— JDL
@JDL Да, конечно. Остаток попытки другого подхода
— Billywob
2
Если 25:0вместо циклического 1:26перехода вы можете перейти 13-i/2к i/2упрощению (27-i):26и i:25+1сэкономить до 6 байтов.
— rturnbull
3

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
— TheBikingViking
источник
Попробуйте ;вместо\
— Исаак
3

Python 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
— XNOR
источник
3

JavaScript (ES6), 85 75 69 68 байт

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

-1 байт благодаря @ l4m2 .

— darrylyeo
источник
2
Разве это не фрагмент, а не функция или программа?
— Нил
1
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+'#'1B короче
— l4m2
@ l4m2 Отлично!
— Даррильо
1
Хорошая идея с использованием базы 36! +1
— Тит
2

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: <>
— MegaTom
источник
4
This should be readable enough as is.Вы говорите о Brain-Flak , верно?
— Эрик Outgolfer
2

Желе , 15 13 байт

-2 байта благодаря @miles (образовалась ниладическая цепочка, которая, как я подозревал, существовала, но не сформировалась)

Ø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)
— Джонатан Аллан
источник
Я нашел способ сформировать ниладическую цепочку, начиная с алфавита, ØaJ’H⁶ẋżṫJ$ṚYкоторый сохраняет 2 байта
— мили
Как вы думаете, объяснение правильно?
— Джонатан Аллан
1
Да, просто думайте об этом как о монадической цепочке с единственным аргументом, являющимся алфавитом
— мили
2

C 72 68 байт

m(i){for(char*k=&k[i=26];i;printf("%*c%s\n",--i/2+1,0,k))*--k=64+i;}
— o79y
источник
1

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 и переворачивает его. если он был *, то он сдвигается вправо, поэтому первый символ выравнивается, в противном случае нет, поэтому последний символ выравнивается.

— Разрушаемый Лимон
источник
1

Perl, 44 байта

Это порт ответа @ xnor .

$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--';
— папа
источник
1

PHP, 71 байт

for(;++$i<27;)echo str_pad(substr(join(range(a,z)),-$i),26," ",2)."\n";
— Йорг Хюльсерманн
источник
1
(26-$i)/2→13-$i/2
— manatwork
Будет ли выдано сообщение об ошибке, если вы удалили последнее двоеточие? Также было бы неплохо, если бы вы предоставили ссылку на веб-сайт с примером, например. sandbox.onlinephpfunctions.com
— RedClover
1

Java 7,128 127 байт

Сохранено 1 байт. Спасибо Кевину.

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

ungolfed

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

ungolfed

  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;
     }
  }
— Numberknot
источник
1
Вы можете удалить =в d+=c+s+"\n". Кроме того, вы можете захотеть немного отформатировать свой код без отступов. Я заметил это и с некоторыми другими вашими ответами. :)
— Кевин Круйссен
1
упс! я снова сделал эту ошибку, позор мне. ...... хорошо @KevinCruijssen Я нахожусь на этом.
— Numberknot
Вы не можете заменить s=v+sв рекурсии s+=v?
— Роман Греф
Нет, потому что шаблон букв в обратном направлении.
— Numberknot
1

Рубин, 64 байта

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}
— Manny42
источник
Несколько комментариев: Вам не нужно ставить квадратные скобки после « join Вызова», eachа mapне излишне, поскольку нас не волнует, что мы возвращаем. Вы можете коллировать lastпо диапазону
— Lee W
Вместо того (0..26).map, чтобы попробовать 27.times; а ('a'..'z').to_a, [*?a..?z]; и вместо того .join, *"".
— Иордания
1

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
— Оливер
источник
1

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
— idrougge
источник
1

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, хотя - я начал в ноябре. Хотите знать, если есть способ объединить инициализацию Pс той, что в макросе.

Каков «правильный» способ проверить последовательность ViM в гольфе? Я проверял с \vi -u /dev/null. Однако в ВМ даже:h<_␍ не работает. Также не очень уверен, почему мой ViM перейдет к первому непробельному персонажу, ха-ха.

PS Прежде, чем я перешел на использование OS X, я играл в гольф в Hexagony с отличными инструментами ... Теперь на OS X я не занимаюсь вином и, следовательно, не использую отличные инструменты для объяснений и отладки. Так началось мое путешествие с ViM!

— Санни Пун
источник
1

C # (.NET Core) , 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
— Aloisdg говорит восстановить Монику
источник
1

Tcl , 92 байта

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

Попробуйте онлайн!

tcl, 94

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

демонстрация

tcl, 101

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

демонстрация

В середине процесса я случайно получил курсивную версию шапки:

ткл, 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]}

демонстрация

— sergiol
источник
— Только для ASCII
@ ASCII-только спасибо!
— sergiol
1

Common 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 с использованием sugestion по ASCII-only для использования <enter>вместо~%

— ASCII-только
источник
1
82
— Только для ASCII
1

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является MODULOфункцией, и переключается между 0 (вставить букву) и 1 (перезаписать пробел).

Если вы предпочитаете заглавные буквы, используйте CHAR(@+63)вместо этого (не изменяет наш счетчик байтов).

— BradC
источник
0

Haskell (Lambdabot), 73 байта

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

той же длины:

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

Я использую init.tailsили tail.initsс возможным реверсом впереди в почти каждом вызове; Я бы хотел, чтобы они уже добавили его в Prelude.

— судейская шапочка
источник
0

Groovy, 53 байта

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

Выход:

            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
— Урна волшебного осьминога
источник
0

QBIC , 57 байт

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

Это удивительно хорошо работает с циклами QBIC 'FOR. Пояснение (предыдущей версии - применяется тот же принцип):

[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>

Выход: 

            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
— steenbergh
источник
Не соответствует ОП.
— Волшебная Урна Осьминога
@carusocomputing это делает сейчас.
— Стинберг
0

Ракетка 137 байт

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

Тестирование: 

(f)

Выход: 

            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
— rnso
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.