Noeud papillon alphanumérique

14

Sortez ce texte exact:

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

Une seule nouvelle ligne de fin est acceptable, mais aucune autre modification de mise en forme n'est autorisée.

Règles et E / S

  • Pas d'entrée
  • La sortie peut être donnée par n'importe quelle méthode pratique .
  • Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
  • Les failles standard sont interdites.
  • Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.
code-golf  kolmogorov-complexity 
— AdmBorkBork
source
1
Pouvons-nous utiliser l'alphabet majuscule à la place?
— Kritixi Lithos
3
@Cowsquack Ce serait un changement de règle. Il indique Sortie ce texte exact .
— Dennis
@Cowsquack Nope - en minuscules est requis.
— AdmBorkBork

Réponses:

13

C, 87 85 81 80 octets

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

Essayez-le en ligne!

Explication

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
source
Je suis étonné d' ^avoir une priorité inférieure à <… quelle jolie réponse!
— Lynn
@Lynn Les opérateurs au niveau du bit en C (et même Java / JS et autres) ont tous une priorité inférieure aux comparaisons. C'est à la fois agréable pour le golf de code et une très bonne source d'erreurs (pensez if (x & 2 == 0), qui évalue toujours 0)
— PurkkaKoodari
3

QBasic, 72 octets

Basé sur la soumission de Taylor Scott .

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

Explication de base

Sur chaque ligne, nous imprimons la chaîne complète 123456789abcdefghi. Ensuite, nous revenons et en écraser une partie avec des espaces.

Explication complète

Avec un code légèrement non 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
source
C'est une utilisation vraiment intelligente de la Locatecommande
— Taylor Scott
2

T-SQL, 108 octets

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

Les retours sont uniquement pour la lisibilité.

J'ai essayé beaucoup d'autres variantes, y compris des tableaux de nombres, c'était la plus courte.

— BradC
source
2

Japt , 20 octets

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

Interprète Japt

Sortie sous forme de tableau de tableaux de caractères. Le -Rdrapeau n'est pas nécessaire pour fonctionner, il rend simplement la sortie plus agréable.

Explication:

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

Stax , 18 octets

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

Exécuter et déboguer

Explication:

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

APL (Dyalog Unicode) , 30 octets

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

Essayez-le en ligne!

↑ convertir en matrice (pads automatiques avec espaces)

  • ,\ les préfixes de

  • 1↓ le premier élément est tombé de

  • ⎕d cette chaîne '0123456789'

  • Cela donne la matrice de caractères

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, concaténé avec

  • ⌽ l'inverse

  • ↑ matricifié

  • ,\ préfixes de

  • ⌽ l'inverse

  • 819⌶ et en minuscules

  • 9↑ 9 premiers éléments de

  • ⎕a cette chaîne 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

  • Cela donne la matrice de caractères

        je
       salut
      ghi
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

et sur ce résultat

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

effectuer le train suivant (⊢⍪1↓⊖)

⊢ le bon argument

⍪ concaténé verticalement avec

1↓ la première ligne a été supprimée (cela évite la répétition de la ligne du milieu)

⊖ le bon argument inversé verticalement

Autres solutions

33 octets

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

Essayez-le en ligne!

33 octets

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

Essayez-le en ligne!

— Kritixi Lithos
source
1

Fusain , 22 17 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｇ↗↓←⁹β

Dessinez un triangle inférieur droit et remplissez-le à l'aide de l'alphabet minuscule. (Le remplissage est basé sur la mosaïque du plan avec l'alphabet, puis sur la copie de la zone dessinée.)

←

Déplacez-vous vers la gauche pour dessiner le triangle numérique.

Ｇ↖↓⁹⭆χι

Tracez un triangle inférieur gauche et remplissez-le à l'aide des chiffres. (Étant donné que le triangle est dessiné à gauche de l'origine, les chiffres sont pris justifiés à droite, donc seuls les chiffres 1 à 9 sont utilisés.)

‖Ｏ↓

Réfléchissez pour terminer la moitié inférieure.

— Neil
source
1

V , 25 , 21 octets

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

Essayez-le en ligne!

2-4 octets enregistrés grâce à nmjcman101!

Hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp
— James
source
Je sais que tout ce que je fais, c'est traquer vos réponses aujourd'hui, mais je pense que cela fonctionne pour 23: Essayez-le en ligne!
— nmjcman101
@ nmjcman101 Pour une raison quelconque, je ne peux pas comprendre comment cette version fonctionne. Mais j'en ai trouvé une encore plus courte, alors merci!
— James
Il est allé à la fin d'une /\d*recherche
— nmjcman101
1

J , 44 octets

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

Essayez-le en ligne!

J'ai essayé de générer numériquement un masque de 1 et zéro à utiliser pour l'indexation, mais le coût de se débarrasser de la ligne supplémentaire était élevé et j'ai abandonné:

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

Japt, 24 octets

Renvoie un tableau de lignes

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

Essaye-le

Explication

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

Alternatives

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

Essaye-le

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

Essaye-le

— Hirsute
source
Je me demande maintenant si la construction horizontale n'aurait pas pu conduire à une solution plus courte! : \
— Shaggy
1

QBasic , 87 octets

Une fonction anonyme qui ne prend aucune entrée et sortie sur la console.

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

Cette réponse est techniquement un polyglotte, et fonctionnera en VBA

— Taylor Scott
source
1

Befunge-93 , 314 308 octets

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

Essayez-le en ligne!

Golfé 6 octets en plaçant un >avec l' pinstruction

— ItsJ0el
source
1

Matlab, 122 octets

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

Essayez-le en ligne!

— DimChtz
source
1

PowerShell 5.1, 70 69 64 57 octets

Merci Mazzy pour -7 octets

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

Il s'avère que le coller ensemble enregistre manuellement un octet. En faisant tout cela une méga-jointure, vous économisez également 5 autres. Fonctionne également en transformant une plage d'ints en char [] pour obtenir l'IA. Utiliser une plage sur les lettres réelles est de 5 octets de mieux.

— Veskah
source
1
essayez ceci: 1..9+8..1|%{-join(1..$_+' '*(9-$_)+' ihgfedcba'[$_..1])}. La note ' '*(9-$_)contient 2 symboles d'espace
— mazzy
1
@mazzy ooof, il manque cette double astuce spatiale. Je pensais à une variété d'énoncés mathématiques, mais la solution évidente ne m'est jamais venue à l'esprit.
— Veskah
1

C (gcc) ,143 142 127 + 10 = 137 136 + 10 = 146 (drapeaux du compilateur) octets

-1 octet en remplaçant OU logique par opérateur au niveau du bit.

-5 octets grâce à Logern.

+9 octets pour corriger la ligne médiane, qui a été sortie deux fois.

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

Drapeau du compilateur:

-DG=g(i,j)

Cette macro factorise les occurrences de g(i,j): déclaration de fonction et appels.

Essayez-le en ligne!

Approche différente de la grande réponse de Pietu1998, score plus simple (et lisible), mais plus élevé.

Le point d'entrée est fonction f(); La fonction g()gère l'impression de chaque ligne consécutive.

Faisable un programme complet en renommant fàmain , mais il augmenterait encore le score.

Jolie version, macro Gdéveloppée:

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
source
— Logern
137 mais +10 pour les drapeaux du compilateur
— joH1
137 est le total, 127 octets de code et 10 octets d'indicateurs de compilation.
— Logern
Oups désolé, ma mauvaise. Mise à jour maintenant!
— joH1
@Logern J'ai pris la liberté de renommer la macro Gpour correspondre au nom de la fonction.
— joH1
0

VBA, 75 octets

Une fonction de fenêtre immédiate VBE anonyme qui ne prend aucune entrée et sortie sur la console.

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

Gelée , 22 21 octets

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

Essayez-le en ligne!

S'appuie sur le comportement involontaire (probable) selon lequel lorsque Ṡ(signe) agit sur un personnage, il produit Python None. Pour cette raison, Ṡest une vérification d'un octet pour savoir si son argument est un entier différent de zéro puisqueNone Falsey est en Python. Si ce comportement est modifié, cela OƑfonctionne également pour un octet de plus.

Fonction qui renvoie une liste de lignes.

— dylnan
source
0

Python 2 , 97 94 octets

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

Essayez-le en ligne!

Publié uniquement comme alternative à l'utilisation eval()et parce que je l'ai finalement obtenu en dessous de 100. Commence essentiellement par la rangée du milieu, puis monte et descend en même temps.

— ElPedro
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.