Faça um holofote do alfabeto!

66

Inspirado por um bug em uma solução para esse desafio , seu desafio é produzir este texto exato:

                         ZYXWVUTSRQPONMLKJIHGFEDCBA
                        YXWVUTSRQPONMLKJIHGFEDCBA
                       XWVUTSRQPONMLKJIHGFEDCBA
                      WVUTSRQPONMLKJIHGFEDCBA
                     VUTSRQPONMLKJIHGFEDCBA
                    UTSRQPONMLKJIHGFEDCBA
                   TSRQPONMLKJIHGFEDCBA
                  SRQPONMLKJIHGFEDCBA
                 RQPONMLKJIHGFEDCBA
                QPONMLKJIHGFEDCBA
               PONMLKJIHGFEDCBA
              ONMLKJIHGFEDCBA
             NMLKJIHGFEDCBA
            MLKJIHGFEDCBA
           LKJIHGFEDCBA
          KJIHGFEDCBA
         JIHGFEDCBA
        IHGFEDCBA
       HGFEDCBA
      GFEDCBA
     FEDCBA
    EDCBA
   DCBA
  CBA
 BA
A
  • A primeira linha terá 25 espaços, depois o alfabeto a partir da 26ª letra ( ZYXWVUTSRQPONMLKJIHGFEDCBA) e, em seguida, uma nova linha.
  • A segunda linha terá 24 espaços, depois o alfabeto a partir da 25ª letra ( YXWVUTSRQPONMLKJIHGFEDCBA) e, em seguida, uma nova linha.
  • ...
  • A última (26ª) linha não terá espaços, depois o alfabeto a partir da 1ª letra ( A) e, em seguida, uma nova linha.

Regras adicionais:

  • Seu programa pode usar qualquer método de saída permitido.
  • Uma nova linha à direita e / ou uma nova linha à frente é permitida.
  • Deve haver uma nova linha entre as linhas que contêm as letras, não mais.
  • As letras devem estar todas em maiúsculas.

Assim como no , a submissão mais curta vence. Boa sorte!

Entre os melhores:

MD XF
fonte
3
Para mim parece que a luz lançada pela bat-sinal
scottinet
4
Relacionado de perto .
Sr. Xcoder 5/09
Cada linha pode ter um espaço extra à sua frente?
HyperNeutrino 5/09
3
Cada linha poderia ter espaços à direita após a última letra?
milhas
11
@ Miles sim, tudo bem.
MD XF

Respostas:

19

05AB1E , 7 bytes

Código:

₂žp.s1Λ

Usa a codificação 05AB1E . Experimente online!

Explicação

 žp.s      # Get the suffixes of ZYX...CBA
      Λ    # Using the canvas mode, print the
₂          # first 26 elements of the array
     1     # into the upper-right direction
Adnan
fonte
2
@MDXF IMO, que é um realmente estúpido regra
DJMcMayhem
3
Hum ... acho que vou remover a regra, então. status-complete
MD XF
2
Eu poderia propor um PR documentando esse recurso quando eu encontrar o tempo. Parece ser uma boa maneira de aprender um pouco de python de um bem escrito, fácil de ler o código
scottinet
6
Por que žpexiste quando Aué dourado? BADUM tissss
Magic Octopus Urn
5
Usando 05AB1E, criar um arquivo de documentar todas as suas características, código shortes ganha: P
Christian
22

R , 67 55 bytes

for(i in 26:1)cat(rep(" ",i-1),LETTERS[i:1],"
",sep="")

Experimente online!

Giuseppe
fonte
4
R está batendo Python em um desafio de string? Agradável. +1 para LETRAS
CriminallyVulgar
11
@CriminallyVulgar é um desafio muito estranho; Haskell está superando o empate do PHP e R, que estão superando o Python ... pelo menos o Perl está à frente de todos eles, como você poderia esperar.
CR Drost
-2 bytes se você mudar seppara s. Funções vai autocomplete argumentos nomeados se não há colisões
Punintended
11
@ Pretendido que não funcionará por causa do ...argumento; os argumentos que vêm antes ...(normalmente) são correspondidos parcialmente e os que não são depois. Acredito que existem algumas exceções, mas catnão é uma delas.
Giuseppe
@Giuseppe I don't see a...
MilkyWay90
15

V , 13 , 11 bytes

¬ZAòY>HGpxl

Experimente online!

Hexdump:

00000000: ac5a 41f2 593e 4847 7078 6c              .ZA.Y>HGpxl

Escrito do meu telefone: P.

¬ZA         " Insert the alphabet backwards
   ò        " Recursively:
    Y       "   Yank this current line
     >H     "   Add one space to every line
       G    "   Move to the last line in the buffer
        p   "   Paste the line we yanked
         x  "   Delete one character
          l "   Move one character to the right, which will throw an error on 
            "   the last time through, breaking the loop
DJMcMayhem
fonte
11
Eu também faço isso no meu telefone, +1
Stan Strum 5/17
12

PowerShell , 42 bytes

25..0|%{' '*$_+-join[char[]]((65+$_)..65)}

Experimente online!

Explicação:

25..0|%{                                 } # Loop from 25 to 0
                             (65+$_)..65   # Construct a range of the specific ASCII codes
                    [char[]](           )  # Cast that as a character array
               -join                       # that has been joined together into a string
        ' '*$_+                            # Prepended with the correct amount of spaces
AdmBorkBork
fonte
11

Bash + GNU sed, 60

printf %s {Z..A}|sed 'h
s/./ /g
G
s/ \n//
:x
p
s/ \S//
tx
d'

Experimente online .

Trauma Digital
fonte
Você pode salvar dois bytes alterando :xpara :e txpara t.
Jordan
10

/// , 105 97 bytes

/:/\\\\*//#/:Z:Y:X:W:V:U:T:S:R:Q:P:O:N:M:L:K:J:I:H:G:F:E:D:C:B:A//\\*/\/\/_____#
\/ //_/     //*#

Experimente online!

Explicação

/// conhece apenas um comando, /<pattern>/<substitution>/<text>substitui todas as ocorrências de <pattern>in <text>por <substitution>. Além disso, \pode ser usado para escapar de caracteres.

Código reduzido para simplificar:

/:/\\\\*//#/:E:D:C:B:A//\\*/\/\/__#
\/ //_/  //*#

O primeiro comando /:/\\\\*/substitui :por \\*no código subseqüente. Isto dá:

/#/\\*E\\*D\\*C\\*B\\*A//\\*/\/\/__#
\/ //_/  //*#

Em seguida, /#/\\*E\\*D\\*C\\*B\\*A/substitui #por \*E\*D\*C\*B\*A:

/\\*/\/\/__\*E\*D\*C\*B\*A
\/ //_/  //*\*E\*D\*C\*B\*A

Em seguida, /\\*/\/\/__\*E\*D\*C\*B\*A<newline>\/ /substitui \*por //__*E*D*C*B*A<newline>/:

/_/  //*//__*E*D*C*B*A
/ E//__*E*D*C*B*A
/ D//__*E*D*C*B*A
/ C//__*E*D*C*B*A
/ B//__*E*D*C*B*A
/ A

Aviso: eu tive que usar \*para substituição. Como *também faz parte da substituição, geraria um loop infinito se eu apenas substituísse *.

Em seguida, o comando /_/ /substitui _por espaços e /*//exclui tudo *:

EDCBA
/ E//    EDCBA
/ D//    EDCBA
/ C//    EDCBA
/ B//    EDCBA
/ A

O próximo comando /#//substitui #por nada. Como não existe #no código, ele não faz nada. Aqui está apenas para remover os dois líderes //do início do código. Isso deixa

EDCBA
/ E//    EDCBA
/ D//    EDCBA
/ C//    EDCBA
/ B//    EDCBA
/ 

Em seguida, o comando é / E//removido <space>E, então isso deixará o código

    EDCBA
   DCBA
/ D//   DCBA
/ C//   DCBA
/ B//   DCBA
/ 

/ D//Remoções semelhantes <space>D:

    EDCBA
   DCBA
  CBA
/ C//  CBA
/ B//  CBA
/ 

/ C//:

    EDCBA
   DCBA
  CBA
 BA
/ B// BA
/ 

/ B//:

    EDCBA
   DCBA
  CBA
 BA
A
/ 

E o último comando está incompleto, por isso não faz nada:

    EDCBA
   DCBA
  CBA
 BA
A
Jakube
fonte
Mesmos comprimentos como as respostas C # e brainfuck: D
Conor O'Brien
9

Haskell, 53 52 bytes

f(a:b)=(b>>" ")++a:b++'\n':f b
f x=x
f['Z','Y'..'A']

Experimente online!

Como funciona

f['Z','Y'..'A']        -- call f with the full backwards alphabet

f(a:b)=                -- let `a` be the first char and `b` the rest. Return
   (b>>" ") ++         -- replace each char in b with a space, followed by
   a:b ++              -- the input string, followed by
   '\n' :              -- a newline, followed by
   f b                 -- a recursive call of `f` with `b`
f x=x                  -- stop on an empty input string
nimi
fonte
Por que não f['Z'..'A']funciona?
Conor O'Brien
11
@ ConorO'Brien: [a..b]começa com ae coleta todos os sucessores ( +1para números inteiros, próximo caractere ascii para caracteres, etc.) até b. Se a > besta é uma lista vazia. No entanto, você pode especificar também o segundo valor (que pode ser menor) a partir do qual um incremento / decremento é calculado. [1,3..8]-> [1,3,5,7], [15,10..0]-> [15,10,5,0], ou ['Z','Y'..'A']qual é o alfabeto maiúsculo para trás.
nimi
Ah, eu vejo agora. Obrigado!
Conor O'Brien
8

Python 2 , 66 64

i=26
while i:i-=1;print' '*i+'ZYXWVUTSRQPONMLKJIHGFEDCBA'[25-i:]

Experimente online!

Artemis_134
fonte
11
Bem-vindo à Programação de quebra-cabeças e código de golfe - ótima primeira resposta!
MD XF
2
Obrigado! Achei que eu tentaria, em vez de apenas espreitar.
Artemis_134
2
Você pode remover o espaço entre printe 'para 65 bytes.
Sr. Xcoder 5/09/17
Eu portado sua resposta em Pyth, dê uma olhada: codegolf.stackexchange.com/a/141939/63757
Stan Strum
7

JavaScript (ES6), 83 77 76 bytes

f=(n=0,p='')=>n<26?f(++n,p+' ')+p+`ZYXWVUTSRQPONMLKJIHGFEDCBA
`.slice(~n):''

o.innerText = f()
<pre id=o>

Arnauld
fonte
Eu queria sugerir uma melhoria, mas depois percebi que nossas abordagens são muito diferentes. Espero que você não se importe.
@ThePirateBay Sem problemas!
Arnauld
7

Gelatina , 12 bytes

ØAµ⁶ṁḊ;ṚµƤṚY

Experimente online!

ØAµ⁶ṁḊ;ṚµƤṚY  Main Link
ØA            "ABC...XYZ"
         Ƥ    For each prefix,
  µ⁶ṁḊ;Ṛµ     Monadic Link
   ⁶          ' '
    ṁ         (with automatic repetition) molded to the shape of
     Ḋ        All but the first letter of the input (repeat - 1)
      ;       With the input          appended to it
       Ṛ                     reversed
           Y  Join on newlines

-3 bytes graças a milhas

HyperNeutrino
fonte
13 bytes
Freira vazada
@LeakyNun Oh bem legal obrigado!
HyperNeutrino 05/09
Yay, outro uso para o prefixo rápido. 12 bytes desde que o molde será remodelado aqui usando o comprimento implicitamente.
milhas
@LeakyNun Na verdade, infelizmente, que tornaria inválida porque não pode haver espaços extras (que levaria 2 bytes para corrigir)
HyperNeutrino
7

brainfuck , 105 bytes

++++++++[>+>+++++++++++>++++>+++<<<<-]>++>++>>++[[->+>+<<]>-[-<<.>>]>[-<<<<.->>>+>]<-[-<+<<+>>>]<<<<.>>>]

Experimente online!

Minificado e formatado:

++++++++[>+>+++
++++++++>++++>+
++<<<<-]>++>++>
>++[[->+>+<<]>-
[-<<.>>]>[-<<<<
.->>>+>]<-[-<+<
<+>>>]<<<<.>>>]

Versão legível:

[
  pre-initialize the tape with the values 10 90 32 >26<
  C_NEWLINE: 10
  V_ALPHA: 90
  C_SPACE: 32
  V_COUNTER: 26

AS:

  10 = 8 *  1 + 2
  90 = 8 * 11 + 2
  32 = 8 *  4 + 0
  26 = 8 *  3 + 2
]

8 ++++++++ [
  *  1 >+
  * 11 >+++++++++++
  *  4 >++++
  *  3 >+++
<<<<-]
PLUS 2 >++
PLUS 2 >++
PLUS 0 >
PLUS 2 >++

UNTIL V_COUNTER == 0 [
  COPY V_COUNTER to RIGHT and RIGHT_RIGHT
  [->+>+<<]
  TAPE: 10 V_ALPHA 32 >0< V_COUNTER_R V_COUNTER_RR
  V_COUNTER_R SUB 1 TIMES: >-[-
     PRINT C_SPACE <<.
  >>]
  TAPE: 10 V_ALPHA 32 0 >0< V_COUNTER_RR
  V_COUNTER_RR TIMES: >[-
    PRINT V_ALPHA <<<<.
    DECREMENT V_ALPHA -
    INCREMENT V_COUNTER_R >>>+
  >]
  TAPE: 10 V_ALPHA 32 0 V_COUNTER_R(26) >0<
  V_COUNTER_R SUB 1 TIMES: <-[-
    INCREMENT V_COUNTER <+
    INCREMENT V_ALPHA <<+
  >>>]
  PRINT C_NEWLINE <<<<.
>>>]
Conor O'Brien
fonte
6

Poético , 601 bytes

one night i camped a bit
throughout all the forest now
the sweet sights
i saw giant things
i saw little small things
here i am
seated around all my trees i saw
i sleep
i sle-e-p
sleep in a cabin
i am sleep-y
i sleep a bit
i awaken in bed
i stand
i walk
i am ready
i saw a vision of a dragon
i am fooled
i know i am
should i f-ight
i f-light
i did f-light
i did a flight
go away,i do imply
i*m afraid
i run
i leave
i flee
i am timid
i*m just a person,not toughie-tough-guy
no,never
i*m waste
i am stupid
a quitter i was
i am stupid
i*m turning around
i do not appreciate camping
i cry
i am crying
no
no

Poetic é um esolang que eu criei em 2018 para um projeto de classe e é um derivado de foda cerebral em que o comprimento das palavras corresponde aos comandos de foda cerebral (e os comandos +, -,> e <têm argumentos de 1 dígito).

O fato de que apenas o comprimento da palavra dita os comandos significa que eu tecnicamente poderia ter criado um programa inteiramente composto de não palavras (ou seja, a letra X quantas vezes for necessário, com espaços entre as palavras), mas eu queria fazer um interessante poema de verso livre, sem adicionar bytes desnecessários.

Se você quiser experimentá-lo on-line (que é metade do ponto do projeto da turma), confira meu intérprete on-line !

JosiahRyanW
fonte
Por que isso não é competitivo?
pppery
A linguagem foi criada após o desafio.
JosiahRyanW
Hum, então acho que isso me dá mais motivação para usar o Poetic como uma linguagem de programação! Heh.
JosiahRyanW 10/10
5

05AB1E , 10 bytes

žpDvÐg<ú,¦

Experimente online!

Explicações:

žpDvÐg<ú,¦
žp           Push the uppercased alphabet, reversed
  D          Duplicate
   v         For each letter (we just want to loop 26 times, so we use the 
                already pushed alphabet for that purpose)
    Ð        Triplicate
     g<      Length of the string - 1
       ú     Add that number of spaces at the beginning of the string
        ,    Print with newline
         ¦   Remove the 1st element of the remaining copy of the string
escoteiro
fonte
5

Perl 6 , 37 bytes

Economizou 9 bytes graças a @Massa.

say " "x$_,chrs $_+65...65 for 25...0

Experimente online!

Explicação: 25...0 é um intervalo de 25 a 0 (conforme o esperado). Nós iteramos nesse intervalo, dizendo (= imprimindo com nova linha) que muitos espaços e a sequência de caracteres que possuem códigos ASCII ( chrs) de 65 + esse número ( $_+65...65).

Ramillies
fonte
11
25...0 é o caminho mais curto :-)
Massa
tente say " "x$_,chrs $_+65...65 for 25...0:-)
Massa
Muito Obrigado! Eu nunca soube disso! E a sub-forma também é melhor (pena que eu fiz essa do alto da minha cabeça). (É por isso que eu gosto de usar Perl 6 para codegolf, eu sempre descobrir algo novo.)
Ramillies
4

Carvão , 19 11 bytes

-8 bytes graças ao ASCII-only.

F²⁶«P⮌…α⊕ι↗

Experimente online! Link é a versão detalhada.

totalmente humano
fonte
Talvez isso? tio.run/##S85ILErOT8z5/…
somente ASCII
Espere, noooooo, há espaço de liderança
somente ASCII
Filho da ... preciso examinar todos os comandos e operadores que o Charcoal possui. > _> Obrigado!
totallyhuman
Corrigido tio.run/…
somente ASCII
11
@ Somente ASCII CycleChop... mas você esqueceu Increment(ou como quer que seja chamado)
Erik the Outgolfer
4

Perl 5 , 36 bytes

Código de 35 bytes + 1 para -p.

$\=$"x$-++.($a=$_.$a).$/.$\for A..Z

Nota : O TIO não suporta entrada vazia ; portanto, uma nova linha é fornecida, isso resulta em uma nova linha externa, mas ao executar na linha de comandos com entrada vazia, isso não é exibido.

Experimente online!

Dom Hastings
fonte
4

Cubix , 43 46 bytes

$/\;u:\s/':(!$u;:'@^!@Wu;oSU;o+<u(;;oN;(!|

Experimente online!

Cubificado

      $ / \
      ; u :
      \ s /
'  : ( ! $ u ; : ' @ ^
! @ W u ; o S U ; o + <
u ( ; ; o N ; ( ! | . .
      . . .
      . . .
      . . .

Veja-o correr

Conseguiram barbear um pouco mais disso, mas foi um pouco mais difícil do que eu pensava. Existe um caractere substituto após a primeira citação para me dar 26.

  • '<sub> empurre 26 na pilha como o número base
  • :(! base duplicada como contador, decremento, teste de verdade
  • uem true pule o $comando e gire para a direita
    • So;u pressione 32, produza como caractere, pop 32 e vire à direita para diminuir
  • $no salto falso o próximo ucomando
  • ;:'@^ pop, duplique o número base, coloque 64 na pilha e redirecione para uma rota torturante
  • $\s/:\/u;$esta é a ordem das etapas na face superior. Tudo se resume a trocar o contador pelo 64. Termina com um pulo sobre o redirecionamento que o coloca aqui.
  • <+o;U redirecione para adicionar, caractere de saída, pop, vire à esquerda
  • (!decréscimo, teste a verdade. Se true inicia em um caminho que atinge a inversão de marcha e volta ao redirecionamento.
  • |(;No em falso, refletir, teste redundante, decremento redundante, pop, push 10 e caractere de saída
  • ;;(u!@Wdesça até o número base, diminua, vire à direita no teste da verdade, pare se falso, caso contrário mude a faixa para a duplicata no início. Enxague e repita.
MickyT
fonte
4

Python, 83 bytes

[print(' '*i+''.join([chr(64+i)for i in range(i+1,0,-1)]))for i in range(25,-1,-1)]

Minha primeira resposta sobre codegolf :)

Jacob Garby
fonte
11
Bem-vindo tardiamente ao PPCG! boa resposta!
Conor O'Brien
4

Vim, 43 pressionamentos de tecla

:h<_<CR>jjYZZPVgUxjpqqy$-i <Esc>lpl"aDYPD"ap+q25@q

Você pode vê-lo em ação neste GIF criado usando o script python de Lynn

insira a descrição da imagem aqui

BlackCap
fonte
3

JavaScript, 75 74 bytes

1 byte economizado graças a Rick Hitchcock

f=(a=65,b='',c)=>a>90?'':f(a+1,b+' ',c=String.fromCharCode(a)+[c])+`
`+b+c

Experimente online!


fonte
Salve um byte inicializando b( b='') e removendo bos colchetes.
Rick Hitchcock
@RickHitchcock. Obrigado.
3

Perl 5 , 49 bytes

$_=$"x26 .join'',reverse A..Z,Z;say while s/ \S//

Experimente online!

Xcali
fonte
Parece que você está perdendo o primeiro A, mas parece que pode ser corrigido mudando $"x25para $"x26!
Dom Hastings
Quando adicionei o extra Z, esqueci de explicar isso.
Xcali 6/09/17
3

Pyke , 8 bytes

G_.<XFo}h-

Experimente aqui!

           -  o = 0
G_         -    reversed(alphabet)
  .<       -   suffixes(^)
    XF     -  for i in ^:
      o    -      o++
       }   -     ^ * 2
        h  -    ^ + 1
         - -   i.lpad(" ", ^)
           - for i in reversed(^):
           -  print i

Eu posso ver o idioma certo fazendo isso em 6 bytes, se eles tiverem um builtin prepend n spaces to stringe o que o Pyke faz

Azul
fonte
3

PHP ( 63 58 55 bytes)

Este é possivelmente o meu canto estranho favorito do PHP, um canto que ele herda do Perl:

for($c=A;$c!=AA;$q="$s$z 
$q",$s.=" ")$z=$c++.$z;echo$q;

Isso gera a nova linha à direita, conforme explicitamente permitido. Isso pode ser executado php -rpara salvar a abertura <?phpnecessária para colocar isso em um arquivo.

Explicação: quando uma variável que contém a cadeia 'A'é incrementado em PHP, torna-se 'B'e, em seguida, 'C'e assim por diante até que 'Z'se torna 'AA'. Não há um dígito antes 'A'para começar nessa álgebra louca, e o operador de decremento não o desfaz; portanto, salvamos o alfabeto invertido incrementalmente em $z(cujo padrão NULLé quando concatenado com uma string se comporta como a string vazia - o o mesmo acontece com $se $q). O espaço em branco é acumulado $se a cadeia inteira é acumulada para trás na variável, o $qque significa que precisamos repeti-la no final.

Agradeço a Titus por jogar golfe nos meus aparelhos encaracolados e me dizer que não preciso aplicar uma penalidade por bandeiras de avaliação em linha como -r.

CR Drost
fonte
11
São 57 bytes, se você usar uma quebra de linha Linux. -ré grátis. Dois bytes mais curtos:for($c=A;$c!=AA;$q="$s$z\n$q",$s.=" ")$z=$c++.$z;echo$q;
Titus
@ Titus obrigado, deu-lhe um parabéns na resposta.
CR Drost
nm. Apenas observe que -Re não-F é gratuito. Veja codegolf.meta.stackexchange.com/questions/2424/…
Titus
Eu acredito que você pode salvar um byte, se você usar $c<AA.
Ismael Miguel
11
@IsmaelMiguel desculpe, eu era muito concisa. Eu estava pensando quando escrevi isso: "talvez exista uma maneira de embaralhar as coisas sem obter bytes, para que o caso A aconteça primeiro e depois possamos detectar AA vs. B, mas não acho que seja inteligente o suficiente para vê-la. . " Eu não quis ser irreverente e vou tentar cuidar disso no futuro.
CR Drost
3

SOGL V0.12 , 10 8 bytes

Z±{Xf}⁰¼

Experimente aqui!

dzaima
fonte
Apenas curioso, quanto tempo dura a versão compactada?
caird coinheringaahing 5/17
@cairdcoinheringaahing TL; DR por muito tempo. A compactação de SOGLs é péssima em (e é feita especificamente para não) coisas repetitivas. Seria muito difícil dizer como a compressão não é automatizado (automação iria fazer com que demore 701 choose xtentativas para qualquer inteiro x), mas uma tentativa grosseira foi de 450 bytes: P
dzaima
3

Lisp comum, 84 82 bytes

(dotimes(i 26)(format t"~v@{ ~}~a
"(- 25 i)(subseq"ZYXWVUTSRQPONMLKJIHGFEDCBA"i)))

Experimente online!

Dois bytes a menos graças ao @ Ascii-only!

Renzo
fonte
82
somente ASCII