¡Hazme un huevo de Pascua!

29

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.
Matthew Roh
fuente
8
¿Por qué el voto negativo? Si no le gusta esta pregunta, haga un
Matthew Roh
2
Una posible razón podría ser que no creen que esta tarea sea lo suficientemente clara o lo suficientemente clara. Diría que es lo suficientemente claro, y tampoco es literalmente trivial. Dicho esto, tampoco estoy particularmente emocionado.
John Dvorak
17
El desafío será muy trivial en la mayoría de los idiomas. El huevo es demasiado corto para permitir mucha originalidad en el golf. En mi opinión, es un desafío poco interesante (que no ha sido protegido, porque parece que estás boicoteando la caja de arena porque no sé qué razones), por lo tanto, lo rechazo.
Dada
25
Elegido porque los desafíos simples como este son excelentes para principiantes como yo para jugar golf.
Shaggy
77
¡MARICÓN! Eres un huevo de pascua. (Lo siento, no pude resistir)
George Cummins

Respuestas:

16

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.

Asistente de trigo
fuente
14
Esta es la mejor explicación que he leído aquí. +1
David Conrad
12

Python 2, 62 bytes

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

print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)
Zarigüeya muerta
fuente
1
62 bytes
mbomb007
@ mbomb007 Buena, gracias
Dead Possum
2
Puede guardar dos bytes utilizando la función lambda de esta manera
Keerthana Prabhakaran
@KeerthanaPrabhakaran No estoy seguro de si las lambdas están bien para los desafíos ascii
Dead Possum
1
¿Cuál es el problema al usar lambda en desafíos ascii? ¿Cómo están relacionados? : o
Keerthana Prabhakaran
10

Carbón , 30 26 16 bytes

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

__↗¹←↑¹↖²↓_‖M←¤S

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 _
‖M←                          Reflect the canvas to the left
¤S                           Fill the shape with the string input
Kritixi Lithos
fuente
←_↘puede ser igual ↓_pero en realidad se puede llenar después de reflexionar durante 16 bytes: __↗¹←↑¹↖²↓_‖M←¤S.
Neil
@Neil Gracias por presentarme¤
Kritixi Lithos
9

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:  __
                                         /~~\
                                        /~~~~\
                                        |~~~~|
                                        \____/
Jonathan Allan
fuente
3
Nomino su explicación de para la explicación más larga de un solo byte.
Urna mágica del pulpo
Parece haberse convertido en un átomo bastante útil, ¡pensé que le daría algo de tiempo en el centro de atención!
Jonathan Allan
2
Veo que Dennis lo usa mucho, esta es la primera vez que siento que realmente lo entendí; el tiempo no fue perdido! Me has dado 1 unidad de aprendizaje.
Magic Octopus Urn
1
Bueno, es uno de mis bebés :)
Jonathan Allan
6

Sed, 43 caracteres

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

Ejecución de muestra:

bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/
hombre trabajando
fuente
Eso es exactamente lo que escribí, solo unos segundos más rápido.
Riley
6

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!

Lanudo
fuente
Sería un poco mejor si pones esas entradas en <pre><code>s. Buen trabajo sin embargo.
Matthew Roh
Gracias, @SIGSEGV. Las consolas conservan el espacio en blanco y, de forma predeterminada, al menos, usan una fuente monoespaciada, por lo que no es necesario enviar a pre.
Shaggy
1
¿Por qué no c+=c?
Neil
Gracias, @Neil, solo estaba editando eso en mí mismo, pero lo actualizaré nuevamente para darle un guiño también.
Shaggy
@Arnauld No necesita contar la f=\nporción para el recuento de bytes. Eso es solo para que se ejecute el fragmento.
AdmBorkBork
5

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.
Martin Ender
fuente
: D está aquí !! Este idioma parece ingenioso
Conor O'Brien
@ ConorO'Brien gracias. Ya he incluido algunos desafíos anteriores en caso de que quieras ver más muestras. :)
Martin Ender
4

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

AdmBorkBork
fuente
4

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

Kritixi Lithos
fuente
4

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.

dzaima
fuente
Tienes que pintar el huevo. (es decir, llenar el interior del huevo con caracteres)
Matthew Roh
@SIGSEGV - Se explica que eso se logra reemplazando los espacios con la entrada y reemplazando los guiones con espacios con el código@,ŗ -@ŗ
Jonathan Allan
¿SOGOL estará en TIO pronto?
Jonathan Allan
@ JonathanAllan Si alguien puede conseguirlo allí, entonces sí.
dzaima
Habla con Dennis en la sala talk-tryitonline-net .
Jonathan Allan
3

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
Emigna
fuente
•jÀňiXƒÐ[Z•6B6ôvy5ÝJ"_ |/\"¹«‡,para 32, aunque completamente diferente. Esto me falsificada y me hizo pensar que podría utilizar palindromize ... Maldito el hecho de que ())(y /\\/son palíndromos.
Urna mágica del pulpo
1
@carusocomputing: debe publicarlo por separado. Es lo suficientemente diferente como para ser interesante por sí mismo :)
Emigna
3

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)

Jonathan Allan
fuente
3

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
++++++++++[>+++>+<<<++++<+<+>>>-]
>++<
<<--<+
>>>,
>..<<<<..>>>>>.<.
<<<<<.
>>>>..<<.>>>>.
<<<<<<.>>>>....<<.>>>>.
<<<.>....<.
>>>.<<<<.<....<.
Lucca Ferri
fuente
2

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!

Urna de pulpo mágico
fuente
1
Esto es 3 bytes más corto. Más similar a tu respuesta que a la mía :)
Emigna
1
@Emigna, que la transliteración directa usando nuevas líneas es una idea novedosa, me gusta; Honestamente, esto podría eliminar 5 bytes de muchas de mis soluciones existentes.
Urna mágica del pulpo
2
Para 26 bytes .
Adnan
1
@adnan - astuto astuto ...
Urna de pulpo mágico
Siento que casi todas mis respuestas necesitan crédito Admigna, realmente no sabría el idioma sin sus dos ejemplos constantes.
Magic Octopus Urn
2

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);
Jörg Hülsermann
fuente
Almacenar el valor duplicado; eliminar espacio innecesario; use el carácter literal de nueva línea: pastebin.com/EghdAYMf
manatwork
@manatwork Gracias, realmente no he pensado en duplicar la entrada
Jörg Hülsermann
ahorre 7 bytes con saltos de línea físicos y sin escapar de las barras diagonales inversas (el último no necesita escapar de todos modos). Ah y por cierto: -Rno es un parámetro, es una opción.
Titus
@Titus odio los saltos de línea físicos Hecho
Jörg Hülsermann
@Titus, a la derecha, aunque los man phpllama parámetro : "También es posible procesar la entrada estándar línea por línea usando el parámetro -R o -F"
Manatwork
2

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.

Fruta Esolanging
fuente
@JoKing Te sugiero que publiques eso como una respuesta separada, porque parece muy diferente a la mía.
Esolanging Fruit
2

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.

Jo King
fuente
2

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!

cleblanc
fuente
No declares *qsimplemente anidarlo directamente en tu bucle for para ahorrar 5 bytes. char*s;f(c){for(s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}
Albert Renshaw
También puede guardar 2 bytes más además de eso declarando *sdentro del argumento de declaración del bucle for:f(c){for(char*s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}
Albert Renshaw
También puede depilar 1 byte más si busca un carácter ASCII que tenga un valor numérico de un dígito. 1está 49en ASCII pero eso es 2 bytes, use algo con un valor de 0-9, por ejemplo, el carácter de tabulación `` es un valor ASCII 9.
Albert Renshaw
Sugerir en *s;f(c){for(slugar def(c){for(int*
ceilingcat
1

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.

Brian
fuente
1

Python, 59 bytes

lambda n:r'''  __
 /a\
/aa\
|aa|
\____/'''.replace('a',n*2)
Rɪᴋᴇʀ
fuente
1

Lua, 66 bytes

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

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

Cotilla
fuente
1

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!

Oliver
fuente
Buena esa. Mi primer intento fue esto por 36 bytes, pero parece que usar des un byte más corto.
ETHproductions
1

[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

usuario11599
fuente
1

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;}
takintoolong
fuente
1

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.

auhmaan
fuente
1

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

Jake Reynolds
fuente