Étant donné un nombre binaire, votre tâche consiste à créer une `` branche '' de ce nombre, avec une profondeur de 2.

Par exemple, donné 0en entrée, vous devez sortir exactement ceci:

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

Cela devrait être assez explicite sur la façon dont les branches doivent être créées. La profondeur 2 signifie que nous calculons des branches pour des nombres jusqu'à 2 nombres plus longs. Nous calculons également les branches dans l'ordre, avec des zéros en haut et des uns en bas.

Plus de cas de test:

0

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

1

     /100
  /10
 /   \101
1
 \   /110
  \11
     \111

00

       /0000
   /000
  /    \0001
00
  \    /0010
   \001
       \0011

01

       /0100
   /010
  /    \0101
01
  \    /0110
   \011
       \0111

10

       /1000
   /100
  /    \1001
10
  \    /1010
   \101
       \1011

11

       /1100
   /110
  /    \1101
11
  \    /1110
   \111
       \1111

Règles

• Vous ne recevrez jamais de caractères dans l'entrée autre que 1et 0.
• 0 < length of input < 11.
• Espaces de fuite autorisés à la fin des lignes.

Gelée , 39 38 octets

L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’

Essayez-le en ligne!

Comment?

L'art à imprimer est:

L  L /N00
L /N0
L/ L \N01
N
L\ L /N10
L \N1
L  L \N11

Où Nest la chaîne d'entrée et Lest une chaîne d'espaces de la longueur de la chaîne d'entrée.

Comme telle , elle est composée de huit éléments ( L, N, /, 0, le caractère de saut de ligne, \, 1, et le caractère d'espace) , et donc peuvent être stockés en tant que nombre de base 8 (qui peut être comprimé sous forme de nombre de base 250 en gelée). L' ṃatome combine la conversion de base et l'indexation en une liste (en fait, on peut définir des chiffres arbitraires à utiliser).

L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - Main link: binary string s  e.g. "100"
 ⁶                                     - space character
  ẋ                                    - repeat by:
L                                      -     length(s)                    [' ',' ',' ']
    W                                  - wrap s in a list                 [['1','0','0']]
   ,                                   - pair               [[' ',' ',' '],['1','0','0']]
      “/0¶\1 ”                         - char list: ['/','0',<newline>,'\',','1',' ']

     ;                                 - concatenate        [[' ',' ',' '],['1','0','0'],'/','0',<newline>,'\',','1',' ']
                “ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - base 250 number: 91531517467460683226372755994113932025707662527
              ṃ@                       - base decompression [reversed @arguments]
                                        -     this uses the concatenated list above as
                                        -     the 8 digits of that number in base 8.
                                        - implicit print

Lot, 178 170 159 octets

@set/pb=
@set s=%b:0= %
@set s=%s:1= %
@set e=@echo %s%
%e%  %s% /%b%00
%e% /%b%0
%e%/ %s% \%b%01
@echo %b%
%e%\ %s% /%b%10
%e% \%b%1
%e%  %s% \%b%11

Edit: Sauvegardé 11 octets grâce à @ ConorO'Brien.

JavaScript (ES6), 112 octets

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

Démo

let f =

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

console.log(f('0'))
console.log(f('11'))
console.log(f('101'))

Python 3 , 117 109 octets

lambda k:'ll   /g00\nl /g0\nl/l  \g01\ng\nl\l  /g10\nl \g1\nll   \g11'.replace('l',' '*len(k)).replace('g',k)

Essayez-le en ligne!

• économisé 8 octets grâce à JonathanAllan (Utilisation de la fonction lambda)

La chaîne de format lors de l'impression ressemble à:

ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

Cela semble déjà bon pour une chaîne de longueur 1. Tout ce que nous avons à faire est de remplacer l par des espaces de longueur égale à celle de g et, bien sûr, g doit être remplacé par la chaîne d'origine

Python 3.6, 172 153 128 octets

Littéralement, cela ne devient pas plus simple que cela ... C'est en fait plus court que ma tentative initiale de le générer avec un algorithme. Quelle tristesse.

k=input()
l=len(k)
b=' '*l
print(f'{b*2}   /{k}00\n{b} /{k}0\n{b}/ {b}\\{k}01\n{k}\n{b}\\ {b}/{k}10\n{b} \\{k}1\n{b*2} \\{k}01')

-19 octets grâce à @Leo
-25 octets grâce à @ L3viathan

C, 170 168 octets

Merci à @Neil d'avoir économisé deux octets!

n;f(char*s){n=strlen(s);printf("%*c%s00\n%*c%s0\n %*c%*c%s01\n%s\n %*c%*c%s10\n%*c%s1\n%*c%s11",2*n+4,47,s,n+2,47,s,n,47,n+3,92,s,s,n,92,n+3,47,s,n+2,92,s,2*n+4,92,s);}

Essayez-le en ligne!

Python 3 , 96 octets

lambda s:"""   /00
 /0
/  \01

\  /10
 \1
   \11""".translate([s,' '*len(s),s])

Essayez-le en ligne! Les caractères non imprimables ne s'affichent pas correctement; le format de la chaîne est le même que celui de officialaimm , mais avec \x01pour let \x02pour g.

ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

Utilise la substitution de chaînes avec la flexibilité de Python 3translate . La liste de traductions est [s,' '*len(s),s]mappée \x01vers ' '*len(s)et \x02vers s. Tous les caractères plus grands sont inchangés car ils donnent des indices qui sont hors limites pour la liste. \x00n'a pas pu être utilisé car un octet nul est lu comme une fin de programme, donc la première entrée est perdue.

PHP , 128 octets

Seule une sortie simple

<?=$b=str_pad("",strlen($a=$argn)),"$b   /{$a}00\n$b /{$a}0\n$b/$b  \\{$a}01\n$a\n$b\\$b  /{$a}10\n$b \\{$a}1\n$b$b   \\{$a}11";

Essayez-le en ligne!

Empilé , 81 octets

{!n#'' '*@s's  s /n00
s /n0
s/ s \n01
n
s\ s /n10
s \n1
s  s \n11' '\l'$#~1/repl}

Essayez-le en ligne!

Pas très intéressant, malheureusement. Voici la partie la plus intéressante:

'\l'$#~1/repl
         repl     replace all
'\l'              letters
    $#~           by evaluating
       1/         over one argument (otherwise, it would evaluate the "last" thingy)

Il s'agit essentiellement d'une interpolation de chaîne, mais de 10 octets de moins que la fonction intégrée.

/// , 116 octets

/[/\\\///x///*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

Essayez-le en ligne!

L'entrée est la suivante:

/[/\\\///x/INPUT HERE!!!!!!!!//*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

Fonctionne en utilisant un modèle de base et en ajoutant des espaces et des caractères si nécessaire.

Le nombre d'octets a augmenté car Ørjan Johansen s'est rendu compte qu'il ne gérait pas l'espacement au début. Mais le problème est résolu.

Python 2 , 101,91 octets 113 octets

lambda y:'   ++/_00\n +/_0\n+/  +\\_01\n_\n+\\  +/_10\n +\\_1\n   ++\\_11'.replace('_',y).replace('+',' '*len(y))

Essayez-le en ligne!

L'entrée est une chaîne de 0 et de 1 de longueur 1 ou 2! C'est 0,01,10 ou 11!

+12 octets - correction de l'espacement dans \ pour la longueur de deux entrées.

Fusain , 34 octets

Ｐ<³←⮌θＦ²«Ｊ³⁻×⁴ι²θＰ<²Ｉι↗Ｆ²«Ｐ⁺⁺θικ↓↓

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｐ<³

Imprimez les paires de /s et \s de gauche .

←⮌θ

Imprimez l'entrée justifiée à droite à la position actuelle.

Ｆ²«

Boucle à travers les branches.

Ｊ³⁻×⁴ι²

Déplacez la position de la branche. Nous pouvons le faire car la racine a été imprimée à droite afin que la branche centrale soit toujours à la même position absolue.

θ

Imprimez l'entrée.

Ｐ<²

Imprimez la bonne paire de /et \.

Ｉι

Imprimez le suffixe de branche.

↗

Passez à la première feuille.

Ｆ²«

Faites une boucle à travers les feuilles.

Ｐ⁺⁺θικ

Imprimez l'entrée et le suffixe de branche et de feuille.

↓↓

Passez à la feuille suivante. Remarque: Si un espace de fin était acceptable, alors Ｆ²⁺⁺⁺θι궶enregistrerait un octet.