Estes são dentes-de-leão ASCII:
\|/ \ / |
/|\ | \|/ |
| | | _\|/_
| | | /|\
Os dentes-de-leão ASCII têm três parâmetros: comprimento do caule (número positivo entre 1 e 256, número de sementes (número positivo entre 0 e 7) e orientação (^ ou v). Os dentes-de-leão acima têm comprimento, sementes e orientação ( 3,5, ^), (3,2, ^), (2,3, ^) e (3,7, v), respectivamente.
As sementes são preenchidas na seguinte ordem (viradas de cabeça para baixo para dentes de leão de cabeça para baixo), ilustradas em um dente de leão com comprimento 2:
seeds: 0 1 2 3 4 5 6 7
| \ / \|/ \ / \|/ _\ /_ _\|/_
| | | | /|\ /|\ /|\ /|\
| | | | | | | |
O desafio:
Escreva um programa / função que, ao receber um dente-de-leão ASCII como entrada, retorne seu comprimento, contagem de sementes e orientação formatados de forma semelhante aos exemplos acima e, quando dados parâmetros nesse formato, retornem um dente-de-leão ASCII com esses parâmetros. Você pode ignorar os parênteses e assumir que a entrada / saída será um número, uma vírgula, um número, uma vírgula e ou ^ou v. Você pode substituir outros caracteres por ^/ venquanto eles ainda puderem ser facilmente interpretados como 'up' / 'down' (por exemplo, u/ d). Você não precisa distinguir entre dentes-de-leão com a mesma aparência, como (2,1, ^) e (3,0, ^) ou (2,1, ^) e (2,1, v). Dada a arte ASCII, qualquer conjunto de parâmetros seria uma saída aceitável e os dois conjuntos de parâmetros podem fornecer a mesma arte ASCII.
Isso é código-golfe , então o código mais curto em bytes vence.
Um exemplo de programa em C # (nem um pouco de golfe):
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() + ",^";
}
}
^ev?Respostas:
Bean , 321 bytes
Aceita entrada como sequência única em stdin sem seguir a nova linha. Os parâmetros serão tomados da mesma maneira, mas formatados como
Os parâmetros de saída do programa quando a entrada é um dente de leão estarão no mesmo formato acima.
Hexdump:
JavaScript equivalente:
Implica
_implicitamente stdin como uma matriz separada por nova linha de seqüências de caracteres não formatadas e gera implicitamente os parâmetros como um trigêmeo. Conjunto de testes abaixo e demonstração aqui :fonte
Javascript
513391379355 bytesAgradecimentos a @Neil por ajudar a tirar 134 bytes de golfe e a @Kritixi Lithos por ajudar a tirar 13 bytes Este programa pressupõe que qualquer dente de leão ASCII que ele esteja tentando identificar tenha uma largura de linha de 5 para todas as linhas da cadeia. ou seja: o tronco tem 2 espaços, a linha vertical e mais 2 espaços. (Não é possível classificar os dentes-de-leão criados devido a esse problema)
Como funciona
A função verifica se o primeiro argumento fornecido tem um comprimento> 1 (é uma string). Se o primeiro argumento for uma sequência, ele identificará os detalhes do dente-de-leão ASCII.
Para obter a altura do dente-de-leão, ele divide a string em torno de caracteres de nova linha e conta o número de elementos - 1. Para obter o número de sementes, conta o número de caracteres não espaciais nas duas linhas superiores e inferiores. se houver mais caracteres no topo, ele será declarado na posição vertical e utilizará a contagem superior 1, caso contrário, será declarado invertido e utilizará a contagem inferior 1. Se a altura total for de apenas 2, ela determinará a verticalidade verificando as contagens de cada linha individualmente e escolhendo o lado com mais caracteres que não sejam espaços.
Caso contrário, a função usa matemática bit a bit para atribuir valores de 0 a 7 de acordo com a forma de cada nível do dente-de-leão a ser desenhado antes de converter cada nível na sequência apropriada.
Experimente online
fonte
(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 você retorna naifpeça de qualquer maneira. Além disso, enquanto estou aqui, eu só queria ressaltar que algumas funções comosplitejoinnão precisam dos()s quando você as invoca em`literais de string entre aspas, e é por isso que não as incluí no meu comentário anterior.`s, não's ou"s.\nnojoin`\n`a uma nova linha (como no personagem). Além disso, você pode alterar o(h>2?1:0)para apenash>2e o(h>2?2:1)para(h>2)+1. tio.run/#IRiKFPython 3,6,
476453448413394 bytesSolução :
Resultado
Desdobrar
fonte