Pajarita alfa-numérica

14

Salida de este texto exacto:

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

Una nueva línea final es aceptable, pero no se permiten otros cambios de formato.

Reglas y E / S

  • Sin entrada
  • La salida se puede dar por cualquier método conveniente .
  • Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
  • Las lagunas estándar están prohibidas.
  • Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).
code-golf  kolmogorov-complexity 
— AdmBorkBork
fuente
1
¿Podemos usar el alfabeto en mayúsculas en su lugar?
— Kritixi Lithos
3
@Cowsquack Eso sería un cambio de regla. Dice Salida este texto exacto .
— Dennis
@Cowsquack Nope: se requiere minúscula.
— AdmBorkBork

Respuestas:

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

Pruébalo en línea!

Explicación

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
fuente
Me sorprende que ^tenga menos prioridad que <... ¡qué bonita respuesta!
— Lynn
@Lynn Los operadores bit a bit en C (e incluso Java / JS y demás) tienen una prioridad más baja que las comparaciones. Esto es bueno para el golf de código y una muy buena fuente de errores (piense if (x & 2 == 0), que siempre se evalúa 0)
— PurkkaKoodari
3

QBasic, 72 bytes

Basado en la presentación de Taylor Scott .

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

Explicación básica

En cada línea, imprimimos la cadena completa 123456789abcdefghi. Entonces nos volvemos y parte de sobreescritura de la misma con espacios.

Explicación completa

Con un código ligeramente sin golf:

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
fuente
Ese es un uso realmente inteligente del Locatecomando
— Taylor Scott el
2

T-SQL, 108 bytes

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

Las devoluciones son solo para legibilidad.

Intenté muchas otras variaciones, incluidas las tablas de números, esta fue la más corta.

— BradC
fuente
2

Japt , 20 bytes

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

Intérprete Japt

Salida como una matriz de matrices de caracteres. El -Rindicador no es necesario para funcionar, solo hace que la salida se vea mejor.

Explicación:

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

Stax , 18 bytes

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

Ejecutar y depurarlo

Explicación:

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

APL (Dyalog Unicode) , 30 bytes

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

Pruébalo en línea!

↑ convertir a una matriz (auto pads con espacios)

  • ,\ los prefijos de

  • 1↓ el primer elemento cayó de

  • ⎕d esta cuerda '0123456789'

  • Esto le da a la matriz de caracteres

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, concatenado con

  • ⌽ el reverso

  • ↑ matriz

  • ,\ prefijos de

  • ⌽ el reverso

  • 819⌶ y en minúsculas

  • 9↑ primeros 9 elementos de

  • ⎕a esta cuerda 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

  • Esto le da a la matriz de caracteres

        yo
       Hola
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

y sobre este resultado

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

realiza el siguiente tren (⊢⍪1↓⊖)

⊢ el argumento correcto

⍪ concatenados verticalmente con

1↓ la primera fila cayó (esto evita la repetición de la fila del medio)

⊖ el argumento correcto invertido verticalmente

Otras soluciones

33 bytes

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

Pruébalo en línea!

33 bytes

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

Pruébalo en línea!

— Kritixi Lithos
fuente
1

Carbón , 22 17 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｇ↗↓←⁹β

Dibuja un triángulo rectángulo inferior y llénalo usando el alfabeto en minúsculas. (El relleno se basa en colocar el plano en mosaico con el alfabeto y luego copiar el área dibujada).

←

Mover a la izquierda para dibujar el triángulo numérico.

Ｇ↖↓⁹⭆χι

Dibuja un triángulo inferior izquierdo y llénalo con los dígitos. (Dado que el triángulo se dibuja a la izquierda del origen, los dígitos se toman justificados a la derecha, por lo que solo se utilizan los dígitos 1 a 9).

‖Ｏ↓

Reflexiona para completar la mitad inferior.

— Neil
fuente
1

V , 25 , 21 bytes

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

Pruébalo en línea!

¡2-4 bytes guardados gracias a nmjcman101!

Hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp
— DJMcMayhem
fuente
Sé que todo lo que estoy haciendo es acechar tus respuestas hoy, pero creo que esto funciona para el 23: ¡ Pruébalo en línea!
— nmjcman101
@ nmjcman101 Por alguna razón, no puedo comprender cómo funciona esa versión. Pero descubrí uno aún más corto, ¡así que gracias!
— DJMcMayhem
Fue al final de una /\d*búsqueda
— nmjcman101
1

J , 44 bytes

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

Pruébalo en línea!

Traté de generar numéricamente una máscara de 1 y cero para usar para la indexación, pero el costo de deshacerme de la fila adicional era alto y me di por vencido:

   (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
fuente
1

Japt, 24 bytes

Devuelve una matriz de líneas.

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

Pruébalo

Explicación

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Ãê

Pruébalo

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

Pruébalo

— Lanudo
fuente
¡Ahora me pregunto si construir esto horizontalmente podría no haber llevado a una solución más corta! : \
— Shaggy
1

QBasic , 87 bytes

Una función anónima que no lleva entradas y salidas a la consola.

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

Esta respuesta es técnicamente un políglota y funcionará en VBA

— Taylor Scott
fuente
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_            ^
                             >:#,_@#:<

Pruébalo en línea!

Golfó 6 bytes colocando un >con la pinstrucción

— ItsJ0el
fuente
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

Pruébalo en línea!

— DimChtz
fuente
1

PowerShell 5.1, 70 69 64 57 Bytes

Gracias Mazzy por -7 bytes

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

Resulta que pegarlo manualmente guarda un byte. Hacerlo todo una megaunión también ahorra 5 más. También funciona convirtiendo un rango de entradas en un carácter [] para obtener el ai. Usar un rango sobre las letras reales es 5 bytes mejor.

— Veskah
fuente
1
intente lo siguiente: 1..9+8..1|%{-join(1..$_+' '*(9-$_)+' ihgfedcba'[$_..1])}. La nota ' '*(9-$_)contiene 2 símbolos espaciales
— mazzy el
1
@mazzy ooof, falta ese truco de doble espacio. Estaba pensando en una variedad de enunciados matemáticos, pero la solución obvia nunca se me ocurrió.
— Veskah
1

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

-1 byte reemplazando OR lógico con operador bit a bit.

-5 bytes gracias a Logern.

+9 bytes para arreglar la línea media, que se emitió dos veces.

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

Indicador del compilador:

-DG=g(i,j)

Esta macro factoriza las ocurrencias de g(i,j): declaración de función y llamadas.

Pruébalo en línea!

Enfoque diferente a la gran respuesta de Pietu1998 , más directo (y legible), pero con mayor puntaje.

El punto de entrada es función f(); funcióng() maneja la impresión de cada línea consecutiva.

Podría hacerse un programa completo renombrándolo famain , pero aún así aumentaría la puntuación.

Versión 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
fuente
— Logern
137 pero +10 para los indicadores del compilador aunque
— joH1
137 es el total, 127 bytes de código y 10 bytes de banderas compiladoras.
— Logern
Ups lo siento, mi mal. Actualizando ahora!
— joH1
@Logern Me tomé la libertad de cambiar el nombre de la macro para Gque coincida con el nombre de la función.
— joH1
0

VBA, 75 bytes

Una función de ventana inmediata anónima de VBE que no lleva entradas ni salidas a la consola.

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

Jalea , 22 21 bytes

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

Pruébalo en línea!

Se basa en el (no probable) comportamiento involuntario que cuando Ṡ(signo) actúa sobre un personaje produce el de Python None. Debido a esto, Ṡes una comprobación de un byte para ver si su argumento es un entero distinto de cero ya que Nonees falsey en Python. Si este comportamiento cambia, entoncesOƑ funciona igual para un byte más.

Función que devuelve una lista de líneas.

— dylnan
fuente
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

Pruébalo en línea!

Solo se publicó como una alternativa al uso eval()y porque finalmente lo obtuve por debajo de 100. Básicamente comienza con la fila del medio y luego funciona hacia arriba y hacia abajo al mismo tiempo.

— ElPedro
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.