No, no el ^^vv<><>BAtipo de huevos de Pascua, los verdaderos huevos de Pascua que pintamos.

Aquí hay un huevo (terriblemente dibujado).

  __
 /  \
/    \
|    |
\____/

En pascua, los pintamos con patrones. Como estos:

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

El reto

Dado un carácter (ascii imprimible) para pintar el huevo, imprima el huevo pintado.

Ejemplos:

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

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

Especificaciones

• Se permiten líneas / espacios finales.

Cerebro-Flak , 270 268 266 + 1 = 267 bytes

+1 de la -cbandera

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

Pruébalo en línea!

Iba a escribir una explicación, pero primero tomé una siesta y olvidé cómo funciona todo este pensamiento. Tu invitado es tan bueno como el mío.

Python 2, 62 bytes

Súper sencillo. Pruébalo en línea .
-1 byte, gracias a @ mbomb007

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

Carbón , 30 26 16 bytes

Dos bytes guardados gracias a @Neil rellenando después de hacer la forma

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

Pruébalo en línea!

Explicación

El programa funciona creando primero la mitad derecha del huevo y luego reflejándolo para generar la mitad izquierda.

__↗¹                          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

Jalea , 24  22 bytes

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

Pruébalo en línea!

¿Cómo?

Ḥ;“ ¶/\|_”“Ṁ¢Ṛ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 caracteres

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

Ejecución de muestra:

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

JavaScript (ES6), 53 49 47 bytes

Estoy seguro de que puedo sacar un poco más de esto: tener que escapar del \s me molesta.

f=

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

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

• 4 bytes guardados al mover el s=c+c asignación de variable dentro del primer conjunto de {}.
• 2 bytes guardados usando en c+=clugar de s=c+c& s=s+s, gracias en parte a Neil que detectó esta mejora al mismo tiempo que la estaba haciendo.

¡Pinta el tuyo!

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, no competidora

Gracias a Leo por salvar indirectamente 1 byte.

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

Pruébalo en línea!

Desafortunadamente, tuve que arreglar un error con y (transliteración) para que esto funcionara, así que lo marqué como no competitivo.

Explicación

La idea básica es crear una cadena del huevo pero con ~un marcador de posición para dos copias de la entrada. Sin embargo, los otros caracteres de la entrada no son particularmente amigables para las cadenas de Alice, porque no pueden contener avances de línea, y todos /\_|necesitarían escapar (porque se tratan como espejos y paredes). Entonces puedo guardar algunos bytes usando marcadores de posición para estos también, y luego transliterándolos. Los marcadores de posición para /\_|son .[^{, que son simplemente el carácter justo antes del que representan. Para el salto de línea que estoy usando} .

Ahora el código ... todo el programa se puede resolver en modo Ordinal ya que solo necesitamos el procesamiento de cadenas y ningún procesamiento de enteros. Además, no necesitamos ningún flujo de control condicional. Todo el programa se puede expresar linealmente. La estructura general del programa es la siguiente:

/...//
@....

En dicho programa, la IP rebota hacia arriba y hacia abajo a través de la ...sección, primero solo ejecuta la mitad de los caracteres. Luego, los dos /al final mueven la IP hacia la derecha por una celda, de modo que en el camino de regreso ejecuta la otra mitad (nuevamente rebotando hacia arriba y hacia abajo) hasta que finalmente @termina el programa. Entonces, si desarrollamos la divertida estructura en zigzag en el medio, el programa que estamos ejecutando realmente se ve así:

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

Veamos esto:

"  ^^} .~[}.~~[}{~~{}[^^^^."
      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

Pruébalo en línea!

Reemplazo directo de la cadena en una cadena literal. No hay mucho espacio para jugar al golf.

-1 byte gracias a HyperNeutrino; -1 byte gracias a wubs

Zanahoria , 34 bytes, no competitiva

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

No compite porque acabo de corregir un error con el intérprete en los espacios en blanco iniciales que no se muestran.

Pruébelo en línea aquí .

Primero, estamos en modo intercalación, donde cada personaje es empujado a la "pila". Y finalmente la "pila" se imprime como salida.

En modo caret, #empuja la entrada, por lo que las instancias de #se reemplazan básicamente por la entrada (FYI# es un programa cat de un byte).

SOGL V0.12 , 21 18 16 bytes

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

Pruébalo aquí!

Todo el programa es el siguiente comprimido:

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

dónde ŗ se reemplaza con la entrada.

13 bytes casi también funciona, pero hace cosas innecesarias con ciertas entradas.

05AB1E , 34 33 32 bytes

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

Pruébalo en línea!

Explicación

„__                               # 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}|
\____/'''

• Función sin nombre que toma el personaje x y devuelve una cadena.
• Utiliza las cadenas f de Python 3.6 como una alternativa adicional a las versiones anteriores .format(): el{} partes adjuntas de la cadena f son código para evaluar.
• La cadena también es una cadena r y una triple cita que ahorra un byte sobre:

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

Sin embargo, no puedo ver un intérprete en línea para Python 3.6.
Pruébalo en repl.it (dice 3.5 pero es 3.6)

Retina 0.8.2 , 43 41 bytes

-2 bytes gracias a Kevin Cruijssen

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

Pruébalo en línea!

Brainfuck - 257 bytes 181 bytes

Golfed: versión en vivo, haga clic aquí

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

Sin embargo, no soy un golfista profesional. Este es mi intento hasta donde puedo recordar: D

Salida:

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

Sin golf (+ comentarios):

; 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 (Gracias a Emigna / Adnan)

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

Pruébalo en línea!

•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.

Versión de 29 bytes (más inteligente sin iteración necesaria debido a la codificación de nuevas líneas también):

05AB1E , 29 bytes (Emigna)

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

Pruébelo en línea 2!

Extensión de 26 bytes de la sugerencia de Emigna, usando S para separar los caracteres en una matriz, luego un [b] para interpolar cada dígito con la ubicación correspondiente en la matriz anterior. Esto es esencialmente una transliteración por elementos (inteligente).

05AB1E , 26 bytes (Adnan)

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

Pruébalo en línea 3!

PHP, 51 bytes

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

PHP, 58 Bytes sin saltos de línea físicos

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

ejecuta esto con -R opción

61 bytes

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

BF, 142 140 bytes

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

Esto se divide en dos líneas para mayor claridad; la nueva línea no se cuenta.

Es bastante fácil escribir este tipo de cosas en BF, pero no es trivial cómo optimizar el orden de las celdas para minimizar el movimiento. Escribí un guión de fuerza bruta para probar todas las combinaciones y encontrar la más corta, y jugué un poco al golf para dar cuenta de una oportunidad de golf que no había incluido en la fuerza bruta.

brainfuck , 114 bytes

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

Pruébalo en línea!

He usado BF Crunch aquí para encontrar una forma más óptima de generar los personajes individuales.

C (gcc) , 95 88 85 bytes

Gracias a Albert por -7 bytes

Gracias también a ceilingcat -3 bytes

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

Pruébalo en línea!

SpecBAS - 70 bytes

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

?es una forma abreviada de PRINTcomando, y el apóstrofe mueve el cursor a la siguiente línea.

Röda , 46 bytes

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

Pruébalo en línea!

Python, 59 bytes

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

Lua, 66 bytes

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

((([[#Dado en el clavo]])))

Retina , 41 bytes

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

Pruébalo en línea!

Japt , 35 bytes

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

Pruébalo en línea!

Solución de 41 bytes:

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

Pruébalo en línea!

[R], 65 bytes

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

Bastante poco espectacular, encuentra uno más corto en R ... Es tu gsub básico

C ++ 208 bytes

En respuesta a los comentarios: esta es una nueva publicación completa.

#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

Golfed

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

Sin golf

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

Legible sin golf

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

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

Código completo

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

Lanzamientos

• v1.0 - 56 bytes- Solución inicial.

Notas

Los resultados impresos dentro del enlace proporcionado no se verán como fingidos, debido a que la fuente utilizada no es monoespacio.

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 sin stdio.h causa advertencias pero no errores, permitiendo una compilación exitosa.

Explicación

Sentencia Printf que agrupa todo en una línea, formateando el carácter de decoración con% c.

Pruébalo en línea

C (gcc) , 84 bytes

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

Pruébalo en línea!