Les ponts sont des métaphores pour tout dans l'Art ASCII

15

(avec des excuses à Jim West pour le titre, et inspiré au hasard par la représentation textuelle de Cisco de leur logo: .:|:.:|:. pour le concept)

Étant donné un entier en entrée 1 <= n <= 255, sortez une représentation artistique ASCII d'un pont suspendu de distance en nsuivant les règles de construction ci-dessous:

  • Le début et la fin du pont (non comptés dans la ndistance) sont toujours -|et |-, donc le pont peut se connecter de manière appropriée aux autoroutes à côté de lui.
  • Le pont ne s'étend pas vers le bas (le niveau de la chaussée, composé de la -rangée, est la rangée inférieure).
  • Il peut y avoir au plus deux morceaux de chaussée --dans une rangée, toute portée plus longue nécessite des câbles de suspension pour le support.
  • Les câbles de suspension \s'étendent de la chaussée jusqu'aux tours |en ligne droite.
  • Les tours |doivent être suffisamment hautes pour supporter les câbles de suspension adjacents, mais pas plus hautes.
  • Le pont doit être équilibré de gauche à droite autour du point médian, en privilégiant les sections centrales dans la mesure du possible.
  • Tout ce qui précède devrait entraîner une minimisation des câbles, mais pour être clair, le nombre de câbles de suspension doit être minimisé tout en respectant les règles ci-dessus.

Pour fournir une représentation visuelle, voici les résultats attendus pour n = 1, 2, 3, ... 15-

1
-|-|-

2
-|--|-

3
-|\-/|-

4
-|\--/|-

5
 |\   /|
-|-\-/-|-

6
 |\    /|
-|-\--/-|-

7
 |\     /|
 | \   / |
-|--\-/--|-

8
 |\      /|
 | \    / |
-|--\--/--|-

9
 |\       /|
 | \     / |
 |  \   /  |
-|\--\-/--/|-

10
 |\        /|
 | \      / |
 |  \    /  |
-|\--\--/--/|-

11
 |\         /|
 | \       / |
 |  \     /  |
 |\  \   /  /|
-|-\--\-/--/-|-

12
 |\          /|
 | \        / |
 |  \      /  |
 |\  \    /  /|
-|-\--\--/--/-|-

13
 |\           /|
 | \         / |
 |  \       /  |
 |\  \     /  /|
 | \  \   /  / |
-|--\--\-/--/--|-

14
 |\            /|
 | \          / |
 |  \        /  |
 |\  \      /  /|
 | \  \    /  / |
-|--\--\--/--/--|-

15
 |\             /|
 | \           / |
 |  \         /  |
 |\  \       /  /|
 | \  \     /  / |
 |  \  \   /  /  |
-|\--\--\-/--/--/|-

Contribution

Un entier positif unique dans un format pratique , n > 9.

Production

Le pont ASCII-art suivant la technique de construction ci-dessus.

Règles

  • Les sauts de ligne ou les espaces de début ou de fin sont tous facultatifs, tant que les caractères de pont eux-mêmes s'alignent correctement.
  • 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.
  • Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que les gens puissent essayer votre code!
  • Les failles standard sont interdites.
  • Il s'agit de donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.
AdmBorkBork
la source
#RageQuit ( 05ab1e.tryitonline.net/… )
Urne de poulpe magique
@carusocomputing Hah, n'abandonnez pas! : D
AdmBorkBork
Je n'ai pas abandonné, j'ai juste dû aller ailleurs et je ne voulais pas perdre ma progression;).
Urne de poulpe magique du
5
@carusocomputing Aha. Donc, plus comme #RageTemporarilyWalkAway.
AdmBorkBork

Réponses:

3

05AB1E , 79 59 58 octets

"\  "×¹<;£R.sð«¹3‹ið}.BvyD¹Éi¨}R„\/„/\‡«'|.øð.ø}ð'-‡¹2›i»}

Essayez-le en ligne! .

Explication:

"\  "×                                                     # Push n copies of "\  ".
      ¹<;£                                                 # Push a[0:(n-1)/2] 
          R.s                                              # Reverse, get substrings.
             ð«                                            # Append a space.
               ¹3‹ið}                                      # If n < 3, push a space.
                     .B                                    # Boxify.
                       vy                      }           # For each...
                         D¹Éi¨}R                           # Dupe, if n is odd, a[0:-1].
                                „\/„/\‡                    # Reverse the slashes.
                                       «'|.øð.ø            # Surround with | and a space.
                                                ð'-‡       # Replace spaces with "-".
                                                    ¹2›i } # If it's more than 2...
                                                        »  # Join stack by newlines.

Trouvé la meilleure solution, la clé était de retourner les tableaux suivants pour chaque numéro comme suit:

1=[" "]
2=["  "]
3=["\"]
4=["\ "]
5=["\"," \"]
6=["\"," \ "]
7=["\"," \","  \"]
8=["\"," \","  \ "]
Etc...
Urne de poulpe magique
la source
4

Python 2, 173 octets

i=input()
f=lambda b:'-|'+b[::-1].replace('/','\\')+-~(~i%2)*'-'+b+'|-'
b=(i*'/--')[:~-i/2]
for x in range(1,~-i/2):print f((len(b)-x)*'-'+b[:x]).replace('-',' ')
print f(b)

Refléter la valeur de b et ajouter le
f=lambda b:'-|'+b[::-1].replace('/','\\')+-~(~i%2)*'-'+b+'|-'
motif de base central "-" (moitié droite de la ligne du bas)
b=(i*'/--')[:~-i/2]
Boucle pour les couches non inférieures
for x in range(1,~-i/2):
Obtenez les premiers x caractères du motif de base et complétez par "-"
(len(b)-x)*'-'+b[:x]
Remplacer tout - avec des espaces à imprimer tous les calques (sauf le bas)
print f().replace('-',' ')
Imprimer le calque inférieur
print f(b)

Barre
la source
5
Vous devez inclure la version brute (sans aucun commentaire) dans votre message
FlipTack
4

Befunge, 150 octets

45&3+:00p4+2/:10p`-v
*\00g1-\`*2*+\1-!+v>1+:20p55+00g>::::00g1--!\:20g+00g-:0`\3%!
`1\*!%3\`0:-\g02:\<^_@#-g01<:,$_^#`\0:-1,g3+**4!-g01g02!:+*3*
 |\/-

Essayez-le en ligne!

J'ai également fourni une version non golfée du code qui illustre mieux l'architecture utilisée dans la construction du pont.

        >4                                         5v
        v+3                                       <&<
        >:00                                     p4+v
        v-`p0                                   1:/2<
*+\1-!+v>1+:20p55+00g>::::00g1--!\:20g+00g-:0`\3%!*\00g1-\`*2
-\g02:\<^_@#-g01<:,$_^#`\0:-1,g6+7+**4!-g01g02!:>#+<v*!%3\`0:
        |\/->3#*                             *#`^#1\<

Essayez-le en ligne!

Les tours gèrent l'entrée et l'initialisation des paramètres. Le jeu est composé de deux boucles calculant les parties du pont qui doivent être sorties pour chaque coordonnée x, y. Et la fondation détient la table de caractères pour ces parties de pont, ainsi que d'autres codes complètement indépendants.

Explication détaillée

Nous commençons par calculer la largeur et la hauteur de la zone de sortie qui devra être itérée pour rendre le pont.

w  = n + 3                (stored at 0,0)
h  = (w + 4)/2            (stored at 1,0)

Notez que la plage y n'est pas basée sur zéro. La valeur initiale est 5 - (h<5)et est itérée jusqu'à h (la valeur actuelle est stockée à 2,0). La valeur x est itérée de w à 0 et est stockée sur la pile.

La boucle interne n'est qu'une série de conditions booléennes déterminant si une coordonnée x , y particulière correspond à l'un des emplacements qui nécessitent un caractère non spatial. Ces calculs sont basés sur deux décalages coulissants qui suivent le chemin des câbles de suspension.

loff = y + x - w
roff = y - x 

Les différentes conditions sont alors déterminées comme suit:

left_tower       = (x == w-1)
left_suspension  = (loff > 0) and (loff%3 == 0) and (x < w-1)
right_tower      = (x == 1)
right_suspension = (roff > 0) and (roff%3 == 0) and (x > 1)
bridge_deck      = (y == h)

Pour traduire ces conditions en décalage de caractères correct, il suffit de multiplier chacune d'elles par un décalage approprié et de additionner le résultat. Ce calcul est effectué lors de l'évaluation des conditions. Cela ressemble donc à ceci:

char_offset =  left_tower
char_offset += left_suspension * 2
char_offset += right_tower
char_offset += right_suspension * 3
char_offset += !char_offset * bridge_deck * 4

Notez que la valeur bridge_deck est fusionnée selon que les autres conditions sont remplies, car un caractère de suspension ou de tour aura priorité sur le pont.

Le résultat final est un décalage dans la table des personnages sur la dernière ligne du champ de jeu. Nous sortons simplement ce caractère et répétons la boucle.

James Holderness
la source
Voulez-vous fournir une explication? avec tous ces va-et-vient, c'est difficile à suivre
MildlyMilquetoast
Vous êtes le seul à poster après avoir ajouté la prime, si personne ne vous bat, je vous attribuerai le 100.
Urne de poulpe magique
@carusocomputing Je sais que vous espériez mieux que cela, mais il reste encore beaucoup de temps, et cela devrait être mieux remarqué une fois qu'il sera plus près du haut de la liste des fonctionnalités.
James Holderness du
C'est une réponse intéressante en soi, elle a déjà plus de votes positifs que la mienne; mieux n'est certainement pas le bon mot.
Magic Octopus Urn
3

Lot, 241 octets

@echo off
set t=set s=
%t%
for /l %%i in (1,1,%1)do call %t% %%s%%
%t% !%s%! 
for /l %%i in (5,2,%1)do call:l 0
:l
%t%%s:\ = \%
%t%%s: /=/ %
%t%%s:!   =!\  %
%t%%s:   !=  /!%
%t%%s:\  !=\ /!%
if %1 gtr 0 %t%%s: =-%
echo %s:!=^|%

Remarque: espace de fuite sur la ligne 5. Commence par construire une rangée d'espaces, puis en ajoutant des câbles si nécessaire, en répétant pour construire des tours à la hauteur souhaitée, pour terminer en remplaçant les espaces restants par une route.

Neil
la source
3

WinDbg, 312 octets

r$t4=@$t0+4;.block{j3>@$t0'r$t5=1';r$t5=(@$t0-1)/2};f8<<16 L@$t4*@$t5 2d;f8<<16 L@$t4*(@$t5-1) 20;.for(r$t1=0;@$t1<@$t5;r$t1=@$t1+1){eb2000001+@$t4*@$t1 7c;e1fffffe+@$t4*(1+@$t1) 7c;j2<@$t0'.for(r$t2=@$t1;@$t2>=0;r$t2=@$t2-3){e2000002+@$t4*@$t1+@$t2 5c;e1fffffd+@$t4*(1+@$t1)-@$t2 2f}'};da/c@$t4 8<<16 L@$t4*@$t5

L'entrée se fait en définissant le pseudo-registre $t0.

Je pense qu'il devrait y avoir un moyen de combiner les deux forboucles en une seule ... peut-être aussi d'autres opportunités de golf ...

Celui-ci fonctionne en remplissant toute la zone de route, puis en remplaçant tout sauf la dernière rangée par de l'espace, et enfin en construisant les colonnes et les câbles.

r$t4 = @$t0+4;                                * Set width to input+4
.block                                        * Code block, needed for some reason...
{                                             * and .block+j is shorter than .if/.else
    j 3>@$t0                                  * If input is less than 3...
    '
        r$t5 = 1                              * ...set height to 1
    ';                                        * Implicit else...
        r$t5 = (@$t0-1)/2                     * ...set height to (input-1)/2
};
f 8<<16 L@$t4*@$t5 2d;                        * Fill area with -
f 8<<16 L@$t4*(@$t5-1) 20;                    * Fill all but last row with space
.for(r$t1=0; @$t1<@$t5; r$t1=@$t1+1)          * For each row
{
    eb 2000001+@$t4*@$t1 7c;                  * Build the left column with |
    e 1fffffe+@$t4*(1+@$t1) 7c;               * Build the right column (e is the same as last e* call, ie- eb)
    j 2<@$t0                                  * If input is more than 2...
    '
        .for(r$t2=@$t1; @$t2>=0; r$t2=@$t2-3) * ...Enumerate from counter back to 0
        {
            e 2000002+@$t4*@$t1+@$t2 5c;      * Build left cables with \
            e 1fffffd+@$t4*(1+@$t1)-@$t2 2f   * Build right cables with /
        }
    '
};
da /c@$t4 8<<16 L@$t4*@$t5                    * Print the string in lines of length width

Exemple de sortie de 1 à 15:

0:000> .for(r$t0=1;@$t0<10;r$t0=@$t0+1){.printf"%d\n",@$t0;r$t4=@$t0+4;.block{j3>@$t0'r$t5=1';r$t5=(@$t0-1)/2};f8<<16 L@$t4*@$t5 2d;f8<<16 L@$t4*(@$t5-1) 20;.for(r$t1=0;@$t1<@$t5;r$t1=@$t1+1){eb2000001+@$t4*@$t1 7c;e1fffffe+@$t4*(1+@$t1) 7c;j2<@$t0'.for(r$t2=@$t1;@$t2>=0;r$t2=@$t2-3){e2000002+@$t4*@$t1+@$t2 5c;e1fffffd+@$t4*(1+@$t1)-@$t2 2f}'};da/c@$t4 8<<16 L@$t4*@$t5}
1
Filled 0x5 bytes
Filled 0x0 bytes
02000000  "-|-|-"
2
Filled 0x6 bytes
Filled 0x0 bytes
02000000  "-|--|-"
3
Filled 0x7 bytes
Filled 0x0 bytes
02000000  "-|\-/|-"
4
Filled 0x8 bytes
Filled 0x0 bytes
02000000  "-|\--/|-"
5
Filled 0x12 bytes
Filled 0x9 bytes
02000000  " |\   /| "
02000009  "-|-\-/-|-"
6
Filled 0x14 bytes
Filled 0xa bytes
02000000  " |\    /| "
0200000a  "-|-\--/-|-"
7
Filled 0x21 bytes
Filled 0x16 bytes
02000000  " |\     /| "
0200000b  " | \   / | "
02000016  "-|--\-/--|-"
8
Filled 0x24 bytes
Filled 0x18 bytes
02000000  " |\      /| "
0200000c  " | \    / | "
02000018  "-|--\--/--|-"
9
Filled 0x34 bytes
Filled 0x27 bytes
02000000  " |\       /| "
0200000d  " | \     / | "
0200001a  " |  \   /  | "
02000027  "-|\--\-/--/|-"
10
Filled 0x38 bytes
Filled 0x2a bytes
02000000  " |\        /| "
0200000e  " | \      / | "
0200001c  " |  \    /  | "
0200002a  "-|\--\--/--/|-"
11
Filled 0x4b bytes
Filled 0x3c bytes
02000000  " |\         /| "
0200000f  " | \       / | "
0200001e  " |  \     /  | "
0200002d  " |\  \   /  /| "
0200003c  "-|-\--\-/--/-|-"
12
Filled 0x50 bytes
Filled 0x40 bytes
02000000  " |\          /| "
02000010  " | \        / | "
02000020  " |  \      /  | "
02000030  " |\  \    /  /| "
02000040  "-|-\--\--/--/-|-"
13
Filled 0x66 bytes
Filled 0x55 bytes
02000000  " |\           /| "
02000011  " | \         / | "
02000022  " |  \       /  | "
02000033  " |\  \     /  /| "
02000044  " | \  \   /  / | "
02000055  "-|--\--\-/--/--|-"
14
Filled 0x6c bytes
Filled 0x5a bytes
02000000  " |\            /| "
02000012  " | \          / | "
02000024  " |  \        /  | "
02000036  " |\  \      /  /| "
02000048  " | \  \    /  / | "
0200005a  "-|--\--\--/--/--|-"
15
Filled 0x85 bytes
Filled 0x72 bytes
02000000  " |\             /| "
02000013  " | \           / | "
02000026  " |  \         /  | "
02000039  " |\  \       /  /| "
0200004c  " | \  \     /  / | "
0200005f  " |  \  \   /  /  | "
02000072  "-|\--\--\-/--/--/|-"
Lait
la source
2

Java 8, 423 , 412 octets

11 octets économisés grâce à Kritixi Lithos

golfé:

void f(int n){int i,j,k,t=n/2+n%2,u=t-2,q;char v=45;char[][]a=new char[t-1][n+4];for(char[]c:a)Arrays.fill(c,' ');a[u][0]=v;a[u][n+3]=v;for(q=0;q<t-1;q++){a[q][1]='|';a[q][n+2]='|';}for(i=t+1;i>1;i--){if((t-i)%3==0){k=u;for(j=i;j>1;j--)a[k--][j]='\\';}else a[u][i]=v;}for(i=n/2+2;i<n+2;i++){if((i-n/2-3)%3==0){k=u;for(j=i;j<n+2;j++)a[k--][j]='/';}else a[u][i]=v;}for(char[]w:a)System.out.println(new String(w));}

non golfé:

void f(int n){
    int i,j,k,t=n/2+n%2,u=t-2;
    char v=45;
    char[][] a=new char[t-1][n+4];
    for (char[]c : a) Arrays.fill(c,' ');
    a[u][0]=v;
    a[u][n+3]=v;

    // left and right columns
    for (int q=0;q<t-1;q++){
        a[q][1]='|';
        a[q][n+2]='|';
    }
    // left part of base
    for (i=t+1;i>1;i--){
        if ((t-i)%3==0){
            k=u;
            for (j=i;j>1;j--)
                a[k--][j]='\\';
        }
        else a[u][i]=v;
    }
    // right part of base
    for (i=n/2+2;i<n+2;i++){
        if ((i-n/2-3)%3==0){
            k=u;
            for (j=i;j<n+2;j++)
                a[k--][j]='/';
        }
        else a[u][i]=v;
    }
    for (char[]w : a) System.out.println(new String(w));
}
Bobas_Pett
la source
Vous pouvez jouer à cette réponse de plusieurs manières, d'abord, vous pouvez avoir toutes vos déclarations int dans une seule déclaration, quelque chose comme int i,j,k,t=n/2+n%2,u=t-2,q=0et au lieu de char v="-";vous pouvez utiliser char v=45;et vous pouvez changer le abc%xyz==0s en abc%xyz<1(je ne l'ai pas testé)
Kritixi Lithos
@KritixiLithos thx! modifié les 2 premiers le dernier n'a pas fonctionné
Bobas_Pett