Nein, nicht die ^^vv<><>BAArt von Ostereiern, echte Ostereier, die wir malen.

Hier ist ein (schrecklich gezeichnetes) Ei.

  __
 /  \
/    \
|    |
\____/

In Ostern malen wir sie mit Mustern. Wie diese:

  __
 /--\
/----\
|----|
\____/
  __
 /%%\
/%%%%\
|%%%%|
\____/
  __
 /~~\
/~~~~\
|~~~~|
\____/

Die Herausforderung

Wenn Sie ein Zeichen (druckbares ASCII) zum Malen des Eies haben, drucken Sie das bemalte Ei.

Beispiele:

&:
  __
 /&&\
/&&&&\
|&&&&|
\____/

#:
  __
 /##\
/####\
|####|
\____/

Technische Daten

• Nachgestellte Zeilenumbrüche / Leerzeichen sind erlaubt.

Brain-Flak , 270 268 266 + 1 = 267 Bytes

+1 von der -cFlagge

(((((((((({}<(((([(()()())]((((((((((({}){}){}){}){}[()]))<>)<>{}())))))<>)<>(((()()()()()){}))({}()){})<>)<>>))))<<>({}<>)((()()()()()){})<>({}<>)>))))<<>((({})<>)({})<((()()()()()){})>[()()])>))<>((((({})<>)[(()()()()())({}){}])<((()()()()()){})<>((({}<>){}()))>))

Probieren Sie es online!

Ich wollte eine Erklärung schreiben, aber ich machte zuerst ein Nickerchen und vergaß, wie dieses ganze Denken funktioniert. Deine Vermutung ist genauso gut wie meine.

Python 2, 62 Bytes

Super unkompliziert. Probieren Sie es online aus .
-1 Byte, danke an @ mbomb007

print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)

Kohle , 30 26 16 Bytes

Zwei Bytes werden dank @Neil gespart, indem sie nach dem Erstellen der Form ausgefüllt werden

__↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ

Probieren Sie es online!

Erläuterung

Das Programm erstellt zuerst die rechte Hälfte des Eies und spiegelt sie dann wieder, um die linke Hälfte zu generieren.

__↗¹                          Write the two bottom _s and write the /
←↑¹                           Move left and write the |
↖²                            Then write two \s
↓_                            And the top _
‖Ｍ←                          Reflect the canvas to the left
¤Ｓ                           Fill the shape with the string input

Gelee , 24  22 Bytes

Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ

Probieren Sie es online!

Wie?

Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ - Main link: character c  e.g. '~'
Ḥ                      - double c: ['~','~']
  “ _¶/\|”             - string literal: [' ','_',<newline>,'/','\','|']
 ;                     - concatenate c:  [['~','~'],' ','_',<newline>,'/','\','|']
          “Ṁ¢ṚR;ḳ}AṠ’  - base 250 number: 3067183430901851641706
                     ṃ - base decompression with reversed @rguments:
                       -     take the number and convert it to a base length(the list)
                       -     then index (1-based) into that same list.
                       -     i.e.: 3067183430901851641706 in base 7
                                 = 22003241534115361163500004
                                   indexed into [['~','~'],' ','_',<newline>,'/','\','|']
                                 = [' ',' ','_','_',<newline>,' ','/',['~','~'],'\',<newline>,'/',['~','~'],['~','~'],'\',<newline>,'|',['~','~'],['~','~'],'|',<newline>,'\','_','_','_','_','/']
                       - implicit print:  __
                                         /~~\
                                        /~~~~\
                                        |~~~~|
                                        \____/

Sed, 43 Zeichen

s:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:

Probelauf:

bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/

JavaScript (ES6), 53 49 47 Bytes

Ich bin mir sicher, dass ich ein bisschen mehr herausholen kann - es \nervt mich, dem s entkommen zu müssen .

f=

c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`

console.log(f`-`)
console.log(f`%`)
console.log(f`~`)
console.log(f`&`)
console.log(f`#`)

• 4 Bytes gespart durch Verschieben der s=c+cVariablenbelegung innerhalb der ersten Menge von {}.
• Durch die Verwendung von c+=canstelle von s=c+c& s=s+swurden 2 Bytes gespart , was zum Teil Neil zu verdanken ist, der diese Verbesserung zur gleichen Zeit wie ich bemerkte.

Malen Sie Ihre Selbst!

f=

c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`

o.innerText=f` `;i.addEventListener("input",function(){o.innerText=f(this.value||" ");})

<input maxlength="1" id="i">
<pre id=o></pre>

Alice , 53 52 Bytes, nicht konkurrierend

Vielen Dank an Leo für das indirekte Speichern von 1 Byte.

/o *^i}'.*[;.h~r}}~"{.[^\\
@"S .^~ y~a}~~.["{!~"}^^^

Probieren Sie es online!

Leider musste ich einen Fehler mit y(Transliteration) beheben , damit dies funktioniert. Daher habe ich ihn als nicht konkurrierend markiert.

Erläuterung

Die Grundidee besteht darin, eine Zeichenfolge aus dem Ei zu erstellen, jedoch ~als Platzhalter für zwei Kopien der Eingabe. Die anderen Zeichen der Eingabe sind jedoch nicht besonders für Alice-Zeichenfolgen geeignet, da diese keine Zeilenvorschübe enthalten können und alle einen Escape-Befehl /\_|benötigen (da sie wie Spiegel und Wände behandelt werden). Ich kann also einige Bytes sparen, indem ich auch für diese Platzhalter verwende und sie dann transliteriere. Die Platzhalter für /\_|sind .[^{, die einfach das Zeichen sind , das direkt vor dem steht, das sie darstellen. Für den Zeilenvorschub verwende ich }.

Nun ist der Code ... das gesamte Programm kann im Ordinal-Modus gelöst werden, da wir nur eine String-Verarbeitung und keine Verarbeitung von ganzen Zahlen benötigen. Darüber hinaus benötigen wir keinen bedingten Kontrollfluss. Das gesamte Programm kann linear ausgedrückt werden. Die allgemeine Struktur des Programms ist wie folgt:

/...//
@....

In einem solchen Programm springt die IP durch den ...Abschnitt nach oben und unten und führt zunächst nur die Hälfte der Zeichen aus. Dann verschieben die beiden /am Ende die IP um eine Zelle nach rechts, so dass sie auf dem Rückweg die andere Hälfte ausführt (wieder auf und ab hüpfen), bis @das Programm schließlich beendet wird. Wenn wir also die lustige Zick-Zack-Struktur in der Mitte aufklappen, sieht das Programm, das wir ausführen, wirklich so aus:

"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So

Lass uns das durchgehen:

"  ^^} .~[}.~~[}{~~{}[^^^^."
      This first string is simply the egg template I've talked about.
"!}"  Push this string. It covers all the characters we need to replace
      in the template except ~.
r     Range expansion. Turns '!}' into '!"#$...z{|}'.
.     Duplicate.
h~;   Split off the first character, swap it to the top and discard it.
a*    Append a linefeed.
      We've now basically rotated the string to the left, but appended
      a linefeed instead of the exclamation mark we've shifted off.
      This maps each character in the string to the next one, except }
      which gets mapped to a linefeed.
y     Transliterate. Since the strings have the same length, this just maps
      each character in the first string to the corresponding character in
      the second string, replacing all of our placeholder characters.
'~    Push "~".
i.*   Read the input and duplicate it.
S     Substitute all "~" with the doubled input.
o     Output the result.

PowerShell , 50 49 48 Bytes

'  __
 /11\
/1111\
|1111|
\____/'-replace1,$args

Probieren Sie es online!

Einfaches Ersetzen der Zeichenfolge in eine Literalzeichenfolge. Nicht viel Platz zum Golfen.

-1 Byte dank HyperNeutrino; -1 Byte dank Wubs

Karotte , 34 Bytes, nicht konkurrierend

  __
 /##\\
/####\\
|####|
\\____/

Nicht konkurrierend, weil ich gerade einen Fehler behoben habe, bei dem der Interpreter in führenden Leerzeichen nicht angezeigt wurde.

Probieren Sie es hier online aus .

Zunächst befinden wir uns im Caret-Modus, in dem jedes Zeichen auf den "Stapel" verschoben wird. Und schließlich wird der "Stapel" als Ausgabe gedruckt.

Drückt im Caret-Modus #die Eingabe, sodass die Instanzen von #im Wesentlichen durch die Eingabe ersetzt werden (FYI #ist ein Ein-Byte-Cat-Programm).

SOGL V0.12 , 21 18 16 Bytes

0≈⁾‛≤¦¶W?5┼EB§  ‘

Probieren Sie es hier aus!

Das ganze Programm ist wie folgt komprimiert:

  __
 /ŗŗ\
/ŗŗŗŗ\
|ŗŗŗŗ|
\____/

wo ŗwird mit der Eingabe ersetzt.

13 Bytes funktioniert fast auch, aber es macht unnötige Dinge mit bestimmten Eingaben.

05AB1E , 34 33 32 Bytes

„__I244S×'/ì'\«`©¦¨'|.ø®R¹'_‡).c

Probieren Sie es online!

Erläuterung

„__                               # push "__"
   I244S×                         # push a list of the input repeated 2 and 4 and 4 times
         '/ì                      # prepend "/"
            '\«                   # append "\"
               `                  # split list to separate items
                ©                 # store a copy of the last one in register
                 ¦¨               # remove first and last item of the string
                   '|.ø           # surround with pipes
                       ®R         # retrieve the string from register and reverse it
                         ¹'_‡     # replace input with "_"
                             ).c  # print each line centered

Python 3.6 , 53 Bytes

lambda x:fr'''  __
 /{2*x}\
/{4*x}\
|{4*x}|
\____/'''

• Unbenannte Funktion, die den Charakter nimmt x und eine Zeichenfolge zurückgibt.
• Verwendet die f-Strings von Python 3.6 als zusätzliche Alternative zu früheren Versionen .format() - die {}beigefügten Teile des F-Strings sind zu bewertender Code.
• Die Zeichenfolge ist auch eine R-Zeichenfolge und wird in dreifachen Anführungszeichen angegeben, wobei ein Byte mehr als die folgenden Zeichenfolgen gespeichert werden:

lambda x:f'  __\n /{2*x}\\\n/{4*x}\\\n|{4*x}|\n\____/'

Ich kann jedoch keinen Online-Interpreter für Python 3.6 finden.
Versuchen Sie es bei repl.it (sagt 3.5, aber es ist 3.6)

Retina 0.8.2 , 43 41 Bytes

-2 Bytes dank Kevin Cruijssen

.
$&$&
..
  __¶ /$&\¶/$&$&\¶|$&$&|¶\____/

Probieren Sie es online!

Brainfuck - 257 Bytes 181 Bytes

Golf: Live-Version hier klicken

+++++++[>++++++<-]>[>+>++>++>++<<<<-]>+++++>>>>++++++++++[>+++>+<<<++++<+<+>>>-]>++<<<--<+>>>,>..<<<<..>>>>>.<.<<<<<.>>>>..<<.>>>>.<<<<<<.>>>>....<<.>>>>.<<<.>....<.>>>.<<<<.<....<.

Ich bin allerdings kein Profigolfer. Soweit ich mich erinnern kann, ist dies mein Versuch: D

Ausgabe:

  __ 
 /XX\ 
/XXXX\ 
|XXXX| 
\____/ where X is the given char.

Ungolfed (+ Kommentare):

; chars:
; _ 95
; / 47
; \ 92
; | 142
; min val = 42 (7 times 6)

; lets do some math
+++++++[>++++++<-]> ; effectively 7 times 6

; now lets copy this to the next pointers multiplying by 2 
the subsequent ones after the 1st
[>+>++>++>++<<<<-]

>+++++
>>>

> ; empty space starting from this pointer
++++++++++[>+++>+<<<++++<+<+>>>-]
>++<
<<--<+
>>>,
>..<<<<..>>>>>.<.
<<<<<.
>>>>..<<.>>>>.
<<<<<<.>>>>....<<.>>>>.
<<<.>....<.
>>>.<<<<.<....<.

05AB1E , 32 29 26 Bytes (Dank an Emigna / Adnan)

•jÀňiXƒÐ[Z•6B6ôvy5ÝJ¹"_ |/\ÿ"‡,

Probieren Sie es online!

•jÀňiXƒÐ[Z•6B6ô # Push ['110011', '135541', '355554', '255552', '400003']
vy               # For each encrypted block...
  5ÝJ            # Push 012345.
     ¹"_ |/\ÿ"   # Push "_ |/\{input_char}".
              ‡, # Swap the charsets.

29 byte version

05AB1E , 29 Bytes (Emigna)

•P£<r7»TwDšç6•5ÝJI"
_/ÿ\|"‡.c

Probieren Sie es online 2!

26-Byte-Erweiterung von Emignas Vorschlag, wobei S verwendet wird, um die Zeichen in ein Array zu trennen, und dann a [b], um jede Ziffer mit der entsprechenden Stelle im vorherigen Array zu interpolieren. Dies ist im Wesentlichen eine elementweise Transliteration (smart).

05AB1E , 26 Byte (Adnan)

"
_/ÿ\|"•P£<r7»TwDšç6•Sè.c

Probieren Sie es online 3!

PHP, 51 Bytes

$a.=$a=$argn;echo"  __
 /$a\
/$a$a\
|$a$a|
\____/";

PHP, 58 Bytes ohne physikalische Zeilenumbrüche

$a.=$a=$argn;echo"  __\n /$a\\\n/$a$a\\\n|$a$a|\n\\____/";

Führen Sie dies mit -R Option aus

61 Bytes

echo strtr("  __\n /88\\\n/8888\\\n|8888|\n\\____/",8,$argn);

BF, 142-140 Bytes

++++[->++++<]>[->+++>++++++>+>++++++>++>++++++++<<<<<<],>->---->------>->..<..<.>>.<<<<.<..
>>.>.<<.<....>>.>.>>>----.<....>.<<<.<.>>....<<<.

Dies ist aus Gründen der Klarheit auf zwei Zeilen aufgeteilt. Der Zeilenumbruch wird nicht gezählt.

Es ist ziemlich einfach, solche Dinge in BF zu schreiben, aber es ist nicht trivial, die Reihenfolge der Zellen zu optimieren, um die Bewegung zu minimieren. Ich habe ein Brute-Forcer-Skript geschrieben, um alle Kombinationen auszuprobieren und die kürzeste zu finden, und ich habe ein bisschen Golf gespielt, um eine Golfgelegenheit zu berücksichtigen, die ich nicht in den Brute-Forcer aufgenommen hatte.

Brainfuck , 114 Bytes

-----[[<+>->++>++<<]->]<+++++++++++<+..<..>>.<.<<.>>,..<---.>>.<<<.>>....<.>>.<<<<---.>>>....<<<.>>>>.<<.+++....<.

Probieren Sie es online!

Ich habe BF Crunch hier verwendet, um einen optimaleren Weg zu finden, um die einzelnen Charaktere zu generieren.

C (GCC) , 95 88 85 Bytes

Vielen Dank an Albert für -7 Bytes

Dank auch an Ceilingcat -3 Bytes

f(c){for(int*s=L"  __\n /00\\\n/0000\\\n|0000|\n\\____/\n";*s;s+=printf(*s%6?s:&c));}

Probieren Sie es online!

SpecBAS - 70 Bytes

1 INPUT a$:  ?"  __"'" /";a$*2;"\"'"/";a$*4;"\"'"|";a$*4;"|"'"\____/"

?ist eine Abkürzung für PRINTbefehl und ein Apostroph bewegt den Cursor in die nächste Zeile.

Röda , 46 Bytes

{a=`  __
 /-\
/--\
|--|
\____/`a~="-",_*2;[a]}

Probieren Sie es online!

Python, 59 Bytes

lambda n:r'''  __
 /a\
/aa\
|aa|
\____/'''.replace('a',n*2)

Lua, 66 Bytes

print((([[  __
 /ee\
/eeee\
|eeee|
\____/]]):gsub("e",io.read())))

((([[#Geschafft]])))

Retina , 41 Bytes

.
$0$0
..
  __¶ /$0\¶/$0$0\¶|$0$0|¶\____/

Probieren Sie es online!

Japt , 35 Bytes

"  __
 /01
/001
|00|
1____/"d0U²1'\

Probieren Sie es online!

41-Byte-Lösung:

[S²'_²RS'/U²'\R'/U²²'\R'|U²²'|R'\'_²²'/]q

Probieren Sie es online!

[R], 65 Bytes

cat(gsub('x',scan(,''),"  __\n /xx\\\n/xxxx\\\n|xxxx|\n\\____/"))

Ziemlich unspektakulär, finden Sie eine kürzere in R ... Es ist Ihre grundlegende gsub

C ++ 208 Bytes

Als Antwort auf Kommentare: Dies ist eine vollständige Neuveröffentlichung.

#include<iostream>
using namespace std;int main(){char e;cin>>e;cout<<"  __  \n";cout<<" /"<<e<<e<<"\\ "<<endl;cout<<"/"<<e<<e<<e<<e<<"\\"<<endl;cout<<"|"<<e<<e<<e<<e<<"|"<<endl;cout<<"\\____/ \n";return 0;}

C # , 56 Bytes

Golf gespielt

i=>"  __\n /i\\\n/ii\\\n|ii|\n\\____/".Replace("i",i+i);

Ungolfed

i => 
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
      .Replace( "i", i + i );

Ungolfed lesbar

i => 
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"

      // Replace every instance of 'i' with the input cloned twice
      .Replace( "i", i + i );

Vollständiger Code

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = i => 
            "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
               .Replace( "i", i + i );

         List<String>
            testCases = new List<String>() {
               "-",
               "%",
               "~",
               "o",
               " ",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput:\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

• v1.0 - 56 bytes- Anfangslösung.

Anmerkungen

Die gedruckten Ergebnisse innerhalb des angegebenen Links sehen nicht so aus, als ob sie vorgetäuscht wären, da die verwendete Schriftart keine Monospace-Schrift ist.

C (gcc) 87 Bytes

e(d){printf("  __\n /%c%c\\\n/%c%c%c%c\\\n|%c%c%c%c|\n\\____/\n",d,d,d,d,d,d,d,d,d,d);}

printf ohne stdio.h verursacht Warnungen, aber keine Fehler und ermöglicht eine erfolgreiche Kompilierung.

Erläuterung

Printf-Anweisung, die alles in eine Zeile packt und das Dekorationszeichen mit% c formatiert.

Probieren Sie es online aus

C (gcc) 84 Bytes

g(f){char e[]={f,f,f,f};printf("  __\n /%.2s\\\n/%.4s\\\n|%.4s|\n\\____/\n",e,e,e);}

Probieren Sie es online!