Triángulos muy simples

47

Escriba un programa o función que tome un entero positivo (a través de stdin, línea de comando o función arg) e imprima o devuelva una cadena de esos muchos triángulos pequeños en mosaico, alternando en qué dirección apuntan:

 /\
/__\

Este único triángulo es la salida si la entrada es 1.

Si la entrada es 2, la salida es

  ____
 /\  /
/__\/

Si la entrada es 3, la salida es

  ____
 /\  /\
/__\/__\

Si la entrada es 4, la salida es

  ________
 /\  /\  /
/__\/__\/

Y así. Su programa debe admitir entradas de hasta 2 16 - 1 = 65535.

Detalles

  • El triángulo más a la izquierda siempre apunta hacia arriba.
  • Puede haber espacios finales pero puede que no haya espacios iniciales innecesarios.
  • Puede haber una nueva línea final opcional.
  • Tenga en cuenta que para 1la salida tiene dos líneas de largo, pero por lo demás son tres. Esto es requerido.
  • La presentación más corta en bytes gana.
Pasatiempos de Calvin
fuente

Respuestas:

32

Pyth, 44 42

ItQpdd*\_*4/Q2)jbms<*dQhQ,c" /\ "2,\/"__\\

La primera línea:

ItQpdd*\_*4/Q2)
ItQ           )    If the input is not 1
   pdd             Print two spaces
      *\_*4/Q2     Then groups of 4 underscores, repeated input/2 times.

Las otras dos líneas son generadas por darse cuenta de que la segunda línea se compone de " /"y "\ "alterna de entrada + 1 veces, y la tercera línea se compone de "/"y "__\"alternan de la misma manera.

isaacg
fuente
158
trazado 44 sigue siendo normal 44 :(
Optimizer
44
42 . ¡Por supuesto!
mbomb007
48
@Optimizer: Me parece infinitamente divertido que su tristeza por la aparición de 44 haya recibido más votos que la pregunta o esta respuesta.
Alex A.
66
Acabo de recibir 10 respuestas en la cadena 44 tachada
Leo
3
@AlexA. Me resulta infinitamente divertido que su diversión por la tristeza de Optimizer por la aparición de 44 haya recibido más votos que la pregunta o esta respuesta.
isaacg
24

SQL, 182 175 173 187 bytes

No es que este sea el más corto, pero aún así es divertido tratar de minimizar sql;) lol Lo hice en Oracle 11, sin embargo, estos deberían ser SQL básico. [editar] como se señaló, no apliqué la regla when input = 1, solo se muestran 2 líneas. no puedo pensar en una mejor manera de hacerlo, sin embargo, ahorré un par de bytes modificando la lógica v;) agregar 2 por adelantado ahorra un par de bytes al no tener que repetirlo más tarde [/ edit]

select decode(&i,1,'',rpad('  ',v,'____')||z)||rpad(' /',v,'\  /')||decode(y,1,'\')||z||rpad('/',v-1,'__\/')||decode(y,1,'__\')from(select 2+floor(&i/2)*4v,mod(&i,2)y,chr(10)z from dual);

[edit1] eliminó algunos espacios innecesarios [/ edit1] [edit2] cambió &&i a solo & i. Corta 2 caracteres, pero obliga al usuario a ingresar el número de triángulos dos veces ...: ¡PI se dio cuenta de que mis "buenos hábitos de codificación" usando && costaban 2 bytes! ¡¡El horror!! [/ edit2]

Explicación (nota: uso && 1 en esta explicación, por lo que solo aparece una vez, el & 1 anterior ahorra espacio en el código, pero aparece varias veces;))

 select  -- line 1
     decode(&&1,1,'',   -- don't need line 1 if input is 1
     rpad('  ',v,'____') || z ) || -- every pair of triangles
     -- line 2
     rpad(' /',v,'\  /') ||  -- every pair of triangles
          decode(y,1,'\') || z || -- add the final triangle, input: 1,3,5 etc.
     -- line 3
     rpad('/',v-1,'__\/') ||  -- every pair of triangles
          decode(y,1,'__\')   -- add the final triangle, input: 1,3,5 etc.
from (select 2+floor(&&i/2)*4 v,   -- common multiplier. 4 extra chars for every triangle pair
             mod(&&i,2) y,  -- Flag for the final triangle (odd inputs, 1,3,5, etc)
             chr(10) z  -- CR, here to save space.
        from dual);

Salida

  SQL> accept i
  1
  SQL> /

   /\
  /__\


  SQL> accept i
  2
  SQL> /

    ____
   /\  /
  /__\/


  SQL> accept i
  3
  SQL> /

    ____
   /\  /\
  /__\/__\


  SQL> accept i
  12
  SQL> /

    ________________________
   /\  /\  /\  /\  /\  /\  /
  /__\/__\/__\/__\/__\/__\/


  SQL>
Ídem
fuente
1
¿Funcionaría para eliminar el espacio después from? Si es así, eso te ahorrará un byte.
Alex A.
Oh, Dios mío ... eso es una locura. solo lo intenté ... y luego "fui a la ciudad" quitando los espacios que pude ... Oo Este tonto es ilegible ahora ... pero aún funciona;) jajaja (NO puedo creer que los alias sigan funcionando así ... Oo jeje )
Ditto
¡Estoy tan confundido con los votos positivos! Oo No está cerca del tamaño más pequeño ... todavía ... ¡votos a favor! Oo wow
Ditto
2
Los votos a favor generalmente denotan que a las personas les gusta su presentación porque es creativa, el lenguaje utilizado es poco común o por varias razones. En mi experiencia, es poco común que la respuesta de golf de código más corto sea también la más votada. Entonces, aunque esta no sea la respuesta más corta, la comunidad la ha considerado buena. :)
Alex A.
@Alex ... genial, salsa :) (Voy a tener que probar esto en Excel el próximo ... jajaja)
Ditto
11

Python 2, 89 88 87 85 83 con nombre / 81 sin nombre

f=lambda n:1%n*("  "+n/2*4*"_"+"\n")+(" /\ "*n)[:2+2*n]+"\n"+("/__\\"*n)[:n-~n+n%2]

(Gracias a @orlp por un byte y a @xnor por otros tres)

Esta es una función que toma un int ny devuelve los triángulos como una cadena usando el enfoque fila por fila.

por ejemplo, print f(10)da

  ____________________
 /\  /\  /\  /\  /\  /
/__\/__\/__\/__\/__\/

Para la primera fila, en lugar de (n>1)*usar 1%n*, ya que 1%nes 0 si n == 1y 1 si n > 1.

Sp3000
fuente
1
Puede afeitarse un personaje, convirtiéndose " /\\ "en " /\ ".
orlp
¿Esta lambda no funciona también en Python 3?
mbomb007
2
@ mbomb007 Hay una división de piso allí
Sp3000
@orlp Permítame ahora, para agregar más confusión, pero eliminando mi comentario;)
FryAmTheEggman
Sospecho de los "\n".join()3 elementos, incluso si la lista se usa para eliminar condicionalmente el primer elemento. ¿Quizás algo así b*(x+"\n")+y+"\n"+zes más corto?
xnor
7

JavaScript (ES6), 101109

Demasiado tiempo

f=(n,z=a=>a.repeat(n/2))=>(n>1?'  '+z('____')+'\n ':' ')+z('/\\  ',w=' /'[++n&1]+'\n')+w+z('/__\\')+w

Explicación

Usando la flecha gorda para la definición de la función. Además, no hay {}bloque: el cuerpo de la función es una única expresión que es el valor de retorno. f=(a,b,c)=>expres equivalente a

function f(a,b,c)
{
  return expr;
}

Dentro de una sola expresión no puede usar declaraciones como ifo var, pero

  • los parámetros con valores predeterminados se pueden usar como variables locales
  • las expresiones condicionales ?:funcionan bien en lugar deif else
  • puede agregar más subexpresiones utilizando el operador de coma o incluso mejor como parámetro no utilizado para las funciones. En este caso, la asignación de wes el segundo parámetro (no utilizado) a la funciónz

Podemos reescribir la ffunción como

f = function(n) {
  var z = function(a) { // use current value of n (that changes)
    return a.repeat(n/2);
  };
  var result;
  if (n > 1) {
    result = '  ' + z('____') + '\n '; // top row if more than 1 triangle
  else
    result = ' '; // else just the blank
  ++n; // increase n, so invert even/odd
  w = ' /'[n&1]+'\n'; //  blank if n is now even, else '/' if n is now odd
  // the next rows will end in "/\" or "\  /" based on n even/odd
  result +=  z('/\\  ') + w; // offset by the blank char added before
  result += z('/__\\') + w;
  return result;
}

Prueba en la consola Firefox / FireBug

console.log(f(1),f(2),f(3),f(4),f(9))

Salida

 /\   
/__\ 

  ____
 /\  /
/__\/

  ____
 /\  /\   
/__\/__\ 

  ________
 /\  /\  /
/__\/__\/

  ________________
 /\  /\  /\  /\  /\   
/__\/__\/__\/__\/__\ 
edc65
fuente
¡Bien hecho! Ayer pasé demasiado tiempo buscando acortarlo y, en el mejor de los casos, pude reproducir el 109 de diferentes maneras. -8 es todo el salto.
DocMax
Bueno. ¿Podría publicar una explicación? No entiendo completamente el uso dew
BadHorsie
Explicación de @BadHorse agregada (realmente, esta vez)
edc65
Por interés, intenté hacerlo sin espacios finales y se me ocurrió n=>(n>1?' '+'____'.repeat(n/2)+'\n':'')+' /\\ '.repeat(n).slice(0,n*2+2-n%2)+'\n'+'/__\\'.repeat(n).slice(0,n*2+1+n%2)119 (deliberadamente sin usar cadenas de plantillas, etc. para que coincida con su respuesta).
Neil
6

Haskell 155 153 139 131 Bytes

Encontré un enfoque ligeramente diferente que resultó ser más corto que mi método original. Mi intento original se conserva a continuación. Como antes, los consejos de golf son apreciados.

m n=unlines.dropWhile(=="  ").z["  "," /","/"].foldr1 z$map t[1..n]
t n|odd n=["","\\","__\\"]
t _=["____","  /","/"]
z=zipWith(++)

Gracias a Nimi por los consejos de golf.


Intento anterior 197 179 Bytes

t n=putStr.unlines.dropWhile(all(==' ')).z(flip(++))(if odd n then["","\\","__\\"]else repeat"").z(++)["  "," /","/"].map(take(4*div n 2).cycle)$["____","\\  /","__\\/"]
z=zipWith
ankh-morpork
fuente
44
Algunos consejos para jugar al golf: (mod n 2)==0es even no uso mejor odd ny cambie el theny elseparte. concat.take(div n 2).repeates take(4*div n 2).cycleporque todos los elementos de la lista son de longitud 4. Asigne nombres cortos a funciones con nombres largos, por ejemplo z=zipWith, luego use z. Puedes patear algunos espacios ...repeat""else[....
nimi
@nimi ¡Gracias por tus sugerencias! Utilizándolos, pude jugar golf mi solución original a 179 bytes. Al reconsiderar mi enfoque, también pude reducir mi solución a 155 Bytes.
ankh-morpork
1
Sugerencias, parte II: foldr z["","",""]es foldr1 z, porque la lista para doblar nunca está vacía. En lugar de all(==' ') usted puede usar ==" "(<- dos espacios intermedios), porque se usa para eliminar la línea vacía en caso de n = 1 y aquí la primera línea es " ". La primera definición de tpuede escribirse en una sola línea: t n|odd....
nimi
4

CJam, 73 68 63 62 60 bytes

Esto definitivamente necesita algo de golf ...

S2*l~:I2/'_4**N]I(g*S"\\  /"'\{I2md@*@@*'/\@}:F~N"__\\/"_W<F

Pruébalo aquí.

Explicación

"Print the first line:";
S2*l~:I2/'_4**N]I(g*

S2*                  "Push a string with 2 spaces.";
   l~:I              "Read and eval the input, store it in I.";
       2/            "Divide by two to get the number of top segments.";
         '_4**       "Push '____' and repeat it by the number of segments.";
              N]     "Push a newline and wrap everything in an array.";
                I(g* "Get sign(I-1) and repeat the array that often. This is a no-op
                      for I > 1 but otherwise empties the array.";

"Print the other two lines. The basic idea is to define block which takes as arguments
 a repeatable 4-character string as well as another string which only gets printed for
 even I.";
S"\\  /"'\{I2md@*@@*'/\@}:F~N"__\\/"_W<F

S                                        "Push a space.";
 "\\__/"'\                               "Push the string '\__/' and the character \.";
          {             }:F~             "Store this block in F and evaluate it.";
           I2md                          "Get I/2 and I%2 using divmod.";
               @*                        "Pull up the second argument and repeat it I%2
                                          times. This turns it into an empty string for
                                          even I.";
                 @@                      "Pull up I/2 and the 4-character string.";
                   *                     "Repeat the string I/2 times.";
                    '/\@                 "Push a / and reorder the three line parts.";
                            N            "Push a newline.";
                             "__\\/"_W<F "Call F again, with '__\/' and '__\'.";
Martin Ender
fuente
4

Julia, 115 bytes

n->(m=2;p=println;k=n%2>0?m+1:m;e=m<k?"":"/";t=" /\\ ";b="/__\\";if n>1 p("  "*"_"^4m)end;p(t^k*" "*e);p(b^k*e))

Esto crea una función sin nombre que acepta un número entero e imprime los triángulos. Para llamarlo, dale un nombre, por ejemplo f=n->(...).

Ungolfed + explicación:

function f(n)

    m = n ÷ 2                    # Number of upside down triangles
    p = println                  # Store println function to save space
    k = n % 2 > 0 ? m + 1 : m    # Number of right side up triangles
    e = m < k ? "" : "/"         # n even? End lines with a /

    # Top of the triangle
    t = " /\\ "

    # Bottom of the triangle
    b = "/__\\"

    # Print the bottoms of any upside down triangles
    # * performs string concatenation
    # ^ performs string repetition
    if n > 1
        println("  " * "_"^4m)
    end

    # Print the triangle tops (these have two trailing spaces
    # if the last triangle isn't upside down)
    println(t^k * " " * e)

    # Print the triangle bottoms
    println(b^k * e)
end

Salida de ejemplo:

julia> for i = 1:10 f(i) end
 /\  
/__\
  ____
 /\  /
/__\/
  ____
 /\  /\  
/__\/__\
  ________
 /\  /\  /
/__\/__\/
  ________
 /\  /\  /\  
/__\/__\/__\
  ____________
 /\  /\  /\  /
/__\/__\/__\/
  ____________
 /\  /\  /\  /\  
/__\/__\/__\/__\
  ________________
 /\  /\  /\  /\  /
/__\/__\/__\/__\/
  ________________
 /\  /\  /\  /\  /\  
/__\/__\/__\/__\/__\
  ____________________
 /\  /\  /\  /\  /\  /
/__\/__\/__\/__\/__\/

Estoy bastante triste porque esto es tan largo. Estoy seguro de que hay muchas oportunidades de golf, pero no están claras para mí en este momento. ¡Avíseme si tiene alguna sugerencia o si desea alguna explicación adicional!

Alex A.
fuente
3

CJam, 68 62 60 bytes

Hasta donde puedo ver, este es un enfoque completamente diferente al de la otra solución de CJam. Esto se puede jugar mucho al golf.

"/__\\ /\\"4/]ri:R(['/"  /"'_4*"__\\"'\L]3/R*<+zR1>SS+*\W%N*

Pruébalo en línea aquí

Optimizador
fuente
3

C # 190

void f(int n){string s=(n>1)?"\n  ":"",t=" /",u = "/";bool b=true;int m=n;while(m-->0){s+=(n>1&&b&&m>0)?"____":"";t+=b?"\\":"  /";u+=b?"__\\":"/";b=!b;}Console.Write("{0}\n{1}\n{2}",s,t,u);}

Sin golf

void f(int n)
{
string s = (n > 1) ? "\n  " : "", t = " /", u = "/";
bool b = true;
int m = n;
while(m-->0)
{
s += (n > 1 && b && m>0) ? "____" : "";
t += b ? "\\" : "  /";
u += b ? "__\\" : "/";
b = !b;
}
Console.Write("{0}\n{1}\n{2}",s,t,u);
}
bacchusbeale
fuente
1
¡Buen trabajo! Tenga en cuenta que nunca es mejor usar un whilebucle, sino usar un forbucle. En este caso, puede guardar 2 bytes incluyendo la definición de men la inicialización del bucle for y, b=!ben el último caso, como se llame. También puede ahorrar ahorrando reemplazando stringy boolcon var. Tampoco necesita el "()" alrededor de las n>1cláusulas, y en la s+=cláusula puede usar el circuito no corto en &lugar de &&que no haya efectos secundarios o desreferencias para salir mal. Finalmente, 1>0es más corto que true;)
VisualMelon
3

C #, 257183 bytes

void C(int t){int i;var n="\r\n";var s="  "+string.Join("____",new string[1+t/2])+n;for(i=0;i++<=t;)s+=i%2<1?"\\ ":" /";s+=n;for(i=0;i++<=t;)s+=i%2<1?"__\\":"/";Console.WriteLine(s);}

Editar: Gracias a los consejos de @VisualMelon, ahorré 74 bytes.

Sé que está lejos de ser el mejor lenguaje para jugar golf, pero estoy interesado principalmente en aprender sobre los diversos matices de C #, en lugar de ganar la competencia. Esto es básicamente un puerto de esta respuesta Pyth.

Estoy pensando que los bucles for podrían jugar más, pero no estoy muy seguro de cómo, dadas las declaraciones terciarias incrustadas en ellos.

Ejemplo (1, 2, 3, 10):

 /\   
/__\  
  ____
 /\  /
/__\/
  ____
 /\  /\ 
/__\/__\
  ____________________
 /\  /\  /\  /\  /\  /
/__\/__\/__\/__\/__\/

Sin golf:

void C2(int t)
{
    int i;
    var n="\r\n";
    var s="  "+string.Join("____",new string[1+t/2])+n;
    for(i=0;i++<=t;)
        s+=i%2<1?"\\ ":" /";
    s+=n;
    for(i=0;i++<=t;)
        s+=i%2<1?"__\\":"/";
    Console.WriteLine(s);
}
Trent
fuente
Si bien los StringBuilders son rápidos y encantadores, si quieres un recuento bajo de bytes, s+=es tu amigo. De hecho, estás para bucles se puede hacer un poco más compacto. La alegría / horror de los operadores ++y --significa que puede hacer la mayor parte del trabajo en la verificación condicional for(i=0;i++<=t;)(esto verifica si ies menor o igual que t luego la incrementa). Haría bien en definir el int iexterior del bucle for, y reutilizarlo, y dado que puede garantizar que inunca será negativo, i%2==0puede intercambiarse por i%2<1. Con estos cambios, se alcanza fácilmente una puntuación inferior a 200bytes.
VisualMelon
1
Además, sospecho que usted escribió esto en LINQPad o similar, porque el acceso Enumerablegeneralmente requiere una using System.Linqdirectiva, y creo que generalmente se pretende que tales cláusulas estén incluidas. Sin embargo , en este caso, el único LINQ puede ser reemplazado por el var s=" "+string.Join("____",new string[1+t/2])+n;que no contiene LINQ, y es más corto que el código actual;) Une muchas cadenas nulas junto con lo que realmente nos importa, "____" (el 1 + t / 2 porque necesitamos otra cadena nula para que quepa otro "____" antes). La variable nse declara como "\ r \ n".
VisualMelon
Grandes consejos! Olvidé que Enumerable necesitaría System.Linq, apenas presto atención en estos días. ¡La punta del bucle for es útil!
Trent
Un poco tarde, pero podría ahorrar 4 bytes usando en Console.Writelugar deConsole.WriteLine
Metoniem
2

Java, 185

String f(int n){int i;String s="";if(n>1){s="  ";for(i=0;i<n/2;i++)s+="____";s+='\n';}for(i=0;i<=n;)s+=i++%2<1?" /":"\\ ";s+='\n';for(i=0;i<=n;i++)s+=i%2<1?i<n?"/_":"/":"_\\";return s;}

Explicación

String f(int n) {
    int i;
    String s = "";
    if (n > 1) {
        s = "  ";
        for (i = 0; i < n / 2; i++) {
            s += "____";
        }
        s += '\n';
    }
    for (i = 0; i <= n; i++) {
        s += i % 2 < 1 ? " /" : "\\ ";
    }
    s += '\n';
    for (i = 0; i <= n; i++) {
        s += i % 2 < 1 ? i < n ? "/_" : "/" : "_\\";
    }
    return s;
}
Ypnypn
fuente
2

C # - 151 146 141 138

Inspirado por la respuesta de @ bacchusbeale

string f(int n){string t="\n",s=n>1?"  "+new string('_',n/2*4)+t:"";for(var b=n<0;n-->=0;t+=b?"__\\":"/",b=!b)s+=b?"\\ ":" /";return s+t;}

Sin golf

    string f(int n)
    {
        string t = "\n", s = n > 1 ? "  " + new string('_', n / 2 * 4) + t : "";
        for (var b = n < 0; n-- >= 0; t += b ? "__\\" : "/", b = !b)
            s += b ? "\\ " : " /";
        return s + t;
    }
tia
fuente
1
¡Agradable, no estoy seguro de cómo me perdí esto antes de comentar las otras respuestas! ¡Esa sobrecarga new Stringes nueva para mí! Parece que se ha perdido su t=""versión de golf, aunque una mejor opción sería inicializar tcomo "\ n". Puede guardar un par de bytes añadiendo a tdonde le da la vuelta b, ahorrando el "{}" en el bucle for: t+=(b=!b)?"/":"__\\".
VisualMelon
1
@tis puede guardar un par más si se define tantes sy agregar ta la cadena en lugar de "\n";)
VisualMelon
1

Ir, 156 144

func f(n int){a,b,c:="  ","","";for i:=0;i<=n;i++{if i<n/2{a+="____"};if i%2<1{b+=" /";c+="/"}else{b+=`\ `;c+=`__\`}};print(a+"\n"+b+"\n"+c)}

Sin golf:

func f(n int) {
    a, b, c := "  ", "", ""   // Initialize 3 accumulators
    for i := 0; i <= n; i++ { // For each required triangle
        if i < n/2 {          // Yay integer math
            a += "____"
        }
        if i%2 < 1 {          // Even, uneven, (are we drawing up or downslope?)
            b += " /"
            c += "/"
        } else {
            b += `\ `
            c += `__\`
        }
    }
    print(a + "\n" + b + "\n" + c)
}

El único truco real aquí (y ni siquiera es bueno) es usar 3 acumuladores para poder condensar la solución en 1 bucle.

El código se puede ejecutar aquí: http://play.golang.org/p/urEO1kIjKv

Kristoffer Sall-Storgaard
fuente
simplemente use en c += `__\` lugar deif i<n{c+="_"}
MarcDefiant
@MarcDefiant Actualizado, gracias
Kristoffer Sall-Storgaard
1

> <> (Fish) , 215 183 156 bytes

Editar: Notepad ++ me estaba dando 5 bytes adicionales debido a CR, por lo que el recuento modificado en consecuencia

Un poco más golfizado, pero es mi primer programa de pesca hasta ahora> _ <El requisito de no tener una primera línea en blanco para 1 triángulo duplicó el tamaño del programa.

99+0{:}1=?.~~"  "oo:2,:1%-v
-1  oooo  "____"  v!?  )0:/!
" /"oa~~.?=1}:{24~/:oo
v!?)0:-1o"\"v!?)0:/!-1ooo"  /"
/v   ~o"/"oa/!
!\:0)?!;"\__"ooo1-:0)?!;"/"o1-

Puede probar en http://fishlanguage.com/ (Int en la pila inicial para la longitud)

Explicación:

       Start with initial stack as input number
99+0   Push 18 and 0 to the top of the stack
{:}    Shift the stack to the left (wraps), copy the top value, and shift it back to the left (i.e. copy bottom of stack to the top)
1=     Check to see if the top of the stack is equal to 1, pushes 1 for true, 0 for false
?.     If top of stack is zero, skip the ., otherwise jumps to x,y coordinates on top of stack (18,0). This skips the next 8 instructions
~~     Pop the top 2 values from the stack (if they're not popped by the jump)
"  "   Push the string literal "  " onto the stack
oo     Pop the top two values of stack and output them as characters
:2,    Copy top value of stack, ad divide by 2
:1%-   Since ><> uses float division, and doesn't have >= notation, remove the decimal part (if exists)
v      Redirect pointer down
/      Redirect pointer left
:0)    Copy top of stack, and see if its greater than 0 (1 for true, 0 for false)
?!v    If top of stack is non-zero, then ! is executed, which skips the next instruction (redirect), otherwise, code is redirected
"____" Push the literal "____" to the stack
oooo   Pop the top four values of stack and output them as characters
1-     Decrement the top of the stack by 1
!/     Ignore the redirect action.
       When the loop gets to 0, it goes to next line, and gets redirected to the left.
~      Pops the top of the stack (0 counter)
42     Pushes 4 and 2 to the stack
{:}    As before, copies the bottom of the stack to the top
1=?.   Also as before, if the initial value is 1, jump to (2,4) (skipping next 4 instructions
~~     Pop 2 values from stack if these instructions haven't been skipped
ao     Push 10 onto the stack and output it as a character (LF)
"/ "oo Push the literal "/ " onto the stack and output it
://    Copies the top of the stack then redirects to the line below, which then redirects to the left
:0)    Copies top of the stack and compares if its greater than 0
?!v    If it is, redirect to next line
"\"o   Push "\" to stack, then output it as a character
1-     Decrement top value of stack
:0)?!v If loop is not greater than 0, redirect to next line
       Either mode of redirect will loop to the left, and (potentially) skip the far right redirect because of the !
ao     Push 10 to stack and output it as a character (LF)
"/"o~  Push "/" to stack, then output it as a character. Pop top value of stack (the 0 from previous loop)
v      Redirects to next line, which then redirects to the right
:0)?!; If the top of the stack is not greater than 0, terminate (;)
"\__"  Pushes "\__" to the stack
ooo    Outputs top 3 stack values as characters ("__\")
1-     Decrement top of stack by 1
:0)?!; If the top of the stack is not greater than 0, terminate (;)
"/"o   Push "/" to top of stack then output it as a character
1-     Decrement top of stack by 1
!\     Ignore the redirect
Fongoid
fuente
1
Buen intérprete! ¿Lo has hecho tú mismo?
Sp3000
Ni siquiera un poco. : PI lo usó ampliamente para enseñarme el idioma ... y para depurar. Acabo de ver el lenguaje flotando y pensé que era muy interesante (también quiero probar Marbles).
Fongoid
1

perl 109 108 106

$i=<>;$t=join$/,$i-1?"  "."_"x($i/2)x4:(),$m.=(" /")[$_&1]||"\\ ",$b.=("/")[$_&1]||"__\\"for 0..$i;print$t

Creo que esto está bien para mi primer golf, utilicé la sección de Vynce para la primera línea, con el resto de mi código para superar el problema de la nueva línea con 1 triángulo.

Ahora para ver si puedo acortarlo :)

Editar : espacios en blanco

Edición 2 : reemplazado "\n"por$/

1:
 /\
/__\

4:
  ________
 /\  /\  /
/__\/__\/
Caek
fuente
1

C89, 150

r(p,q,n)int*p,*q;{n?printf(p),r(q,p,n-1):puts(p);}main(c,v)int**v;{c=atoi(v[1]);if(c>1)printf("  "),r("","____",c-1);r(" /","\\ ",c);r("/","__\\",c);}

Una versión sin golf:

r(p, q, n) char *p, *q; {
    if(n > 0) {
        printf(p);
        r(q, p, n-1); /* swap p and q */
    } else {
        puts(p);
    }
}

main(c, v) char**v; {
    c = atoi(v[1]);
    if(c>1) {
        printf("  ");
        r("", "____", c - 1);
    }
    r(" /", "\\ ", c);
    r("/", "__\\", c);
}

La salida:

$ seq 1 3 10 | xargs -n1 ./triangles
 /\
/__\
  ________
 /\  /\  /
/__\/__\/
  ____________
 /\  /\  /\  /\
/__\/__\/__\/__\
  ____________________
 /\  /\  /\  /\  /\  /
/__\/__\/__\/__\/__\/

La pila se desborda si entro 65535(¡pero no si compilas con ella -O3!), Pero en teoría debería funcionar ;-)

editar: el programa ahora cumple el requisito de que solo se emitan dos líneas si 1se pasa al programa editar 2: usar en int*lugar dechar*

MarcDefiant
fuente
Podrías declarar maincomo main(c,v)**v;si eso funcionara.
FUZxxl
Me preguntaba si podría guardar algo teniendo co ncomo una variable global, por lo que no tiene que pasarle ese parámetro r(). No creo que su respuesta cumplaNote that for 1 the output is two lines long but otherwise it's three. This is required.
Level River St
@FUZxxl desafortunadamente esto no funciona :-(error: expected declaration specifiers before ‘*’ token main(c,v)**v;{
MarcDefiant
@steveverrill lo arregló, pero necesitaba alargar el código. No se pudo encontrar una solución global no cmás corta tampoco.
MarcDefiant
@MarcDefiant ¿Pudiste pasar un int**?
FUZxxl
1

C ++ stdlib, 194 bytes

string f(int n){char* p[]={"____"," /\\ ","/__\\"};int x[]={(n-n%2)*2,n*2+2-n%2,n*2+1+n%2},i,j;string s=n>1?"  ":"";for (i=n>1?0:1;i<3;s+=++i<3?"\n":"")for (j=0;j<x[i];)s+=p[i][j++%4];return s;}

Programa de prueba:

#include <string>
#include <iostream>

using namespace std;

string f(int n)
{
    char* p[]={"____"," /\\ ","/__\\"};
    int x[]={(n-n%2)*2,n*2+2-n%2,n*2+1+n%2},i,j;
    string s=n>1?"  ":"";
    for (i=n>1?0:1;i<3;s+=++i<3?"\n":"")
        for (j=0;j<x[i];)
            s+=p[i][j++%4];
    return s;
}

int main(int argc, char* argv[])
{
    cout << f(10);
    return 0;
}
Oleg
fuente
1

Bash, 166 127 125 119 105 bytes

printf -v l %$[$1/2]s;(($1%2))&&r= j=$l\ ||r=/ j=$l;echo "  ${l// /____}
${j// / /\ } $r
${j// //__\\}"$r

En una función:

triangle() {
    printf -v l %$[$1/2]s;(($1%2))&&r= j=$l\ ||r=/ j=$l;echo "  ${l// /____}
${j// / /\ } $r
${j// //__\\}"$r
}

Con algunas presentaciones:

for i in {1..5} 10 31;do
    paste -d\  <(
        figlet -fsmall $i |
             sed 's/^/         /;s/^ *\(.\{10\}\)$/\1  /;$d'
    ) <(triangle $i)
  done

Puede renderizar (si tiene figlet instalado):

        _      
       / |    /\  
       | |   /__\
       |_|   
      ___      ____
     |_  )    /\  /
      / /    /__\/
     /___|   
      ____     ____
     |__ /    /\  /\  
      |_ \   /__\/__\
     |___/   
     _ _       ________
    | | |     /\  /\  /
    |_  _|   /__\/__\/
      |_|    
      ___      ________
     | __|    /\  /\  /\  
     |__ \   /__\/__\/__\
     |___/   
   _  __       ____________________
  / |/  \     /\  /\  /\  /\  /\  /
  | | () |   /__\/__\/__\/__\/__\/
  |_|\__/    
    _____      ____________________________________________________________
   |__ / |    /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  
    |_ \ |   /__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\
   |___/_|   

Guardar 2 caracteres si la entrada de la variable en lugar de $1: 103

printf -v l %$[i/2]s;((i%2))&&r= j=$l\ ||r=/ j=$l;echo "  ${l// /____}
${j// / /\ } $r
${j// //__\\}"$r

En el bucle:

for i in {1..3} {31..34};do
    [ $i == 31 ] && figlet -fsmall ...
    paste -d\  <(
        figlet -fsmall $i |
            sed 's/^/         /;s/^ *\(.\{10\}\)$/\1   /;$d'
    ) <(
        printf -v l %$[i/2]s;((i%2))&&r= j=$l\ ||r=/ j=$l;echo "  ${l// /____}
${j// / /\ } $r
${j// //__\\}"$r
    )
  done

Renderizará (aproximadamente) lo mismo:

        _       
       / |     /\  
       | |    /__\
       |_|    
      ___       ____
     |_  )     /\  /
      / /     /__\/
     /___|    
      ____      ____
     |__ /     /\  /\  
      |_ \    /__\/__\
     |___/    


 _ _ _ 
(_|_|_)

    _____       ____________________________________________________________
   |__ / |     /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  
    |_ \ |    /__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\
   |___/_|    
  _______       ________________________________________________________________
 |__ /_  )     /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /
  |_ \/ /     /__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/
 |___/___|    
  ________      ________________________________________________________________
 |__ /__ /     /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  
  |_ \|_ \    /__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\
 |___/___/    
 _____ _        ____________________________________________________________________
|__ / | |      /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /
 |_ \_  _|    /__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/__\/
|___/ |_|     
F. Hauri
fuente
1
¡Debe publicar una pregunta sobre un codegolf de implementación de figlets!
sergiol
1

Carbón , 27 bytes (sin competencia)

Sin competencia porque el lenguaje es posterior al desafío.

FEN﹪鲫P×⁴_↗⊗¬ι↓P↘²↘⊗ι↑P↗⊗ι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

FEN﹪鲫

Genere una lista de bits alternos de longitud ny repítalos.

P×⁴_

Dibuja ____sin mover el cursor.

↗⊗¬ι↓

En el primer y cada dos triángulos, dibuja el /lado izquierdo .

P↘²

Dibuja el \lado sin mover el cursor.

↘⊗ι↑

En el segundo y cada dos triángulos, dibuja el \lado izquierdo nuevamente para mover el cursor.

P↗⊗ι

En el segundo y cada dos triángulos, dibuja el /lado derecho , sin mover el cursor.

Neil
fuente
1
Las respuestas ya no tienen que ser marcadas como no competidoras
Jo King
1

PowerShell , 116 95 bytes

Muchas gracias a Mazzy y ASCII-Only por guardar 21 bytes.

param($n)@("  "+"_"*4*($x=$n-shr1))[$n-eq1]
" /"+"\  /"*$x+"\"*($a=$n%2)
"/"+"__\/"*$x+"__\"*$a

Pruébalo en línea!

No permitir una línea vacía para n = 1 consumió como 14 10 bytes. Esta solución es bastante mortal ahora mucho más inteligente con una cantidad mínima de código repetido. El redondeo bancario sigue siendo el verdadero demonio.

Veskah
fuente
¿No se permite una línea vacía?
Solo ASCII
@ Solo ASCII Lea la cuarta viñeta del OP.
Veskah
maldita sea
solo ASCII
1
@ Solo para ASCII Saltos en x = 3 El reemplazo de la cuerda es cómo se evita el redondeo del banquero
Veskah
1
@mazzy no puedes generar una primera línea, de lo contrario sería 102
solo ASCII
0

C, 368 bytes

void p(char* c){printf(c);}
int x(int s,int f){int t=0,p=s;for(int i=0;i<f;i++){if(p==1){t++;p=0;}else{p=1;}}return t;}
int main(int argc,char* argv[]){int t=atoi(argv[1]);if(t>1){p("  ");for(int i=0;i<x(0,t);i++)
{p("____");}p("\n");}for(int i=0;i<x(1,t);i++){p(" /\\ ");}if(t%2==0){p(" /");}p("\n");
for(int i=0;i<x(1,t);i++){p("/__\\");}if(t%2==0){p("/");}p("\n");}

Es más si cuenta las #includedeclaraciones, pero se compiló en gcc, aunque con advertencias, sin ellas. Sé que no es el más corto de lejos, pero todavía me gusta que lo hice en C.

Hola llama
fuente
La macro #define p(c)printf(c)es más corta que su función. Puede omitir los tipos de retorno en las funciones (por defecto son int). También puede definir la función en un C89estilo como este main(c,v)char**v;{}. Esa es la abreviatura deint main(int c, char** v){}
MarcDefiant
0

Perl (simple) 131 125 120

primer pase bastante sencillo:

$i=<>;print join"\n",$i-1?"  "."_"x(4*int($i/2)):(),join("",map{(" /","\\ ")[$_%2]}0..$i),join"",map{("/","__\\")[$_%2]}0..$i

oh quien necesita int explícito?

$i=<>;print join"\n",$i-1?"  "."_"x($i/2)x4:(),join("",map{(" /","\\ ")[$_%2]}0..$i),join"",map{("/","__\\")[$_%2]}0..$i
Vynce
fuente
0

Prólogo, 126 bytes

A+B:-writef(A,B).
$N:-(N>1,"  %r\n"+['____',N//2];!),(0is N/\1,T='/';T='')," %r%w\n"+['/\\  ',N/2,T],"%r%w\n"+['/__\\',N/2,T].

Invocar como $3.

Más legible:

triangle(N):-
    (   N > 1
    ->  writef("  %r\n", ['____', N//2])
    ;   true
    ),
    (   0 is N mod 2
    ->  T = '/'
    ;   T = ''
    ),
    writef(" %r%w\n", ['/\\  ', N/2, T]),
    writef("%r%w\n", ['/__\\', N/2, T]).

Ejemplo:

?- findall(N,between(1,10,N),NN), maplist($, NN), !.
 /\  
/__\
  ____
 /\  /
/__\/
  ____
 /\  /\  
/__\/__\
  ________
 /\  /\  /
/__\/__\/
  ________
 /\  /\  /\  
/__\/__\/__\
  ____________
 /\  /\  /\  /
/__\/__\/__\/
  ____________
 /\  /\  /\  /\  
/__\/__\/__\/__\
  ________________
 /\  /\  /\  /\  /
/__\/__\/__\/__\/
  ________________
 /\  /\  /\  /\  /\  
/__\/__\/__\/__\/__\
  ____________________
 /\  /\  /\  /\  /\  /
/__\/__\/__\/__\/__\/
NN = [1, 2, 3, 4, 5, 6, 7, 8, 9|...].
kay
fuente
0

C #: 1 línea LINQ, 198 bytes

string f(int n){return(n>1?"  ":"")+string.Join("\n",new[]{"____"," /\\ ","/__\\"}.Zip(new[]{(n-n%2)*2,n*2+2-n%2,n*2+1+n%2},(s,l)=>string.Join(s,new string[n+1]).Substring(0,l)).Where(x=>x.Any()));}
Oleg
fuente
0

Retina , 88 bytes (sin competencia)

Sin competencia porque el lenguaje es posterior al desafío.

K`  ____¶ /\  /¶/__\/
%`....$
$+*$&
%`(.+)\1$
$1
(  (____)*)__(¶.*)  /(¶.*)/
$1$3$4
G`\S

Pruébalo en línea! Explicación:

K`  ____¶ /\  /¶/__\/

Reemplace la entrada con un par de triángulos.

%`....$
$+*$&

Multiplica los triángulos por la entrada original.

%`(.+)\1$
$1

Divide los triángulos por 2.

(  (____)*)__(¶.*)  /(¶.*)/
$1$3$4

Retire el medio triángulo sobrante.

G`\S

Elimine la primera línea si ahora está en blanco.

Neil
fuente
0

Perl 6 , 83 bytes

{~["  {'____'x$_/2-.5}
"x($_>2),'/\  'x$_/2~($!='/'x$_%2),"
"~'/__\\'x$_/2~$!]}o*+1

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una cadena.

Jo King
fuente
0

05AB1E , 37 bytes

≠iðð'_I2÷4*×J}„ /„\ ‚I>∍J'/…__\‚I>∍J»

Pruébelo en línea o verifique las primeras 10 salidas .

Explicación:

i            } # If the (implicit) input is NOT 1:
                #   i.e. 1 → 0 (falsey)
                #   i.e. 5 → 1 (truthy)
  ðð            #  Push two spaces "  "
    '_         '#  Push string "_"
      I         #  Push the input
       2÷       #  Integer-divide it by 2
                #   i.e. 5 → 2
         4*     #  And then multiply it by 4
                #   i.e. 2 → 8
           ×    #  Repeat the "_" that many times
                #   i.e. "_" and 8 → "________"
            J   #  Join everything on the stack together to a single string
                #   i.e. "  ________"
 /             # Push string " /"
   \           # Push string "\ "
               # Pair them together: [" /","\ "]
      I>        # Push the input+1
               # Extend the list to that size
                #  i.e. [" /","\ "] and 2 → [" /","\ "]
                #  i.e. [" /","\ "] and 6 → [" /","\ "," /","\ "," /","\ "]
         J      # Join the list together to a single string
                #  i.e. [" /","\ "] → " /\ "
                #  i.e. [" /","\ "," /","\ "," /","\ "] → " /\  /\  /\ "
'/             '# Push string "/"
  __\          # Push string "__\"
               # Pair them together: ["/","__\"]
       I>       # Push the input+1
               # Extend the list to that size
                #  i.e. ["/","__\"] and 2 → ["/","__\"]
                #  i.e. ["/","__\"] and 6 → ["/","__\","/","__\","/","__\"]
          J     # Join the list together to a single string
                #  i.e. ["/","__\"] → "/__\"
                #  i.e. ["/","__\","/","__\","/","__\"] → "/__\/__\/__\"
»               # Join the entire stack with a newline delimiter
                #  i.e. " /\ " and "/__\" → " /\ \n/__\"
                #  i.e. "  ________", " /\  /\  /\ " and "/__\/__\/__\"
                #   → "  ________\n /\  /\  /\ \n/__\/__\/__\"
                # (and output the result implicitly)
Kevin Cruijssen
fuente
0

Java 11, 122 bytes

n->(n>1?"  "+"_".repeat(n/2*4)+"\n":"")+" /\\ ".repeat(n).substring(0,++n*2)+"\n"+"/__\\".repeat(n).substring(0,n/2*4+n%2)

Pruébalo en línea.

Explicación:

n->                   // Method with integer parameter and String return-type
  (n>1?               //  If the input is larger than 1:
    "  "              //   Return two spaces
    +"_".repeat(      //   Appended with "_" repeated the following amount of times:
          n/2         //    The input integer-divided by 2
             *4)      //    And then multiplied by 4
    +"\n"             //   Appended with a newline
   :                  //  Else:
    "")               //   Return nothing
  +" /\\ ".repeat(n)  //  Appended with " /\ " repeated the input amount of times
    .substring(0,     //   After which we only leave the first `x` characters, where `x` is:
      ++n             //    Increase the input by 1 first with `++n`
         *2)          //    And then multiply it by 2
                      //     i.e. For input 1, `x` becomes 4 here
                      //     i.e. For input 6, `x` becomes 14 here
  +"\n"               //  Appended with a newline
  +"/__\\".repeat(n)  //  Appended with "/__\" repeated the input amount of times
    .substring(0,     //   After which we only leave the first `y` characters, where `y` is:
      n/2             //    The input+1 integer-divided by 2
         *4           //    Then multiplied by 4
           +n%2)      //    And then the input+1 modulo-2 added
                      //     i.e. For input 1, `y` becomes 4 here
                      //     i.e. For input 6, `y` becomes 13 here
Kevin Cruijssen
fuente