Desenhar um chapéu de festa do alfabeto

22

Sua tarefa é imprimir este texto exato:

            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

Caso não importa.

Lembre-se de que isso é código-golfe , portanto o código com o menor número de bytes vence.

code-golf  kolmogorov-complexity  alphabet 
— Oliver Ni
fonte
2
Por que os votos negativos?
— Oliver Ni
19
Suspeito que algumas pessoas estejam cansadas de todos os desafios do KC de arte-padrão do alfabeto ASCII.
— Xnor
Podemos fazer isso em maiúsculas?
— Downgoat 26/10/16
7
Sério, outro desafio do alfabeto?
— Erik the Outgolfer
2
Eu gosto desses desafios do alfabeto. Este poderia facilmente ser renomeado como uma árvore de Natal.
— Pete Arden

Respostas:

6

Queijo Cheddar, 50 45 42 37 bytes

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

Simples, mas utiliza a sintaxe abrangente e variada do cheddar (numérica e alfabética)

Experimente online!

Explicação

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é um código de char para Ae 90paraA

— Downgoat
fonte
1
Zé 90não A.
— Mego
5

05AB1E , 15 13 bytes

A.svy12N;ï-ú,

Experimente online! (ligeiramente diferente de cima comoú ainda não está no TIO)

Explicação

  1. Empurre o alfabeto
  2. Calcular os sufixos do alfabeto
  3. Anexar 12 espaços de índice / 2
  4. Impressão
— Emigna
fonte
4

Python 2, 70 bytes

Portado da resposta de Emigna , -2 bytes para substituir -i-1por~i

for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]
— Karl Napf
fonte
Estou bastante certo usando mapa pode render um alfabeto mais curto, exceto talvez minúsculas ter valores mais elevados
— Destrutível Lemon
Na verdade, não tenho mais certeza. Eu acho que não iria funcionar para isso de qualquer maneira :( soz
— Destructible Lemon
4

R, 67 66 59 bytes

EDIT: salvou alguns bytes graças a @rturnbull

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

Explorar o fato de que qualquer número passado para a repfunção é arredondado automaticamente para o número inteiro mais próximo (por exemplo rep("*",1.99) => "*"), o que significa que a sequência real passada é 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
fonte
1
Isso sai mais curto do que minha tentativa de matriz. Substituir 14...-1por 13?
— JDL
@JDL Ah sim, é claro. Um remanescente de tentar outra abordagem
— Billywob 26/10/16
2
Se você percorrer 25:0, em vez de 1:26, você pode mudar 13-i/2para i/2, e simplificar (27-i):26a i:25+1, poupando 6 bytes.
— rturnbull
3

Pitão, 15 bytes

j_m+*/d2\ >GdUG

Um programa que imprime o resultado em STDOUT.

Experimente online

Como funciona

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
fonte
Tente em ;vez de\
— isaacg 26/10
3

Python 2, 52 bytes

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

Acumula a sequência sa ser impressa e atualiza o número de espaços à esquerda n/2. Um whileloop que termina em 0é um loop numérico raro que supera um execloop (53 bytes):

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

Também uma alternativa de 53 bytes:

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

JavaScript (ES6), 85 75 69 68 bytes

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

-1 byte graças a @ l4m2 .

— darrylyeo
fonte
2
Isso não é um fragmento, e não uma função ou programa?
— Neil
1
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+'#'1B mais curto
— l4m2 5/0118
@ l4m2 Brilhante!
— precisa saber é
1
Boa ideia usando a base 36! +1
— Titus
2

Flak cerebral , 244 bytes

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

Experimente online!

Isso deve ser legível o suficiente como está. Se você precisar, tenho uma explicação completa:

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
fonte
4
This should be readable enough as is.Você está falando sobre Brain-Flak , certo?
— Erik the Outgolfer
2

Geléia , 15 13 bytes

-2 bytes graças a @miles (formava uma cadeia niládica que eu suspeitava existir, mas não se formou)

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

TryItOnline!

Quão?

Ø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)
— Jonathan Allan
fonte
Eu encontrei uma maneira de formar uma cadeia niladic começando com o alfabeto ØaJ’H⁶ẋżṫJ$ṚYque salva 2 bytes
— milhas
Você acha que a explicação está correta?
— Jonathan Allan
1
Sim, pense nisso como uma cadeia monádica, com um único argumento sendo o alfabeto
— miles
2

C, 72 68 bytes

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

Turtlèd , 70 68 bytes

observe o espaço à direita

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

Experimente online!

Como funciona:

#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

Explicação legível por humanos (?):

Ele usa a string var para conter o alfabeto. Cada iteração reduz o índice em um, até que ele se mova e pare depois de chegar à última linha. Para os recuos alternados, ele usa o char var. Cada iteração verifica o char var e vira-o. se fosse *, muda para a direita, o primeiro caractere se alinha; caso contrário, não, o último caractere.

— Limão destrutível
fonte
1

Perl, 44 bytes

Esta é uma porta da resposta do @ xnor .

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

Precisa -E(ou -M5.010) executar:

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

Java 7,128 127 bytes

Salvo 1 byte.Graças a 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;}

destroçado

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

Sem passar 122 em uma função

132 bytes

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

destroçado

  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
fonte
1
Você pode remover o =at d+=c+s+"\n". Além disso, você pode formatar um pouco o código não-bloqueado com indentações. Notei isso com algumas de suas outras respostas também. :)
— Kevin Cruijssen 26/10/16
1
oops! eu cometi esse erro novamente, que vergonha para mim. ...... ok @KevinCruijssen eu estou nele.
— Numberknot 26/10/16
Você não pode substituir o s=v+sna recursão por s+=v?
— Roman Gräf
Não ... porque o padrão de letras está ao contrário.
— Numberknot
1

Ruby, 64 bytes

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}
— Manny42
fonte
Alguns comentários: Você não precisa para colocar os suportes após join Chamando eachem vez de mapé desnecessária, uma vez que não se preocupam com o que estamos voltando Você pode chamar lastde uma série
— Lee W
Em vez de (0..26).map, tente 27.times; em vez de ('a'..'z').to_a, [*?a..?z]; e em vez de .join, *"".
— Jordan
1

Japonês , 16 bytes

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

Experimente online!

Explicação:

;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
— Oliver
fonte
1

REXX, 52 bytes

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

Saída:

            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
fonte
1

Vim, 25 Pressionamentos de tecla

:h<_␍jjYZZPqqPxYPr Yq12@q

Onde ␍ é a tecla Enter, também às vezes anotada como <cr>.

Explicação

: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

No entanto, sou novo no ViM - comecei em novembro. Pensando se existe uma maneira de mesclar a inicialização Pcom a da macro.

Qual é a maneira "correta" de testar uma sequência do ViM com golfe? Eu testei com \vi -u /dev/null. No entanto, em uma VM, mesmo :h<_␍não funciona. Também não sei ao certo por que meu ViM passará para o primeiro personagem não espacial haha.

PS Antes de me mudar para usar o OS X, jogava golfe no Hexagony com ótimas ferramentas ... Agora, no OS X, eu não pratico vinho e, portanto, não estou executando as ótimas ferramentas para explicações e depuração. Então comecei minha jornada com o ViM!

— Sunny Pun
fonte
1

C # (.NET Core) , 112 bytes

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

Experimente online!

()=>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 diz Restabelecer Monica
fonte
1

Tcl , 92 bytes

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

Experimente online!

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

demonstração

No meio do processo, recebi acidentalmente a versão em itálico do chapéu:

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

demonstração

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

demonstração

No meio do processo, recebi acidentalmente a versão em itálico do chapéu:

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

demonstração

— sergiol
fonte
— somente ASCII
@ Obrigado apenas ASCII!
— Sergiol #
1

Lisp comum, SBCL, 83 82 bytes

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

Explicação

(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 usando sugestão do ASCII - somente para usar em <enter>vez de~%

— Somente ASCII
fonte
1
82
— somente ASCII
1

T-SQL, 107 bytes

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

Modifica a sequência de caracteres para cada linha colocando a letra correta na posição correta usando a função SQL STUFF(). Formatado:

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

@/2usa divisão inteira (sem restante) para determinar a posição para inserir a letra. @%2é oMODULO função e alterna entre 0 (inserir a letra) e 1 (substituir um espaço).

Se preferir letras maiúsculas, use CHAR(@+63)(não altera a contagem de bytes).

— BradC
fonte
0

Haskell (Lambdabot), 73 bytes

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

Mesmo comprimento:

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

Eu uso init.tailsou tail.initscom um possível reverso na frente em praticamente todos os desafios; Eu gostaria que eles adicionassem ao Prelude já.

— BlackCap
fonte
0

Python 2, 66 64 bytes

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

Groovy, 53 bytes

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

Saída:

            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
— Urna de polvo mágico
fonte
0

QBIC , 57 bytes

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

Este funciona surpreendentemente bem com os loops QBIC 'FOR. Explicação (da versão anterior - o mesmo princípio se aplica):

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

Saída: 

            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
fonte
Não corresponde ao OP.
— Magic Octopus Urn
@carusocomputing agora.
— steenbergh
0

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

Teste: 

(f)

Saída: 

            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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.