Um desafio geométrico

23

Todo mundo adora geometria. Então, por que não tentamos codificá-lo? Esse desafio envolve receber letras e números e criar formas dependendo dele.

A entrada

A entrada será na forma de (shapeIdentifier)(size)(inverter).

Mas o que são identificador de forma, tamanho e inversor?

O identificador de forma é o identificador do tipo de forma que você criará com *s. A seguir estão os identificadores de forma:

  • s - Quadrado
  • t - Triângulo

O tamanho ficará entre 1-20e é o tamanho da figura.

O inversor é se a forma ficará ou não de cabeça para baixo, indicada por a +ou a -. Observe: s3-== (igual a) s3+porque os quadrados são simétricos. No entanto t5-,! = (Não é igual) t5+.

O espaço em branco à direita é bom na saída, mas o espaço em branco à esquerda não é.

Exemplos de saída

Input: s3+
Output:
***
***
***

Input: t5+

Output:
  *
 ***
*****

Input: t3-
Output:
***
 *

Notas especiais

A entrada do triângulo sempre será um número ímpar; portanto, os triângulos sempre terminarão com 1 *na parte superior.

O tamanho do triângulo é o tamanho da base se o inversor for +e é o tamanho da parte superior se o inversor for -.

intboolstring
fonte
3
Como alguém que está estudando geometria agora (e estudando para uma final de geometria), posso dizer com 100% de certeza: a geometria é absolutamente nada divertida ... D: #
Ashwin Gupta

Respostas:

9

Pitão, 40 36 34 32 bytes

-1 byte por @isaacg

JstPz_W}\+zjl#m.[J*\*-J*}\tzyd;J

Um ponto-e-vírgula dentro de um lambda agora é o valor global da variável lambda, um recurso que economiza um byte.

                         Implicit: z = input
JstPz                    J = size.
_W }\+z                  Reverse if "+" in z
j l# m                J  Join the nonempty lines in map lambda d:... over range(J)
      .[J            ;   Pad the following with spaces (;) to length J
         *\*               "*", this many times:
            -J*}\tzyd        J if "t" not  in z,
                             otherwise the correct number for a triangle.

Experimente aqui .

Conjunto de teste .

lirtosiast
fonte
1
Muito tempo, ainda batendo Japt por 15 bytes? Eu não posso esperar para ver como isso será golfed :)
ETHproductions
Ótima solução! Você pode salvar um byte, substituindo qez\+por }\+z, porque +só pode aparecer na última posição.
Isaacg
6

Pitão, 38 bytes

JsPtzj?}\szm*\*JJ_W}\-zm.[J*\*hyd;/hJ2

Suíte de teste

Basicamente, o mais simples possível. Eu gostaria de poder combinar um pouco da lógica para as duas formas, mas atualmente é separada.

isaacg
fonte
5

JavaScript (ES6), 142 146 147

Editar 1 byte salvo thx @ETHproductions Editar 2 bytes sve thx @ user81655

i=>([,a,b]=i.match`.(.+)(.)`,Array(l=i<'t'?+a:-~a/2).fill('*'.repeat(a)).map((r,i)=>l-a?(' '.repeat(i=b<'-'?--l:i)+r).slice(0,a-i):r).join`
`)

Teste (executado no FireFox)

F=i=>(
  [,a,b]=i.match`.(.+)(.)`,
  Array(l=i<'t'?+a:-~a/2).fill('*'.repeat(a))
  .map((r,i)=>l-a?(' '.repeat(i=b<'-'?--l:i)+r).slice(0,a-i):r)
  .join`\n`
)

function test() { O.textContent=F(I.value) }

test()
Input: <input id=I oninput="test()" value="t11-"/>
<pre id=O></pre>

edc65
fonte
\d-> ., já que é garantido que haja exatamente um não dígito antes e depois
ETHproductions
@ETHproductions bem, obrigado
edc65
Agradável. Eu acho que este é o algoritmo ideal em JS, não consigo encontrar um menor.
ETHproductions
i.match(/.(.+)(.)/)->i.match`.(.+)(.)`
user81655
@ user81655 boa dica, graças
edc65
5

Python 2, 106 bytes

s=raw_input()
n=int(s[1:-1])
for i in[range(1,n+1,2),n*[n]][s<'t'][::2*('+'in s)-1]:print('*'*i).center(n)

A saída é um retângulo perfeito, com cada linha preenchida com espaços à direita, o que eu suponho que seja bom com base nos comentários no OP.

Nota: ainda não tenho certeza se inputé permitido no Python 2 para problemas como esses ...

Sp3000
fonte
4

Japt, 62 60 55 52 51 bytes

V=Us1 n;U<'t?Vo ç*pV):0oV2 £S²pY iY'*pV-X})·z2*!Uf-

Experimente online!

A primeira coisa que precisamos fazer é descobrir o tamanho da nossa forma. Isso é bem simples:

      // Implicit: U = input string, S = space
V=    // Set variable V to
Us1   // everything after the first char of U,
n;    // converted to a number. This turns e.g. "12+" into 12.

Agora, organizamos a forma da saída:

U<'t?      // If U comes before "t" lexicographically (here, if the first char is "s"),
Vo         //  make a list of V items,
ç*pV)      //  and set each item to V asterisks.
:0oV2      // Otherwise, create the range [0, V) with steps of 2 (e.g. 7 -> [0,2,4,6]),
£       }) //  and map each item X and index Y to:
S²pY       //   Repeat 2 spaces Y times. This creates a string of Y*2 spaces.
iY'*pV-X   //   At position Y in this string (right in the middle), insert V-X asterisks.
·          // Join with newlines.

Até agora, cuidamos do tamanho e da forma da saída. Tudo o que resta é a rotação. Atualmente, os triângulos estão apontados para cima, portanto, precisamos alterá-los se o terceiro caractere for +:

!Uf-    // Take the logical not of U.match("-").
        // If U contains "-", this returns false; otherwise, returns true.
2*      // Multiply by two. This converts true to 2, false to 0.
z       // Rotate the list 90° that many times.
        // Altogether, this turns the shape by 180° if necessary.

E com saída implícita, nosso trabalho aqui está concluído. :-)

ETHproductions
fonte
4

Python 2, 235 193 167 157 bytes

Atualizar:

Fiz alguma otimização significativa usando compreensão de lista e str.center (). Tenho a sensação de que posso fazer um pouco mais, vou ter um novo olhar mais tarde.

Atualização 2

Guardou 10 bytes com as sugestões de Sherlock9. Muito obrigado! :)

d=raw_input()
x=int(d[1:-1])
o="\n".join("*"*x for i in range(x))if d<"t"else"\n".join(("*"*i).center(x)for i in range(x,0,-2))
print o[::-1]if"+"in d else o

Resposta antiga

d=raw_input()
x=int(d[1:-1])
if "s" in d:
 for y in range(x):
    o+="*"*x+"\n"
 o=o[:-1]
else:
 b=0
 while x+1:
    o+=" "*b+"*"*x+" "*b+"\n"
    x-=2
    b+=1
 o=o[:-1]
 if d[-1]=="+":
    o=o[::-1]
print o

Abordagem bastante direta. Escrevendo linha por linha em uma string que eu produzo no final. Os triângulos são sempre desenhados invertidos e revertidos, se necessário. O fato de você poder multiplicar uma string com um Inteiro me salvou muitos bytes!

Vou tentar jogar isso um pouco mais tarde, e gostaria de receber sugestões nesse meio tempo, já que ainda não sou muito experiente com isso.

edit: Joguei bastante com a ajuda dos comentários e roubando o cálculo do tamanho de uma das outras respostas em python. Eu acho que é o máximo que posso fazer com esse algoritmo.

Denker
fonte
Como você contou? Ao usar wcisso, obtive-me uma contagem de bytes de 235. Estou errado?
ბიმო
1
Na verdade, são 235 bytes. Conselho de golfe: use guias em vez de dois espaços, válidos no Python 2 e cortando 5 bytes.
Maçaneta
Além disso, você não precisa usar raw_input, o uso inputeconomiza 4 bytes. Além disso, você não precisa dos colchetes na segunda linha, isso e não usar a variável x(usando if"s"in d) economiza mais 9 bytes.
ბიმო
2
@DenkerAffe quando a contagem na janela, subtrair 1 byte para cada nova linha - novas linhas são 2 bytes no Windows, mas 1 byte em outros ambientes
edc65
1
Primeiro, você pode remover os []colchetes em cada uma das joinchamadas de função. Segundo, if d<"t"elseé mais curto e funciona porque "s3+"<"t"<"t3+"em Python. Terceiro, else"\n".joine .center(x)for. Sem espaço. Não é necessário. Em quarto lugar, print o[::-1]if"+"in d else oonde eu reorganizadas as coisas por dois bytes (um espaço entre ]e ife outra entre ife "+".
Sherlock9
3

JavaScript, 220 bytes.

q=s=>+s.slice(1,s.length-1);f=s=>s[0]=="s"?("*".repeat(q(s))+"\n").repeat(q(s)):Array.apply(0,Array(-~(q(s)/2))).map((_,n)=>(s[s.length-1]=="-"?~~(q(s)/2)-n:n)).map(n=>(" ".repeat(q(s)/2-n)+"*".repeat(n*2+1))).join("\n")

Correr com f(input here)

Experimente aqui!

Os quadrados têm novas linhas à direita, mas os triângulos não. Explicação:

q=s=>+s.slice(1,s.length-1);                                                                                                                                                                                                 Define a function, q, that takes returns the argument, without the first and last character, casted into an integer.
                            f=s=>                                                                                                                                                                                            Define a function, f, that takes one argument, s. (This is the main function)
                                 s[0]=="s"?                                                                                                                                                                                  If the first character of s is "s" then...
                                           ("*".repeat(q(s))     )                                                                                                                                                           Repeat the "*" character q(s) times.
                                           (                +"\n")                                                                                                                                                           Append a newline to that
                                                                  .repeat(q(s))                                                                                                                                              Repeat that q(s) times.
                                                                               :                                                                                                                                             Else... (the first character of s isn't "s")
                                                                                Array.apply(0,Array(          ))                                                                                                             Create an array of length...
                                                                                Array.apply(0,Array(-~(q(s)/2)))                                                                                                             floor(q(s)/2)+1
                                                                                                                .map((_,n)=>                                   )                                                             Map each element, _ with index n to...
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?              ))                                                             If the last element of s is "-" then...
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?~~(q(s)/2)-n  ))                                                             floor(q(s)/2)-n
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?            : ))                                                             Else...
                                                                                                                .map((_,n)=>(s[s.length-1]=="-"?             n))                                                             Just n
                                                                                                                                                                .map(n=>                                        )            Map each element into...
                                                                                                                                                                .map(n=>(" ".repeat(q(s)/2-n)                   )            Repeat " ", q(s)/2-n times.
                                                                                                                                                                .map(n=>(                   )+"*".repeat(n*2+1)))            Append "*", repeated 2n+1 times.
                                                                                                                                                                .map(n=>(" ".repeat(        )+"*".repeat(n*2+1))).join("\n") Join with newlines
Loovjo
fonte
O comprimento da sua primeira linha é de 338 caracteres. Leva um monitor e meio para exibir.
Isanae
3
@isanae Diz 220 aqui.
Loovjo 21/01
1
Não clicarei em um link tinyurl aleatório, mas verifique novamente. De qualquer forma, tente evitar as barras de rolagem nas caixas de código, pois fica muito mais difícil ler.
Isanae
1
@ Loovjo Acho que ele quer dizer a primeira linha da explicação. Normalmente, recuo minha explicação em vez deste estilo para respostas JavaScript, assim você não precisa rolar para ver metade dela.
user81655
@ user81655 Sim, eu quis dizer na explicação. Agora eu entendo a confusão!
Isanae
3

Python 2, 157 132 bytes

def f(s):
 S=int(s[1:-1])
 for n in([range(1,S+2,2),range(S,0,-2)]['-'in s],[S]*S)['s'in s]:
  print "{:^{S}}".format('*'*n,S=S)

A primeira tentativa confirmou que o +/-final era opcional, me livrar disso deixei-me raspar um monte

A idéia aqui é fazer uma lista que pode ser lançada em uma saída genérica. A parte mais difícil foi separar o comprimento da entrada.

wnnmaw
fonte
Para obter o comprimento que eu usei x=int(d[1]if len(d)<4 else d[1:3])com d sendo a string de entrada. Isso é 5 bytes mais curto que a sua solução. Você ainda está muito à frente da minha resposta em python, precisa tentar entender o que você fez lá e vencê-lo na próxima vez! :)
Denker
1
Na verdade, x=int(d[1:-1])é muito mais curto para isso, apenas vi na outra resposta python.
Denker
@DenkerAffe, por qualquer motivo eu me lembro o inversor sendo facultativa, de modo que não iria funcionar, mas eu acho que eu só inventei isso
wnnmaw
2

Retina , 102 85 bytes

A contagem de bytes supõe que o código fonte seja codificado como ISO 8859-1.

\d+
$0$*:¶
^((\w)+):(:+)
$1$2$3$2¶$0
m`s$|:t

)`(.+)¶-(\D*)
-$2¶$1
m`^.

G`.
T`ts:` *

Experimente online.

Vou tentar jogar isso mais tarde.

Martin Ender
fonte
O Notepad ++ diz que seu código tem 89 bytes, e não 85. Usei a codificação ISO-8859-1 e continuei em Editar> Conversão EOL> Formato UNIX / Linux, para usar em \nvez de \r\n. Base64 do conteúdo: XGQrCiQwJCo6wrYKXigoXHcpKyk6KDorKQokMSQyJDMkMsK2JDAKbWBzJHw6dAoKKWAoLispwrYtKFxEKikKLSQywrYkMQptYF4uCgpHYC4KVGB0czpgICo=(cópia direta do Notepad ++). Por incrível que pareça, qualquer solução on-line me fornece 85 bytes ... Hum ...
Ismael Miguel
@IsmaelMiguel Tem que haver algo de errado com a forma como o Notepad ++ conta . Eles são definitivamente um byte único na ISO 8859-1 (com valor 182).
Martin Ender
2

Sério, 54 bytes

,#i's=`≈;'**@½≈";#dXdXεj' +"£n`@`≈;'**n`@Iƒ('-=WXa0WXü

Experimente Online

,#i                                                    Take input, push chars separately
   's=                                   Iƒ            IF the first char is "s":
                                `      `@                run the quoted function
                                 ≈;'**n                  make list of n strings of n *'s
      `                       `@                       ELSE run the quoted function:
       ≈;                                                make two copies of int n
         '**                                             use one to make string of n *'s
            @½≈                                          cut the other in half (e.g. 5->2)
               "           "£n                           run n/2 times the quoted function:
                ;#                                        copy the string as list of chars
                  dXdX                                    discard the last 2 *'s
                      εj                                  join back into string
                        ' +                               prepend a space
                                           ('-=WX 0WX  IF the third character is "-":
                                                 a       invert the stack
                                                     ü pop and print the entire stack

@Ego: vê isso #dXdXεj? STRING SLICING ????

quintopia
fonte
2

ES6, 178 172 159 bytes

s=>(p=s.match(/d+|./g),u=n=+p[1],m=n+1>>1,t=' '.repeat(n)+'*'.repeat(n),v=s<'t'?0:p[2]<'-'?(u=m,1):-1,[...Array(s<'t'?n:m)].map(_=>t.substr(u,u,u+=v)).join`
`)

Isso funciona devido a uma observação interessante que fiz. Se você repetir nespaços e nasteriscos, obtém (por exemplo, para n=5) isso:

     *****

Agora, pegue substrings com o mesmo começo e comprimento:

     |*****| (5)
    | ***| (4)
   |  *| (3)

Essas substrings são exatamente as strings que precisamos t5.

Editar: salvou 6 bytes graças a @ edc65.

Edit: Salvo 13 bytes, graças a ocultar o u+=vno terceiro argumento substr, permitindo-me simplificar a inicialização.

Neil
fonte
@ThomasKwa Huh, depois de eu ter corrigido o tcódigo de manipulação descobriu-se que we utornou-se equivalente e que me salvou suficiente bytes para me levar de volta para 178!
Neil
[,b,c]=s.matche mais tarde s<'t'... deve salvar alguns bytes (Firefox apenas)
edc65
@ edc65 Apenas não salvar a correspondência spermite que eu use, o s<'t'que me salvou em 6 bytes, obrigado.
Neil
2

MATL , 48 bytes

' *'jt4Y2m)U1$l't'Gm?2MQ2/:1L3$)R!P!R'+'Gm?P]]Q)

Usa a versão atual (10.1.0) do idioma / compilador.

O código aceita caracteres de entrada em qualquer ordem: todos s11+, 11s+e até 1+s1seria cadeias de entrada válidos.

EDIT (30 de julho de 2016): o código vinculado substitui 1L3$)por Y)para estar em conformidade com as alterações recentes no idioma

Experimente online!

Explicação

' *'        % push string. Will be indexed into to obtain final result
j           % input string
t           % duplicate
4Y2         % predefined literal string '0123456789'
m           % logical index of digits in input string
)           % index into input string to obtain substring with digits
U           % convert to number
1$l         % generate square of ones with that size
't'         % push character 't'
G           % push input string
m           % true if input string contains 't'
?           % if so...
  2M        % push argument of call to function `l`, i.e. square size
  Q2/       % add 1 and divide by 2. Call result T
  :         % generate vector [1, 2, ... T]
  1L        % predefined literal representing Matlab's `:` index
  3$)       % two dimensional index. Transforms square into rectangle
  R         % remove (set to zero) lower-left corner
  !P!       % flip horizontally
  R         % remove lower-left corner. This gives inverted triangle
  '+'       % push character '+'
  G         % push input
  m         % true if input contains '+'
  ?         % if so...
    P       % flip vertically
  ]         % end if
]           % end if
Q           % add 1. This gives array of values 1 and 2
)           % index string ' *' with this array to produce char array
            % implicitly display that char array
Luis Mendo
fonte
1

C, 259 bytes

#define x(y);)putchar(y)
#define m(n)for(n=0;n++<
#define T {m(q)i x(32);m(q)s-i*2 x(42);puts("");}
main(q,v,i,s)char**v;{s=atoi(v[1]+1);if(*v[1]=='s')m(i)s*s x(42)&&!(i%s)&&puts("");else if(strchr(v[1],'+'))for(i=s/2+1;i-->0;)T else for(i=-1;i++<s/2+1;)T}

destroçado

main(q,v,i,size)char**v; // neat way of declaring variables
{
    size=atoi(v[1]+1);
    if(*v[1]=='s')
    {
        for(i=0;i++<size*size;)
        {
            putchar(42); // returns 42 (true)
            if(!(i%size))
                puts("");
        }
    }
    else if(strchr(v[1],'+')) // if finds plus sign
    {
        for(i=size/2+1;i-->0;) // iterate the height of the triangle
        {
            for(q=0;q++<i;)putchar(32); // conveniently i is the number os spaces before each line
            for(q=0;q++<size-i*2;) putchar(42);
            puts("");
        }
    }
    else for(i=-1;i++<size/2+1;) // does the same as above but inverted order
    {
        for(q=0;q++<i;)putchar(32);
        for(q=0;q++<size-i*2;)putchar(42);
        puts("");
    }
}

Sugestões e críticas são bem-vindas.

Lince Assassino
fonte
1

Ruby, 99

->s{n=s[1,2].to_i
n.times{|i|d=(s.ord-115)*(s[-1]<=>?,)*(n-1-i*2)
d<1&&puts((?**(n+d)).center(n))}}

Calcula um quadrado ou triângulo de altura ne largura média n alterando a inclinação dos lados (portanto, a largura calculada do triângulo é 2n-1 na base, 1 na ponta.) Mas ele apenas imprime as linhas que não excedem os ncaracteres.

ungolfed no programa de teste

f=->s{                         #take a string as an argument
  n=s[1,2].to_i                #take 2 characters starting at index 1 and convert to a number for the size
  n.times{|i|                  #iterate through n rows    
    d=                         #calculate how many stars "MORE THAN" n we need on a row
    (s.ord-115)*               #ascii code for 1st character of string - 115 : s-->0, t-->1
    (s[-1]<=>?,)*              #compare last character of input with comma character - --> +1 + --> -1
    (n-1-i*2)                  #row number * 2: 0 at centre, positive above it, negative below it
    d<1&&                      #only output if d is nonpositive (i.e we need less than n or exactly n stars)
    puts((?**(n+d)).center(n)) #print n+d stars, centred in a field of n characters padded by whitespace
  }
}

f[gets.chomp]
Level River St
fonte
1

Jolf, 37 bytes, não-competitivo

Eu adicionei funções depois que esse desafio foi lançado, portanto, isso não pode ser considerado para aceitação. Isso está codificado na ISO-8859-7. Experimente todos os casos de teste aqui .

onFiΒ€ioSgiγ?='sn―sΒ'*―TΒ1'*?='-SZiγγ

Parte 1: analisando a sequência

onFiΒ€ioSgi
on          set n to
  Fi         the first entity of i (the shape identifier)
    Β       set Β (beta) to
     €i      the "inside" of i (in this case, the size) as a number
       oS   set S to
         gi  the last entity of i (the inverter)

Parte 2: obtendo o resultado

γ?='sn―sΒ'*―TΒ1'*
γ                 set γ (gamma) to the result of the following expression
 ?='sn             if n is the character s,
      ―sΒ'*         then return a pattern "s" (a square) made with "*"s
           ―TΒ1'*    otherwise, return a pattern "T" (triangle) that is centered and
                     has a scale factor of 1, made with "*"s

Parte 3: invertendo o resultado

?='-SZiγγ
?='-S     if S is a "-"
     Ziγ   return γ, inverted across its lines
        γ  otherwise, return γ untouched
Conor O'Brien
fonte