Introdução
Todos nós conhecemos o S legal (também conhecido como Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S etc. etc.): bilhões de crianças em idade escolar em todo o mundo desenharam este S e imediatamente ficaram orgulhosos deles mesmos. Caso você tenha esquecido ou tido uma infância completamente chata , aqui está uma imagem do dito S legal:
Dado um fator de escala n
como entrada (onde \ $ 1 \ leq n \ leq 20 \ $), produza Cool S na arte ASCII.
Como desenhar
da página da Wikipedia no Cool S:
Saída
O Cool S quando n
= 1 é:
^ / \ / \ / \ | | | | | | \ \ / \ \/ /\ \ / \ \ | | | | | | \ / \ / \ / v
E para diferentes valores de n
, você simplesmente torna a saída n
vezes maior. exemplo, n
= 2:
^ / \ / \ / \ / \ / \ | | | | | | | | | | | | \ \ / \ \ / \ \/ /\ \ / \ \ / \ \ | | | | | | | | | | | | \ / \ / \ / \ / \ / v
Observe que as seções verticais são duas vezes mais longas e o espaçamento entre as as linhas verticais são duas vezes mais largas.
E quando n
= 3:
^ / \ / \ / \ / \ / \ / \ / \ | | | | | | | | | | | | | | | | | | \ \ / \ \ / \ \ / \ \/ /\ \ / \ \ / \ \ / \ \ | | | | | | | | | | | | | | | | | | \ / \ / \ / \ / \ / \ / \ / v
Observação: Embora não seja necessário irado, seu código também pode ser compatível com n
= 0:
^ / \ \\/ /\\ \ / v
Vencedor
O programa mais curto em bytes vence.
Comentários
Resposta
Carvão , 58 53 47 43 41 bytes
Nθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖B↓‖M← vMδ⁰⊗θ↗⊕θM⁰δ↗θ/⊗θ⟲T
Eu só queria tentar outra abordagem, que desenha o exterior por meio de reflexos (obrigado ao Neil por expandir a ideia) e depois desenha a parte interna. Como o carvão vegetal tem :Left
como direção padrão para desenhar linhas, faço uso dessa direção tanto quanto possível para economizar alguns bytes desenhando o S horizontalmente, assim:
/----\ /----\ / \ / \ / \/ \ / / \ / / \ v ----/ /---- ^ \ / / \ / / \ /\ / \ / \ / \----/ \----/
E então eu só preciso girar a tela 90 graus no sentido anti-horário.
Comentários
- Você pode estar no caminho certo … 22 bytes leva você de fora …
- @Neil era ‘ t exatamente assim, sua ideia precisava de uma pequena correção, mas na verdade esta foi uma grande melhoria!
- Sim, cometi um erro semelhante em minha postagem original porque não ‘ t verifique o efeito do dimensionamento corretamente.
- Alguém disse
Rotate
? Isso me dá uma ideia … - @Neil ei, você conseguiu uma grande melhoria aí! 🙂
Resposta
Python 3 , 255 249 248 209 bytes
-6 bytes graças a Kevin Cruijssen
-1 byte graças a Kevin Cruijssen
-39 bytes graças a Rod e Jo King
n=int(input()) m=2*n a,b,q,c,l="\ \n/|" f=m*b s=q+q.join([f[d:]+c+b*2*d+b+a+f[d:]for d in range(m+1)]+[l+f+l+f+l]*m+[d*b+a+f+a+f[d*2:]+c+d*b for d in range(n)]+[n*b+a+f+a+c+n*b]) print(f,"^"+s+q+s[::-1]+f,"v")
Agora processa n = 0.
Comentários
- Ambos
o+~d
podem serm-d
erange(o)
pode serrange(m+1)
, e então você pode removero=m+1\n
para economizar 6 bytes. Boa resposta, porém, +1 meu. - Ah, e mais um byte alterando
p(s)\np(s[::-1])
parap(s+q+s[::-1])
: 248 bytes - Você pode economizar 6 bytes se usar um único
print
e mais 4 removendo[]
dejoin([...])
, totalizando 238 bytes - Você também pode armazenar
q.join
em uma variável para salvar um byte - 217 . Juntou todos os
q.join
se algumas outras coisas
Resposta
Carvão , 47 42 41 bytes
Fv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θMθ⁺⊗θ⊕θ⟲⁴
Experimente online! O link é para a versão detalhada do código.Explicação: Desenha as seguintes linhas em ordem:
^ / \ / \ / \ | 1 | | 1 | \ 2 / \ 2/ 8\ 2 8 \ 2 7 | 3 7 9 3 6 4 6 4 6 4 5
Onde 5
é o caractere atual da string v^
. No final do primeiro loop, o cursor é então posicionado no ponto 9
. A tela inteira é girada para que a outra metade do Cool S possa ser desenhada. (Na verdade, a tela é girada duas vezes, mas isso é apenas um detalhe de implementação.)
O carvão não suporta RotateCopy(:Up, 4)
, mas se fosse, isso funcionaria para 33 bytes:
↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖BM↓↙⊗θ→↓⊗θ⟲C↑⁴J⁰¦⁰v
Comentários
- @BetaDecay Desculpe. Eu também coloquei o byte errado conte de qualquer maneira …
- Legal, acertou n = 0 também
Resposta
Canvas , 36 32 29 bytes
«|*‼l├/L1^╋;╶╵\∔∔│α╶«├:╵╋:↔↕∔
Muita manipulação de pilha. Explicação (desatualizada):
«|* an array of input*2 "|"s ‼ cast to a 2D object (needed because bug) : duplicate that (saved for the center line) l├ height+2 / create a diagonal that long L1^╋ and in it, at (width; 1) insert "^" ;∔ append the vertical bars ^ / so far done: / / | | ⁸╵ input+1 \ antidiagonal with that size ∔ appended to the above │ mirror horizontally ^ / \ / \ / \ current: | | | | \ / \ / | α get the 2nd to last popped thing - the antidiagonal | └∔ append it to the vertical line copied way before: \ ⁸«├ input/2 + 2 \ :╵ duplicate + 1 ╋ at (input/2 + 2; input/2 + 3) in the big part insert ^ :↔↕∔ mirror a copy vertically & horizontally and append that to the original
Resposta
Python 2 , 227 208 207 202 196 181 bytes
I=n=2*input() R,L,S,P="/\ |" k=n*[2*(P+S*n)+P] exec"k=[R+S+2*S*I+L]+k+-~I%2*[L+S*n+L+S*I+R];I-=1;"*-~n print"\n".join(t.center(2*n+3)for t in["^"]+k+[a[::-1]for a in k[::-1]]+["v"])
Obrigado Jo King por 1 byte; e outro total de 5 bytes (via n => 2*n
).
Funciona para n=0
também.
Resposta
C (gcc) , 379 353 344 334 bytes
Usei alguns #define
s para eliminação de subexpressão e vários globais para se comunicar entre as funções internas. O loop principal vai {0,1,2,3,3,2,1,0} para construir o S.
Obrigado a Jonathan Frech pelas sugestões.
#define z(a,b...)printf("%*c%*c%*c\n"+a,b);} #define y(a){for(i=~-a*t;v*i<v*a*!t+t;i+=v) i,n,p,r,t,u,v;a(){z(6,r+2,94+t*24)b()y(-~r)z(3,-i-~r,47+u,i*2+2,92-u)c()y(r)z(0,~r,124,~r,124,~r,124)d()y(-~n)z(0,i+1,92-u,2*(n-t*i)+1,92,2*(n-!t*i)+1,47+u)(*x[])()={a,b,c,d};f(s){r=2*s;for(p=0;p<8;x[7*t-p++*(2*t-1)](n=s))t=p>3,v=2*!t-1,u=t*45;}
Comentários
-
w -r-1
possivelmente podem ser jogados paraw~r
. - Embora o inlining seja um byte a menos .
- 344 bytes .
- 321 bytes
Resposta
C (gcc) , 260 254 bytes
-6 bytes graças a roofcat .
f(n){int s=2*n++,t=s+1,I[]={1,t,s,n,n,s,t,1},A[]={s,1,1,1,2*t,1,t,t,1,t,1,n,t,t,1,t,t,1,1,1,t,s,1,1},x;for(s=8;s--;)for(n=0;n<I[s];n++,puts(""))for(t=3;t--;)x=s*3+t,printf("%*c",n*("AAAA?BAAAAC@?ABAAACA@AAA"[x]-65)+A[x],"w!!!0]}}}]]00]]}}}]!0_!!"[x]-1);}
Resumo
Podemos dividir a forma em partes:
^ Top cap / \ Top slope ||| Sides \\/ Twist, part 1 /\\ Twist, part 2 ||| Sides \ / Bottom slope v Bottom cap
Cada parte pode ser descrita por um número de linhas, três caracteres e três relacionamentos com certos valores que decidem a largura do campo em cada linha.
Uma primeira iteração veio ser:
#define g(x,s,A,B,C)for(i=0;i<x;i++)printf("%*c%*c%*c\n",A,*s,B,s[1],C,s[2]); f(n) { int s=2*n++,t=s+1,i; g(1, " ^", 1, 1, t-1) g(t, "/ \\",t-i, 1,2*i+1) g(s, "|||", 1, t, t) g(n,"\\\\/",i+1, t,t-2*i) g(n,"/\\\\",n-i, 2*i+1, t) g(s, "|||", 1, t, t) g(t, "\\/ ",i+1,2*t-2*i, 1) g(1, " v", 1, 1, t-1) }
As chamadas para o g()
a macro parece muito com uma tabela que poderia ser construída e reiniciada. As larguras dos campos às vezes estão relacionadas ao contador de índice, às vezes não. Podemos generalizar a largura do campo para ser F * i + A
, onde F é algum fator para multiplicar i
, e A é algum valor a ser adicionado para a largura. Portanto, a última largura da quarta chamada acima seria -2 * i + t
, por exemplo.
Assim, obtemos:
f(n){int s=2*n++,t=s+1, s = size of "side" parts, t = size of top and bottom slopes I[]={1,t,s,n,n,s,t,1}, The number of lines per part. A[]={...},x; A[] holds the values to add to each field-width. for(s=8;s--;) Loop through the parts. for(n=0;n<I[s];n++,puts("")) I[s] decides how many lines to the part. Ends with newline. for(t=3;t--;) Go through the three chars of each line. x=s*3+t, Calculate offset. printf("%*c", Print the char. n*("..."[x]-65)+A[x], Build field-width. The string holds the index factor, A[] holds the offset part. "..."[x]-1);} The char itself is grabbed from the string. Shifted by 1 to eliminated double backspaces.
No final, não era muito mais curto do que uma versão simplificada do g()
chamar um, mas o mais curto é mais curto.
Comentários
- @ceilingcat Cheers.
- @ceilingcat A ordem de avaliação indefinida da função argumentos me dão uma pausa.
Resposta
Java, 435 bytes
A própria função leva 435 bytes. Certamente há espaço para melhorias, “alto nível”, analisando as regras sobre onde colocar qual personagem (no final, o S é simétrico), e “baixo nível”, pelo golfe clássico (talvez retirando outra variável ou combinando dois dos for
-loops). Mas é uma primeira tentativa com esta linguagem um tanto antipática:
import static java.util.Arrays.*; import static java.lang.System.*; public class CoolS { public static void main(String[] args) { print(1); print(2); print(3); } static void print(int n){int i,r,d=3+6*n,w=3+n*4,h=6+n*10,m=n+n,v=w/2,k=h-1,j=w-1;char t[],S="/",B="\\",P="|",s[][]=new char[h][w];for(char x[]:s)fill(x," ");s[0][v]="^";s[k][v]="v";for(i=0;i<1+m;i++){r=i+1;t=s[r];t[v-r]=S;t[v+r]=B;t=s[k-r];t[v-r]=B;t[v+r]=S;}for(i=0;i<m;i++){r=2+m+i;t=s[r];t[0]=t[v]=t[j]=P;t=s[k-r];t[0]=t[v]=t[j]=P;}for(i=0;i<1+n;i++){r=2+m+m+i;t=s[r];t[i]=t[i+1+m]=B;t[j-i]=S;t=s[d-i];t[i]=S;t[v-i]=t[j-i]=B;}for(char x[]:s)out.println(x);} }
Comentários
- Olá. As importações são parte da contagem de bytes que ‘ temo, então sua resposta atual é na verdade 478 bytes . Você no entanto, pode jogar golfe até (por coincidência) seus 435 bytes atuais, com algumas coisas básicas para golfe.
- Consegui jogar golfe um pouco mais até 405 bytes removendo algumas variáveis e usando
t=...
um pouco menos onde economizaria bytes. Se você tiver alguma dúvida sobre qualquer uma das alterações que fiz, entre em contato. 🙂 - Obrigado @KevinCruijssen, infelizmente não posso investir mais tempo aqui – isso foi apenas uma coisa recreativa, e considerando a ” verbosidade ” de Java, não é um concorrente sério de qualquer maneira 😉 Considere adicionar sua solução como uma resposta própria, entretanto – então temos pelo menos alguma competição intra-idioma: -)
Resposta
PHP , 378 374 378 377 376 335 331 328 bytes
-3 bytes, graças ao manatwork
-4 bytes, usado str_pad em vez de str_repeat
-41 bytes, graças ao manatworks “sugestões
-1 byte, mesclou dois incrementos em + = 2
-1 byte, removeu o supérfluo \
-4 bytes por eco uma vez. Esqueci que precisava passar a string para a função, então isso tem mais bytes
Funciona para n = 0 também.
Comentários
- Como a declaração de função é muito cara e você usa t () apenas duas vezes, seria mais curto sem ela . Se além dos 9 avisos você receber 1 aviso também, poderá remover as aspas em torno de
'v'
noecho
final. - Você poderia usar um único loop para as partes oblíquas superior e inferior. A inicialização de $ a e $ i pode ser compactada movendo-os no primeiro uso.
- Ah, e
$i>0
e$m>0
pode ser escrito simplesmente como$i
e$m
. - Com espaços à direita , como em algumas outras soluções.
- Você também pode mover a declaração de $ c para seu primeiro uso. Basta alterar a
.
concatenação depois dela para,
. Experimente online!
Resposta
Python 3 , 321 307 bytes
Obrigado a @EsolangingFruit por economizar 14 bytes
n=int(input()) b,f="\/" c,l=4*n+3,10*n+6 r=range h=c//2 L=[c*[" "]for _ in r(l)] L[0][h],L[-1][h]="^v" for i in r(h):a=L[h-i];a[i],a[c+~i]=f,b for i in r(2*n):L[h-~i][0::h]="|"*3 for i in r(n+1):a=L[h+h+i];a[c+~i],a[i:c-1:h]=f,b*2 for i in r(1,l//2):L[l+~i]=L[i][::-1] print("\n".join("".join(i)for i in L))
Python 2 , 303 bytes
n=int(input()) b,f="\/" c,l,r=4*n+3,10*n+6,range h=c/2 L=[c*[" "]for _ in r(l)] L[0][h],L[-1][h]="^v" for i in r(h):a=L[h-i];a[i],a[c+~i]=f,b for i in r(2*n):L[h-~i][0::h]="|"*3 for i in r(n+1):a=L[h+h+i];a[c+~i],a[i:c-1:h]=f,b*2 for i in r(1,l/2):L[l+~1]=L[i][::-1] print"\n".join("".join(i)for i in L)
Comentários
- Você pode substituir
'\\','/'
na segunda linha por*'\/'
para economizar três bytes. - 307 bytes: Experimente online!
- Obrigado! @EsolangingFruit! Eu não estava ciente das operações de bits em Python. Além disso, economizaria alguns bytes para usar Python2 devido à divisão e parênteses em
print
- No Python 2,
input()
automaticamenteeval()
s a string, então você pode pular aint()
chamada também. - Para Python 3, você pode alterar a última linha para
for l in L:print(*l,sep="")
(não ‘ não acho que haja um equivalente no Python 2).
Λ