Objetivo: Escreva um programa ou função que imprima uma sequência de entrada em uma forma sinusoidal.

O senoide ASCII

Aqui está um período do sinusóide:

         .......                                 
      ...       ...                              
    ..             ..                            
   .                 .                           
  .                   .                          
 .                     .                         
.                       .                       .
                         .                     . 
                          .                   .  
                           .                 .   
                            ..             ..    
                              ...       ...      
                                 .......         

Observe que há exatamente um ponto em cada coluna.

• Cada caractere na sequência de entrada substituirá um ponto na forma acima, da esquerda para a direita.
• Os espaços na entrada devem ser gerados como caracteres normais, no lugar de um ponto.
• O caractere inicial corresponde ao ponto mais à esquerda na figura acima.
• Este é apenas um período, as entradas podem ser maiores que o número de pontos acima.

Entrada

• As entradas são cadeias ASCII que contêm apenas caracteres entre o decimal ASCII 32 (espaço) e o decimal ASCII 126 (Tilde ~).
• As entradas sempre serão apenas uma linha (sem quebras de linha).
• As entradas podem ser obtidas via STDIN, parâmetros de função, argumentos de linha de comando ou qualquer coisa semelhante.

Saída

• A saída deve ser impressa exatamente como nos casos de teste fornecidos.
• Os espaços à direita nas linhas são permitidos desde que o comprimento da linha com esses espaços à direita não exceda o comprimento da linha mais longa (aquela com o último caractere).
• Nenhuma linha inicial / final é permitida.

Casos de teste

• Entrada: .................................................

Saída:

         .......                                 
      ...       ...                              
    ..             ..                            
   .                 .                           
  .                   .                          
 .                     .                         
.                       .                       .
                         .                     . 
                          .                   .  
                           .                 .   
                            ..             ..    
                              ...       ...      
                                 .......         

• Entrada: Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

Saída:

         ng Puzz                                         ion and                                         siasts                                          stratio           
      mmi       les                                   est        an                                   thu       and                                   egi       n r        
    ra              &                               qu             sw                               en              c                                r             eq      
   g                                                                 e                                               o                             o                 u     
  o                   C                           a                   r                           e                   d                           n                   i    
 r                     o                                                                         l                     e                                               r   
P                       d                       s                       s                       z                                               ,                       e  
                         e                     i                         i                     z                         g                     e                         d 
                                                                          t                   u                           o                   e                           .
                           G                 e                             e                 p                             l                 r                             
                            ol             ng                                f             g                                fe              f                              
                              f S       cha                                   or        min                                   rs.       00%                                
                                 tack Ex                                         program                                          It's 1                                   

• Entrada: Short text.

Saída:

         t.
      tex  
    t      
   r       
  o        
 h         
S          

• Entrada: The quick brown fox jumps over the lazy dog

Saída:

          brown                            
      ick       fox                        
    qu              j                      
                     u                     
  e                   m                    
 h                     p                   
T                       s                  

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

Pontuação

Isso é código-golfe , então o programa ou função mais curto em bytes vence.

Pitão, 59 bytes (57 caracteres)

Xjb.sC.>V+R*12\ Xz\ C9*+-L12K+JsM._+6jC\཈2tP_JKlz]*dlzC9d

Demonstração.

Uma tabela de pesquisa binária é codificada dentro ཈, com o valor 3912. Isso é convertido em binário, dando [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Isso é tratado como as diferenças entre alturas consecutivas. Anexando um 6, formando todos os prefixos e mapeando cada um para sua soma, o primeiro quarto da onda é gerado.

sM._+6jC\཈2avalia [6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]como descrito acima. Em seguida, o código concatena no verso dessa string para formar a primeira metade da onda e, em seguida, subtrai-o de 12 para fornecer a onda inteira.

Em seguida, formamos linhas de cada caractere de entrada seguidas por 12 espaços. Essa linha é girada para a direita pelo parâmetro de altura da onda correspondente a esse local e, em seguida, as linhas são transpostas e unidas em novas linhas.

Em seguida, retiramos as linhas em branco à esquerda e à esquerda. No entanto, não podemos remover linhas em branco à esquerda ou à direita que tenham espaços da entrada. Isso é implementado substituindo espaços na entrada por tabs ( C9), que não podem estar na entrada, eliminando linhas em branco e transformando as guias novamente em espaços.

Python 2, 156 bytes

l=map(int,"654322111%08d1122345"%1);l+=[12-c for c in l]
def f(t):
 h=len(t);o=bytearray(' '*h+'\n')*13;i=0
 for c in t:o[i-~h*l[i%48]]=c;i+=1
 print o[:-1]

Explicação

• O código inteiro simplesmente cria um bloco de espaços ( o) e substitui os espaços corretos pelas letras da entrada t.

• A variável larmazena uma lista de compensações da parte superior. Para que o nth caractere de testeja na linha l[n].

• O bytearray oserve como uma sequência mutável, pois as sequências são imutáveis ​​em python.

• -~hé o mesmo que h+1economiza espaço porque não preciso de parênteses.

Java, 219 209 199 bytes

void p(char[]s){int r=6,c;String t="";for(;r>-7;r--,t+='\n')for(c=0;c<s.length;c++)t+=(s(c%48)==r?s[c]:' ');System.out.println(t);}int s(int a){return a<4?a:a<6?4:a<9?5:a<15?6:a<24?s(24-a):-s(a-24);}

Eu ainda sou um novato aqui e espero que seja compatível com as regras a introdução de uma subfunção (quando os bytes dessa função forem contados, é claro). Caso contrário, tentarei converter a sinfunção em alguma pesquisa inteligente de array ...

public class SinusText
{
    public static void main(String[] args)
    {
        SinusText s = new SinusText();
        s.p(".................................................".toCharArray());
        s.p("Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.".toCharArray());
        s.p("Short text.".toCharArray());
        s.p("The quick brown fox jumps over the lazy dog".toCharArray());
    }
    void p(char[]s){int r=6,c;String t="";for(;r>-7;r--,t+='\n')for(c=0;c<s.length;c++)t+=(s(c%48)==r?s[c]:' ');System.out.println(t);}int s(int a){return a<4?a:a<6?4:a<9?5:a<15?6:a<24?s(24-a):-s(a-24);}
}

Perl, 222 bytes

$n[$_%13].=substr$l[$_/13],$_%13,1for 0..13*(@l=map{(map{sprintf"%013b",$_}@t=(64,128,256,512,(1024)x2,(2048)x3),(4096)x7,reverse@u=(32,16,8,4,4,2,2,2),(1)x7,(reverse@u),@t)[$-++%48]=~s/./$&?$_:$"/egr}<>=~/./g);$,=$/;say@n

Requer -Epara say, armazena as posições como números inteiros convertidos em números binários e a inversão da matriz provavelmente não é muito eficiente em bytes. Também tenho certeza de que há muitas economias a serem feitas, então continuarei cutucando e cutucando.

Exemplo de saída:

$perl -E '$n[$_%13].=substr$l[$_/13],$_%13,1for 0..13*(@l=map{(map{sprintf"%013b",$_}@t=(64,128,256,512,(1024)x2,(2048)x3),(4096)x7,reverse@u=(32,16,8,4,4,2,2,2),(1)x7,(reverse@u),@t)[$-++%48]=~s/./$&?$_:$"/egr}<>=~/./g);$,=$/;say@n' <<< '.................................................'
         .......                                 
      ...       ...                              
    ..             ..                            
   .                 .                           
  .                   .                          
 .                     .                         
.                       .                       .
                         .                     . 
                          .                   .  
                           .                 .   
                            ..             ..    
                              ...       ...      
                                 .......         

$perl -E '$n[$_%13].=substr$l[$_/13],$_%13,1for 0..13*(@l=map{(map{sprintf"%013b",$_}@t=(64,128,256,512,(1024)x2,(2048)x3),(4096)x7,reverse@u=(32,16,8,4,4,2,2,2),(1)x7,(reverse@u),@t)[$-++%48]=~s/./$&?$_:$"/egr}<>=~/./g);$,=$/;say@n' <<< 'Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It'\''s 100% free, no registration required.'
         ng Puzz                                         ion and                                         siasts                                          stratio           
      mmi       les                                   est        an                                   thu       and                                   egi       n r        
    ra              &                               qu             sw                               en              c                                r             eq      
   g                                                                 e                                               o                             o                 u     
  o                   C                           a                   r                           e                   d                           n                   i    
 r                     o                                                                         l                     e                                               r   
P                       d                       s                       s                       z                                               ,                       e  
                         e                     i                         i                     z                         g                     e                         d 
                                                                          t                   u                           o                   e                           .
                           G                 e                             e                 p                             l                 r                             
                            ol             ng                                f             g                                fe              f                              
                              f S       cha                                   or        min                                   rs.       00%                                
                                 tack Ex                                         program                                          It's 1                                   

JavaScript, 251 243 224 220 217

Implementação realmente simples: ele usa uma sequência de caracteres para representar a posição y de cada caractere na onda (compensado por a, que é o código ASCII 97). Ele itera através de todas as linhas possíveis; se o valor y da linha atual for o mesmo que a posição y na onda, ele gravará um caractere da sequência. Há também uma limpeza no final para remover a linha, se estiver completamente em branco.

Observe que a saída aparecerá instável na alert()janela, se não estiver usando uma fonte monoespaçada, você pode alterá-la console.log()para verificar se a saída está correta.

s=prompt(o=[])
for(y=i=0;y<13;++y){o[i]=""
for(x=0;x<s.length;++x)o[i]+=y=="gfedccbbbaaaaaaabbbccdefghijkklllmmmmmmmlllkkjih".charCodeAt(x%48)-97?s[x]:" "
if(o[i++].trim().length<1)o.splice(--i,1)}
alert(o.join("\n"))

EDIT1: ++e --existe.

EDIT2: A remoção da linha em branco agora é feita no mesmo loop que o restante, salvando 17 caracteres. Também não precisava desses suportes, para 2 caracteres extras.

EDIT3: Não há necessidade de declarar a forma de onda como uma variável, salvando 4 caracteres.

EDIT4: Como apontado por Dom Hastings nos comentários, a contagem de bytes incluiu o retorno de carro, bem como o caractere de nova linha, atualizou a contagem de bytes para todas as revisões para excluir o retorno de carro.

EDIT5: Salvo 3 bytes, cortesia de Dom Hastings. Não implementei a o.splicecorreção, pois isso falha ao remover as linhas em branco (pelo menos no final).

Matlab, 133 , 130 bytes

O forro único:

s=input('');y=ceil(5.6*sin(0:pi/24:pi-.1).^.9);l=[-y y]+7;n=numel(s);t=repmat(' ',13,n);for k=1:n;t(l(mod(k-1,48)+1),k)=s(k);end;t

E a versão expandida:

function f(s)
    y=ceil(5.6*sin(0:pi/24:pi-.1).^.9);l=[-y y]+7;  %// calculate the line number for each column position
    n=numel(s);                                     %// number of character in input
    t=repmat(' ',13,n);                             %// Create a blank canvas of whitespace characters
    for k=1:n
        t(l(mod(k-1,48)+1),k)=s(k);                 %// place each input character where it should be
    end
    t                                               %// force the output display

O liner único recebe entrada do console ( stdin) e tem 130 bytes. A versão expandida substitui a entrada do console por uma definição de função (+1 byte), mas é muito mais confortável de usar no caso de teste em um loop:

Descrição:

O índice de linha de cada caractere é calculado por meio período, depois espelhado e concatenado para ter um período completo.
Criamos um plano de fundo em branco de caractere de espaço em branco (mesmo comprimento da string de entrada. Colocamos cada caractere de acordo com sua posição na linha relevante. Se a string de entrada for maior que um período, o modoperador (modulo) quebra isso para que não Não saia do limite ao solicitar o número da linha.

Caso de teste:

Salve a versão da função textsine.mem seu caminho e execute:

s = {'.................................................';...
    'Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It''s 100% free, no registration required.';...
    'Short text.';...
    'The quick brown fox jumps over the lazy dog'};

for txtcase=1:4
    textsine(s{txtcase,1})
end

irá produzir:

t =

         .......                                 
      ...       ...                              
    ..             ..                            
   .                 .                           
  .                   .                          
 .                     .                         
.                       .                       .
                         .                     . 
                          .                   .  
                           .                 .   
                            ..             ..    
                              ...       ...      
                                 .......         


t =

         ng Puzz                                         ion and                                         siasts                                          stratio           
      mmi       les                                   est        an                                   thu       and                                   egi       n r        
    ra              &                               qu             sw                               en              c                                r             eq      
   g                                                                 e                                               o                             o                 u     
  o                   C                           a                   r                           e                   d                           n                   i    
 r                     o                                                                         l                     e                                               r   
P                       d                       s                       s                       z                                               ,                       e  
                         e                     i                         i                     z                         g                     e                         d 
                                                                          t                   u                           o                   e                           .
                           G                 e                             e                 p                             l                 r                             
                            ol             ng                                f             g                                fe              f                              
                              f S       cha                                   or        min                                   rs.       00%                                
                                 tack Ex                                         program                                          It's 1                                   


t =

         t.
      tex  
    t      
   r       
  o        
 h         
S          








t =

          brown                            
      ick       fox                        
    qu              j                      
                     u                     
  e                   m                    
 h                     p                   
T                       s                  

                          o                
                           v               
                            er             
                               th       dog
                                 e lazy    

se você quiser testar a versão de uma linha com entrada de stdin, sua entrada deve ser inserida como uma única string, portanto, você deve incluir sua entrada entre 'caracteres. Exemplo:

'Short text.'   %//   valid input
Short text.     %// INVALID input

_{Obrigado Luis Mendopor raspar 3 bytes ;-)}

Scala 377 caracteres

primeiro corte. provavelmente pode obter uma fórmula melhor para traduzir xparay

(s:String)⇒s.zipWithIndex.map(t⇒(t._1,t._2,t._2%48 match{
case i if i<5⇒6-i
case 5|19⇒2
case 6|7|8|16|17|18⇒1
case i if i<16⇒0
case i if i<29⇒i%20+2
case 29|43⇒10
case 30|31|32|40|41|42⇒11
case i if i<40⇒12
case i if i>43⇒10-i%44
})).groupBy(_._3).toSeq.map{case(y,xs)⇒(""→0/:xs.sortBy(_._2)){case((p,l),(c,x,_))⇒(p+" "*(x-l-1)+c)→x}._1→y}.sortBy(_._2).map(_._1).mkString("\n")

Lisp comum, 205 bytes

(lambda(s &aux p v o)(dotimes(r 13)(setf o 0 p v v(round(*(/ 24 pi)(+(asin(-(/ r 6)1))pi))))(when p(map()(lambda(c)(princ(if(some(lambda(k)(<= p(mod k 48)(1- v)))`(,o,(- 23 o)))c" "))(incf o))s)(terpri))))

Testes

Consulte http://pastebin.com/raw.php?i=zZ520FTU

Observações

Imprima a linha de saída por linha, calculando os índices nas sequências que devem ser impressas usando a função inversa senoidal asin. A saída não corresponde exatamente às entradas esperadas na pergunta, mas como o OP reconhece que as saídas de exemplo não são senoidais reais, acho que está tudo bem. Pelo menos, sempre há apenas um caractere escrito para cada coluna.

Python 2, 172 bytes

Isso não é tão bom quanto a resposta de Alex L , mas é bem próximo. Recebe entrada da entrada padrão e funciona melhor em um .pyarquivo.

l=map(int,bin(9960000)[2:]);l+=[-c for c in l];s=6;o=[];i=9
for c in raw_input():b=[' ']*13;b[s]=c;o+=[b];s+=l[i%48];i+=1
print''.join(sum(zip(*o+['\n'*13])[::-1],())[:-1])

Decidi construir a saída transposta (cada coluna é uma linha) e depois transpor o resultado, já que em python a transposição de uma matriz é map(*m).

• l: A representação binária de 9960000(após cortar o "0b"de bin) é 100101111111101001000000. Este é o "passo" da onda senoidal em cada coluna, começando no último caractere do ponto mais baixo. Copio esta lista, nego cada número e colo-a no final de si mesma para formar o que é efetivamente um derivado da função.
• s: Essa é a variável que controla em qual linha (coluna na transposição) o próximo caractere é inserido.
• o: Saída final, transposta
• i: Mantém o controle do período das ondas senoidais. Começa às 9, pois lé ligeiramente deslocada.

No forloop, crio uma lista de 13 espaços (eu estava usando bytes, mas as listas de caracteres têm uma instrução de impressão mais curta) e, em seguida, substituo o scaractere pelo caractere de entrada. Anexe bao final de o, adicione a etapa apropriada ae sincremente i.

Eu esperava que a printdeclaração fosse tão simples quanto \n'.join(*zip(o)), mas não tive tanta sorte. zip(*o+['\n'*13])[::-1]anexa uma coluna de novas linhas e depois inverte e transpõe a coisa toda (sem a inversão, a onda senoidal está de cabeça para baixo), sum(...,())concatena as tuplas juntas em uma tupla de caracteres e, em seguida, ''.join(...)concatena os caracteres e a imprime.

Outras coisas que tentei foram criar uma matriz de espaços de 12 caracteres e inserir o novo caractere no local apropriado, e substituir l+=[-c for c in l];por algum tipo de matemática por algum tipo de multiplicação 1e -1com o resultado da indexação l, mas nada que eu pudesse descobrir acabou sendo mais curto.

Mathematica, 131 bytes

i=[input string];c=Characters@i;l=Length@c;StringJoin@Riffle[StringJoin@@@SparseArray[Table[{7-Round[6 Sin[.13(x-1)]],x},{x,l}]->c,{13,l}," "],"\n"]

São 131 caracteres, incluindo os três para i=foo;. Essa parecia uma maneira razoável de receber a opinião; Eu poderia ter colocado direto na definição ce salvo alguns golpes, mas isso parece injusto.

É bem direto - quase até legível. Ele divide a cadeia de caracteres em uma lista de caracteres e, em seguida, coloca esses caracteres em uma matriz esparsa nas posições determinadas a partir de Table(qualquer ponto da matriz sem um caractere padrão para um espaço). As linhas são montadas separadamente e as novas linhas são espalhadas entre elas. O StringJoin final une tudo.

NB: Como algumas outras soluções, isso pode não ser realmente válido porque produz um sinusóide real, e não o exemplo (bonito) artesanal.

Testes:

(*i=Programming Puzzles...*)
         ng Puzz                                          on and                                          iasts                                           tration          
       mi       le                                     sti       a                                      us      and                                     is        r        
     am           s                                   e           ns                                  th            c                                 eg           eq      
    r               &                               qu              we                              en               o                               r               u     
  og                  C                                               r                                               d                            o                  ir   
 r                     o                          a                                               e                    e                          n                     e  
P                       d                       s                       si                       l                       g                                               d 
                         e                     i                          t                    zz                         o                     ,                         .
                           G                                               e                  u                            lf                 ee                           
                            o               ge                               f               p                               e               r                             
                             lf           an                                  or           g                                  rs            f                              
                                St      ch                                       p      min                                     .        0%                                
                                  ack Ex                                          rogram                                          It's 10                                  
(*i=.... ...*)
         .......                                 
       ..       ..                               
     ..           ..                             
    .               .                            
  ..                 ..                          
 .                     .                         
.                       .                       .
                         ..                    . 
                           .                  .  
                            .               ..   
                             ..           ..     
                               ...      ..       
                                  ......         
(*i= Short text.*)
         t.
       ex  
      t    
    t      
  or       
 h         
S          





(*i=The quick...*)              
          brown                            
       ck       fo                         
     ui           x                        
    q               j                      
  e                  um                    
 h                     p                   
T                       s                  
                          o                
                           v               
                            e              
                             r            g
                               the      do 
                                   lazy