Fammi un uovo di Pasqua!

29

No, non il ^^vv<><>BAtipo di uova di Pasqua, vere uova di Pasqua che dipingiamo.

Ecco un uovo (terribilmente disegnato).

  __
 /  \
/    \
|    |
\____/

A pasqua, li dipingiamo con motivi. Come questi:

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

La sfida

Dato un carattere (ascii stampabile) per dipingere l'uovo, stampare l'uovo dipinto.

Esempi:

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

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

Specifiche

  • Sono consentite nuove righe / spazi finali.
code-golf  ascii-art 
— Matthew Roh
fonte
8
Perché il downvote? Se questa domanda non ti piace, fai un
— Matthew Roh,
2
Una potenziale ragione potrebbe essere che non pensano che questo compito sia abbastanza chiaro o abbastanza chiaro. Direi che è abbastanza chiaro e nemmeno letteralmente banale. Detto questo, non sono nemmeno particolarmente entusiasta.
— John Dvorak,
17
La sfida sarà molto banale nella maggior parte delle lingue. L'uovo è troppo corto per consentire molta originalità nel golf. Secondo me, è una sfida poco interessante (che non è stata sottoposta a sandbox, perché sembra che tu stia boicottando la sandbox perché non so per quali motivi), quindi la declassamento.
— Dada,
25
È stato votato perché semplici sfide come questa sono ottime per i principianti come me che vogliono giocare a golf.
— Shaggy,
7
PUF! Sei un uovo di Pasqua. (Mi dispiace, non ho potuto resistere)
— George Cummins

Risposte:

16

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

+1 dalla -cbandiera

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

Provalo online!

Stavo per scrivere una spiegazione, ma prima ho fatto un pisolino e ho dimenticato come funziona tutto questo. La tua ipotesi è buona come la mia.

— Mago del grano
fonte
14
Questa è la migliore spiegazione che abbia mai letto qui. +1
— David Conrad,
12

Python 2, 62 byte

Super diretto. Provalo online .
-1 byte, grazie a @ mbomb007

print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)
— Dead Possum
fonte
1
— mbomb007,
@ mbomb007 Bene, grazie
— Dead Possum,
2
Puoi salvare due byte usando la funzione lambda in questo modo
— Keerthana Prabhakaran,
@KeerthanaPrabhakaran Non sono sicuro che le lambda siano OK per le sfide ASCII
— Dead Possum
1
qual è il problema nell'uso di lambda nelle sfide ASCII? come sono persino imparentati !? : o
— Keerthana Prabhakaran,
10

Carbone di legna , 30 26 16 byte

Due byte salvati grazie a @Neil riempiendo dopo aver creato la forma

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

Provalo online!

Spiegazione

Il programma funziona creando prima la metà destra dell'uovo, quindi riflettendola per generare la metà sinistra.

__↗¹                          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
— Kritixi Lithos
fonte
←_↘può essere solo ↓_, ma in realtà si può riempire dopo si riflette per 16 byte: __↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ.
— Neil,
@Neil Grazie per avermi fatto conoscere¤
— Kritixi Lithos il
9

Gelatina , 24  22 byte

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

Provalo online!

Come?

Ḥ;“ ¶/\|_”“Ṁ¢Ṛ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
fonte
3
Nomino la tua spiegazione ṃper la spiegazione più lunga di un singolo byte.
— Magic Octopus Urn
Sembra che sia diventato un atomo abbastanza utile, ho pensato di concedergli un po 'di tempo sotto i riflettori!
— Jonathan Allan,
2
Vedo che Dennis lo usa molto, questa è la prima volta che mi sembra di averlo capito; il tempo non è stato sprecato! Mi hai dato 1 unità di apprendimento.
— Magic Octopus Urn
1
Bene, è uno dei miei bambini :)
— Jonathan Allan,
6

Sed, 43 caratteri

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

Esecuzione di esempio:

bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/
— uomo al lavoro
fonte
È esattamente quello che ho scritto, solo pochi secondi più veloce.
— Riley,
6

JavaScript (ES6), 53 49 47 byte

Sono sicuro di poter spremere un po 'di più da questo - dover scappare dalla \s mi dà fastidio.

f=

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

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

  • 4 byte salvati spostando l' s=c+cassegnazione variabile all'interno della prima serie di {}.
  • 2 byte salvati usando c+=cinvece di s=c+c& s=s+s, grazie in parte a Neil che ha notato questo miglioramento mentre lo stavo realizzando.

Dipingi il tuo!

Mostra snippet di codice

— ispido
fonte
Sarebbe un po 'meglio se metti questi input in <pre><code>s. Bel lavoro però.
— Matthew Roh,
Grazie, @SIGSEGV. Le console preservano lo spazio bianco e, per impostazione predefinita, utilizzano almeno un carattere a spaziatura fissa, quindi non è necessario eseguire l'output a pre.
— Shaggy,
1
Perché no c+=c?
— Neil,
Grazie, @Neil, lo stavo solo modificando da solo, ma lo aggiornerò di nuovo per dare anche un cenno del capo.
— Shaggy,
@Arnauld Non è necessario contare la f=\nparte per il conteggio dei byte. È solo così che funziona lo snippet.
— AdmBorkBork,
5

Alice , 53 52 byte, non competitiva

Grazie a Leo per il risparmio indiretto di 1 byte.

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

Provalo online!

Sfortunatamente, ho dovuto correggere un bug con y(traslitterazione) per farlo funzionare, quindi l'ho contrassegnato come non competitivo.

Spiegazione

L'idea di base è quella di creare una stringa dell'uovo ma con ~come segnaposto per due copie dell'input. Tuttavia, gli altri caratteri dell'input non sono particolarmente amichevoli per le stringhe di Alice, perché quelli non possono contenere avanzamenti di riga e tutti /\_|dovrebbero scappare (perché sono trattati come specchi e pareti). Quindi posso salvare alcuni byte usando anche i segnaposto per questi, e poi traslitterli. I segnaposto per /\_|sono .[^{, che sono semplicemente il personaggio giusto prima di quello che rappresentano. Per l'alimentazione di linea che sto usando }.

Ora il codice ... l'intero programma può essere risolto in modalità Ordinale poiché abbiamo solo bisogno di elaborazione di stringhe e nessuna elaborazione di numeri interi. Inoltre, non abbiamo bisogno di alcun flusso di controllo condizionale. L'intero programma può essere espresso in modo lineare. La struttura generale del programma è questa:

/...//
@....

In un tale programma, l'IP rimbalza su e giù attraverso la ...sezione, eseguendo prima solo la metà dei caratteri. Quindi i due /alla fine spostano l'IP a destra di una cella, in modo che sulla via del ritorno esegua l'altra metà (rimbalzando di nuovo su e giù) fino alla @fine del programma. Quindi se apriamo la divertente struttura a zigzag nel mezzo, il programma che stiamo eseguendo sembra davvero così:

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

Andiamo attraverso questo:

"  ^^} .~[}.~~[}{~~{}[^^^^."
      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
fonte
: D è qui !! Questa lingua sembra elegante
— Conor O'Brien,
@ ConorO'Brien grazie. Ho già risolto alcune vecchie sfide nel caso tu voglia vedere più campioni. :)
— Martin Ender,
4

PowerShell , 50 49 48 byte

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

Provalo online!

Semplice sostituzione della stringa in una stringa letterale. Non c'è molto spazio per il golf.

-1 byte grazie a HyperNeutrino; -1 byte grazie ai mozzi

— AdmBorkBork
fonte
4

Carota , 34 byte, non competitiva

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

Non competitiva perché ho appena corretto un bug con l'interprete nel principale spazio bianco che non veniva mostrato.

Provalo online qui .

Innanzitutto, siamo in modalità cursore, dove ogni personaggio viene spinto nella "pila". E infine la "pila" viene stampata come output.

In modalità cursore, #invia l'input, quindi le istanze di #vengono sostanzialmente sostituite con l'input (FYI #è un programma cat a un byte).

— Kritixi Lithos
fonte
4

SOGL V0.12 , 21 18 16 byte

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

Provalo qui!

L'intero programma è il seguente compresso:

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

dove ŗviene sostituito con l'input.

Anche quasi 13 byte funzionano, ma fa cose non necessarie con determinati input.

— dzaima
fonte
Devi dipingere l'uovo. (ovvero riempi l'interno dell'uovo con dei caratteri)
— Matthew Roh,
@SIGSEGV - Si spiega che ciò si ottiene sostituendo gli spazi con l'input e sostituendo i trattini con spazi con il codice@,ŗ -@ŗ
— Jonathan Allan
SOGOL sarà presto al TIO?
— Jonathan Allan,
@JonathanAllan Se qualcuno ci riesce, allora sì.
— dzaima,
Parla con Dennis nella stanza dei talk-tryitonline-net .
— Jonathan Allan,
3

05AB1E , 34 33 32 byte

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

Provalo online!

Spiegazione

„__                               # 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
fonte
•jÀňiXƒÐ[Z•6B6ôvy5ÝJ"_ |/\"¹«‡,per 32, completamente diverso però. Questo mi ha falsificato fuori e mi ha fatto pensare che potevo usare palindromize ... Accidenti il fatto che ())(e /\\/sono palindromi.
— Magic Octopus Urn
1
@carusocomputing: dovresti pubblicarlo separatamente. È abbastanza diverso da essere interessante da solo :)
— Emigna
3

Python 3.6 , 53 byte

lambda x:fr'''  __
 /{2*x}\
/{4*x}\
|{4*x}|
\____/'''
  • Funzione senza nome che prende il carattere xe restituisce una stringa.
  • Usa le f-string di Python 3.6 come alternativa aggiuntiva alle versioni precedenti .format(): le {}parti racchiuse della f-stringa sono codice da valutare.
  • La stringa è anche una stringa r e una virgoletta tripla che salva un byte su:

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

Non riesco a vedere un interprete online per Python 3.6 però.
Provalo su repl.it (dice 3.5 ma è 3.6)

— Jonathan Allan
fonte
3

Brainfuck - 257 byte 181 byte

Golfed: versione live clicca qui

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

Non sono un golfista professionista però. Questo è il mio tentativo per quanto posso ricordare: D

Produzione:

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

Ungolfed (+ commenti):

; 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
fonte
2

05AB1E , 32 29 26 byte (Grazie a Emigna / Adnan)

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

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

Versione a 29 byte (più intelligente senza iterazione necessaria anche per la codifica di nuove righe):

05AB1E , 29 byte (Emigna)

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

Provalo online 2!

Estensione di 26 byte del suggerimento di Emigna, usando S per separare i caratteri in un array, quindi a [b] per interpolare ogni cifra con la posizione corrispondente nell'array precedente. Questa è essenzialmente una traslitterazione saggia (intelligente).

05AB1E , 26 byte (Adnan)

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

Provalo online 3!

— Urna di polpo magico
fonte
1
Si tratta di 3 byte in meno. Più simile alla tua risposta della mia :)
— Emigna
1
@Emigna che la traslitterazione diretta usando le nuove righe è un'idea nuova, mi piace; questo potrebbe onestamente eliminare 5 byte da molte delle mie soluzioni esistenti.
— Magic Octopus Urn
2
— Adnan,
1
@adnan Sè- subdolo subdolo ...
— Magic Octopus Urn
Sento che quasi tutte le mie risposte hanno bisogno di credito Admigna, non conoscerei davvero la lingua senza entrambi i tuoi esempi costanti.
— Magic Octopus Urn
2

PHP, 51 byte

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

PHP, 58 byte senza interruzioni di riga fisiche

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

eseguilo con l' -Ropzione

61 byte

echo strtr("  __\n /88\\\n/8888\\\n|8888|\n\\____/",8,$argn);
— Jörg Hülsermann
fonte
Memorizza il valore raddoppiato; rimuovere lo spazio non necessario; usa il carattere letterale newline: pastebin.com/EghdAYMf
— manatwork
@manatwork Grazie, non ho davvero pensato a raddoppiare l'ingresso
— Jörg Hülsermann
salvare 7 byte con interruzioni di riga fisiche e non sfuggire alle barre rovesciate (l'ultimo non deve comunque sfuggire). Oh e btw: -Rnon è un parametro, è un'opzione.
— Tito
@Titus odio le interruzioni di linea fisiche Fatto
— Jörg Hülsermann
@Titus, giusto, anche se man phpli chiama parametro : "È anche possibile elaborare l'input standard riga per riga usando il parametro -R o -F."
— manatwork
2

BF, 142 140 byte

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

Questo è diviso su due linee per chiarezza; la nuova riga non viene conteggiata.

È abbastanza facile scrivere questo genere di cose in BF, ma non è banale come ottimizzare l'ordine delle celle per ridurre al minimo i movimenti. Ho scritto una sceneggiatura di bruto-forcer per provare tutte le combinazioni e trovare la più breve, e l'ho giocata un po 'per spiegare un'opportunità di golf che non avevo incluso nel brute-forcer.

— Esolanging Fruit
fonte
@JoKing Ti suggerisco di postarlo come risposta separata, perché sembra molto diversa dalla mia.
— Esolanging Fruit
2

Brainfuck , 114 byte

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

Provalo online!

Ho usato BF Crunch qui per trovare un modo più ottimale per generare i singoli personaggi.

— Jo King
fonte
2

C (gcc) , 95 88 85 byte

Grazie ad Albert per -7 byte

Grazie anche a ceilingcat -3 byte

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

Provalo online!

— cleblanc
fonte
Non dichiarare *qsemplicemente annidalo nel tuo for-loop per salvare 5 byte. char*s;f(c){for(s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}
— Albert Renshaw,
Puoi anche salvare altri 2 byte sopra quello dichiarando *sall'interno dell'argomento della dichiarazione del for-loop:f(c){for(char*s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}
— Albert Renshaw,
Puoi radere anche un altro byte controllando un carattere ASCII che abbia un valore numerico di una cifra. 1è 49in ASCII ma sono 2 byte, usa qualcosa con un valore compreso tra 0 e 9, ad esempio il carattere di tabulazione `` è valore ASCII 9.
— Albert Renshaw,
Suggerisci *s;f(c){for(sinvece dif(c){for(int*
— ceilingcat il
1

SpecBAS - 70 byte

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

?è una scorciatoia per il PRINTcomando e l'apostrofo sposta il cursore sulla riga successiva.

— Brian
fonte
1

Python, 59 byte

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

Lua, 66 byte

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

((([[#Azzeccato]])))

— spifferare
fonte
1

[R], 65 byte

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

Abbastanza spettacolare, ne trovi uno più corto in R ... È il tuo gsub di base

— user11599
fonte
1

C ++ 208 byte

In risposta ai commenti: questo è un re-post completo.

#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
fonte
1

C # , 56 byte

golfed

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

Leggibile non golfato

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

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

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

Uscite

  • v1.0 - 56 bytes- Soluzione iniziale.

Gli appunti

I risultati stampati all'interno del link fornito non sembreranno pretesi, a causa del carattere utilizzato non monospace.

— auhmaan
fonte
1

C (gcc) , 87 byte

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 senza stdio.h provoca avvisi ma nessun errore, consentendo la compilazione corretta.

Spiegazione

Dichiarazione Printf che racchiude tutto in una riga, formattando il carattere decorativo con% c.

Provalo online

— Jake Reynolds
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.