Hintergrundgeschichte

_{^{Nicht wirklich real, sshh!}}

Alles begann eines Tages, als ein Mitarbeiter zum Geburtstag meines Chefs ein hausgemachtes Brot mitbrachte .

Mein Chef mochte dieses Brot wirklich und er wollte ein anderes. Leider hat mein Kollege gekündigt, und mein Chef braucht mich , um ihm ein weiteres Brot zu geben.

Das Problem ist, ich habe keine Ahnung, wie man Brot macht. Also sagte ich meinem Chef, dass ich kein Koch bin und härter nach jemandem suchen soll, der es ist.

Er sagte: "Sicher ... aber du verlierst deinen Job, wenn du mich nicht zum Brot machen kannst."

Dann hatte ich eine Idee.

Ich würde ihn mit meinem Codierungs-Skilz zu einem ASCII-Kunst- Brot machen! Er sagte ja, unter 1 Bedingung: "Sie müssen es in weniger als 351 Bytes schaffen." Leider brachte mich mein bestes Code-Golfen auf 375 Bytes. Oh oh.

Dann fügte mein Chef zwei Dinge hinzu: "Sie müssen mir dieses Brot in einer Woche (4/13) geben, und wenn Sie dies tun, erhalten Sie ein höheres Gehalt. Je geringer die Anzahl der von Ihnen verwendeten Bytes ist, desto besser ist das Gehalt. Aber denken Sie daran, Wenn Sie über 349 gehen, verlieren Sie Ihren Job. "

Ich brauche Ihre Hilfe in der Sprache Ihrer Wahl, damit ich meinen Job behalten kann!

Regeln

Ich wollte gerade curl ... | sheine TinyURL machen, aber mein Chef sagte mir, dass ich keine Liste von Lücken verwenden kann . Ich könnte wahrscheinlich die Regeln umgehen, aber mein Job steht auf dem Spiel, also ist es keine gute Idee.

Was zählt als Laib

Ihr Programm oder Ihre Funktion muss 3 positive ganze Zahlen als Eingabe verwenden. Wenn Ihre Sprache eine Liste oder ein Array enthält, können Sie eine Liste oder ein Array dieser Zahlen erstellen. Sie können sie auch als Argumente für eine Funktion oder ein Programm oder als durch Leerzeichen getrennte Zahlenfolge für STDIN, als Befehlszeilen- oder Funktionsargument usw. verwenden.

Die erste Zahl ist die Breite Ihres Laibs

Die zweite Zahl ist die Höhe Ihres Laibs.

Die dritte Zahl ist die Tiefe Ihres Laibs.

Hier ist ein Laib mit einer Breite 3, einer Höhe 2und einer Tiefe von 1:

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

Sieht komisch aus? Hier ist ein 3x2x2:

  / --- \
 / |
/ --- \ |
| | /.
| ___ | /

Wie wäre es mit einem 3x3x3:

   / --- \
  / |
 / |
/ --- \ |
| | /.
| | /.
| ___ | /

A 4x1x2:

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

Ich hoffe, Sie verstehen! Ein Beispiel finden Sie in meiner JS (ES6) -Antwort unten.

Siehe auch vollständige Testfälle

Anmerkungen:

• Mach dir keine Sorgen über gültige Eingaben. Alle Größen sind positive ganze Zahlen.
• Sie müssen alle positiven Ganzzahlen akzeptieren, die Ihre Sprache unterstützen kann.
• Wenn die Zahlen so hoch sind, dass Ihre Sprachen durch StackOverflow, maximalen Überlauf der Zeichenfolgenlänge usw. abstürzen, ist das in Ordnung.

Die kürzeste Antwort in Bytes gewinnt!

Holzkohle , 35 33 30 Bytes

2 Bytes dank @ ASCII-only gespeichert

Dank @Neil wurden 3 Bytes gespeichert, indem die Reihenfolge neu geordnet wurde, in der die Linien gezeichnet wurden

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

Probieren Sie es online aus!

Dies ist mein erster Versuch bei Charcoal. Ich habe gehört, dass es gut in ASCII-Kunst ist , also habe ich es ausprobiert.

Erklärung (veraltet)

ＮωＮηＮδ                  # 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

Jetzt ist der hintere Teil des Laibs fertig. Jetzt kommt die Vorderseite.

↑↑η                       # 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 "|/");}

Schließlich (nach zwei drei falschen Versionen) funktioniert es auch bei großen Größen korrekt.

Probieren Sie es online aus!

JS (ES6), 375 Byte

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}

Ungolfed:

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])

Probieren Sie es online aus!

Sicher, es kann viel mehr Golf gespielt werden, aber es ist ein Anfang. 210 wird für mich vorerst tun.

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

Klingt so, als wäre jemand gefeuert - versuchen Sie vielleicht, Ihren Chef davon zu überzeugen, dass es im Backend viel cooler ist.

Die Eingabe ist an die URL-Zeichenfolge angehängt: ?a=[width]&b=[height]&c=[depth] - Sie können sie online auf meinem billigen Host ausprobieren. In diesen Situationen liebe ich es wirklich, GET-Anfragen zu verwenden.

Ungolfed für Transparenz:

<?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 Byte

(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`

Wobei \ndas wörtliche Zeilenumbruchzeichen steht.

Anstatt mit sich wiederholenden Zeichen herumzuspielen, wird lediglich ein Array mit geeigneter Größe erstellt und berechnet, welches Zeichen in jeder Zelle angezeigt wird.