Fais-moi un œuf de Pâques!

29

Non, pas le ^^vv<><>BAgenre d'oeufs de Pâques, de vrais oeufs de Pâques que nous peignons.

Voici un œuf (terriblement dessiné).

  __
 /  \
/    \
|    |
\____/

A Pâques, nous les peignons avec des motifs. Comme ceux-ci:

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

Le défi

Étant donné un caractère (ascii imprimable) pour peindre l'œuf, imprimez l'œuf peint.

Exemples:

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

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

Spécifications

  • Les sauts de ligne / espaces sont autorisés.
code-golf  ascii-art 
— Matthew Roh
source
8
Pourquoi le downvote? Si vous n'aimez pas cette question, votez contre puis laissez une raison s'il vous plaît.
— Matthew Roh
2
Une raison potentielle pourrait être qu'ils ne pensent pas que cette tâche soit suffisamment claire ou suffisamment claire. Je dirais que c'est assez clair, et ce n'est pas non plus insignifiant. Cela dit, je ne suis pas particulièrement excité non plus.
— John Dvorak
17
Le défi sera très trivial dans la plupart des langues. L'œuf est trop court pour permettre beaucoup d'originalité au golf. À mon avis, c'est un défi inintéressant (qui n'a pas été mis en bac à sable, parce que vous semblez boycotter le bac à sable pour je ne sais pas pour quelles raisons), donc, je le vote contre.
— Dada
25
Voté parce que de simples défis comme celui-ci sont parfaits pour les débutants comme moi pour se lancer dans le golf.
— Shaggy
7
POOF! Tu es un œuf de Pâques. (Désolé, je n'ai pas pu résister)
— George Cummins

Réponses:

16

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

+1 du -cdrapeau

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

Essayez-le en ligne!

J'allais écrire une explication, mais j'ai d'abord fait une sieste et oublié comment tout cela fonctionne. Votre supposition est aussi bonne que la mienne.

— Assistant de blé
source
14
C'est la meilleure explication que j'ai jamais lue ici. +1
— David Conrad
12

Python 2, 62 octets

Super simple. Essayez-le en ligne .
-1 octet, merci à @ mbomb007

print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)
— Possum mort
source
1
— mbomb007
@ mbomb007 Bon, merci
— Dead Possum
2
Vous pouvez enregistrer deux octets en utilisant la fonction lambda comme celle-ci
— Keerthana Prabhakaran
@KeerthanaPrabhakaran Je ne sais pas si les lambdas sont OK pour les défis ascii
— Dead Possum
1
quel est le problème de l'utilisation de lambda dans les défis ascii? comment sont-ils même liés!? : o
— Keerthana Prabhakaran
10

Fusain , 30 26 16 octets

Deux octets économisés grâce à @Neil en remplissant après avoir fait la forme

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

Essayez-le en ligne!

Explication

Le programme fonctionne en créant d'abord la moitié droite de l'œuf, puis en la réfléchissant pour générer la moitié gauche.

__↗¹                          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
source
←_↘peut être juste , ↓_mais en fait , vous pouvez remplir une fois que vous réfléchissiez pour 16 octets: __↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ.
— Neil
@Neil Merci de m'avoir présenté¤
— Kritixi Lithos
9

Gelée , 24  22 octets

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

Essayez-le en ligne!

Comment?

Ḥ;“ ¶/\|_”“Ṁ¢Ṛ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
source
3
Je nomme votre explication de ṃpour la plus longue explication d'un seul octet.
— Magic Octopus Urn
Il semble être devenu un atome assez pratique, je pensais lui donner un peu de temps sous les projecteurs!
— Jonathan Allan
2
Je vois que Dennis l'utilise beaucoup, c'est la première fois que j'ai l'impression de l'avoir bien compris; le temps n'a pas été perdu! Vous m'avez donné 1 unité d'apprentissage.
— Urne de poulpe magique du
1
Eh bien, c'est l'un de mes bébés :)
— Jonathan Allan
6

Sed, 43 personnages

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

Exemple d'exécution:

bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/
— homme au travail
source
C'est exactement ce que j'ai écrit, juste quelques secondes plus vite.
— Riley
6

JavaScript (ES6), 53 49 47 octets

Je suis sûr que je peux en tirer un peu plus - devoir m'échapper \m'ennuie.

f=

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

console.log(f`-`)
console.log(f`%`)
console.log(f`~`)
console.log(f`&`)
console.log(f`#`)
Développer l'extrait

  • 4 octets enregistrés en déplaçant l' s=c+caffectation de variable à l'intérieur du premier ensemble de {}.
  • 2 octets enregistrés en utilisant c+=cau lieu de s=c+c& s=s+s, avec en partie merci à Neil qui a repéré cette amélioration en même temps que je la faisais.

Peignez le vôtre!

Afficher l'extrait de code

— Hirsute
source
Ce serait un peu mieux si vous mettez ces entrées dans l' <pre><code>art. Beau travail cependant.
— Matthew Roh
Merci, @SIGSEGV. Les consoles préservent l'espace blanc et, par défaut, au moins, utilisent une police à espacement fixe, donc pas besoin de sortir vers a pre.
— Shaggy
1
Pourquoi ne pas c+=c?
— Neil
Merci, @Neil, je ne faisais que le modifier moi-même, mais je mettrai à jour à nouveau pour vous donner un signe de tête également.
— Shaggy
@Arnauld Vous n'avez pas besoin de compter la f=\npartie pour le nombre d'octets. C'est uniquement pour que l'extrait s'exécute.
— AdmBorkBork
5

Alice , 53 52 octets, non concurrente

Merci à Leo d'avoir économisé indirectement 1 octet.

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

Essayez-le en ligne!

Malheureusement, j'ai dû corriger un bogue avec y(translittération) pour que cela fonctionne, donc je l'ai marqué comme non concurrent.

Explication

L'idée de base est de créer une chaîne de l'œuf mais avec ~comme espace réservé pour deux copies de l'entrée. Cependant, les autres caractères de l'entrée ne sont pas particulièrement conviviaux pour les chaînes Alice, car ceux-ci ne peuvent pas contenir de sauts de ligne, et tous /\_|auraient besoin d'être échappés (car ils sont traités comme des miroirs et des murs). Je peux donc économiser quelques octets en utilisant des espaces réservés pour ceux-ci également, puis en les translittérant. Les espaces réservés pour /\_|sont .[^{, qui sont simplement le caractère juste avant celui qu'ils représentent. Pour le saut de ligne que j'utilise }.

Maintenant, le code ... tout le programme peut être résolu en mode Ordinal car nous n'avons besoin que d'un traitement de chaîne et pas de traitement d'entiers. De plus, nous n'avons besoin d'aucun flux de contrôle conditionnel. L'ensemble du programme peut être exprimé de façon linéaire. La structure générale du programme est la suivante:

/...//
@....

Dans un tel programme, l'IP rebondit de haut en bas dans la ...section, n'exécutant d'abord que la moitié des caractères. Ensuite, les deux /à la fin déplacent l'IP vers la droite d'une cellule, de sorte qu'au retour, il exécute l'autre moitié (rebondissant de nouveau de haut en bas) jusqu'à ce que @le programme se termine enfin . Donc, si nous déplions la structure en zigzag drôle au milieu, le programme que nous exécutons ressemble vraiment à ceci:

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

Passons par là:

"  ^^} .~[}.~~[}{~~{}[^^^^."
      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
source
: D c'est ici !! Cette langue a l'air astucieuse
— Conor O'Brien
@ ConorO'Brien merci. J'ai déjà plâtré des défis plus anciens avec lui au cas où vous voudriez voir plus d'échantillons. :)
— Martin Ender
4

PowerShell , 50 49 48 octets

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

Essayez-le en ligne!

Remplacement de chaîne simple en chaîne littérale. Pas beaucoup de place pour le golf.

-1 octet grâce à HyperNeutrino; -1 octet grâce aux wubs

— AdmBorkBork
source
4

Carotte , 34 octets, non concurrente

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

Non compétitif car je viens de corriger un bug avec l'interpréteur dans les espaces de tête non affichés.

Essayez-le en ligne ici .

Tout d'abord, nous sommes en mode curseur, où chaque personnage est poussé vers la "pile". Et enfin, la "pile" est imprimée en sortie.

En mode curseur, #pousse l'entrée, de sorte que les instances de #sont fondamentalement remplacées par l'entrée (FYI #est un programme cat à un octet).

— Kritixi Lithos
source
4

SOGL V0.12 , 21 18 16 octets

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

Essayez-le ici!

L'ensemble du programme est le suivant compressé:

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

où ŗest remplacé par l'entrée.

13 octets fonctionne presque aussi, mais il fait des choses inutiles avec certaines entrées ..

— dzaima
source
Vous devez peindre l'œuf. (c'est-à-dire remplir l'intérieur de l'œuf avec des personnages)
— Matthew Roh
@SIGSEGV - Il est expliqué que cela est réalisé en remplaçant les espaces par l'entrée et en remplaçant les tirets par des espaces par le code@,ŗ -@ŗ
— Jonathan Allan
SOGOL sera-t-il bientôt chez TIO?
— Jonathan Allan
@JonathanAllan Si quelqu'un peut y arriver, alors oui.
— dzaima
Parlez à Dennis dans la salle talk-tryitonline-net .
— Jonathan Allan
3

05AB1E , 34 33 32 octets

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

Essayez-le en ligne!

Explication

„__                               # 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
source
•jÀňiXƒÐ[Z•6B6ôvy5ÝJ"_ |/\"¹«‡,pour 32, tout à fait différent cependant. Cela m'a truqué et m'a fait penser que je pouvais utiliser palindromize ... Merde le fait que ())(et /\\/sont des palindromes.
— Urne de poulpe magique
1
@carusocomputing: vous devez le publier séparément. C'est assez différent pour être intéressant par lui-même :)
— Emigna
3

Python 3.6 , 53 octets

lambda x:fr'''  __
 /{2*x}\
/{4*x}\
|{4*x}|
\____/'''
  • Fonction sans nom prenant le caractère xet renvoyant une chaîne.
  • Utilise les chaînes f de Python 3.6 comme alternative supplémentaire aux versions antérieures .format()- les {}parties incluses de la chaîne f sont du code à évaluer.
  • La chaîne est également une chaîne r et des guillemets triples économisant un octet sur:

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

Cependant, je ne peux pas voir d'interprète en ligne pour Python 3.6.
Essayez-le sur repl.it (dit 3.5 mais c'est 3.6)

— Jonathan Allan
source
3

Brainfuck - 257 octets 181 octets

Golfed: Live version cliquez ici

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

Je ne suis pas un golfeur professionnel. Voici ma tentative pour autant que je me souvienne: D

Sortie:

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

Non golfé (+ commentaires):

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

05AB1E , 32 29 26 octets (Merci à Emigna / Adnan)

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

Essayez-le en ligne!

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

Version 29 octets (plus intelligent sans itération nécessaire en raison du codage des nouvelles lignes également):

05AB1E , 29 octets (Emigna)

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

Essayez-le en ligne 2!

Extension de 26 octets de la suggestion d'Emigna, en utilisant S pour séparer les caractères dans un tableau, puis a [b] pour interpoler chaque chiffre avec l'emplacement correspondant dans le tableau précédent. Il s'agit essentiellement d'une translittération élément par élément (intelligente).

05AB1E , 26 octets (Adnan)

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

Essayez-le en ligne 3!

— Urne de poulpe magique
source
1
C'est 3 octets plus court. Plus semblable à votre réponse que la mienne :)
— Emigna
1
@Emigna que la translittération directe à l'aide de nouvelles lignes est une idée nouvelle, j'aime ça; cela pourrait honnêtement faire tomber 5 octets de plusieurs de mes solutions existantes.
— Urne de poulpe magique
2
— Adnan
1
@adnan Sè- sneaky sneaky ...
— Urne de poulpe magique
J'ai l'impression que presque toutes mes réponses doivent être créditées Admigna, je ne connais pas vraiment la langue sans vos deux exemples constants.
— Urne de poulpe magique
2

PHP, 51 octets

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

PHP, 58 octets sans sauts de ligne physiques

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

exécuter cela avec -Roption

61 octets

echo strtr("  __\n /88\\\n/8888\\\n|8888|\n\\____/",8,$argn);
— Jörg Hülsermann
source
Stockez la valeur doublée; supprimer l'espace inutile; utiliser un caractère de nouvelle ligne littéral: pastebin.com/EghdAYMf
— manatwork
@manatwork Merci, je n'ai pas vraiment pensé à doubler l'entrée
— Jörg Hülsermann
économisez 7 octets avec des sauts de ligne physiques et sans échapper aux barres obliques inverses (le dernier n'a pas besoin de s'échapper de toute façon). Oh et btw: ce -Rn'est pas un paramètre, c'est une option.
— Titus
@Titus je déteste les sauts de ligne physiques Terminé
— Jörg Hülsermann
@Titus, à droite, mais les man phpappelle paramètre : «Il est également possible de traiter l'entrée standard ligne par ligne en utilisant le paramètre -R ou -F.»
— manatwork
2

BF, 142 140 octets

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

Ceci est divisé en deux lignes pour plus de clarté; la nouvelle ligne n'est pas comptée.

Il est assez facile d'écrire ce genre de chose en BF, mais il n'est pas trivial d'optimiser l'ordre des cellules pour minimiser le mouvement. J'ai écrit un script de brute-forcer pour essayer toutes les combinaisons et trouver la plus courte, et je l'ai joué un peu pour tenir compte d'une opportunité de golf que je n'avais pas incluse dans le brute-forcer.

— Esolanging Fruit
source
@JoKing Je vous suggère de poster cela comme une réponse séparée, car cela semble très différent du mien.
— Esolanging Fruit
2

brainfuck , 114 octets

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

Essayez-le en ligne!

J'ai utilisé BF Crunch ici pour trouver un moyen plus optimal de générer les personnages individuels.

— Jo King
source
2

C (gcc) , 95 88 85 octets

Merci à Albert pour -7 octets

Merci aussi à plafondcat -3 octets

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

Essayez-le en ligne!

— cleblanc
source
Ne déclarez pas *qsimplement l'imbriquez directement dans votre boucle for pour économiser 5 octets. char*s;f(c){for(s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}
— Albert Renshaw
Vous pouvez également enregistrer 2 octets supplémentaires au-dessus de cela en déclarant *sà l'intérieur de l'argument de déclaration de la boucle for:f(c){for(char*s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}
— Albert Renshaw
Vous pouvez également raser 1 octet supplémentaire en recherchant un caractère ASCII ayant une valeur numérique d'un chiffre. 1est 49en ASCII mais cela fait 2 octets, utilisez quelque chose avec une valeur de 0 à 9, par exemple le caractère de tabulation `` est une valeur ASCII 9.
— Albert Renshaw du
Suggérer à la *s;f(c){for(splace def(c){for(int*
— plafondcat
1

SpecBAS - 70 octets

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

?est un raccourci pour la PRINTcommande, et l'apostrophe déplace le curseur sur la ligne suivante.

— Brian
source
1

Python, 59 octets

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

Lua, 66 octets

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

((([[#J'y suis arrivé]])))

— Jaser
source
1

[R], 65 octets

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

Assez peu spectaculaire, veuillez en trouver un plus court dans R ... C'est votre gsub de base

— user11599
source
1

C ++ 208 octets

En réponse aux commentaires: Ceci est une re-publication complète.

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

C # , 56 octets

Golfé

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

Non golfé

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

Non lisible non lisible

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

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

Code complet

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

Communiqués

  • v1.0 - 56 bytes- Solution initiale.

Remarques

Les résultats imprimés dans le lien fourni ne ressembleront pas à des faux, car la police utilisée n'est pas monospace.

— auhmaan
source
1

C (gcc) , 87 octets

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 sans stdio.h provoque des avertissements mais aucune erreur, permettant une compilation réussie.

Explication

Instruction Printf qui rassemble tout sur une seule ligne, formatant le caractère de décoration avec% c.

Essayez-le en ligne

— Jake Reynolds
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.