Gravata Alfa-Numérica

14

Saída este texto exato:

1                i
12              hi
123            ghi
1234          fghi
12345        efghi
123456      defghi
1234567    cdefghi
12345678  bcdefghi
123456789abcdefghi
12345678  bcdefghi
1234567    cdefghi
123456      defghi
12345        efghi
1234          fghi
123            ghi
12              hi
1                i

Uma única nova linha à direita é aceitável, mas nenhuma outra alteração de formatação é permitida.

Regras e E / S

  • Sem entrada
  • A saída pode ser fornecida por qualquer método conveniente .
  • Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
  • As brechas padrão são proibidas.
  • Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.
code-golf  kolmogorov-complexity 
— AdmBorkBork
fonte
1
Podemos usar o alfabeto maiúsculo?
— Kritixi Lithos
3
@ Cowsquack Isso seria uma mudança de regra. Diz Saída este texto exato .
— Dennis
@ Cowsquack Nope - é necessário usar letras minúsculas.
— AdmBorkBork

Respostas:

13

C, 87 85 81 80 bytes

j;main(i){for(;++i<19;)for(j=19;j--;)putchar(j?j<i^j<20-i?32:106-j-j/10*39:10);}

Experimente online!

Explicação

j; // same as int j;
main(i){ // same as int main(int i){, where i = argc (1 with no arguments)
  for(;++i<19;) // loop over rows, i = 2..18
    for(j=19;j--;) // loop over chars, j = 19..0
      putchar(j?j<i^j<20-i?32:106-j-j/10*39:10); // output characters:
      //      j?                           :10 // on last char (j=0), output \n
      //        j<i                            // check for top/left half
      //            j<20-i                     // check for bottom/left half
      //           ^                           // 1 if only one half matched
      //                  ?32:                 // if so, output space
      //                      106              // char code for j
      //                         -j            // get desired letter
      //                           -j/10*39    // subtract 39 for j>9 (numbers)
}
— PurkkaKoodari
fonte
Estou impressionado que ^tem precedência mais baixa do que <… que resposta bonita!
— Lynn
@ Lynn Os operadores bit a bit em C (e até Java / JS e outros) têm uma precedência menor do que as comparações. Isto é tanto agradável para o golfe código e um muito bom fonte de erros (pense if (x & 2 == 0), que sempre avalia a 0)
— PurkkaKoodari
3

QBasic, 72 bytes

Baseado na submissão de Taylor Scott .

FOR y=-8TO 8
z=ABS(y)
?"123456789abcdefghi";
LOCATE,10-z
?SPC(2*z)"
NEXT

Explicação básica

Em cada linha, imprimimos a sequência completa 123456789abcdefghi. Depois voltamos e substituímos parte dele com espaços.

Explicação completa

Com código um pouco não-destruído:

FOR y = -8 TO 8           ' Loop for 17 rows
 z = ABS(y)               ' z runs from 8 to 0 and back to 8
 ? "123456789abcdefghi";  ' Print the full string and stay on the same line (important!)
 LOCATE , 10-z            ' Go back to column 10-z on that line
 ? SPC(2*z); ""           ' Print 2*z spaces
                          ' (SPC keeps the cursor on the same line unlesss you print
                          ' something after it, so we'll use the empty string)
NEXT                      ' Go to the next y value
— DLosc
fonte
Isso é um uso realmente inteligente do Locatecomando
— Taylor Scott
2

T-SQL, 108 bytes

DECLARE @ INT=8a:
PRINT STUFF('123456789abcdefghi',10-abs(@),2*abs(@),SPACE(2*abs(@)))
SET @-=1IF @>-9GOTO a

Os retornos são apenas para legibilidade.

Tentei muitas outras variações, incluindo tabelas numéricas, essa foi a mais curta.

— BradC
fonte
2

Japonês , 20 bytes

9Æ9Ç>YÃê1 Ë?S:°EsH
ê

Intérprete Japt

Saída como uma matriz de matrizes de caracteres. O -Rsinalizador não é necessário para o trabalho, apenas torna a saída mais agradável.

Explicação:

9Æ9Ç                    create a 9x9 2D array 
    >YÃ                 fill bottom left triangle with "false", upper right with "true"
       ê1               mirror horizontally
          Ë?S           replaces "true" with a space
             :°EsH      replaces "false" with the horizontal index + 1 converted to base 32
                  \n    Store the result in U (saves bytes by not closing braces)
                    ê   palindromize vertically
— Kamil Drakari
fonte
1

Stax , 18 bytes

â4+╤jo♂▐▀3bkWíæß╝╖

Execute e depure

Explicação:

9R$|[|<Va17T|]r|>\|pm Full program
9R$                   Produce "123456789"
   |[|<               Left-aligned prefixes (["1        ", "12       ", ...])
       Va17T          Produce "abcdefghi"
            |]        Suffixes (["abcdefghi", "bcdefghi", ...])
              r|>     Reverse and left-align (["        i", "       hi", ...])
                 \    Zip both arrays (["1                i", "12              hi", ...])
                  |p  Palindromize array
                    m Map over array, printing each with a newline
— wastl
fonte
1

APL (Dyalog Unicode) , 30 bytes

(⊢⍪1↓⊖)(↑,\1↓⎕d),⌽↑,\⌽819⌶9↑⎕a

Experimente online!

↑ converter em uma matriz (blocos automáticos com espaços)

  • ,\ os prefixos de

  • 1↓ o primeiro elemento caiu

  • ⎕d essa string '0123456789'

  • Isso fornece a matriz de caracteres

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, concatenado com

  • ⌽ o invertido

  • ↑ matrificado

  • ,\ prefixos de

  • ⌽ o invertido

  • 819⌶ e em minúsculas

  • 9↑ primeiros 9 elementos de

  • ⎕a essa string 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

  • Isso fornece a matriz de caracteres

        Eu
       Oi
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

e nesse resultado

1 i
12 oi
123 ghi
1234 fghi
12345 efghi
123456 defghi
1234567 cdefghi
12345678 bcdefghi
123456789abcdefghi

execute o seguinte trem (⊢⍪1↓⊖)

⊢ o argumento certo

⍪ concatenado verticalmente com

1↓ a primeira linha caiu (isso evita a repetição da linha do meio)

⊖ o argumento certo inverteu verticalmente

Outras soluções

33 bytes

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⎕ucs 106-q←⍳9

Experimente online!

33 bytes

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⌽⎕ucs 96+q←⍳9

Experimente online!

— Kritixi Lithos
fonte
1

Carvão , 22 17 bytes

Ｇ↗↓←⁹β←Ｇ↖↓⁹⭆χι‖Ｏ↓

Experimente online! Link é a versão detalhada do código. Explicação:

Ｇ↗↓←⁹β

Desenhe um triângulo inferior direito e preencha-o usando o alfabeto em minúsculas. (O preenchimento é baseado no ladrilho do avião com o alfabeto e, em seguida, na cópia da área desenhada.)

←

Mova para a esquerda para desenhar o triângulo numérico.

Ｇ↖↓⁹⭆χι

Desenhe um triângulo inferior esquerdo e preencha-o usando os dígitos. (Como o triângulo é desenhado à esquerda da origem, os dígitos são justificados à direita, para que apenas os dígitos de 1 a 9 sejam usados.)

‖Ｏ↓

Reflita para completar a metade inferior.

— Neil
fonte
1

V , 25 , 21 bytes

¬19¬ai8ñHÄ/á
r ge.YGp

Experimente online!

2-4 bytes salvos graças a nmjcman101!

Hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp
— DJMcMayhem
fonte
Sei que tudo o que estou fazendo é perseguir suas respostas hoje, mas acho que isso funciona para os 23: experimente on-line!
— nmjcman101
@ nmjcman101 Por qualquer motivo, não consigo entender como essa versão funciona. Mas eu descobri um ainda mais curto, então obrigado!
— DJMcMayhem
Foi no final de uma /\d*pesquisa #
— nmjcman101
1

J , 44 bytes

(m]\u:49+i.9),.(m=.,}.@|.)]\&.(|."1)u:97+i.9

Experimente online!

Tentei gerar numericamente uma máscara de 1 e zero para usar na indexação, mas o custo de se livrar da linha extra era alto e desisti:

   (9-.~i.18){0<:-/~(,|.)i.9
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
— Galen Ivanov
fonte
1

Japt, 24 bytes

Retorna uma matriz de linhas

9Æ´AçXÄ
c¡A°îYd#a
Vù y ê

Teste-o

Explicação

9Æ            :Map each X in the range [0,9)
  ´A          :  Prefix decrement A (initially 10)
    ç         :  Repeat
     XÄ       :  X+1
\n            :Assign to variable U
 ¡            :Map each element at index Y in U
  A°          :  Postfix increment A
    î         :  Repeat
      d       :  The character at codepoint
     Y #a     :  Y+97
c             :Concatenate with U
\n            :Assign to variable V
Vù            :Left pad each element in V to the length of the longest element
   y          :Transpose
     ê        :Palindromise

Alternativas

9õÈîZqÃú Ë+EòdEn#i)¬ù9Ãê

Teste-o

9ÇòdZn#i)cZòÄ)¬Ãú ®éJ´Ãê

Teste-o

— Shaggy
fonte
Estou pensando agora se a construção horizontal não pode ter levado a uma solução mais curta! : \
— Shaggy
1

QBasic , 87 bytes

Uma função anônima que não recebe entrada e saída para o console.

For y=-8To 8:z=Abs(y):a$="123456789abcdefghi":?Mid$(a$,1,9-z)Spc(2*z)Mid$(a$,10+z):Next

Esta resposta é tecnicamente poliglota e funcionará no VBA

— Taylor Scott
fonte
1

Befunge-93 , 314 bytes

<p0+3*67p0+4*77p0+3*77p0-7*88p0-6*88"#v#v>"
"i        "11g1-21p56+1g1+56+1p28*1g1+28*1p  ^       >25*
"        1"92g1+82p56+2g1-56+2p28*2g1-28*2p91g00g`#v_^   >
"ihgfedcba "93p26*3g1-26*3p">^"88*7-0p88*7-4pv     >25*
"987654321 "14p26*4g1+26*4p26*4g12g`#v_            ^
                             >:#,_@#:<

Experimente online!

Golfou 6 bytes colocando um >com a pinstrução

— ItsJ0el
fonte
1

Matlab, 122 bytes

function[r]=f,s=[49:57,'a':'i'];r=[];for i=1:9,r=[r;s(1:i),repmat(' ',[1,18-2*i]),s(19-i:18)];end,r=[r;flip(r(1:8,:))];end

Experimente Online!

— DimChtz
fonte
1

PowerShell 5.1, 70 69 64 57 bytes

Obrigado Mazzy por -7 bytes

1..9+8..1|%{-join(1..$_+'  '*(9-$_)+' ihgfedcba'[$_..1])}

Acontece que colá-lo manualmente salva um byte. Tornar tudo isso uma mega-junção também economiza mais 5. Também funciona transformando um intervalo de ints em um char [] para obter o ai. Usar um intervalo acima das letras reais é 5 bytes melhor.

— Veskah
fonte
1
tente o seguinte: 1..9+8..1|%{-join(1..$_+' '*(9-$_)+' ihgfedcba'[$_..1])}. Nota' '*(9-$_) contém 2 símbolos de espaço
— mazzy
1
@mazzy ooof, faltando esse truque de espaço duplo. Eu estava pensando em uma variedade de afirmações matemáticas, mas a solução óbvia nunca me ocorreu.
— Veskah 5/09/19
1

C (gcc) ,143 142 127 + 10 = 137 136 + 10 = 146 (sinalizadores do compilador) bytes

-1 byte substituindo OR lógico por operador bit a bit.

-5 bytes graças ao Logern.

+9 bytes para corrigir a linha mediana, que foi emitida duas vezes.

char*s="123456789abcdefghi";G{for(;j<18;++j)putchar(i>j|j>17-i?s[j]:32);puts("");}f(){int i=0,j=0;for(;i++<8;)G;g(i+1,j);for(;i-->1;)G;}

Sinalizador do compilador:

-DG=g(i,j)

Essa macro fatora as ocorrências de g(i,j): declaração de função e chamadas.

Experimente online!

Abordagem diferente da grande resposta de Pietu1998 mais direta (e legível), mas mais alta.

Ponto de entrada é função f(); funçãog() lida com a impressão de cada linha consecutiva.

Pode ser feito um programa completo renomeando fparamain , mas ainda assim aumentaria a pontuação.

Versão bonita, macro Gexpandida:

char *s = "123456789abcdefghi";
int g(int i, int j) {
    for(; j < 18; ++j)
        putchar((i > j | j > 17 - i) ? s[j] : 32);
    puts(""); // Break the line -- shorter than putchar(10) or printf("\n")
}
int f() {
    int i = 0, j = 0; // j is constant, declared here to not have to declare and init it inside g()
    for(; i++ < 8;) // Upper half of the tie
        g(i, j);
    g(i + 1, j); // Median line
    for(; i-- > 1;) // Lower half; --i > 0 would also work for the condition
        g(i, j);
}
— joH1
fonte
— Logern
137 mas +10 para as bandeiras de compilador embora
— joH1
137 é o total, 127 bytes de código e 10 bytes de sinalizadores do compilador.
— Logern
Opa, desculpe, meu mal. Atualizando agora!
— joH1 25/09/18
@ Logern Tomei a liberdade de renomear a macro Gpara corresponder ao nome da função.
— JoH1
0

VBA, 75 bytes

Uma função de janela imediata anônima do VBE que não recebe entrada nem saída no console.

For y=-8To 8:z=Abs(y):a="123456789abcdefghi":Mid(a,10-z)=Space(2*z):?a:Next
— Taylor Scott
fonte
0

Geléia , 22 21 bytes

9R€z⁶Zµạ106Ọ$Ṡ¡€Uṭ)ŒḄ

Experimente online!

Baseia-se no comportamento (não provável) não intencional de que, quando Ṡ(sinal) age em um personagem, ele gera o Python None. Por causa disso, Ṡé uma verificação de um byte para saber se o argumento é um número inteiro diferente de zero, uma vez que Noneé falsey no Python. Se esse comportamento for alterado, também OƑfuncionará para mais um byte.

Função que retorna uma lista de linhas.

— dylnan
fonte
0

Python 2 , 97 94 bytes

i=o="123456789abcdefghi";c=8
while c:i=i[:c]+' '*(9-c)*2+i[-c:];o=i+'\n'+o+'\n'+i;c-=1
print o

Experimente online!

Somente postado como uma alternativa ao uso eval()e porque finalmente cheguei abaixo de 100. Basicamente, começa com a linha do meio e depois trabalha para cima e para baixo ao mesmo tempo.

— ElPedro
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.