Branches binaires


15

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

4
0 < length of input < 11est 11décimal ou binaire? : P
ETHproductions

@ETHproductions Decimal: P
Okx

Réponses:


4

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

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

5

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.


Je ne compte que 149 octets .
Engineer Toast

Je suppose que Neil compte les sauts de ligne comme CRLF de style Windows tandis que TIO les compte comme LF. Je ne sais pas si LF fonctionne pour Batch sous Windows.
Alex A.

4

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


pourquoi pas [n,n,s.replace(/./g,' '),s,'\\'][n]?
tsh

@tsh Cela nécessiterait de rechercher /\d/gplutôt que /./gd'ignorer les caractères non numériques.
Arnauld

4

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


1
Vous pouvez enregistrer un octet à l'aide d'un lambda sans nom, ce qui signifie également que vous pouvez vous débarrasser de l'impression (car le retour de la chaîne devrait être acceptable) et enregistrer sept autres octets. Vous pouvez ensuite en enregistrer deux de plus en utilisant une chaîne multiligne vous ramenant à 107 ... TIO
Jonathan Allan

4

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


Je pense qu'il serait plus court de supprimer a, c et d, et d'utiliser uniquement b et des espaces dans la chaîne finale. (a is b*2+' ')
Leo

Bizarre, semble toujours 172 octets pour moi.
programmer5000

@ programmer5000 Désolé, ce serait parce que j'ai oublié de mettre à jour le code lui-même.
HyperNeutrino

Enregistrez 26 caractères avec des chaînes de format:print(f'{a}/{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')
L3viathan

@ L3viathan Pouvez-vous vérifier la syntaxe à ce sujet? Cela me donne une erreur de syntaxe.
HyperNeutrino

3

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!


1
Plutôt que d'imprimer un /ou ` padded to width n + 1 , why not print a space, and then a / `ou \rembourré à la largeur n?
Neil

Ugh, laissez-moi réessayer. Plutôt que d'imprimer un /ou \rembourré en largeur n+1, pourquoi ne pas imprimer un espace, puis un /ou \rembourré en largeur n?
Neil

3

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.



2

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.


2

/// , 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.


Je vous ai donné un vote positif avant de vérifier que cela fonctionnait - mais vous ne réglez pas l'espacement pour la longueur. Je ne vois pas de façon succincte de le faire avec un format d'entrée aussi littéral.
Ørjan Johansen

Ou attendez, ce n'est pas totalement désespéré car il y a une limite de longueur d'entrée de 11.
Ørjan Johansen

Quelque chose comme /*/\/y0\/ y\/\/y1\/ y\//**********/y///s/yx/et puis vous obtenez un espacement avec s.
Ørjan Johansen

@ ØrjanJohansen Oups, j'ai oublié l'espacement ... merci. Comment pourrais-je incorporer votre code dans la réponse?
Camarade SparklePony

FWIW /00/0|0//01/0|1//10/1|0//11/1|1//|/<\\y>//z/<y>x//<y>0/ //<y>1/ //<\\y\>///s/z/peut gérer des longueurs arbitraires.
Ørjan Johansen

1

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.


3
votre sortie ne s'ajuste pas selon la longueur de la chaîne.
officialaimm

1
... et la question précise " 0 < length of input < 11".
Jonathan Allan

1
@officialaimm oh ouais. Vient de le remarquer. Merci. Va mettre à jour ma réponse! Jonathan .. c'était une faute de frappe. Merci je l'ai corrigé.
Keerthana Prabhakaran

0

Fusain , 34 octets

P<³←⮌θF²«J³⁻×⁴ι²θP<²Iι↗F²«P⁺⁺θικ↓↓

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

P<³

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

←⮌θ

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

F²«

Boucle à travers les branches.

J³⁻×⁴ι²

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.

P<²

Imprimez la bonne paire de /et \.

Iι

Imprimez le suffixe de branche.

Passez à la première feuille.

F²«

Faites une boucle à travers les feuilles.

P⁺⁺θικ

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 F²⁺⁺⁺θι궶enregistrerait un octet.

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.