아니, ^^vv<><>BA부활절 달걀 의 종류가 아니라 우리가 칠하는 진짜 부활절 달걀.

여기 계란이 있습니다.

  __
 /  \
/    \
|    |
\____/

부활절에서는 패턴으로 그립니다. 이것들처럼:

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

도전

달걀을 칠하기 위해 문자 (인쇄 가능한 ASCII)가 주어지면 칠한 달걀을 인쇄하십시오.

예 :

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

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

명세서

• 후행 줄 바꿈 / 공백이 허용됩니다.

뇌 플랙 , 270 (268) 266 + 1 = 267 바이트

-c깃발 에서 +1

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

온라인으로 사용해보십시오!

설명을 쓰려고했지만 낮잠을 자고이 전체가 어떻게 작동하는지 잊어 버렸습니다. 당신의 추측은 나의 것만 큼 좋습니다.

파이썬 2, 62 바이트

매우 간단합니다. 온라인으로 사용해보십시오 .
@ mbomb007 덕분에 -1 바이트

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

숯 , 30 26 16 바이트

@Neil 덕분에 모양을 만든 후 채우기로 2 바이트 절약

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

온라인으로 사용해보십시오!

설명

이 프로그램은 먼저 계란의 오른쪽 절반을 만든 다음 반영하여 왼쪽 절반을 생성합니다.

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

젤리 , 24  22 바이트

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

온라인으로 사용해보십시오!

방법?

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

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

샘플 실행 :

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

자바 스크립트 (ES6), 53 49 47 바이트

나는 이것을 조금 더 짜낼 수 있다고 확신 \한다.

f=

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

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

• s=c+c의 첫 번째 세트 내에서 변수 할당 을 이동하여 4 바이트가 절약됩니다 {}.
• 사용하여 저장된 2 바이트 c+=c대신 s=c+c& s=s+s에 대한 부분 감사와 함께, 닐 내가 그것을 만들고 있었다과 동시에 이러한 개선을 발견했다.

당신의 자신의 페인트!

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 바이트, 비경쟁

1 바이트를 간접적으로 저장해 준 Leo에게 감사합니다.

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

온라인으로 사용해보십시오!

불행히도, y이 작업을 수행하기 위해 (음역)으로 버그를 수정해야 했기 때문에 경쟁이 아닌 것으로 표시했습니다.

설명

기본 아이디어는 계란의 문자열을 만드는 것이지만 입력 사본 두 개에 ~대한 자리 표시 자로 사용하는 것입니다 . 그러나 입력의 다른 문자는 Alice 문자열에 특히 적합하지 않습니다. Alice 문자열에는 줄 바꿈을 포함 할 수 없으며 모든 문자 는 거울과 벽으로 처리되므로 이스케이프해야합니다. 따라서 이것에 대한 자리 표시자를 사용하고 음역하여 바이트를 절약 할 수 있습니다. 에 대한 자리 표시 자는로 표시 되는 바로 앞에있는 문자입니다. 사용중인 줄 바꿈의 경우/\_|/\_|.[^{} 있습니다.

이제 코드 ... 문자열 처리 만 필요하고 정수 처리가 필요하지 않기 때문에 전체 프로그램을 서수 모드에서 해결할 수 있습니다. 또한 조건부 제어 흐름이 필요하지 않습니다. 전체 프로그램을 선형 적으로 표현할 수 있습니다. 프로그램의 일반적인 구조는 다음과 같습니다.

/...//
@....

이러한 프로그램에서 IP는 ...섹션의 위아래로 튀어 오며 , 먼저 문자의 절반 만 실행합니다. 그런 다음 /끝에 있는 두 개 는 IP를 하나의 셀만큼 오른쪽으로 이동하여 마지막으로 @프로그램 이 종료 될 때까지 다른 절반을 위아래로 튀어 오릅니다 . 중간에 재미있는 지그재그 구조를 펼치면 실제로 실행하는 프로그램은 다음과 같습니다.

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

이것을 통해 봅시다 :

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

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

온라인으로 사용해보십시오!

리터럴 문자열로 간단한 문자열 교체. 골프를위한 공간이 많지 않습니다.

HyperNeutrino 덕분에 -1 바이트; 워블 덕분에 -1 바이트

당근 , 34 바이트, 비경쟁

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

앞 공백이 표시되지 않는 인터프리터로 버그를 수정했기 때문에 경쟁이 아닙니다.

여기에서 온라인으로 사용해보십시오 .

먼저, 캐럿 모드에서 모든 캐릭터가 "스택"으로 푸시됩니다. 마지막으로 "스택"이 출력으로 인쇄됩니다.

캐럿 모드에서는 #입력을 푸시하므로 #기본적으로 인스턴스가 입력으로 대체됩니다 (FYI #는 1 바이트 cat 프로그램입니다).

SOGL V0.12 , 21 18 16 바이트

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

여기 사용해보십시오!

전체 프로그램은 다음과 같이 압축되어 있습니다.

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

여기서 ŗ입력으로 대체됩니다.

13 바이트도 거의 작동하지만 특정 입력에 필요 하지 않은 작업 을 수행합니다.

05AB1E , 34 33 32 바이트

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

온라인으로 사용해보십시오!

설명

„__                               # 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

파이썬 3.6 , 53 바이트

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

• 이름없는 함수가 문자를 가져 와서 x문자열을 반환합니다.
• 이전 버전의 대안으로 Python 3.6의 f- 문자열을 사용합니다. f- 문자열 .format()의 {}동봉 된 부분은 평가할 코드입니다.
• 문자열은 또한 r- 문자열이며 3 바이트로 인용하여 1 바이트를 절약합니다.

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

그래도 Python 3.6의 온라인 인터프리터를 볼 수 없습니다. repl.it
에서 시도하십시오 (3.5라고 말하지만 3.6입니다)

레티 나 0.8.2 , 43 41 바이트

Kevin Cruijssen 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

Brainfuck- 257 바이트 181 바이트

골프 : 라이브 버전 여기를 클릭 하십시오

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

나는 프로 골퍼가 아닙니다. 이것은 내가 기억할 수있는 한 나의 시도이다 : D

산출:

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

Ungolfed (+ 댓글) :

; 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 바이트 (Emigna / Adnan에게 감사)

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

온라인으로 사용해보십시오!

•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 바이트 버전 (줄 바꿈 인코딩으로 인해 반복없는 스마트) :

05AB1E , 29 바이트 (Emigna)

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

온라인으로 사용해보십시오 2!

S를 사용하여 문자를 배열로 분리 한 다음 a [b]를 사용하여 각 배열을 이전 배열의 해당 위치로 보간합니다. 이것은 본질적으로 요소 별 음역 (스마트)입니다.

05AB1E , 26 바이트 (Adnan)

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

온라인으로 사용해보십시오 3!

PHP, 51 바이트

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

물리적 줄 바꿈이없는 PHP, 58 바이트

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

-R옵션으로 이것을 실행하십시오.

61 바이트

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

BF, 142140 바이트

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

명확성을 위해 두 줄로 나뉩니다. 줄 바꿈은 계산되지 않습니다.

BF에서 이런 종류의 것을 작성하는 것은 상당히 쉽지만, 움직임을 최소화하기 위해 세포의 순서를 최적화하는 방법은 간단하지 않습니다. 나는 모든 조합을 시도하고 가장 짧은 것을 찾기 위해 무차별 대입 스크립트를 작성했으며, 나는 무차별 대입에 포함되지 않은 골프 기회를 설명하기 위해 약간의 골프를 쳤다.

brainfuck , 114 바이트

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

온라인으로 사용해보십시오!

내가 사용했습니다 BF 위기를 각각의 캐릭터를 생성하는 더 최적의 방법을 보려면 여기를.

C (gcc) , 95 88 85 바이트

-7 바이트의 Albert에게 감사

ceilingcat -3 바이트 덕분에

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

온라인으로 사용해보십시오!

SpecBAS-70 바이트

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

?대한 속기 PRINT명령 및 아포스트로피 움직임은 다음 행으로 커서.

로다 , 46 바이트

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

온라인으로 사용해보십시오!

파이썬, 59 바이트

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

루아, 66 바이트

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

((([[#NailedIt]]))))

레티 나 , 41 바이트

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

온라인으로 사용해보십시오!

apt , 35 바이트

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

온라인으로 사용해보십시오!

41 바이트 솔루션 :

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

온라인으로 사용해보십시오!

[R], 65 바이트

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

꽤 무례한, R에서 더 짧은 것을 찾으십시오 ... 그것은 당신의 기본 gsub입니다

C ++ 208 바이트

의견에 대한 답변 : 이것은 완전한 다시 게시입니다.

#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 바이트

골프

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

언 골프

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

언 골프 가능

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

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

전체 코드

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

자료

• V1.0 - 56 bytes- 초기 솔루션입니다.

노트

제공된 링크 내에서 인쇄 된 결과는 사용 된 글꼴이 모노 스페이스가 아니기 때문에 가장 한 것처럼 보이지 않습니다.

C (gcc) , 87 바이트

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

stdio.h가없는 printf는 경고를 발생 시키지만 오류가 발생하지 않아 컴파일이 성공적으로 완료됩니다.

설명

모든 문자를 한 줄로 채우고 장식 문자를 % c로 형식화하는 Printf 문.

온라인으로 사용해보십시오

C (gcc) , 84 바이트

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

온라인으로 사용해보십시오!