Trasfondo

_{^{No es realmente real, sshh!}}

Todo comenzó un día cuando un compañero de trabajo trajo una hogaza de pan casera para el cumpleaños de mi jefe.

A mi jefe realmente le gustaba esta barra de pan, y quería otra. Por desgracia, mi compañero de trabajo ha dejar de fumar, por lo que mi jefe necesita de mí para darle otra hogaza.

El problema es que no tengo idea de cómo hacer pan. Entonces le dije a mi jefe que no soy chef y que debería buscar a alguien que lo sea.

Él dijo: "Claro ... pero pierdes tu trabajo si no puedes hacerme un pan".

Entonces tuve una idea.

¡Le haría un pan de arte ascii con mi habilidad de codificación! Él dijo que sí, bajo 1 condición: "Debe hacerlo en menos de 351 bytes". Desafortunadamente para mí, mi mejor código de golf me llevó a 375 bytes. UH oh.

Luego mi jefe agregó 2 cosas: "Debes darme ese pan en una semana (4/13), y si lo haces, obtienes un mayor salario. Cuanto menor sea la cantidad de bytes que uses, mejor salario. Pero recuerda, si superas los 349 pierdes tu trabajo ".

¡Entonces necesito su ayuda en el idioma que elija para ayudarme a mantener mi trabajo!

Reglas

Estaba a punto de hacer un curl ... | shTinyURL, pero mi jefe me dijo que no puedo usar una lista de lagunas . Probablemente podría eludir las reglas, pero mi trabajo está en juego, así que no es una buena idea.

Lo que cuenta como un pan

Su programa o función debe tomar 3 enteros positivos como entrada. Si su idioma tiene una lista o matriz, puede tomar una lista o matriz de esos números. También puede tomarlos como argumentos para una función o programa, o una cadena de números separados por espacios para STDIN, una línea de comando o argumento de función, etc.

El primer número es el ancho de tu pan

El segundo número es la altura de su pan.

El tercer número es la profundidad de su pan.

Aquí hay un pan con un ancho 3, una altura 2y una profundidad de 1:

 / --- \
/ --- \ |
El | ||
| ___ | /

¿Parece extraño? Aquí hay un 3x2x2:

  / --- \
 / |
/ --- \ |
El | El | / /
| ___ | /

¿Qué tal un 3x3x3:

   / --- \
  / |
 / |
/ --- \ |
El | El | / /
El | El | / /
| ___ | /

Un 4x1x2:

  / ---- \
 / |
/ ---- \ /
| ____ | /

¡Espero que entiendas! Vea mi respuesta JS (ES6) a continuación para ver un ejemplo.

Ver también casos de prueba completos

Notas:

• No te preocupes por la entrada válida. Todos los tamaños serán enteros positivos.
• Debe aceptar los enteros positivos que su idioma pueda admitir.
• Si los números son tan altos, sus idiomas se bloquean por StackOverflow, desbordamiento de la longitud máxima de la cadena, etc., está bien.

¡La respuesta más corta en bytes gana!

Carbón , 35 33 30 bytes

Guardado 2 bytes gracias a @ ASCII-only

Ahorró 3 bytes gracias a @Neil al reorganizar el orden en que se dibujaron las líneas

ＮωＮηＮδ↓η↗→×_ω↑η←\←ω↗δ→/ω↓\↓η↙δ

Pruébalo en línea!

Este es mi primer intento en carbón. Escuché que era bueno en ascii-art , así que lo probé.

Explicación (obsoleta)

ＮωＮηＮδ                  # Take the width, height and depth as input
↗¹                        # Write 1 /
↗δ                        # Write depth times /
¶ω                        # Move the cursor down and write - width times
\                         # Write \
↙↓η                       # Move the cursor one down and one left, and then write | height times
↙δ                        # Write / depth times

Ahora la parte posterior del pan está completa. Ahora viene la cara frontal.

↑↑η                       # Go up and write | height times
←\                        # Write a \ and move 1 to the left
←ω                        # Write - width times
↓↓η                       # Go down and write | height times
↗Ｐ×_ω                    # Go northeast and write _ width times

C, 270 290 320 328 bytes

#define P printf(
p(n,s)char*s;{P s,--n&&p(n,s));}i,j,k;f(w,h,d){P "%*c",d+1,47);p(w,"-");P "\\\n");for(i=d,j=h,k=0;--i;)P "%*c%*c\n",i+1,47,w+d+1-i-k+!!k,j-->0?124:(++k>0)*47);P "/");p(w,"-");P "\\%*c\n",d-k,j-->0?124:47);for(k&&k++;++i<h;)P "|%*c%*c\n",w+1,124,d-k>!k?d+1-k-!k:0,j-->0?124:(++k>0)*47);P "|");p(w,"_");P "|/");}

Finalmente (después de dos tres versiones incorrectas) funciona correctamente con tamaños grandes también.

Pruébalo en línea!

JS (ES6), 375 bytes

s=(s,t)=>s.repeat(t);(d,c,e)=>{z=" ",y=`
`,x="\\",w="/",v="|",u="-";a=s(z,e--);a=a+w+s(u,d);a+=x+y;for(b=0;b<e;b++)a+=s(z,e-b),b<c?(a+=w,a+=s(z,d+b+1),a+=v):(a+=w,a+=s(z,d+c+1),a+=w),a+=y;a=a+w+s(u,d);a+=x;f=0;b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w);b++;f++;a+=y;for(g=0;g<c;g++)a+=v,a+=s((g==c-1?"_":z),d),a+=v,b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w),b++,f++,a+=y;return a}

Sin golf:

var proc = function(width, height, depth){
    var str = "";

    //Back of loaf (depth)
    str += " ".repeat(depth);//initial padding before start of back of loaf
    str += "/";//top left corner of back of loaf
    str += "-".repeat(width);//top edge of back of loaf
    str += "\\";//top left corner of back of loaf
    str += "\n";//end line

    //Depth lines
    for(var i = 0; i < depth - 1; i++){
        console.log(i)
        str += " ".repeat(depth - i - 1);//space padding before start of left middle edge
        if(i < height){
            //str += " ".repeat(depth - i - 2);
            str += "/";//left middle edge
            str += " ".repeat(width + i + 1);//middle of loaf
            str += "|";//end that edge
            str += "\n";//end line
        }else{
            str += "/";//left middle edge
            str += " ".repeat(width + height + 1);//between two /s
            str += "/";//right middle edge
            str += "\n";//end line
        }
    }

    //front top edge of loaf
    str += "/";//top left corner
    str += "-".repeat(width);//top edge
    str += "\\";//top right corner

    var i3 = 0;

    if(i < height){
        str += " ".repeat(depth - 1);//space for the incoming far right edge
        str += "|";//far right edge
        i++;
        i3++;
    }else{
        str += " ".repeat(height - i3);//space for the incoming far right edge
        str += "/";//far right edge
        i++;
        i3++;
    }

    str += "\n";//newline


    for(var i2 = 0; i2 < height; i2++){
        str += "|";//left edge
        str += (i2 === height - 1 ? "_" : " ").repeat(width);//if we are at the bottom, use underscores to mark that, otherwise spaces.
        str += "|";
        if(i < height){
            str += " ".repeat(depth - 1);//space for the incoming far right edge
            str += "|";//far right edge
            i++;
            i3++;
        }else{
            str += " ".repeat(height - i3);//space for the incoming far right edge
            str += "/";//far right edge
            i++;
            i3++;
        }
        str += "\n";//newline
    }

    return str;
};

s=(s,t)=>s.repeat(t);
var bakeBread = (d,c,e)=>{z=" ",y=`
`,x="\\",w="/",v="|",u="-";a=s(z,e--);a=a+w+s(u,d);a+=x+y;for(b=0;b<e;b++)a+=s(z,e-b),b<c?(a+=w,a+=s(z,d+b+1),a+=v):(a+=w,a+=s(z,d+c+1),a+=w),a+=y;a=a+w+s(u,d);a+=x;f=0;b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w);b++;f++;a+=y;for(g=0;g<c;g++)a+=v,a+=s((g==c-1?"_":z),d),a+=v,b<c?(a+=s(z,e),a+=v):(a+=s(z,c-f),a+=w),b++,f++,a+=y;return a}

<input type = "number" id = "a1">
<br/>
<input type = "number" id = "a2">
<br/>
<input type = "number" id = "a3">
<br/>
<button onclick = "document.getElementById('textarea').innerText = bakeBread(+(document.getElementById('a1').value), +(document.getElementById('a2').value), +(document.getElementById('a3').value))">Bake Bread!</button>
<br/>
<textarea id = "textarea"></textarea>

Python 2 , 234 216 210 bytes

w,h,d=input()
f,g='|','/';z,s=g+'-'*w+'\\',' '
print'\n'.join([s*d+z]+[s*(d-c)+g+s*(w+c)+(f,g)[c>h]for c in range(1,d)]+[z+s*(d-1)+(f,g)[d>h]]+[f+s*w+f+s*(h-e-1)+(f,s+g)[d>=h]for e in range(1,h)]+[f+'_'*w+f+g])

Pruébalo en línea!

Claro que se puede jugar mucho más al golf, pero es un comienzo. 210 lo hará por mí por ahora.

PHP, 420 bytes

<?php $a=$_GET["a"];$b=$_GET["b"];$c=$_GET["c"];$w="<br>";$s="&nbsp;";$u="&#95";$p="|";$k="/";$t=str_repeat;$l='';$r=$t($s,$c).$k.$t("-",$a)."\\".$w;for($i=0;$i<$c+$b-1;$i++){$i<=$b-1?($i<$c-1?$l=$t($s,$a+$i+1).$p:$l=$t($s,$c-1).$p):($i<$c-1?$l=$t($s,$a+$b+1).$k:$l=$t($s,$c+$b-$i-1).$k);$i<$c-1?$r.=$t($s,$c-$i-1).$k.$l.$w:($i==$c-1?$r.=$k.$t("-",$a)."\\".$l.$w:$r.=$p.$t($s,$a).$p.$l.$w);};echo$r.=$p.$t($u,$a).$p.$k?>

Parece que alguien ha sido despedido, tal vez intente convencer a su jefe de que es mucho mejor en el backend.

La entrada se adjunta a la cadena de URL: ?a=[width]&b=[height]&c=[depth] - puede probarlo en línea en mi host barato. En estas situaciones, me encanta usar solicitudes GET.

Sin espíritu de transparencia:

<?php 
$a=$_GET["a"];$b=$_GET["b"];$c=$_GET["c"];
$w="<br>";$s="&nbsp;";$u="&#95"; $p="|";$k="/";$t=str_repeat;$f=$v=$m=$l='';
//first line
$r=$t($s,$c).$k.$t("-",$a)."\\".$w;


for($i=0;$i<$c+$b-1;$i++){

    //right side of the loaf
    $i <= $b-1 
    ? ($i < $c-1 ? $l=$t($s,$a+$i+1).$p : $l=$t($s,$c-1).$p)  
    : ($i < $c-1 ? $l=$t($s,$a+$b+1).$k : $l=$t($s,$c+$b-$i-1).$k) ;

    //left side, with the right side attached
    $i<$c-1 
        ? $r.=$t($s,$c-$i-1).$k.$f.$l.$w
        : ($i==$c-1 
            ? $r.=$k.$t("-",$a)."\\".$f.$l.$w
            : $r.=$p.$t($s,$a).$p.$f.$l.$w);

};
    //final line
    echo $r.=$p.$t($u,$a).$p.$k;

?>

JavaScript (ES6), 204 bytes

(w,h,d)=>[...Array(h-~d)].map((_,y)=>[...Array(w-~d)].map((_,x)=>x+y==d|x+y==h+w-~d?`/`:x==w+d&y<=h&&y||!x|x==w&&y>d?`|`:y==h+d&x<w?`_`:!y|y==d?x+y==w+d?`\\`:x+y>d&x+y<w+d?`-`:` `:` `).join``,++w).join`\n`

Donde \nrepresenta el carácter literal de nueva línea.

En lugar de jugar con caracteres repetidos, esto solo crea una matriz de tamaño adecuado y calcula qué carácter aparece en cada celda.