Los puentes son metáforas de todo en el arte ASCII

15

(con disculpas a Jim West por el título e inspirado al azar por la representación textual de su logotipo por parte de Cisco: .:|:.:|:. por el concepto)

Dado un entero de entrada 1 <= n <= 255, genera una representación artística ASCII de un puente colgante de distancia nsiguiendo las siguientes reglas de construcción:

  • El inicio y el final del puente (sin contar en la ndistancia) son siempre -|y|- , por lo que el puente puede conectarse adecuadamente a las carreteras cercanas.
  • El puente no se extiende hacia abajo (el nivel de la carretera, compuesto por el - fila, es la fila inferior).
  • Puede haber como máximo dos piezas de calzada -- seguidas, cualquier tramo más largo requiere cables de suspensión para soporte.
  • Los cables de suspensión se \extienden desde la carretera hasta las torres.| en línea recta.
  • Las torres | deben ser lo suficientemente altas como para soportar los cables de suspensión adyacentes, pero no más altas.
  • El puente debe estar equilibrado de izquierda a derecha sobre el punto medio, favoreciendo las secciones centrales siempre que sea posible.
  • Todo lo anterior debería resultar en una minimización de los cables, pero para ser claros, el número de cables de suspensión debe minimizarse sin dejar de seguir las reglas anteriores.

Para proporcionar una representación visual, aquí están los resultados esperados para n = 1, 2, 3, ... 15:

1
-|-|-

2
-|--|-

3
-|\-/|-

4
-|\--/|-

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

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

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

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

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

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

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

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

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

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

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

Entrada

Un número entero positivo solo en cualquier formato conveniente , n > 9.

Salida

El puente de arte ASCII siguiendo la técnica de construcción anterior.

Reglas

  • Las nuevas líneas o espacios en blanco iniciales o finales son opcionales, siempre que los caracteres del puente se alineen correctamente.
  • Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
  • Si es posible, incluya un enlace a un entorno de prueba en línea para que las personas puedan probar su código.
  • 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 ascii-art AdmBorkBork
fuente
#RageQuit ( 05ab1e.tryitonline.net/… )
Urna de pulpo mágico
@carusocomputing ¡Ja, no te rindas! : D
AdmBorkBork
No me rendí, solo tenía que ir a otro lado y no quería perder mi progreso;).
Urna de pulpo mágico
55
@carusocomputing Aha. Entonces, más como #RageTempomporaryWalkAway.
AdmBorkBork

Respuestas:

3

05AB1E , 79 59 58 bytes

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

Pruébalo en línea! .

Explicación:

"\  "×                                                     # 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.

Encontró la mejor solución, la clave fue devolver las siguientes matrices para cada número de la siguiente manera:

1=[" "]
2=["  "]
3=["\"]
4=["\ "]
5=["\"," \"]
6=["\"," \ "]
7=["\"," \","  \"]
8=["\"," \","  \ "]
Etc...
Urna de pulpo mágico
fuente
4

Python 2, 173 bytes

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)

Refleje el valor de b y agregue el
f=lambda b:'-|'+b[::-1].replace('/','\\')+-~(~i%2)*'-'+b+'|-'
patrón base "-" central (mitad derecha de la línea inferior)
b=(i*'/--')[:~-i/2]
Bucle para capas no inferiores
for x in range(1,~-i/2):
Obtenga los primeros x caracteres del patrón base y complete con "-"
(len(b)-x)*'-'+b[:x]
Reemplazar todo - con espacios para imprimir todas las capas (excepto la parte inferior)
print f().replace('-',' ')
Imprimir capa inferior
print f(b)

varilla
fuente
55
Debe incluir la versión sin
formato
4

Befunge, 150 bytes

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*
 |\/-

Pruébalo en línea!

También proporcioné una versión no codificada del código que demuestra mejor la arquitectura utilizada en la construcción del puente.

        >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\<

Pruébalo en línea!

Las torres manejan la entrada y la inicialización de parámetros. La plataforma se compone de dos bucles que calculan las partes del puente que deben emitirse para cada coordenada x, y. Y la base contiene la tabla de caracteres para esas partes del puente, así como algún otro código completamente no relacionado.

Explicación detallada

Comenzamos calculando el ancho y la altura del área de salida que deberá iterarse para representar el puente.

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

Tenga en cuenta que el rango y no está basado en cero. El valor inicial es 5 - (h<5)y se repite hasta h (el valor actual se almacena en 2,0). El valor de x se repite desde w hasta 0 y se almacena en la pila.

El bucle interno es solo una serie de condiciones booleanas que determinan si una coordenada x , y particular coincide con alguna de las ubicaciones que requieren un carácter no espacial. Estos cálculos se basan en dos desplazamientos deslizantes que siguen el camino de los cables de suspensión.

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

Las diversas condiciones se determinan de la siguiente manera:

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)

Para traducir estas condiciones al desplazamiento correcto de caracteres, solo necesitamos multiplicar cada una de ellas por un desplazamiento apropiado y sumar el resultado. Este cálculo se realiza a medida que se evalúan las condiciones. Entonces se ve algo como esto:

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

Tenga en cuenta que el puente_deck valor de se fusiona en función de si se ha cumplido alguna de las otras condiciones, ya que un carácter de suspensión o torre tendrá prioridad sobre el mazo.

El resultado final es un desplazamiento en la tabla de personajes en la última línea del campo de juego. Simplemente sacamos ese carácter y repetimos el ciclo.

James Holderness
fuente
¿Te importaría dar una explicación? con todos esos
juegos
Eres el único que publica después de agregar la recompensa, si nadie más te gana, te otorgaré los 100.
Urna de pulpo mágico el
@carusocomputing Sé que esperabas algo mejor que esto, pero todavía hay mucho tiempo, y debería recibir más atención una vez que esté más cerca de la parte superior de la lista destacada.
James Holderness
Esta es una respuesta genial en sí misma, ya tiene más votos positivos que los míos; Definitivamente, mejor no es la palabra correcta.
Urna de pulpo mágico
3

Lote, 241 bytes

@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:!=^|%

Nota: Espacio final en la línea 5. Comienza construyendo una fila de espacios, luego agrega cables según sea necesario, repitiendo para construir torres a la altura deseada, y termina reemplazando los espacios restantes con la carretera.

Neil
fuente
3

WinDbg, 312 bytes

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

La entrada se realiza configurando el pseudo-registro $t0.

Siento que debería haber una manera de combinar los dos for bucles en uno ... tal vez algunas otras oportunidades de golf también ...

Este funciona llenando toda el área con camino, luego reemplazando todo excepto la última fila con espacio y finalmente construyendo las columnas y los cables.

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

Salida de muestra 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  "-|\--\--\-/--/--/|-"
Leche
fuente
2

Java 8, 423 , 412 bytes

11 bytes guardados gracias a Kritixi Lithos

golfizado:

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

sin 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
fuente
Puede jugar esta respuesta de muchas maneras, primero, puede tener todas sus declaraciones int en una sola declaración, algo así int i,j,k,t=n/2+n%2,u=t-2,q=0como, en lugar de tener char v="-";, puede usar char v=45;y puede cambiar el abc%xyz==0s a abc%xyz<1(no lo he probado)
Kritixi Lithos
@KritixiLithos gracias! editó los primeros 2 el último no funcionó
Bobas_Pett