Papillon alfanumerico

14

Stampa questo testo esatto:

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

È accettabile una singola riga finale finale, ma non sono consentite altre modifiche alla formattazione.

Regole e I / O

  • Nessun input
  • L'output può essere fornito con qualsiasi metodo conveniente .
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Sono vietate le scappatoie standard .
  • Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).
code-golf  kolmogorov-complexity 
— AdmBorkBork
fonte
1
Possiamo usare invece l'alfabeto maiuscolo?
— Kritixi Lithos,
3
@Cowsquack Sarebbe un cambio di regola. Dice Output questo testo esatto .
— Dennis,
@Cowsquack No: è richiesta la minuscola.
— AdmBorkBork,

Risposte:

13

C, 87 85 81 80 byte

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

Provalo online!

Spiegazione

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
Sono stupito che ^abbia una precedenza inferiore rispetto a <... che bella risposta!
— Lynn,
@Lynn Gli operatori bit a bit in C (e persino Java / JS e simili) hanno tutti una precedenza inferiore rispetto ai confronti. Questo è bello sia per il golf del codice che una fonte di errori davvero piacevole (si pensi if (x & 2 == 0), che valuta sempre 0)
— PurkkaKoodari,
6

R , 64 byte

for(i in abs(8:-8))cat(intToUtf8(c(57-8:i,32*!!-i:i,97+i:8,13)))

Provalo online!

  • -3 byte grazie a @Giuseppe
  • -5 byte grazie a @ J.Doe
— digEmAll
fonte
67 byte conintToUtf8
— J.Doe
catper un byte?
— JayCe,
2
64 byte sulla base della tua soluzione, usando la scorciatoia di @ Giuseppe per repaggiungere la funzione intToUtf8che a 0si trasforma in a "".
— J.Doe,
@J.Doe grande trucco!
— JayCe
@J.Doe: fantastico, grazie!
— digEmAll
3

QBasic, 72 byte

Sulla base della presentazione di Taylor Scott .

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

Spiegazione di base

Su ogni riga, stampiamo la stringa completa 123456789abcdefghi. Quindi torniamo indietro e ne sovrascriviamo una parte con degli spazi.

Spiegazione completa

Con codice leggermente non golfato:

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
È un uso davvero intelligente del Locatecomando
— Taylor Scott,
2

T-SQL, 108 byte

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

I ritorni sono solo per leggibilità.

Ho provato molte altre varianti, comprese le tabelle dei numeri, questa è stata la più breve.

— BradC
fonte
2

Japt , 20 byte

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

Interprete Japt

Output come una matrice di matrici di caratteri. Il -Rflag non è necessario per funzionare, ma rende l'output più gradevole.

Spiegazione:

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 byte

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

Esegui ed esegui il debug

Spiegazione:

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 byte

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

Provalo online!

↑ convertire in una matrice (pad automatici con spazi)

  • ,\ i prefissi di

  • 1↓ il primo elemento è caduto da

  • ⎕d questa stringa '0123456789'

  • Questo dà la matrice del personaggio

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, concatenato con

  • ⌽ l'inverso

  • ↑ matrixified

  • ,\ prefissi di

  • ⌽ l'inverso

  • 819⌶ e in minuscolo

  • 9↑ primi 9 elementi di

  • ⎕a questa stringa 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

  • Questo dà la matrice del personaggio

        io
       Ciao
      ghi
     FGHI
    efghi
   DEFGHI
  cdefghi
 bcdefghi
abcdefghi

e su questo risultato

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

eseguire il seguente treno (⊢⍪1↓⊖)

⊢ l'argomento giusto

⍪ concatenato verticalmente con

1↓ la prima riga è caduta da (questo evita la ripetizione della riga centrale)

⊖ l'argomentazione giusta si è invertita verticalmente

Altre soluzioni

33 byte

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

Provalo online!

33 byte

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

Provalo online!

— Kritixi Lithos
fonte
1

Carbone , 22 17 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｇ↗↓←⁹β

Disegna un triangolo in basso a destra e riempilo usando l'alfabeto minuscolo. (Il riempimento si basa sulla piastrellatura del piano con l'alfabeto e quindi sulla copia dell'area disegnata.)

←

Spostati a sinistra per disegnare il triangolo numerico.

Ｇ↖↓⁹⭆χι

Disegna un triangolo in basso a sinistra e riempilo usando le cifre. (Poiché il triangolo è disegnato a sinistra dell'origine, le cifre sono prese giustificate a destra, quindi vengono utilizzate solo le cifre da 1 a 9).

‖Ｏ↓

Rifletti per completare la metà inferiore.

— Neil
fonte
1

V , 25 , 21 byte

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

Provalo online!

2-4 byte salvati grazie a nmjcman101!

hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp
— Giacomo
fonte
So che tutto ciò che sto facendo è cercare le tue risposte oggi, ma penso che questo funzioni
— nmjcman101,
@ nmjcman101 Per qualsiasi motivo, non riesco a capire come funzioni quella versione. Ma ne ho trovato uno ancora più corto, quindi grazie!
— James,
Andò alla fine di una /\d*ricerca
— nmjcman101,
1

J , 44 byte

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

Provalo online!

Ho provato a generare numericamente una maschera di 1 e zero da utilizzare per l'indicizzazione, ma il costo per sbarazzarsi della riga aggiuntiva era alto e ho rinunciato:

   (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 byte

Restituisce una matrice di linee

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

Provalo

Spiegazione

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

alternative

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

Provalo

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

Provalo

— ispido
fonte
Mi chiedo ora se costruire questo in orizzontale potrebbe non aver portato a una soluzione più breve! : \
— Shaggy,
1

QBasic , 87 byte

Una funzione anonima che non accetta input e output sulla console.

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

Questa risposta è tecnicamente un poliglotta e funzionerà in VBA

— Taylor Scott
fonte
1

Befunge-93 , 314 308 byte

<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_            ^
                             >:#,_@#:<

Provalo online!

Golfato 6 byte inserendo a >con l' pistruzione

— ItsJ0el
fonte
1

Matlab, 122 byte

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

Provalo online!

— DimChtz
fonte
1

PowerShell 5.1, 70 69 64 57 byte

Grazie Mazzy per -7 byte

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

Si scopre incollandolo insieme salva manualmente un byte. Facendo tutto con un mega-join risparmi anche altri 5. Funziona anche trasformando una gamma di ints in un carattere [] per ottenere l'IA. L'uso di un intervallo superiore alle lettere effettive è migliore di 5 byte.

— Veskah
fonte
1
provare questo: 1..9+8..1|%{-join(1..$_+' '*(9-$_)+' ihgfedcba'[$_..1])}. La nota ' '*(9-$_)contiene 2 simboli spaziali
— mazzy,
1
@mazzy ooof, manca quel doppio trucco spaziale. Stavo pensando a una varietà di affermazioni matematiche ma la soluzione ovvia non mi è mai venuta in mente.
— Veskah,
1

C (gcc) ,143 142 127 + 10 = 137 136 + 10 = 146 (flag del compilatore) byte

-1 byte sostituendo OR logico con operatore bit a bit.

-5 byte grazie a Logern.

+9 byte per correggere la linea mediana, che è stata emessa due volte.

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

Flag del compilatore:

-DG=g(i,j)

Questa macro fattorizza le occorrenze di g(i,j): dichiarazione di funzione e chiamate.

Provalo online!

Approccio diverso rispetto alla grande risposta di Pietu1998 , più semplice (e leggibile), ma punteggio più alto.

Il punto di ingresso è funzione f(); la funzione g()gestisce la stampa di ogni riga consecutiva.

Potrebbe essere creato un programma completo rinominandolo finmain , ma aumenterebbe comunque il punteggio.

Versione carina, macro Gespansa:

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 ma +10 per le bandiere del compilatore
— joH1
137 è il totale, 127 byte di codice e 10 byte di flag del compilatore.
— Logern,
Oops mi dispiace, mia cattiva. Aggiornamento ora!
— joH1
@Logern Ho preso la libertà di rinominare la macro G, in modo che corrisponda al nome della funzione.
— joH1
0

VBA, 75 byte

Una funzione finestra immediata VBE anonima che non accetta input e output sulla console.

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

Gelatina , 22 21 byte

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

Provalo online!

Si basa sul comportamento (probabile) non intenzionale che quando Ṡ(segno) agisce su un personaggio produce Python None. Per questo motivo , Ṡè un controllo a un byte per verificare se l'argomento è un numero intero Nonediverso da zero poiché è falso in Python. Se questo comportamento viene modificato, OƑfunziona anche per un altro byte.

Funzione che restituisce un elenco di righe.

— dylnan
fonte
0

Python 2 , 97 94 byte

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

Provalo online!

Inserito solo come alternativa all'utilizzo eval()e perché finalmente l'ho ottenuto con meno di 100. Fondamentalmente inizia con la riga centrale, quindi funziona sia su che giù allo stesso tempo.

— ElPedro
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.