Vous devez construire des pylônes ASCII!

24

Croix postée depuis mon post anagolf (note: peut contenir des spoilers, post mortem).

Sortez exactement le texte suivant.

  • Vous pouvez avoir des espaces de fin supplémentaires sur chaque ligne, ainsi que des retours à la ligne de fin.
  • Le code le plus court, en octets, gagne.
                                                
                                              !"!
                                             "#$#"
                                            #$%&%$#
                                           $%&'('&%$
                                          %&'()*)('&%
                                         &'()*+,+*)('&
                                        '()*+,-.-,+*)('
                                       ()*+,-./0/.-,+*)(
                                      )*+,-./01210/.-,+*)
                                     *+,-./012343210/.-,+*
                                    +,-./0123456543210/.-,+
                                   ,-./01234567876543210/.-,
                                  -./0123456789:9876543210/.-
                                 ./0123456789:;<;:9876543210/.
                                /0123456789:;<=>=<;:9876543210/
                               0123456789:;<=>?@?>=<;:9876543210
                              123456789:;<=>?@ABA@?>=<;:987654321
                             23456789:;<=>?@ABCDCBA@?>=<;:98765432
                            3456789:;<=>?@ABCDEFEDCBA@?>=<;:9876543
                           456789:;<=>?@ABCDEFGHGFEDCBA@?>=<;:987654
                          56789:;<=>?@ABCDEFGHIJIHGFEDCBA@?>=<;:98765
                         6789:;<=>?@ABCDEFGHIJKLKJIHGFEDCBA@?>=<;:9876
                        789:;<=>?@ABCDEFGHIJKLMNMLKJIHGFEDCBA@?>=<;:987
                       89:;<=>?@ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA@?>=<;:98
                      9:;<=>?@ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA@?>=<;:9
                     :;<=>?@ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA@?>=<;:
                    ;<=>?@ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA@?>=<;
                   <=>?@ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA@?>=<
                  =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA@?>=
                 >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>
                ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?
               @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@
              ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA
             BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCB
            CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDC
           DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFED
          EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFE
         FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGF
        GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHG
       HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIH
      IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJI
     JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJ
    KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLK
   LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONML
  MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONM
 NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPON
OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPO
code-golf  string  kolmogorov-complexity 
— Conor O'Brien
source
3
Existe-t-il une première ligne intentionnelle réservée aux espaces blancs?
— AdmBorkBork
9
@AdmBorkBork c'est un espace parce que c'est le premier caractère ASCII lol
— HyperNeutrino
2
@ the4kman et le <=>=<poisson.
— pizzapants184
4
Y a-t-il une raison pour laquelle ceci n'est pas intitulé "Vous devez construire des pylônes ASCII!"?
— mattdm
3
@mattdm Je ne suis venu ici que de la liste HNQ pour voter en raison de son titre. Bien fait.
— Todd Wilcox

Réponses:

4

Toile , 15 14 octets

0ｃ［Ｃ²［ｊ｝¹ｍ］／││

Essayez-le ici!

Notez qu'en faisant cela, j'ai ajouté quelques intégrés ( ｃ& Ｃ) car Canvas n'avait en quelque sorte aucune intégration pour ASCII / unicode auparavant ...

Explication (certains caractères ont été remplacés pour paraître monospaces):

0c              push the charcode of "0" - 48
  {       ]     map over 1..48
   C              push the ASCII characters
    ²[ ]          repeat by the counter (0-indexed)
      j             remove the last character
        ¹m        mold to the length of the counter
           /    pad each line with spaces so it looks like a diagonal
            ││  palindromize the whole thing horizontally
— dzaima
source
16

PowerShell , 73 octets

' '*48;46..0|%{" "*$_+-join[char[]](($x=79-$_)..($y=$x+$j++)+(++$y)..$x)}

Essayez-le en ligne!

Génère la première ligne d'espace blanc uniquement, puis passe de 46à 0. Chaque itération génère le nombre d'espaces correspondant, puis un -joinensemble de chartableaux des symboles appropriés, via certains calculs.

— AdmBorkBork
source
1
Pouvez-vous enregistrer certains calculs en traitant la première ligne comme 47 espaces suivis d'un caractère espace?
— Riking
@Riking Pour ce faire, vous aurez besoin d'un cas particulier de création du tableau de caractères pour créer un seul élément au lieu de 3 ou plus. Par conséquent, la ligne réservée aux espaces est plus courte que dans le cas spécial complètement séparément.
— AdmBorkBork
11

Fusain , 13 octets

Ｅ⁴⁸⮌✂γι⊕⊗ι‖Ｏ←

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

 ⁴⁸             Literal 48
Ｅ               Map over implicit range
      ι  ι      Current index
        ⊗       Doubled
       ⊕        Incremented
     γ          Printable ASCII
    ✂           Slice
   ⮌            Reverse
                Implicitly print each slice on separate lines
          ‖Ｏ←   Reflect with overlap
— Neil
source
5
La sortie me semble fausse.
— M. Xcoder
1
@ Mr.Xcoder Ugh, erreur off-by-1 classique ...
— Neil
8

Python 2 , 73 octets

i=48
while i:i-=1;r=range(79-i,127-i*2);print' '*i+bytearray(r+r[-2::-1])

Essayez-le en ligne! Crossposted from anarchy golf (voir ma soumission ).

Analyse post-mortem rapide: xnor et dianne ont découvert exactement la même solution . ebicochneal a soumis une solution de 71 octets qui a été améliorée à 70 octets . Ils évitent de traiter bytearray(ce qui est long) ou ''.join(map(chr,…))(ce qui est encore plus long) entièrement, en gardant une variable "ligne courante" et en la mettant intelligemment à jour.

— Lynn
source
4

Lisp commun , 110 octets

(dotimes(i 48)(dotimes(j 96)(princ(if(>(abs(- j 48))i)" "(code-char(+(-(* i 2)(abs(- j 48)))32)))))(princ"
"))

Essayez-le en ligne!

Explication

(dotimes(i 48)                   ;; for i from 0 up to 47
    (dotimes(j 96)               ;; for j from 0 up to 95
        (princ                   ;; print
            (if(>(abs(- j 48))i) ;; if abs(j - 48) > i
                " "              ;; print " "
                (code-char(+(-(* i 2)(abs(- j 48)))32)) ;; else print appropriate character
            )
        )
    )(princ"
") ;; print newline
)
— ASCII uniquement
source
3

VBA, 71 octets

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

For i=0To 47:?Spc(47-i);:For j=-i To i:?Chr(32-Abs(j)+2*i);:Next:?:Next
— Taylor Scott
source
3

Ruby , 70 octets

s=[*?\s..?~]*'';48.times{|i|puts s[i,i+1].rjust(48)+s.reverse[-2*i,i]}

Essayez-le en ligne!

Construit la chaîne ASCII imprimable complète, puis imprime le nombre requis de tranches avant (remplies d'espaces) + arrière.

— Kirill L.
source
2

C (gcc), 117 octets

c;i;main(){for(i=0;i<48;++i){for(c=2*i-15;c<32+2*i;++c)putchar(c>31+i?c:32);for(;c>31+i;--c)putchar(c);putchar(10);}}

Essayez-le en ligne!

Non golfé:

int ch;
int row;
int main(void) {
    for (row = 0; row < 48; ++row) {
        for (ch = 2*row-15; ch < 32 + 2*row; ++ch) {
            // The first character in the row is 2*row - 15 (row is zero-indexed)
            if (ch > 31+row)
                putchar(ch);
            else
                // If the current character is not in the pyramid, mask it with a space
                putchar(' ');
        }
        for (; ch > 31+row; --ch) {
            // Finish the other side of the pyramid
            putchar(ch);
        }
        putchar('\n');
    }
}
— pizzapants184
source
— plafondcat
2

T-SQL, 153 octets

DECLARE @ INT=33,@t CHAR(95)=''a:PRINT @t;
SET @t=LEFT(STUFF(STUFF(@t,63-@/2,2,''),46,0,CHAR(@-1)+CHAR(@)+CHAR(@+1)+CHAR(@)),33+@/2)
SET @+=2IF @<128GOTO a

Les retours sont pour l'affichage uniquement.

J'ai essayé plusieurs idées, dont une boucle pour préconstruire la chaîne complète (163 caractères) et une boucle imbriquée pour la construire à la volée (168 caractères), mais cela a fini par être le plus court.

Fondamentalement, à chaque boucle, j'entasse 4 nouveaux caractères au centre de la chaîne, puis je supprime les extras des deux extrémités, en utilisant la fonction SQLSTUFF() .

Formaté et expliqué:

DECLARE @ INT=33,                      --Using a single counter for both rows and CHAR
        @t CHAR(95)=''                 --a non-null CHAR field will pre-fill with spaces
a:                                     --GOTO loop, shorter than a WHILE
    PRINT @t                           --duh
    SET @t = LEFT(                     --lops off the character at the end
            STUFF(                     --crams 4 new characters in the middle
            STUFF(@t, 63-@/2, 2, '')   --snips out a space and the leading character
                 ,46, 0, CHAR(@-1) + CHAR(@) + CHAR(@+1) + CHAR(@))
                 ,33 + @/2)            --rest of the LEFT()
    SET @+=2
IF @<128 GOTO a
— BradC
source
2

J , 47 44 octets

(,.~}:@|."1)(1+i.48)([|.@{.}.)"0 1 u:31+i.96

Essayez-le en ligne!

Merci à Conor O'Brien pour le modèle! Merci à FrownyFrog d'avoir indiqué la solution invalide.

— Galen Ivanov
source
1
C'est peut-être plus facilement modifiable: essayez-le en ligne!
— Conor O'Brien
@Conor O'Brien - Merci pour le modèle, j'ai mis à jour le lien.
— Galen Ivanov
Imprime une ligne supplémentaire en haut.
— FrownyFrog
@FrownyFrog Oh, ce n'est que maintenant que je vois que seules les nouvelles lignes de fin sont autorisées, pas en tête. Je vais essayer de le réparer.
— Galen Ivanov
@FrownyFrog - Fixe et légèrement golfé.
— Galen Ivanov
2

Rubis, 59 octets

48.times{|i|-47.upto(i){|c|putc~c<i ?32-c.abs+2*i:32};puts}

Cross-posté de ma réponse sur anagol.

— histocrate
source
2

Japt -R, 18 15 octets

14 octets si une nouvelle ligne de tête supplémentaire est autorisée.

#0õ_odH+ZÉ ¬êÃû

Essaye-le

Explication

#0                  :48
  õ                 :Range [1,48]
   _         Ã      :Pass each Z through a function
    o               :  Range [0,Z)
      H+ZÉ          :    To each add 32+Z-1
     d              :    Get the character at that codepoint
           ¬        :  Join to a string
            ê       :  Palinrdomise
              û     :Centre pad each element to the length of the longest element
                    :Implicitly join with newlines and output
— Hirsute
source
2

J ,  40 37  32 octets

40 expressions u:30+2>.(+:@i.@(2&+)(-*(>+:))"0 _|@i:)47grâce à + Galen Ivanov & + Conor O'Brien pour les idées dans leurs solutions

37 écho inclus echo u:32+|.(~.(>:*+:@[-])"0 _])|i:47

echo u:32+|.(~.(>:*[+-)"{])|i:47

incorporant les conseils @FrownyFrog des commentaires

TIO

— Jayprich
source
Je ne pense pas que les expressions soient des soumissions valides.
— LyricLy
@LyricLy, l'opinion semble varier car je vois une autre réponse J sous cette forme .. de toute façon merci de m'avoir incité à me raser encore 8 octets .. maintenant j'ai de la place pour ajouter "écho": j'espère que vous êtes heureux :)
— :)
"0 _ → "{
— FrownyFrog
+:@[-] → [+-
— FrownyFrog
belle .. merci pour ces conseils @FrownyFrog
— jayprich
1

Python 2 , 98 88 octets

-1 octet grâce à @ Mr.Xcoder

i=32
exec"print''.join(chr(i+i-32-abs(j))for j in range(32-i,i-31)).center(95);i+=1;"*48

Essayez-le en ligne!

— Possum mort
source
-i+32=> 32-iet vous pourriez utiliser ' '*(79-i)au lieu de .center(95)pour enregistrer des octets.
— M. Xcoder
@ Mr.Xcoder merci! ' '*(79-i)+ne sauve pas vraiment les octets: D
— Dead Possum
1

Rubis , 78 octets

s=*32;48.times{puts (s.map(&:chr)*'').center 95;c=*s[0]+1;s=c+s.map{|x|x+2}+c}

Essayez-le en ligne!

Programme complet. Non golfé:

s=*32;                              # s is an array of integers
48.times{                           # Repeat 48 times:
  puts (s.map(&:chr)*'').center 95; # Turn each int to a char, join, center, and print
  c = *s[0] + 1;                    # c is a singleton array. It will bookend the next line
  s = c + s.map{|x|x+2} + c         # Add 2 to each element of s before adding the bookends
}
— benj2240
source
1

Gol> <> , 29 octets

`0FaLssLF:P|LF:M|`/L-R` lRo|;

Essayez-le en ligne!

Comment ça marche

`0FaLssLF:P|LF:M|`/L-R` lRo|;

`0F                        |;  Repeat the following 48 times and halt...
   a                           Push 10 (\n)
    Lss                        Push L(loop counter) + 32
       LF:P|                   Repeat "Clone the top and increment" L times
            LF:M|              Repeat "Clone the top and decrement" L times
                 `/L-R`        Push 32 (space) 47-L times (space is significant)
                        lRo    Print everything as char, from the top,
                               until the stack is empty
— Bubbler
source
1

Tcl , 129 122 118 118 117 octets

time {incr i;set j -48;set a {};time {set a $a[format %c [expr abs([incr j])>=$i?32:$i*2-abs($j)+30]]} 96;puts $a} 48

Essayez-le en ligne!

Explication

time { # for i from 0 up to 47
    incr i
    set j -48
    set a {}
    time { # for j from -48 up to 47
        # add next character to a
        set a $a[format %c [expr abs([incr j])>$i?32:$i*2-abs($j)+32]]
    } 96
    puts $a # print a
} 48
— ASCII uniquement
source
1

C (gcc) 199 octets

#include<stdio.h>
int i,j=32,k=32,l=49;int main(){while(k<127){for(i=0;i<l;++i)printf(" ");for(i=j;i<k;++i)printf("%c",i);printf("%c",k);for(i=k-1;i>=j;--i)printf("%c",i);printf("\n");j++;k+=2;l--;}}

Essayez-le en ligne!

Merci à Picard et PunPun1000 pour toute l'aide

— Jonathan Landrum
source
@Picard J'ai supprimé les espaces. Je pourrais encore minifier avec une variable d'itérateur global.
— Jonathan Landrum le
@Picard Je l'ai édité sur mon téléphone; ne réalisait pas que j'avais laissé une ligne vierge.
— Jonathan Landrum le
1
Il y a des espaces inutiles dans les appels printf après les virgules, et les noms de variables peuvent être raccourcis à une lettre. De plus, ce serait bien si vous pouviez inclure un lien TIO et le nombre d'octets réel. Voici le lien pour votre code actuel TIO
— PunPun1000
ok, je l'ai serré un peu plus, je pense que je devrais changer l'algorithme pour le réduire davantage
— Jonathan Landrum
1

Haskell, 102 octets

main=putStr$do
i<-[48,47..0]
let l=replicate i 32++[79-i..126-i*2]
map toEnum$l++tail(reverse l)++[10]

Les choses que j'ai essayées n'étaient pas plus courtes:

  • Tout exprimer en termes de littéraux de caractères et / succou predpour sauvegarder le map toEnum.
  • Écriture d'une plage descendante au lieu d'utiliser reverse.
— Kevin Reid
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.