Ramas binarias

15

Dado un número binario, su tarea es crear una 'rama' de ese número, con una profundidad de 2.

Por ejemplo, dado 0como entrada, debe generar exactamente esto:

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

Esto debería explicarse por sí mismo de cómo se deben crear las ramas. La profundidad 2 significa que calculamos ramas para números de hasta 2 números más largos. También calculamos las ramas en orden, con ceros en la parte superior y unos en la parte inferior.

Más casos de prueba:

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

Reglas

  • Nunca recibirá caracteres en la entrada que no sean 1y 0.
  • 0 < length of input < 11.
  • Se permiten espacios en blanco al final de las líneas.
Okx
fuente
44
0 < length of input < 11es 11decimal o binario? : P
ETHproductions
@ETHproductions Decimal: P
Okx

Respuestas:

4

Jalea , 39 38 bytes

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

Pruébalo en línea!

¿Cómo?

El arte a imprimir es:

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

Donde Nestá la cadena de entrada y Les una cadena de espacios de la longitud de la cadena de entrada.

Como tal, se compone de ocho componentes ( L, N, /, 0, el carácter de nueva línea, \, 1, y el carácter de espacio) y por lo tanto pueden ser almacenados como un número de base-8 (que puede ser comprimido como un número de base 250 en Jelly). El átomo combina la conversión de base y la indexación en una lista (efectivamente, uno puede definir dígitos arbitrarios para ser utilizados).

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
Jonathan Allan
fuente
5

Lotes, 178 170 159 bytes

@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

Editar: Guardado 11 bytes gracias a @ ConorO'Brien.

Neil
fuente
Solo cuento 149 bytes .
Engineer Toast
Supongo que Neil cuenta los saltos de línea como el CRLF de estilo Windows, mientras que TIO los cuenta como LF. No estoy seguro de si LF funciona para Batch en Windows.
Alex A.
4

JavaScript (ES6), 112 bytes

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)

Manifestación

Arnauld
fuente
¿por qué no [n,n,s.replace(/./g,' '),s,'\\'][n]?
tsh
@tsh Eso requeriría buscar en /\d/glugar de /./gignorar caracteres no numéricos.
Arnauld
4

Python 3 , 117109 bytes

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

Pruébalo en línea!

  • guardado 8 bytes gracias a JonathanAllan (Uso de la función lambda)

La cadena de formato cuando se imprime se ve así:

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

Esto ya se ve bien para una cadena de longitud 1. Todo lo que tenemos que hacer es reemplazar l por espacios de longitud igual a la de gy, por supuesto, g debe ser reemplazada por la cadena original

officialaimm
fuente
1
Puede guardar un byte utilizando una lambda sin nombre, lo que también significa que puede deshacerse de la impresión (ya que devolver la cadena debería ser aceptable) y guardar otros siete bytes. Luego puede guardar dos más utilizando una cadena multilínea que lo lleva a 107 ... TIO
Jonathan Allan
4

Python 3.6, 172 153 128 bytes

Literalmente no se vuelve más directo que esto ... Esto es en realidad más corto que mi intento original de generarlo con un algoritmo. Qué triste.

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 bytes gracias a @Leo
-25 bytes gracias a @ L3viathan

Hiperneutrino
fuente
Creo que sería más corto soltar a, c y d, y usar solo b y espacios en la cadena final. (a is b*2+' ')
Leo
Extraño, todavía parece 172 bytes para mí.
programmer5000
@ programmer5000 Lo siento, sería porque olvidé actualizar el código en sí.
HyperNeutrino
Guarde 26 caracteres con cadenas de formato: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 ¿Puedes verificar la sintaxis en eso? Me está dando un error de sintaxis.
HyperNeutrino
3

C, 170 168 bytes

¡Gracias a @Neil por guardar dos bytes!

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

Pruébalo en línea!

Steadybox
fuente
1
¿En lugar de imprimir a /o ` padded to width n + 1 , why not print a space, and then a / `o \relleno al ancho n?
Neil
Ugh, déjame intentarlo de nuevo. En lugar de imprimir un /o \acolchado al ancho n+1, ¿por qué no imprimir un espacio y luego un /o \acolchado al ancho n?
Neil
3

Python 3 , 96 bytes

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

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

Pruébalo en línea! Los caracteres no imprimibles no se muestran correctamente; el formato de cadena es el mismo que el de officialaimm , pero con \x01for ly \x02for g.

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

Utiliza la sustitución de cadenas con Python 3's flexibletranslate . La lista de traducción se [s,' '*len(s),s]asigna \x01a ' '*len(s)y \x02para s. Los caracteres más grandes no cambian porque dan índices que están fuera de los límites de la lista. \x00no se pudo utilizar porque se lee un byte nulo como final del programa, por lo que se desperdicia la primera entrada.

xnor
fuente
3

PHP , 128 bytes

Solo una salida 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";

Pruébalo en línea!

Jörg Hülsermann
fuente
2

Apilado , 81 bytes

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

Pruébalo en línea!

No muy interesante, desafortunadamente. Aquí está la parte más interesante:

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

Esto es básicamente una interpolación de cadenas, pero 10 bytes más corto que el incorporado.

Conor O'Brien
fuente
2

/// , 116 bytes

/[/\\\///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

Pruébalo en línea!

La entrada es la siguiente:

/[/\\\///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

Funciona utilizando una plantilla básica y agregando espacios y caracteres donde sea necesario.

El recuento de bytes aumentó porque Ørjan Johansen se dio cuenta de que al principio no manejaba el espacio. Pero el problema es saber arreglado.

Camarada SparklePony
fuente
Le di un voto a favor antes de verificar que funcionó, pero no está ajustando el espacio por la longitud. No veo una manera sucinta de hacerlo con un formato de entrada tan literal.
Ørjan Johansen
O espere, no es totalmente imposible ya que hay un límite de longitud de entrada de 11.
Ørjan Johansen
Algo así /*/\/y0\/ y\/\/y1\/ y\//**********/y///s/yx/y luego te espacias s.
Ørjan Johansen
@ ØrjanJohansen Vaya, se olvidó del espacio ... gracias. ¿Cómo incorporaría su código en la respuesta?
Camarada 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/puede manejar longitud arbitraria.
Ørjan Johansen
1

Python 2 , 101,91 bytes 113 bytes

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

Pruébalo en línea!

¡La entrada es una cadena de 0 y 1 de longitud 1 o 2! ¡Eso es 0,01,10 u 11!

+12 bytes: se corrigió el espaciado en \ para la entrada de longitud dos.

Keerthana Prabhakaran
fuente
3
su salida no se ajusta según la longitud de la cadena.
officialaimm
1
... y la pregunta especifica " 0 < length of input < 11".
Jonathan Allan
1
@officialaimm oh si. Me acabo de dar cuenta. Gracias. ¡Actualizaré mi respuesta! Jonathan ... eso fue un error tipográfico. Gracias lo corregí.
Keerthana Prabhakaran
0

Carbón , 34 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

P<³

Imprime los pares izquierdos de / sy \s.

←⮌θ

Imprima la entrada justificada a la derecha en la posición actual.

F²«

Recorre las ramas.

J³⁻×⁴ι²

Mueve la posición de la rama. Podemos hacer esto porque la raíz se imprimió justificada a la derecha para que la rama central esté siempre en la misma posición absoluta.

θ

Imprime la entrada.

P<²

Imprima el par correcto de /y \.

Iι

Imprime el sufijo de la rama.

Moverse a la primera hoja.

F²«

Recorre las hojas.

P⁺⁺θικ

Imprima la entrada y el sufijo de rama y hoja.

↓↓

Pasar a la siguiente hoja. Nota: Si el espacio en blanco al final fuera aceptable, F²⁺⁺⁺θι궶se ahorraría un byte.

Neil
fuente