Estos son dientes de león ASCII:
\|/ \ / |
/|\ | \|/ |
| | | _\|/_
| | | /|\
Los dientes de león ASCII tienen tres parámetros: longitud del tallo (número positivo entre 1 y 256, número de semillas (número positivo entre 0 y 7) y orientación (^ o v). Los dientes de león anteriores tienen longitud, semillas y orientación, ( 3,5, ^), (3,2, ^), (2,3, ^) y (3,7, v) respectivamente.
Las semillas se rellenan en el siguiente orden (volteadas para los dientes de león con la cabeza hacia abajo), ilustradas en un diente de león con longitud 2:
seeds: 0 1 2 3 4 5 6 7
| \ / \|/ \ / \|/ _\ /_ _\|/_
| | | | /|\ /|\ /|\ /|\
| | | | | | | |
El reto:
Escriba un programa / función que, cuando se le da un diente de león ASCII como entrada, devuelve su longitud, recuento de semillas y orientación con un formato similar a los ejemplos anteriores y cuando los parámetros dados en ese formato devuelve un diente de león ASCII con esos parámetros. Puede ignorar el paréntesis y asumir que la entrada / salida será un número, una coma, un número, una coma y cualquiera ^o v. Puede sustituir otros caracteres por ^/ vsiempre que puedan interpretarse fácilmente como 'arriba' / 'abajo' (por ejemplo, u/ d). No necesita distinguir entre dientes de león que se ven iguales, como (2,1, ^) y (3,0, ^) o (2,1, ^) y (2,1, v). Dado el arte ASCII, cualquier conjunto de parámetros sería un resultado aceptable, y ambos conjuntos de parámetros pueden dar el mismo arte ASCII.
Este es el código de golf , por lo que gana el código más corto en bytes.
Un programa de ejemplo en C # (ni siquiera ligeramente golfizado):
string Dandelion(string s)
{
if (s.Contains(','))
{
//got parameters as input
string[] p = s.Split(',');
//depth and width (number of seeds)
int d = int.Parse(p[0]);
int w = int.Parse(p[1]);
//draw stem
string art = " |";
while (d > 2)
{
d--;
art += "\n |";
}
//draw head
string uhead = (w % 2 == 1 ? "|" : " ");
string dhead = uhead;
if (w > 1)
{
uhead = "\\" + uhead + "/";
dhead = "/" + dhead + "\\";
if (w > 5)
{
uhead = "_" + uhead + "_\n /|\\";
dhead = "_\\|/_\n " + dhead;
}
else if (w > 3)
{
uhead = " " + uhead + " \n /|\\";
dhead = " \\|/ \n " + dhead;
}
else
{
uhead = " " + uhead + " \n |";
dhead = " |\n " + dhead;
}
}
else
{
uhead = " " + uhead + "\n |";
dhead = " |\n " + dhead;
}
//add head to body
if (p[2] == "^")
{
return uhead + "\n" + art;
}
return art + "\n" + dhead;
}
else
{
//ASCII input
string[] p = s.Split('\n');
int l = p.Length - 1;
int offset = 0;
//find first non-' ' character in art
while (p[0][offset] == ' ')
{
offset++;
}
int w = 0;
if (p[0][offset] == '|')
{
//if '|', either head-down or no head.
if (offset == 0 || p[l][offset - 1] == ' ')
{
//if no space for a head to the left or no head at the bottom, no head.
return l.ToString() + ",1,^";
}
//head must have at least size 2, or else indistinguishable from no head case
w = 6;
if (p[l][offset] == '|')
{
//odd sized head
w = 7;
}
if (offset == 1 || p[l - 1][offset - 2] == ' ')
{
//not size 6 or 7
w -= 2;
if (p[l - 1][offset - 1] == ' ')
{
//not size 4 or 5
w -= 2;
}
}
return l.ToString() + "," + w.ToString() + ",v";
}
else if (p[0][offset] == '\\')
{
//head at least size 2 and not 6/7, or indistinguishable from no head.
w = 4;
if (p[0][offset + 1] == '|')
{
w = 5;
}
if (p[1][offset] == ' ')
{
w -= 2;
}
}
else
{
w = 6;
if (p[0][offset + 2] == '|')
{
w = 7;
}
}
return l.ToString() + "," + w.ToString() + ",^";
}
}
^yv?Respuestas:
Bean , 321 bytes
Acepta la entrada como una sola cadena en stdin sin arrastrar nueva línea. Los parámetros se tomarán de la misma manera, pero formateados como
Los parámetros de salida del programa cuando la entrada es un diente de león estarán en el mismo formato que el anterior.
Hexdump:
JavaScript equivalente:
Implícitamente toma stdin como una matriz separada de nueva línea de cadenas sin formato
_y genera implícitamente los parámetros como un triplete. Conjunto de pruebas a continuación y demostración aquí :fuente
Javascript
513391379355 bytesGracias a @Neil por ayudar al golf con 134 bytes y a @ Kritixi Lithos por ayudar al golf a 13 bytes. Este programa asume que cualquier diente de león ASCII que está tratando de identificar tiene un ancho de línea de 5 para todas las líneas de la cadena. es decir: el tallo es de 2 espacios, la línea vertical y luego otros 2 espacios. (No puede clasificar los dientes de león que crea debido a este problema)
Cómo funciona
La función verifica si el primer argumento que se le da tiene una longitud> 1 (es una cadena). Si el primer argumento es una cadena, identifica los detalles del diente de león ASCII.
Para obtener la altura del diente de león, divide la cadena alrededor de los caracteres de nueva línea y cuenta el número de elementos: 1. Para obtener el número de semillas, cuenta el número de caracteres no espaciales en las dos líneas superiores e inferiores. si hay más caracteres en la parte superior, se declara en posición vertical y usa el conteo superior 1, de lo contrario se declara al revés y usa el conteo inferior 1. Si la altura total es solo 2, determina la verticalidad al verificar los recuentos de cada línea individualmente y elegir el lado con más caracteres que no sean espacios.
De lo contrario, la función utiliza matemática bit a bit para asignar valores de 0 a 7 de acuerdo con la forma de cada nivel del diente de león que se dibujará antes de convertir cada nivel en la cadena adecuada.
Pruébalo en línea
fuente
(x,y,z,a=[...Array(x+1)].fill(1))=>a.map(n=>', |, \\ /, \\|/,_\\ //,_\\|/_, / \\, /|\\'.split`,`[n],z<'v'?(a[0]=y&4?y-2:y,a[1]=y&4?7:1):(a[x-1]=1+(y>4)*2+(y>4)*(y&2),a[x]=y&1+(y>2)*6)).join`\n`elseporque regresa en laifparte de todos modos. Además, mientras estoy aquí, solo quería señalar que algunas funciones comosplityjoinno necesitan las()s cuando las`invocas en literales de cadena entre comillas, es por eso que no las incluí en mi comentario anterior.`s, no'so"s.\ndejoin`\n`una nueva línea (como en el carácter). También puede cambiar(h>2?1:0)a justh>2y a(h>2?2:1)to(h>2)+1. tio.run/#IRiKFPython 3.6,
476453448413394 bytesSolución :
Resultado
Desplegar
fuente